java.sql.Array

Here are the examples of the java api class java.sql.Array taken from open source projects.

1. CallableStatementTest#testGetArray()

Project: pgjdbc-ng
File: CallableStatementTest.java
@Test
public void testGetArray() throws SQLException {
    CallableStatement call = con.prepareCall(func + pkgName + "getarray()}");
    call.registerOutParameter(1, Types.ARRAY);
    call.execute();
    Array arr = call.getArray(1);
    ResultSet rs = arr.getResultSet();
    assertTrue(rs.next());
    assertEquals(1, rs.getInt(1));
    assertTrue(rs.next());
    assertEquals(2, rs.getInt(1));
    assertTrue(!rs.next());
    rs.close();
    call.close();
}

2. ArrayTest#testCreatePrimitiveArray()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testCreatePrimitiveArray() throws SQLException {
    double[][] in = new double[2][2];
    in[0][0] = 3.5;
    in[0][1] = -4.5;
    in[1][0] = 10.0 / 3;
    in[1][1] = 77;
    Array arr = conn.createArrayOf("float8", in);
    Double[][] out = (Double[][]) arr.getArray();
    assertEquals(2, out.length);
    assertEquals(2, out[0].length);
    assertEquals(3.5, out[0][0], 0.00001);
    assertEquals(-4.5, out[0][1], 0.00001);
    assertEquals(10.0 / 3, out[1][0], 0.00001);
    assertEquals(77, out[1][1], 0.00001);
}

3. ArrayTest#testCreateArrayWithoutServer()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testCreateArrayWithoutServer() throws SQLException {
    String[][] in = new String[2][2];
    in[0][0] = "a";
    in[0][1] = "";
    in[1][0] = "\\";
    in[1][1] = "\"\\'z";
    Array arr = conn.createArrayOf("varchar", in);
    String[][] out = (String[][]) arr.getArray();
    assertEquals(2, out.length);
    assertEquals(2, out[0].length);
    assertEquals("a", out[0][0]);
    assertEquals("", out[0][1]);
    assertEquals("\\", out[1][0]);
    assertEquals("\"\\'z", out[1][1]);
}

4. ArrayTest#testCreateEmptyArrayOfIntViaAlias()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testCreateEmptyArrayOfIntViaAlias() throws SQLException {
    PreparedStatement pstmt = conn.prepareStatement("SELECT ?::int[]");
    Integer[] in = new Integer[0];
    pstmt.setArray(1, conn.createArrayOf("integer", in));
    ResultSet rs = pstmt.executeQuery();
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Integer[] out = (Integer[]) arr.getArray();
    assertEquals(0, out.length);
    ResultSet arrRs = arr.getResultSet();
    assertFalse(arrRs.next());
}

5. ArrayTest#testCreateArrayOfNull()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testCreateArrayOfNull() throws SQLException {
    String sql = "SELECT ?::int8[]";
    PreparedStatement pstmt = conn.prepareStatement(sql);
    String[] in = new String[2];
    in[0] = null;
    in[1] = null;
    pstmt.setArray(1, conn.createArrayOf("int8", in));
    ResultSet rs = pstmt.executeQuery();
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Long[] out = (Long[]) arr.getArray();
    assertEquals(2, out.length);
    assertNull(out[0]);
    assertNull(out[1]);
}

6. ArrayTest#testCreateArrayOfMultiString()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testCreateArrayOfMultiString() throws SQLException {
    PreparedStatement pstmt = conn.prepareStatement("SELECT ?::text[]");
    String[][] in = new String[2][2];
    in[0][0] = "a";
    in[0][1] = "";
    in[1][0] = "\\";
    in[1][1] = "\"\\'z";
    pstmt.setArray(1, conn.createArrayOf("text", in));
    ResultSet rs = pstmt.executeQuery();
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    String[][] out = (String[][]) arr.getArray();
    assertEquals(2, out.length);
    assertEquals(2, out[0].length);
    assertEquals("a", out[0][0]);
    assertEquals("", out[0][1]);
    assertEquals("\\", out[1][0]);
    assertEquals("\"\\'z", out[1][1]);
}

7. ArrayTest#testCreateArrayOfInt()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testCreateArrayOfInt() throws SQLException {
    PreparedStatement pstmt = conn.prepareStatement("SELECT ?::int[]");
    Integer[] in = new Integer[3];
    in[0] = 0;
    in[1] = -1;
    in[2] = 2;
    pstmt.setArray(1, conn.createArrayOf("int4", in));
    ResultSet rs = pstmt.executeQuery();
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Integer[] out = (Integer[]) arr.getArray();
    assertEquals(3, out.length);
    assertEquals(0, out[0].intValue());
    assertEquals(-1, out[1].intValue());
    assertEquals(2, out[2].intValue());
}

8. ArrayTest#testWriteMultiDimensional()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testWriteMultiDimensional() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    rs.close();
    stmt.close();
    String sql = "SELECT ?::int[]";
    PreparedStatement pstmt = conn.prepareStatement(sql);
    pstmt.setArray(1, arr);
    rs = pstmt.executeQuery();
    assertTrue(rs.next());
    arr = rs.getArray(1);
    Integer[][] i = (Integer[][]) arr.getArray();
    assertEquals(1, i[0][0].intValue());
    assertEquals(2, i[0][1].intValue());
    assertEquals(3, i[1][0].intValue());
    assertEquals(4, i[1][1].intValue());
}

9. ArrayTest#testNullString()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testNullString() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{a,NULL}'::text[]");
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    String[] s = (String[]) arr.getArray();
    assertEquals(2, s.length);
    assertEquals("a", s[0]);
    assertNull(s[1]);
}

10. ArrayTest#testUnknownArrayType()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testUnknownArrayType() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT relacl FROM pg_class WHERE relacl IS NOT NULL LIMIT 1");
    ResultSetMetaData rsmd = rs.getMetaData();
    assertEquals(Types.ARRAY, rsmd.getColumnType(1));
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    assertEquals("aclitem", arr.getBaseTypeName());
    ResultSet arrRS = arr.getResultSet();
    ResultSetMetaData arrRSMD = arrRS.getMetaData();
    assertEquals("aclitem", arrRSMD.getColumnTypeName(2));
}

11. ArrayTest#testNullValues()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testNullValues() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT ARRAY[1,NULL,3]");
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Integer[] i = (Integer[]) arr.getArray();
    assertEquals(3, i.length);
    assertEquals(1, i[0].intValue());
    assertNull(i[1]);
    assertEquals(3, i[2].intValue());
}

12. ArrayTest#testMultiDimensionalArray()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testMultiDimensionalArray() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Object[] oa = (Object[]) arr.getArray();
    assertEquals(2, oa.length);
    Integer[] i0 = (Integer[]) oa[0];
    assertEquals(2, i0.length);
    assertEquals(1, i0[0].intValue());
    assertEquals(2, i0[1].intValue());
    Integer[] i1 = (Integer[]) oa[1];
    assertEquals(2, i1.length);
    assertEquals(3, i1[0].intValue());
    assertEquals(4, i1[1].intValue());
    rs.close();
    stmt.close();
}

13. ArrayTest#testNonStandardBounds()

Project: pgjdbc-ng
File: ArrayTest.java
/**
   * Starting with 8.0 non-standard (beginning index isn't 1) bounds the
   * dimensions are returned in the data. The following should return
   * "[0:3]={0,1,2,3,4}" when queried. Older versions simply do not return the
   * bounds.
   */
@Test
public void testNonStandardBounds() throws SQLException {
    Statement stmt = conn.createStatement();
    stmt.executeUpdate("INSERT INTO arrtest (intarr) VALUES ('{1,2,3}')");
    stmt.executeUpdate("UPDATE arrtest SET intarr[0] = 0");
    ResultSet rs = stmt.executeQuery("SELECT intarr FROM arrtest");
    assertTrue(rs.next());
    Array result = rs.getArray(1);
    Integer[] intarr = (Integer[]) result.getArray();
    assertEquals(4, intarr.length);
    for (int i = 0; i < intarr.length; i++) {
        assertEquals(i, intarr[i].intValue());
    }
}

14. ArrayTest#nullArray()

Project: pgjdbc
File: ArrayTest.java
@Test
public void nullArray() throws SQLException {
    PreparedStatement ps = con.prepareStatement("INSERT INTO arrtest(floatarr) VALUES (?)");
    ps.setNull(1, Types.ARRAY, "float8");
    ps.execute();
    ps.close();
    ps = con.prepareStatement("select floatarr from arrtest");
    ResultSet rs = ps.executeQuery();
    Assert.assertTrue("arrtest should contain a row", rs.next());
    Array getArray = rs.getArray(1);
    Assert.assertNull("null array should return null value on getArray", getArray);
    Object getObject = rs.getObject(1);
    Assert.assertNull("null array should return null on getObject", getObject);
}

15. ArrayTest#testEvilCasing()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testEvilCasing() throws SQLException {
    PGobject cc = new PGobject();
    cc.setType("\"Evil.Table\"");
    cc.setValue("(1)");
    Object[] in = new Object[1];
    in[0] = cc;
    Array arr = _conn.createArrayOf("\"Evil.Table\"", in);
    PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::\"Evil.Table\"[]");
    pstmt.setArray(1, arr);
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Object[] resArr = (Object[]) rs.getArray(1).getArray();
    Assert.assertTrue(resArr[0] instanceof PGobject);
    PGobject resObj = (PGobject) resArr[0];
    Assert.assertEquals("(1)", resObj.getValue());
}

16. ArrayTest#testCasingBuiltinNonAlias()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCasingBuiltinNonAlias() throws SQLException {
    Array arr = _conn.createArrayOf("INT4", new Integer[] { 1, 2, 3 });
    PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::INT4[]");
    pstmt.setArray(1, arr);
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Integer[] resArr = (Integer[]) rs.getArray(1).getArray();
    Assert.assertArrayEquals(new Integer[] { 1, 2, 3 }, resArr);
}

17. ArrayTest#testCasingBuiltinAlias()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCasingBuiltinAlias() throws SQLException {
    Array arr = _conn.createArrayOf("INT", new Integer[] { 1, 2, 3 });
    PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::INT[]");
    pstmt.setArray(1, arr);
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Integer[] resArr = (Integer[]) rs.getArray(1).getArray();
    Assert.assertArrayEquals(new Integer[] { 1, 2, 3 }, resArr);
}

18. ArrayTest#testCasingComposite()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCasingComposite() throws SQLException {
    PGobject cc = new PGobject();
    cc.setType("\"CorrectCasing\"");
    cc.setValue("(1)");
    Object[] in = new Object[1];
    in[0] = cc;
    Array arr = _conn.createArrayOf("\"CorrectCasing\"", in);
    PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::\"CorrectCasing\"[]");
    pstmt.setArray(1, arr);
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Object[] resArr = (Object[]) rs.getArray(1).getArray();
    Assert.assertTrue(resArr[0] instanceof PGobject);
    PGobject resObj = (PGobject) resArr[0];
    Assert.assertEquals("(1)", resObj.getValue());
}

19. ArrayTest#testCreatePrimitiveArray()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCreatePrimitiveArray() throws SQLException {
    double in[][] = new double[2][2];
    in[0][0] = 3.5;
    in[0][1] = -4.5;
    in[1][0] = 10.0 / 3;
    in[1][1] = 77;
    Array arr = _conn.createArrayOf("float8", in);
    Double out[][] = (Double[][]) arr.getArray();
    Assert.assertEquals(2, out.length);
    Assert.assertEquals(2, out[0].length);
    Assert.assertEquals(3.5, out[0][0], 0.00001);
    Assert.assertEquals(-4.5, out[0][1], 0.00001);
    Assert.assertEquals(10.0 / 3, out[1][0], 0.00001);
    Assert.assertEquals(77, out[1][1], 0.00001);
}

20. ArrayTest#testCreateArrayWithoutServer()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCreateArrayWithoutServer() throws SQLException {
    String in[][] = new String[2][2];
    in[0][0] = "a";
    in[0][1] = "";
    in[1][0] = "\\";
    in[1][1] = "\"\\'z";
    Array arr = _conn.createArrayOf("varchar", in);
    String out[][] = (String[][]) arr.getArray();
    Assert.assertEquals(2, out.length);
    Assert.assertEquals(2, out[0].length);
    Assert.assertEquals("a", out[0][0]);
    Assert.assertEquals("", out[0][1]);
    Assert.assertEquals("\\", out[1][0]);
    Assert.assertEquals("\"\\'z", out[1][1]);
}

21. ArrayTest#testCreateEmptyArrayOfIntViaAlias()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCreateEmptyArrayOfIntViaAlias() throws SQLException {
    PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::int[]");
    Integer in[] = new Integer[0];
    pstmt.setArray(1, _conn.createArrayOf("integer", in));
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Integer out[] = (Integer[]) arr.getArray();
    Assert.assertEquals(0, out.length);
    ResultSet arrRs = arr.getResultSet();
    Assert.assertFalse(arrRs.next());
}

22. ArrayTest#testCreateArrayWithNonStandardDelimiter()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCreateArrayWithNonStandardDelimiter() throws SQLException {
    PGbox in[] = new PGbox[2];
    in[0] = new PGbox(1, 2, 3, 4);
    in[1] = new PGbox(5, 6, 7, 8);
    PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::box[]");
    pstmt.setArray(1, _conn.createArrayOf("box", in));
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    ResultSet arrRs = arr.getResultSet();
    Assert.assertTrue(arrRs.next());
    Assert.assertEquals(in[0], arrRs.getObject(2));
    Assert.assertTrue(arrRs.next());
    Assert.assertEquals(in[1], arrRs.getObject(2));
    Assert.assertFalse(arrRs.next());
}

23. ArrayTest#testCreateArrayOfMultiString()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCreateArrayOfMultiString() throws SQLException {
    PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::text[]");
    String in[][] = new String[2][2];
    in[0][0] = "a";
    in[0][1] = "";
    in[1][0] = "\\";
    in[1][1] = "\"\\'z";
    pstmt.setArray(1, _conn.createArrayOf("text", in));
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    String out[][] = (String[][]) arr.getArray();
    Assert.assertEquals(2, out.length);
    Assert.assertEquals(2, out[0].length);
    Assert.assertEquals("a", out[0][0]);
    Assert.assertEquals("", out[0][1]);
    Assert.assertEquals("\\", out[1][0]);
    Assert.assertEquals("\"\\'z", out[1][1]);
}

24. ArrayTest#testCreateArrayOfInt()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCreateArrayOfInt() throws SQLException {
    PreparedStatement pstmt = _conn.prepareStatement("SELECT ?::int[]");
    Integer in[] = new Integer[3];
    in[0] = 0;
    in[1] = -1;
    in[2] = 2;
    pstmt.setArray(1, _conn.createArrayOf("int4", in));
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Integer out[] = (Integer[]) arr.getArray();
    Assert.assertEquals(3, out.length);
    Assert.assertEquals(0, out[0].intValue());
    Assert.assertEquals(-1, out[1].intValue());
    Assert.assertEquals(2, out[2].intValue());
}

25. CompositeTest#testNullArrayElement()

Project: pgjdbc
File: CompositeTest.java
public void testNullArrayElement() throws SQLException {
    PreparedStatement pstmt = _conn.prepareStatement("SELECT array[NULL, NULL]::compositetabletest[]");
    ResultSet rs = pstmt.executeQuery();
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    assertEquals("compositetabletest", arr.getBaseTypeName());
    Object[] items = (Object[]) arr.getArray();
    assertEquals(2, items.length);
    assertNull(items[0]);
    assertNull(items[1]);
}

26. CallableStmtTest#testGetArray()

Project: pgjdbc
File: CallableStmtTest.java
public void testGetArray() throws SQLException {
    CallableStatement call = con.prepareCall(func + pkgName + "getarray()}");
    call.registerOutParameter(1, Types.ARRAY);
    call.execute();
    Array arr = call.getArray(1);
    ResultSet rs = arr.getResultSet();
    assertTrue(rs.next());
    assertEquals(1, rs.getInt(1));
    assertTrue(rs.next());
    assertEquals(2, rs.getInt(1));
    assertTrue(!rs.next());
}

27. ArrayTest#testNonStandardDelimiter()

Project: pgjdbc
File: ArrayTest.java
/*
   * The box data type uses a semicolon as the array element delimiter instead of a comma which
   * pretty much everything else uses.
   */
@Test
public void testNonStandardDelimiter() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{(3,4),(1,2);(7,8),(5,6)}'::box[]");
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    ResultSet arrRS = arr.getResultSet();
    Assert.assertTrue(arrRS.next());
    PGbox box1 = (PGbox) arrRS.getObject(2);
    PGpoint p1 = box1.point[0];
    Assert.assertEquals(3, p1.x, 0.001);
    Assert.assertEquals(4, p1.y, 0.001);
    Assert.assertTrue(arrRS.next());
    PGbox box2 = (PGbox) arrRS.getObject(2);
    PGpoint p2 = box2.point[1];
    Assert.assertEquals(5, p2.x, 0.001);
    Assert.assertEquals(6, p2.y, 0.001);
    Assert.assertTrue(!arrRS.next());
}

28. ArrayTest#testWriteMultiDimensional()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testWriteMultiDimensional() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    rs.close();
    stmt.close();
    String sql = "SELECT ?";
    if (TestUtil.isProtocolVersion(conn, 2)) {
        sql = "SELECT ?::int[]";
    }
    PreparedStatement pstmt = conn.prepareStatement(sql);
    pstmt.setArray(1, arr);
    rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    arr = rs.getArray(1);
    Integer i[][] = (Integer[][]) arr.getArray();
    Assert.assertEquals(1, i[0][0].intValue());
    Assert.assertEquals(2, i[0][1].intValue());
    Assert.assertEquals(3, i[1][0].intValue());
    Assert.assertEquals(4, i[1][1].intValue());
}

29. ArrayTest#testNullString()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testNullString() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{a,NULL}'::text[]");
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    String s[] = (String[]) arr.getArray();
    Assert.assertEquals(2, s.length);
    Assert.assertEquals("a", s[0]);
    if (TestUtil.haveMinimumServerVersion(conn, "8.2")) {
        Assert.assertNull(s[1]);
    } else {
        Assert.assertEquals("NULL", s[1]);
    }
}

30. ArrayTest#testUnknownArrayType()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testUnknownArrayType() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT relacl FROM pg_class WHERE relacl IS NOT NULL LIMIT 1");
    ResultSetMetaData rsmd = rs.getMetaData();
    Assert.assertEquals(Types.ARRAY, rsmd.getColumnType(1));
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Assert.assertEquals("aclitem", arr.getBaseTypeName());
    ResultSet arrRS = arr.getResultSet();
    ResultSetMetaData arrRSMD = arrRS.getMetaData();
    Assert.assertEquals("aclitem", arrRSMD.getColumnTypeName(2));
}

31. ArrayTest#testNullValues()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testNullValues() throws SQLException {
    if (!TestUtil.haveMinimumServerVersion(conn, "8.2")) {
        return;
    }
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT ARRAY[1,NULL,3]");
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Integer i[] = (Integer[]) arr.getArray();
    Assert.assertEquals(3, i.length);
    Assert.assertEquals(1, i[0].intValue());
    Assert.assertNull(i[1]);
    Assert.assertEquals(3, i[2].intValue());
}

32. ArrayTest#testMultiDimensionalArray()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testMultiDimensionalArray() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Object oa[] = (Object[]) arr.getArray();
    Assert.assertEquals(2, oa.length);
    Integer i0[] = (Integer[]) oa[0];
    Assert.assertEquals(2, i0.length);
    Assert.assertEquals(1, i0[0].intValue());
    Assert.assertEquals(2, i0[1].intValue());
    Integer i1[] = (Integer[]) oa[1];
    Assert.assertEquals(2, i1.length);
    Assert.assertEquals(3, i1[0].intValue());
    Assert.assertEquals(4, i1[1].intValue());
    rs.close();
    stmt.close();
}

33. ArrayTest#testNonStandardBounds()

Project: pgjdbc
File: ArrayTest.java
/**
   * Starting with 8.0 non-standard (beginning index isn't 1) bounds the dimensions are returned in
   * the data. The following should return "[0:3]={0,1,2,3,4}" when queried. Older versions simply
   * do not return the bounds.
   */
@Test
public void testNonStandardBounds() throws SQLException {
    Statement stmt = conn.createStatement();
    stmt.executeUpdate("INSERT INTO arrtest (intarr) VALUES ('{1,2,3}')");
    stmt.executeUpdate("UPDATE arrtest SET intarr[0] = 0");
    ResultSet rs = stmt.executeQuery("SELECT intarr FROM arrtest");
    Assert.assertTrue(rs.next());
    Array result = rs.getArray(1);
    Integer intarr[] = (Integer[]) result.getArray();
    Assert.assertEquals(4, intarr.length);
    for (int i = 0; i < intarr.length; i++) {
        Assert.assertEquals(i, intarr[i].intValue());
    }
}

34. OracleAvroGenericEventFactory#getJdbcArray()

Project: databus
File: OracleAvroGenericEventFactory.java
private static Array getJdbcArray(ResultSet rs, Schema schema) throws EventCreationException {
    // fails if schema isn't for array type
    Schema elementSchema = schema.getElementType();
    String dbFieldName = SchemaHelper.getMetaField(elementSchema, "dbFieldName");
    if (dbFieldName == null) {
        throw new EventCreationException("array field is missing required metadata dbFieldName. " + schema.getName());
    }
    Array array;
    try {
        array = rs.getArray(dbFieldName);
    } catch (SQLException e) {
        throw new EventCreationException("unable to read array field: " + dbFieldName + ": " + e.getMessage(), e);
    }
    return array;
}

35. ConnectionHandle#createArrayOf()

Project: bonecp
File: ConnectionHandle.java
public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
    Array result = null;
    checkClosed();
    try {
        result = this.connection.createArrayOf(typeName, elements);
    } catch (SQLException e) {
        throw markPossiblyBroken(e);
    }
    return result;
}

36. ArrayTest#testEscaping()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testEscaping() throws SQLException {
    Statement stmt = conn.createStatement();
    String sql = "SELECT E'{{c\\\\\"d, ''}, {\"\\\\\\\\\",\"''\"}}'::text[]";
    ResultSet rs = stmt.executeQuery(sql);
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    String[][] s = (String[][]) arr.getArray();
    assertEquals("c\"d", s[0][0]);
    assertEquals("'", s[0][1]);
    assertEquals("\\", s[1][0]);
    assertEquals("'", s[1][1]);
    ResultSet arrRS = arr.getResultSet();
    assertTrue(arrRS.next());
    Array a1 = arrRS.getArray(2);
    ResultSet rs1 = a1.getResultSet();
    assertTrue(rs1.next());
    assertEquals("c\"d", rs1.getString(2));
    assertTrue(rs1.next());
    assertEquals("'", rs1.getString(2));
    assertTrue(!rs1.next());
    assertTrue(arrRS.next());
    Array a2 = arrRS.getArray(2);
    ResultSet rs2 = a2.getResultSet();
    assertTrue(rs2.next());
    assertEquals("\\", rs2.getString(2));
    assertTrue(rs2.next());
    assertEquals("'", rs2.getString(2));
    assertTrue(!rs2.next());
}

37. ArrayTest#testRecursiveResultSets()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testRecursiveResultSets() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    ResultSet arrRS = arr.getResultSet();
    ResultSetMetaData arrRSMD = arrRS.getMetaData();
    assertEquals(Types.ARRAY, arrRSMD.getColumnType(2));
    assertEquals("_int4", arrRSMD.getColumnTypeName(2));
    assertTrue(arrRS.next());
    assertEquals(1, arrRS.getInt(1));
    Array a1 = arrRS.getArray(2);
    ResultSet a1RS = a1.getResultSet();
    ResultSetMetaData a1RSMD = a1RS.getMetaData();
    assertEquals(Types.INTEGER, a1RSMD.getColumnType(2));
    assertEquals("int4", a1RSMD.getColumnTypeName(2));
    assertTrue(a1RS.next());
    assertEquals(1, a1RS.getInt(2));
    assertTrue(a1RS.next());
    assertEquals(2, a1RS.getInt(2));
    assertTrue(!a1RS.next());
    a1RS.close();
    assertTrue(arrRS.next());
    assertEquals(2, arrRS.getInt(1));
    Array a2 = arrRS.getArray(2);
    ResultSet a2RS = a2.getResultSet();
    assertTrue(a2RS.next());
    assertEquals(3, a2RS.getInt(2));
    assertTrue(a2RS.next());
    assertEquals(4, a2RS.getInt(2));
    assertTrue(!a2RS.next());
    a2RS.close();
    arrRS.close();
    rs.close();
    stmt.close();
}

38. ArrayTest#testEscaping()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testEscaping() throws SQLException {
    Statement stmt = conn.createStatement();
    String sql = "SELECT ";
    if (TestUtil.haveMinimumServerVersion(conn, "8.1")) {
        sql += 'E';
    }
    // Uggg. Three levels of escaping: Java, string literal, array.
    sql += "'{{c\\\\\"d, ''}, {\"\\\\\\\\\",\"''\"}}'::text[]";
    ResultSet rs = stmt.executeQuery(sql);
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    String s[][] = (String[][]) arr.getArray();
    Assert.assertEquals("c\"d", s[0][0]);
    Assert.assertEquals("'", s[0][1]);
    Assert.assertEquals("\\", s[1][0]);
    Assert.assertEquals("'", s[1][1]);
    ResultSet arrRS = arr.getResultSet();
    Assert.assertTrue(arrRS.next());
    Array a1 = arrRS.getArray(2);
    ResultSet rs1 = a1.getResultSet();
    Assert.assertTrue(rs1.next());
    Assert.assertEquals("c\"d", rs1.getString(2));
    Assert.assertTrue(rs1.next());
    Assert.assertEquals("'", rs1.getString(2));
    Assert.assertTrue(!rs1.next());
    Assert.assertTrue(arrRS.next());
    Array a2 = arrRS.getArray(2);
    ResultSet rs2 = a2.getResultSet();
    Assert.assertTrue(rs2.next());
    Assert.assertEquals("\\", rs2.getString(2));
    Assert.assertTrue(rs2.next());
    Assert.assertEquals("'", rs2.getString(2));
    Assert.assertTrue(!rs2.next());
}

39. ArrayTest#testRecursiveResultSets()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testRecursiveResultSets() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT '{{1,2},{3,4}}'::int[]");
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    ResultSet arrRS = arr.getResultSet();
    ResultSetMetaData arrRSMD = arrRS.getMetaData();
    Assert.assertEquals(Types.ARRAY, arrRSMD.getColumnType(2));
    Assert.assertEquals("_int4", arrRSMD.getColumnTypeName(2));
    Assert.assertTrue(arrRS.next());
    Assert.assertEquals(1, arrRS.getInt(1));
    Array a1 = arrRS.getArray(2);
    ResultSet a1RS = a1.getResultSet();
    ResultSetMetaData a1RSMD = a1RS.getMetaData();
    Assert.assertEquals(Types.INTEGER, a1RSMD.getColumnType(2));
    Assert.assertEquals("int4", a1RSMD.getColumnTypeName(2));
    Assert.assertTrue(a1RS.next());
    Assert.assertEquals(1, a1RS.getInt(2));
    Assert.assertTrue(a1RS.next());
    Assert.assertEquals(2, a1RS.getInt(2));
    Assert.assertTrue(!a1RS.next());
    a1RS.close();
    Assert.assertTrue(arrRS.next());
    Assert.assertEquals(2, arrRS.getInt(1));
    Array a2 = arrRS.getArray(2);
    ResultSet a2RS = a2.getResultSet();
    Assert.assertTrue(a2RS.next());
    Assert.assertEquals(3, a2RS.getInt(2));
    Assert.assertTrue(a2RS.next());
    Assert.assertEquals(4, a2RS.getInt(2));
    Assert.assertTrue(!a2RS.next());
    a2RS.close();
    arrRS.close();
    rs.close();
    stmt.close();
}

40. TestResultSet#testArray()

Project: ThriftyPaxos
File: TestResultSet.java
private void testArray() throws SQLException {
    trace("Test ARRAY");
    ResultSet rs;
    stat.execute("CREATE TABLE TEST(ID INT PRIMARY KEY, VALUE ARRAY)");
    PreparedStatement prep = conn.prepareStatement("INSERT INTO TEST VALUES(?, ?)");
    prep.setInt(1, 1);
    prep.setObject(2, new Object[] { new Integer(1), new Integer(2) });
    prep.execute();
    prep.setInt(1, 2);
    prep.setObject(2, new Object[] { 11, 12 });
    prep.execute();
    prep.close();
    rs = stat.executeQuery("SELECT * FROM TEST ORDER BY ID");
    rs.next();
    assertEquals(1, rs.getInt(1));
    Object[] list = (Object[]) rs.getObject(2);
    assertEquals(1, ((Integer) list[0]).intValue());
    assertEquals(2, ((Integer) list[1]).intValue());
    Array array = rs.getArray(2);
    Object[] list2 = (Object[]) array.getArray();
    assertEquals(1, ((Integer) list2[0]).intValue());
    assertEquals(2, ((Integer) list2[1]).intValue());
    list2 = (Object[]) array.getArray(2, 1);
    assertEquals(2, ((Integer) list2[0]).intValue());
    rs.next();
    assertEquals(2, rs.getInt(1));
    list = (Object[]) rs.getObject(2);
    assertEquals(11, ((Integer) list[0]).intValue());
    assertEquals(12, ((Integer) list[1]).intValue());
    array = rs.getArray("VALUE");
    list2 = (Object[]) array.getArray();
    assertEquals(11, ((Integer) list2[0]).intValue());
    assertEquals(12, ((Integer) list2[1]).intValue());
    list2 = (Object[]) array.getArray(2, 1);
    assertEquals(12, ((Integer) list2[0]).intValue());
    list2 = (Object[]) array.getArray(Collections.<String, Class<?>>emptyMap());
    assertEquals(11, ((Integer) list2[0]).intValue());
    assertEquals(Types.NULL, array.getBaseType());
    assertEquals("NULL", array.getBaseTypeName());
    assertTrue(array.toString().endsWith(": (11, 12)"));
    // free
    array.free();
    assertEquals("null", array.toString());
    assertThrows(ErrorCode.OBJECT_CLOSED, array).getBaseType();
    assertThrows(ErrorCode.OBJECT_CLOSED, array).getBaseTypeName();
    assertThrows(ErrorCode.OBJECT_CLOSED, array).getResultSet();
    assertFalse(rs.next());
    stat.execute("DROP TABLE TEST");
}

41. ArrayCast#toCFType()

Project: railo
File: ArrayCast.java
@Override
public Object toCFType(TimeZone tz, int type, ResultSet rst, int columnIndex) throws SQLException, IOException {
    Array arr = rst.getArray(columnIndex);
    if (arr == null)
        return null;
    return arr.getArray();
}

42. CompositeTest#testCompositeFromTable()

Project: pgjdbc
File: CompositeTest.java
public void testCompositeFromTable() throws SQLException {
    PreparedStatement pstmt = _conn.prepareStatement("INSERT INTO compositetabletest VALUES(?, ?)");
    PGobject pgo1 = new PGobject();
    pgo1.setType("public.simplecompositetest");
    pgo1.setValue("(1,2.2,)");
    pstmt.setObject(1, pgo1);
    String[] ctArr = new String[1];
    ctArr[0] = "(\"{1,2}\",{},\"(1,2.2,)\")";
    Array pgarr1 = _conn.createArrayOf("\"Composites\".\"ComplexCompositeTest\"", ctArr);
    pstmt.setArray(2, pgarr1);
    int res = pstmt.executeUpdate();
    assertEquals(1, res);
    pstmt = _conn.prepareStatement("SELECT * FROM compositetabletest");
    ResultSet rs = pstmt.executeQuery();
    assertTrue(rs.next());
    PGobject pgo2 = (PGobject) rs.getObject(1);
    Array pgarr2 = (Array) rs.getObject(2);
    assertEquals("public.simplecompositetest", pgo2.getType());
    assertEquals("\"Composites\".\"ComplexCompositeTest\"", pgarr2.getBaseTypeName());
    Object[] pgobjarr2 = (Object[]) pgarr2.getArray();
    assertEquals(1, pgobjarr2.length);
    PGobject arr2Elem = (PGobject) pgobjarr2[0];
    assertEquals("\"Composites\".\"ComplexCompositeTest\"", arr2Elem.getType());
    assertEquals("(\"{1,2}\",{},\"(1,2.2,)\")", arr2Elem.getValue());
    rs.close();
    pstmt = _conn.prepareStatement("SELECT c FROM compositetabletest c");
    rs = pstmt.executeQuery();
    assertTrue(rs.next());
    PGobject pgo3 = (PGobject) rs.getObject(1);
    assertEquals("compositetabletest", pgo3.getType());
    assertEquals("(\"(1,2.2,)\",\"{\"\"(\\\\\"\"{1,2}\\\\\"\",{},\\\\\"\"(1,2.2,)\\\\\"\")\"\"}\")", pgo3.getValue());
}

43. SQLInputImplTests#test06()

Project: openjdk
File: SQLInputImplTests.java
/*
     * Validate a Array can be read
     */
@Test(enabled = true)
public void test06() throws Exception {
    Object[] coffees = new Object[] { "Espresso", "Colombian", "French Roast", "Cappuccino" };
    Array a = new StubArray("VARCHAR", coffees);
    Object[] values = { a };
    SQLInputImpl sqli = new SQLInputImpl(values, map);
    Array a2 = sqli.readArray();
    assertTrue(Arrays.equals((Object[]) a2.getArray(), (Object[]) a.getArray()));
    assertTrue(a.getBaseTypeName().equals(a2.getBaseTypeName()));
}

44. UpdateableResultTest#testArray()

Project: pgjdbc-ng
File: UpdateableResultTest.java
@Test
public void testArray() throws SQLException {
    Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
    stmt.executeUpdate("INSERT INTO updateable (id, intarr) VALUES (1, '{1,2,3}'::int4[])");
    ResultSet rs = stmt.executeQuery("SELECT id, intarr FROM updateable");
    assertTrue(rs.next());
    rs.updateObject(2, rs.getArray(2));
    rs.updateRow();
    Array arr = rs.getArray(2);
    assertEquals(Types.INTEGER, arr.getBaseType());
    Integer[] intarr = (Integer[]) arr.getArray();
    assertEquals(3, intarr.length);
    assertEquals(1, intarr[0].intValue());
    assertEquals(2, intarr[1].intValue());
    assertEquals(3, intarr[2].intValue());
    rs.close();
    rs = stmt.executeQuery("SELECT id,intarr FROM updateable");
    assertTrue(rs.next());
    arr = rs.getArray(2);
    assertEquals(Types.INTEGER, arr.getBaseType());
    intarr = (Integer[]) arr.getArray();
    assertEquals(3, intarr.length);
    assertEquals(1, intarr[0].intValue());
    assertEquals(2, intarr[1].intValue());
    assertEquals(3, intarr[2].intValue());
    rs.close();
    stmt.close();
}

45. ArrayTest#testSetObjectFromJavaArray()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testSetObjectFromJavaArray() throws SQLException {
    String[] strArray = new String[] { "a", "b", "c" };
    PreparedStatement pstmt = conn.prepareStatement("INSERT INTO arrtest(strarr) VALUES (?)");
    // Correct way, though the use of "text" as a type is non-portable.
    // Only supported for JDK 1.6 and JDBC4
    Array sqlArray = conn.createArrayOf("text", strArray);
    pstmt.setArray(1, sqlArray);
    pstmt.executeUpdate();
    /*
     * The original driver reasons these 2 tests should fail but we support
     * them; and supporting them doesn't cause any JDBC spec invalidation.
     */
    // Incorrect, but commonly attempted by many ORMs:
    pstmt.setObject(1, strArray, Types.ARRAY);
    pstmt.executeUpdate();
    // Also incorrect, but commonly attempted by many ORMs:
    pstmt.setObject(1, strArray);
    pstmt.executeUpdate();
    pstmt.close();
}

46. ArrayTest#testSetArray()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testSetArray() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet arrRS = stmt.executeQuery("SELECT '{1,2,3}'::int4[]");
    assertTrue(arrRS.next());
    Array arr = arrRS.getArray(1);
    arrRS.close();
    stmt.close();
    PreparedStatement pstmt = conn.prepareStatement("INSERT INTO arrtest(intarr) VALUES (?)");
    pstmt.setArray(1, arr);
    pstmt.executeUpdate();
    pstmt.setObject(1, arr, Types.ARRAY);
    pstmt.executeUpdate();
    pstmt.setObject(1, arr);
    pstmt.executeUpdate();
    pstmt.close();
    Statement select = conn.createStatement();
    ResultSet rs = select.executeQuery("SELECT intarr FROM arrtest");
    int resultCount = 0;
    while (rs.next()) {
        resultCount++;
        Array result = rs.getArray(1);
        assertEquals(Types.INTEGER, result.getBaseType());
        assertEquals("int4", result.getBaseTypeName());
        Integer[] intarr = (Integer[]) result.getArray();
        assertEquals(3, intarr.length);
        assertEquals(1, intarr[0].intValue());
        assertEquals(2, intarr[1].intValue());
        assertEquals(3, intarr[2].intValue());
    }
    assertEquals(3, resultCount);
}

47. ArrayTest#testRetrieveResultSets()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testRetrieveResultSets() throws SQLException {
    Statement stmt = conn.createStatement();
    // you need a lot of backslashes to get a double quote in.
    stmt.executeUpdate("INSERT INTO arrtest VALUES ('{1,2,3}','{3.1,1.4}', '{abc,f''a,fa\\\"b,def}')");
    ResultSet rs = stmt.executeQuery("SELECT intarr, decarr, strarr FROM arrtest");
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    assertEquals(Types.INTEGER, arr.getBaseType());
    ResultSet arrrs = arr.getResultSet();
    assertTrue(arrrs.next());
    assertEquals(1, arrrs.getInt(1));
    assertEquals(1, arrrs.getInt(2));
    assertTrue(arrrs.next());
    assertEquals(2, arrrs.getInt(1));
    assertEquals(2, arrrs.getInt(2));
    assertTrue(arrrs.next());
    assertEquals(3, arrrs.getInt(1));
    assertEquals(3, arrrs.getInt(2));
    assertTrue(!arrrs.next());
    assertTrue(arrrs.previous());
    assertEquals(3, arrrs.getInt(2));
    arrrs.first();
    assertEquals(1, arrrs.getInt(2));
    arrrs.close();
    arr = rs.getArray(2);
    assertEquals(Types.NUMERIC, arr.getBaseType());
    arrrs = arr.getResultSet();
    assertTrue(arrrs.next());
    assertEquals(new BigDecimal("3.1"), arrrs.getBigDecimal(2));
    assertTrue(arrrs.next());
    assertEquals(new BigDecimal("1.4"), arrrs.getBigDecimal(2));
    arrrs.close();
    arr = rs.getArray(3);
    assertEquals(Types.VARCHAR, arr.getBaseType());
    arrrs = arr.getResultSet(2, 2);
    assertTrue(arrrs.next());
    assertEquals(2, arrrs.getInt(1));
    assertEquals("f'a", arrrs.getString(2));
    assertTrue(arrrs.next());
    assertEquals(3, arrrs.getInt(1));
    assertEquals("fa\"b", arrrs.getString(2));
    assertTrue(!arrrs.next());
    arrrs.close();
    rs.close();
    stmt.close();
}

48. ArrayTest#testRetrieveArrays()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testRetrieveArrays() throws SQLException {
    Statement stmt = conn.createStatement();
    // you need a lot of backslashes to get a double quote in.
    stmt.executeUpdate("INSERT INTO arrtest VALUES ('{1,2,3}','{3.1,1.4}', '{abc,f''a,fa\\\"b,def}')");
    ResultSet rs = stmt.executeQuery("SELECT intarr, decarr, strarr FROM arrtest");
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    assertEquals(Types.INTEGER, arr.getBaseType());
    Integer[] intarr = (Integer[]) arr.getArray();
    assertEquals(3, intarr.length);
    assertEquals(1, intarr[0].intValue());
    assertEquals(2, intarr[1].intValue());
    assertEquals(3, intarr[2].intValue());
    arr = rs.getArray(2);
    assertEquals(Types.NUMERIC, arr.getBaseType());
    BigDecimal[] decarr = (BigDecimal[]) arr.getArray();
    assertEquals(2, decarr.length);
    assertEquals(new BigDecimal("3.1"), decarr[0]);
    assertEquals(new BigDecimal("1.4"), decarr[1]);
    arr = rs.getArray(3);
    assertEquals(Types.VARCHAR, arr.getBaseType());
    String[] strarr = (String[]) arr.getArray(2, 2);
    assertEquals(2, strarr.length);
    assertEquals("f'a", strarr[0]);
    assertEquals("fa\"b", strarr[1]);
    rs.close();
    stmt.close();
}

49. ArrayTest#testSendRecvMultiple()

Project: pgjdbc-ng
File: ArrayTest.java
@Test
public void testSendRecvMultiple() throws SQLException {
    PreparedStatement ps = conn.prepareStatement("SELECT ?::int[], ?::decimal(2,1)[], ?::text[]");
    ps.setObject(1, new Integer[] { 1, 2, 3 });
    ps.setObject(2, new Float[] { 3.1f, 1.4f });
    ps.setObject(3, new String[] { "abc", "def" });
    ResultSet rs = ps.executeQuery();
    assertTrue(rs.next());
    Array arr = rs.getArray(1);
    assertEquals(Types.INTEGER, arr.getBaseType());
    Integer[] intarr = (Integer[]) arr.getArray();
    assertEquals(3, intarr.length);
    assertEquals(1, intarr[0].intValue());
    assertEquals(2, intarr[1].intValue());
    assertEquals(3, intarr[2].intValue());
    arr = rs.getArray(2);
    assertEquals(Types.NUMERIC, arr.getBaseType());
    BigDecimal[] decarr = (BigDecimal[]) arr.getArray();
    assertEquals(2, decarr.length);
    assertEquals(new BigDecimal("3.1"), decarr[0]);
    assertEquals(new BigDecimal("1.4"), decarr[1]);
    arr = rs.getArray(3);
    assertEquals(Types.VARCHAR, arr.getBaseType());
    String[] strarr = (String[]) arr.getArray();
    assertEquals("abc", strarr[0]);
    assertEquals("def", strarr[1]);
}

50. ArrayTest#createNullArray()

Project: pgjdbc
File: ArrayTest.java
@Test(expected = NullPointerException.class)
public void createNullArray() throws SQLException {
    Array arr = con.createArrayOf("float8", null);
    Assert.fail("createArrayOf(float8, null) should fail with NPE");
}

51. ArrayTest#testToString()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testToString() throws SQLException {
    Double[] d = new Double[4];
    d[0] = 3.5;
    d[1] = -4.5;
    d[2] = null;
    d[3] = 77.0;
    Array arr = con.createArrayOf("float8", d);
    PreparedStatement pstmt = con.prepareStatement("INSERT INTO arrtest(floatarr) VALUES (?)");
    ResultSet rs = null;
    try {
        pstmt.setArray(1, arr);
        pstmt.execute();
    } finally {
        TestUtil.closeQuietly(pstmt);
    }
    Statement stmt = null;
    try {
        stmt = con.createStatement();
        rs = stmt.executeQuery("select floatarr from arrtest");
        while (rs.next()) {
            Array doubles = rs.getArray(1);
            String actual = doubles.toString();
            if (actual != null) {
                // Remove all double quotes. They do not make a difference here.
                actual = actual.replaceAll("\"", "");
                // Replace X.0 with just X
                actual = actual.replaceAll("\\.0+([^0-9])", "$1");
            }
            Assert.assertEquals("Array.toString should use square braces", "{3.5,-4.5,NULL,77}", actual);
        }
    } finally {
        TestUtil.closeQuietly(rs);
        TestUtil.closeQuietly(stmt);
    }
}

52. ArrayTest#testGetArrayOfComposites()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testGetArrayOfComposites() throws SQLException {
    PreparedStatement insert_parent_pstmt = _conn.prepareStatement("INSERT INTO arrcompprnttest (name) " + "VALUES ('aParent');");
    insert_parent_pstmt.execute();
    String[] children = { "November 5, 2013", "\"A Book Title\"", "4\" by 6\"", "5\",3\"" };
    PreparedStatement insert_children_pstmt = _conn.prepareStatement("INSERT INTO arrcompchldttest (name,description,parent) " + "VALUES ('child1',?,1)," + "('child2',?,1)," + "('child3',?,1)," + "('child4',?,1);");
    insert_children_pstmt.setString(1, children[0]);
    insert_children_pstmt.setString(2, children[1]);
    insert_children_pstmt.setString(3, children[2]);
    insert_children_pstmt.setString(4, children[3]);
    insert_children_pstmt.execute();
    PreparedStatement pstmt = _conn.prepareStatement("SELECT arrcompprnttest.name, " + "array_agg(" + "DISTINCT(arrcompchldttest.id, " + "arrcompchldttest.name, " + "arrcompchldttest.description)) " + "AS children " + "FROM arrcompprnttest " + "LEFT JOIN arrcompchldttest " + "ON (arrcompchldttest.parent = arrcompprnttest.id) " + "WHERE arrcompprnttest.id=? " + "GROUP BY arrcompprnttest.name;");
    pstmt.setInt(1, 1);
    ResultSet rs = pstmt.executeQuery();
    Assert.assertNotNull(rs);
    Assert.assertTrue(rs.next());
    Array childrenArray = rs.getArray("children");
    Assert.assertNotNull(childrenArray);
    ResultSet rsChildren = childrenArray.getResultSet();
    Assert.assertNotNull(rsChildren);
    while (rsChildren.next()) {
        String comp = rsChildren.getString(2);
        PGtokenizer token = new PGtokenizer(PGtokenizer.removePara(comp), ',');
        // remove surrounding double quotes
        token.remove("\"", "\"");
        if (2 < token.getSize()) {
            int childID = Integer.parseInt(token.getToken(0));
            // remove double quotes escaping with double quotes
            String value = token.getToken(2).replace("\"\"", "\"");
            Assert.assertEquals(children[childID - 1], value);
        } else {
            Assert.fail("Needs to have 3 tokens");
        }
    }
}

53. ArrayTest#testSetObjectFromJavaArray()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testSetObjectFromJavaArray() throws SQLException {
    String[] strArray = new String[] { "a", "b", "c" };
    PreparedStatement pstmt = _conn.prepareStatement("INSERT INTO arrtest(strarr) VALUES (?)");
    // Incorrect, but commonly attempted by many ORMs:
    try {
        pstmt.setObject(1, strArray, Types.ARRAY);
        pstmt.executeUpdate();
        Assert.fail("setObject() with a Java array parameter and Types.ARRAY shouldn't succeed");
    } catch (org.postgresql.util.PSQLException ex) {
    }
    // Also incorrect, but commonly attempted by many ORMs:
    try {
        pstmt.setObject(1, strArray);
        pstmt.executeUpdate();
        Assert.fail("setObject() with a Java array parameter and no Types argument shouldn't succeed");
    } catch (org.postgresql.util.PSQLException ex) {
    }
    // Correct way, though the use of "text" as a type is non-portable.
    // Only supported for JDK 1.6 and JDBC4
    Array sqlArray = _conn.createArrayOf("text", strArray);
    pstmt.setArray(1, sqlArray);
    pstmt.executeUpdate();
    pstmt.close();
}

54. ArrayTest#testUUIDArray()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testUUIDArray() throws SQLException {
    UUID uuid1 = UUID.randomUUID();
    UUID uuid2 = UUID.randomUUID();
    UUID uuid3 = UUID.randomUUID();
    // insert a uuid array, and check
    PreparedStatement pstmt1 = _conn.prepareStatement("INSERT INTO arrtest(uuidarr) VALUES (?)");
    pstmt1.setArray(1, _conn.createArrayOf("uuid", new UUID[] { uuid1, uuid2, uuid3 }));
    pstmt1.executeUpdate();
    PreparedStatement pstmt2 = _conn.prepareStatement("SELECT uuidarr FROM arrtest WHERE uuidarr @> ?");
    pstmt2.setObject(1, _conn.createArrayOf("uuid", new UUID[] { uuid1 }), Types.OTHER);
    ResultSet rs = pstmt2.executeQuery();
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    UUID out[] = (UUID[]) arr.getArray();
    Assert.assertEquals(3, out.length);
    Assert.assertEquals(uuid1, out[0]);
    Assert.assertEquals(uuid2, out[1]);
    Assert.assertEquals(uuid3, out[2]);
    // concatenate a uuid, and check
    UUID uuid4 = UUID.randomUUID();
    PreparedStatement pstmt3 = _conn.prepareStatement("UPDATE arrtest SET uuidarr = uuidarr || ? WHERE uuidarr @> ?");
    pstmt3.setObject(1, uuid4, Types.OTHER);
    pstmt3.setArray(2, _conn.createArrayOf("uuid", new UUID[] { uuid1 }));
    pstmt3.executeUpdate();
    // --
    pstmt2.setObject(1, _conn.createArrayOf("uuid", new UUID[] { uuid4 }), Types.OTHER);
    rs = pstmt2.executeQuery();
    Assert.assertTrue(rs.next());
    arr = rs.getArray(1);
    out = (UUID[]) arr.getArray();
    Assert.assertEquals(4, out.length);
    Assert.assertEquals(uuid1, out[0]);
    Assert.assertEquals(uuid2, out[1]);
    Assert.assertEquals(uuid3, out[2]);
    Assert.assertEquals(uuid4, out[3]);
}

55. ArrayTest#testCreateArrayOfNull()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testCreateArrayOfNull() throws SQLException {
    if (!TestUtil.haveMinimumServerVersion(_conn, "8.2")) {
        return;
    }
    String sql = "SELECT ?";
    // We must provide the type information for V2 protocol
    if (TestUtil.isProtocolVersion(_conn, 2)) {
        sql = "SELECT ?::int8[]";
    }
    PreparedStatement pstmt = _conn.prepareStatement(sql);
    String in[] = new String[2];
    in[0] = null;
    in[1] = null;
    pstmt.setArray(1, _conn.createArrayOf("int8", in));
    ResultSet rs = pstmt.executeQuery();
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Long out[] = (Long[]) arr.getArray();
    Assert.assertEquals(2, out.length);
    Assert.assertNull(out[0]);
    Assert.assertNull(out[1]);
}

56. UpdateableResultTest#testArray()

Project: pgjdbc
File: UpdateableResultTest.java
public void testArray() throws SQLException {
    Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
    stmt.executeUpdate("INSERT INTO updateable (id, intarr) VALUES (1, '{1,2,3}'::int4[])");
    ResultSet rs = stmt.executeQuery("SELECT id, intarr FROM updateable");
    assertTrue(rs.next());
    rs.updateObject(2, rs.getArray(2));
    rs.updateRow();
    Array arr = rs.getArray(2);
    assertEquals(Types.INTEGER, arr.getBaseType());
    Integer intarr[] = (Integer[]) arr.getArray();
    assertEquals(3, intarr.length);
    assertEquals(1, intarr[0].intValue());
    assertEquals(2, intarr[1].intValue());
    assertEquals(3, intarr[2].intValue());
    rs.close();
    rs = stmt.executeQuery("SELECT id,intarr FROM updateable");
    assertTrue(rs.next());
    arr = rs.getArray(2);
    assertEquals(Types.INTEGER, arr.getBaseType());
    intarr = (Integer[]) arr.getArray();
    assertEquals(3, intarr.length);
    assertEquals(1, intarr[0].intValue());
    assertEquals(2, intarr[1].intValue());
    assertEquals(3, intarr[2].intValue());
    rs.close();
    stmt.close();
}

57. ArrayTest#testNullFieldString()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testNullFieldString() throws SQLException {
    Array arr = new PgArray((BaseConnection) conn, 1, (String) null);
    Assert.assertNull(arr.toString());
}

58. ArrayTest#testSetArray()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testSetArray() throws SQLException {
    Statement stmt = conn.createStatement();
    ResultSet arrRS = stmt.executeQuery("SELECT '{1,2,3}'::int4[]");
    Assert.assertTrue(arrRS.next());
    Array arr = arrRS.getArray(1);
    arrRS.close();
    stmt.close();
    PreparedStatement pstmt = conn.prepareStatement("INSERT INTO arrtest(intarr) VALUES (?)");
    pstmt.setArray(1, arr);
    pstmt.executeUpdate();
    pstmt.setObject(1, arr, Types.ARRAY);
    pstmt.executeUpdate();
    pstmt.setObject(1, arr);
    pstmt.executeUpdate();
    pstmt.close();
    Statement select = conn.createStatement();
    ResultSet rs = select.executeQuery("SELECT intarr FROM arrtest");
    int resultCount = 0;
    while (rs.next()) {
        resultCount++;
        Array result = rs.getArray(1);
        Assert.assertEquals(Types.INTEGER, result.getBaseType());
        Assert.assertEquals("int4", result.getBaseTypeName());
        Integer intarr[] = (Integer[]) result.getArray();
        Assert.assertEquals(3, intarr.length);
        Assert.assertEquals(1, intarr[0].intValue());
        Assert.assertEquals(2, intarr[1].intValue());
        Assert.assertEquals(3, intarr[2].intValue());
    }
    Assert.assertEquals(3, resultCount);
}

59. ArrayTest#testRetrieveResultSets()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testRetrieveResultSets() throws SQLException {
    Statement stmt = conn.createStatement();
    // you need a lot of backslashes to get a double quote in.
    stmt.executeUpdate("INSERT INTO arrtest VALUES ('{1,2,3}','{3.1,1.4}', '" + TestUtil.escapeString(conn, "{abc,f'a,\"fa\\\"b\",def}") + "')");
    ResultSet rs = stmt.executeQuery("SELECT intarr, decarr, strarr FROM arrtest");
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Assert.assertEquals(Types.INTEGER, arr.getBaseType());
    ResultSet arrrs = arr.getResultSet();
    Assert.assertTrue(arrrs.next());
    Assert.assertEquals(1, arrrs.getInt(1));
    Assert.assertEquals(1, arrrs.getInt(2));
    Assert.assertTrue(arrrs.next());
    Assert.assertEquals(2, arrrs.getInt(1));
    Assert.assertEquals(2, arrrs.getInt(2));
    Assert.assertTrue(arrrs.next());
    Assert.assertEquals(3, arrrs.getInt(1));
    Assert.assertEquals(3, arrrs.getInt(2));
    Assert.assertTrue(!arrrs.next());
    Assert.assertTrue(arrrs.previous());
    Assert.assertEquals(3, arrrs.getInt(2));
    arrrs.first();
    Assert.assertEquals(1, arrrs.getInt(2));
    arrrs.close();
    arr = rs.getArray(2);
    Assert.assertEquals(Types.NUMERIC, arr.getBaseType());
    arrrs = arr.getResultSet();
    Assert.assertTrue(arrrs.next());
    Assert.assertEquals(new BigDecimal("3.1"), arrrs.getBigDecimal(2));
    Assert.assertTrue(arrrs.next());
    Assert.assertEquals(new BigDecimal("1.4"), arrrs.getBigDecimal(2));
    arrrs.close();
    arr = rs.getArray(3);
    Assert.assertEquals(Types.VARCHAR, arr.getBaseType());
    arrrs = arr.getResultSet(2, 2);
    Assert.assertTrue(arrrs.next());
    Assert.assertEquals(2, arrrs.getInt(1));
    Assert.assertEquals("f'a", arrrs.getString(2));
    Assert.assertTrue(arrrs.next());
    Assert.assertEquals(3, arrrs.getInt(1));
    Assert.assertEquals("fa\"b", arrrs.getString(2));
    Assert.assertTrue(!arrrs.next());
    arrrs.close();
    rs.close();
    stmt.close();
}

60. ArrayTest#testRetrieveArrays()

Project: pgjdbc
File: ArrayTest.java
@Test
public void testRetrieveArrays() throws SQLException {
    Statement stmt = conn.createStatement();
    // you need a lot of backslashes to get a double quote in.
    stmt.executeUpdate("INSERT INTO arrtest VALUES ('{1,2,3}','{3.1,1.4}', '" + TestUtil.escapeString(conn, "{abc,f'a,\"fa\\\"b\",def}") + "')");
    ResultSet rs = stmt.executeQuery("SELECT intarr, decarr, strarr FROM arrtest");
    Assert.assertTrue(rs.next());
    Array arr = rs.getArray(1);
    Assert.assertEquals(Types.INTEGER, arr.getBaseType());
    Integer intarr[] = (Integer[]) arr.getArray();
    Assert.assertEquals(3, intarr.length);
    Assert.assertEquals(1, intarr[0].intValue());
    Assert.assertEquals(2, intarr[1].intValue());
    Assert.assertEquals(3, intarr[2].intValue());
    arr = rs.getArray(2);
    Assert.assertEquals(Types.NUMERIC, arr.getBaseType());
    BigDecimal decarr[] = (BigDecimal[]) arr.getArray();
    Assert.assertEquals(2, decarr.length);
    Assert.assertEquals(new BigDecimal("3.1"), decarr[0]);
    Assert.assertEquals(new BigDecimal("1.4"), decarr[1]);
    arr = rs.getArray(3);
    Assert.assertEquals(Types.VARCHAR, arr.getBaseType());
    String strarr[] = (String[]) arr.getArray(2, 2);
    Assert.assertEquals(2, strarr.length);
    Assert.assertEquals("f'a", strarr[0]);
    Assert.assertEquals("fa\"b", strarr[1]);
    rs.close();
    stmt.close();
}

61. SQLOutputImplTests#test04()

Project: openjdk
File: SQLOutputImplTests.java
/*
     * Validate a Array can be written and returned
     */
@Test(enabled = true)
public void test04() throws Exception {
    Object[] coffees = new Object[] { "Espresso", "Colombian", "French Roast", "Cappuccino" };
    Array a = new StubArray("VARCHAR", coffees);
    outImpl.writeArray(a);
    SerialArray sa = (SerialArray) results.get(0);
    assertTrue(Arrays.equals(coffees, (Object[]) sa.getArray()));
    assertTrue(a.getBaseTypeName().equals(sa.getBaseTypeName()));
}

62. CommonCachedRowSetTests#createDataTypesRows()

Project: openjdk
File: CommonCachedRowSetTests.java
/*
     * Add rows to DATAYPES table
     */
protected void createDataTypesRows(RowSet crs) throws SQLException {
    Integer aInteger = 100;
    String aChar = "Oswald Cobblepot";
    Long aLong = Long.MAX_VALUE;
    Short aShort = Short.MAX_VALUE;
    Double aDouble = Double.MAX_VALUE;
    BigDecimal aBigDecimal = BigDecimal.ONE;
    Boolean aBoolean = false;
    Float aFloat = Float.MAX_VALUE;
    Byte aByte = Byte.MAX_VALUE;
    Date aDate = Date.valueOf(LocalDate.now());
    Time aTime = Time.valueOf(LocalTime.now());
    Timestamp aTimeStamp = Timestamp.valueOf(LocalDateTime.now());
    Array aArray = new StubArray("INTEGER", new Object[1]);
    Ref aRef = new SerialRef(new StubRef("INTEGER", query));
    byte[] bytes = new byte[10];
    crs.moveToInsertRow();
    crs.updateInt(1, aInteger);
    crs.updateString(2, aChar);
    crs.updateString(3, aChar);
    crs.updateLong(4, aLong);
    crs.updateBoolean(5, aBoolean);
    crs.updateShort(6, aShort);
    crs.updateDouble(7, aDouble);
    crs.updateBigDecimal(8, aBigDecimal);
    crs.updateFloat(9, aFloat);
    crs.updateByte(10, aByte);
    crs.updateDate(11, aDate);
    crs.updateTime(12, aTime);
    crs.updateTimestamp(13, aTimeStamp);
    crs.updateBytes(14, bytes);
    crs.updateArray(15, aArray);
    crs.updateRef(16, aRef);
    crs.updateDouble(17, aDouble);
    crs.insertRow();
    crs.moveToCurrentRow();
}

63. BaseRowSetTests#testAdvancedParameters()

Project: openjdk
File: BaseRowSetTests.java
/*
     * DataProvider used to set advanced parameters for types that are supported
     */
@DataProvider(name = "testAdvancedParameters")
private Object[][] testAdvancedParameters() throws SQLException {
    byte[] bytes = new byte[10];
    Ref aRef = new SerialRef(new StubRef("INTEGER", query));
    Array aArray = new SerialArray(new StubArray("INTEGER", new Object[1]));
    Blob aBlob = new SerialBlob(new StubBlob());
    Clob aClob = new SerialClob(new StubClob());
    Reader rdr = new StringReader(query);
    InputStream is = new StringBufferInputStream(query);
    ;
    brs = new StubBaseRowSet();
    brs.setBytes(1, bytes);
    brs.setAsciiStream(2, is, query.length());
    brs.setRef(3, aRef);
    brs.setArray(4, aArray);
    brs.setBlob(5, aBlob);
    brs.setClob(6, aClob);
    brs.setBinaryStream(7, is, query.length());
    brs.setUnicodeStream(8, is, query.length());
    brs.setCharacterStream(9, rdr, query.length());
    return new Object[][] { { 1, bytes }, { 2, is }, { 3, aRef }, { 4, aArray }, { 5, aBlob }, { 6, aClob }, { 7, is }, { 8, is }, { 9, rdr } };
}

64. ArrayTypeHandler#getNullableResult()

Project: mybatis-3
File: ArrayTypeHandler.java
@Override
public Object getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
    Array array = cs.getArray(columnIndex);
    return array == null ? null : array.getArray();
}

65. ArrayTypeHandler#getNullableResult()

Project: mybatis-3
File: ArrayTypeHandler.java
@Override
public Object getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
    Array array = rs.getArray(columnIndex);
    return array == null ? null : array.getArray();
}

66. ArrayTypeHandler#getNullableResult()

Project: mybatis-3
File: ArrayTypeHandler.java
@Override
public Object getNullableResult(ResultSet rs, String columnName) throws SQLException {
    Array array = rs.getArray(columnName);
    return array == null ? null : array.getArray();
}

67. ArrayTypeHandler#getNullableResult()

Project: mybatis
File: ArrayTypeHandler.java
@Override
public Object getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
    Array array = cs.getArray(columnIndex);
    return array == null ? null : array.getArray();
}

68. ArrayTypeHandler#getNullableResult()

Project: mybatis
File: ArrayTypeHandler.java
@Override
public Object getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
    Array array = rs.getArray(columnIndex);
    return array == null ? null : array.getArray();
}

69. ArrayTypeHandler#getNullableResult()

Project: mybatis
File: ArrayTypeHandler.java
@Override
public Object getNullableResult(ResultSet rs, String columnName) throws SQLException {
    Array array = rs.getArray(columnName);
    return array == null ? null : array.getArray();
}

70. JdbcTest#testArray()

Project: calcite
File: JdbcTest.java
/** Tests accessing a column in a JDBC source whose type is ARRAY. */
@Test
public void testArray() throws Exception {
    final String url = MultiJdbcSchemaJoinTest.TempDb.INSTANCE.getUrl();
    Connection baseConnection = DriverManager.getConnection(url);
    Statement baseStmt = baseConnection.createStatement();
    baseStmt.execute("CREATE TABLE ARR_TABLE (\n" + "ID INTEGER,\n" + "VALS INTEGER ARRAY)");
    baseStmt.execute("INSERT INTO ARR_TABLE VALUES (1, ARRAY[1,2,3])");
    baseStmt.execute("CREATE TABLE ARR_TABLE2 (\n" + "ID INTEGER,\n" + "VALS INTEGER ARRAY,\n" + "VALVALS VARCHAR(10) ARRAY)");
    baseStmt.execute("INSERT INTO ARR_TABLE2 VALUES (1, ARRAY[1,2,3], ARRAY['x','y'])");
    baseStmt.close();
    baseConnection.commit();
    Properties info = new Properties();
    info.put("model", "inline:" + "{\n" + "  version: '1.0',\n" + "  defaultSchema: 'BASEJDBC',\n" + "  schemas: [\n" + "     {\n" + "       type: 'jdbc',\n" + "       name: 'BASEJDBC',\n" + "       jdbcDriver: '" + jdbcDriver.class.getName() + "',\n" + "       jdbcUrl: '" + url + "',\n" + "       jdbcCatalog: null,\n" + "       jdbcSchema: null\n" + "     }\n" + "  ]\n" + "}");
    Connection calciteConnection = DriverManager.getConnection("jdbc:calcite:", info);
    Statement calciteStatement = calciteConnection.createStatement();
    ResultSet rs = calciteStatement.executeQuery("SELECT ID, VALS FROM ARR_TABLE");
    assertTrue(rs.next());
    assertEquals(1, rs.getInt(1));
    Array array = rs.getArray(2);
    assertNotNull(array);
    assertArrayEquals(new int[] { 1, 2, 3 }, (int[]) array.getArray());
    assertFalse(rs.next());
    rs.close();
    rs = calciteStatement.executeQuery("SELECT ID, CARDINALITY(VALS), VALS[2] FROM ARR_TABLE");
    assertTrue(rs.next());
    assertEquals(1, rs.getInt(1));
    assertEquals(3, rs.getInt(2));
    assertEquals(2, rs.getInt(3));
    assertFalse(rs.next());
    rs.close();
    rs = calciteStatement.executeQuery("SELECT * FROM ARR_TABLE2");
    final ResultSetMetaData metaData = rs.getMetaData();
    assertThat(metaData.getColumnTypeName(1), equalTo("INTEGER"));
    assertThat(metaData.getColumnTypeName(2), equalTo("INTEGER ARRAY"));
    assertThat(metaData.getColumnTypeName(3), equalTo("VARCHAR(10) ARRAY"));
    assertTrue(rs.next());
    assertEquals(1, rs.getInt(1));
    assertThat(rs.getArray(2), notNullValue());
    assertThat(rs.getArray(3), notNullValue());
    assertFalse(rs.next());
    calciteConnection.close();
}

71. TestPoolUtil#testPoolUtilExceptions()

Project: bonecp
File: TestPoolUtil.java
/**
	 * Tests formatting stuff (exceptions case)
	 * @throws SQLException 
	 */
@Test
public void testPoolUtilExceptions() throws SQLException {
    Map<Object, Object> logParams = new LinkedHashMap<Object, Object>();
    logParams.put("1", "123");
    logParams.put("2", null);
    Blob mockBlob = createNiceMock(Blob.class);
    expect(mockBlob.length()).andThrow(new SQLException());
    replay(mockBlob);
    logParams.put("3", mockBlob);
    Clob mockClob = createNiceMock(Clob.class);
    expect(mockClob.length()).andThrow(new SQLException());
    replay(mockClob);
    logParams.put("4", mockClob);
    Array mockArray = createNiceMock(java.sql.Array.class);
    expect(mockArray.getBaseTypeName()).andThrow(new SQLException());
    replay(mockArray);
    logParams.put("5", mockArray);
    Ref mockSerialRef = createNiceMock(Ref.class);
    expect(mockSerialRef.getBaseTypeName()).andThrow(new SQLException());
    replay(mockSerialRef);
    logParams.put("6", mockSerialRef);
    // test proper replacement/escaping
    assertEquals("ID='123' AND FOO='?' and LALA=\"BOO\" NULL (blob of unknown length) (cblob of unknown length) (array of unknown type) (ref of unknown type) ?", PoolUtil.fillLogParams("ID=? AND FOO='?' and LALA=\"BOO\" ? ? ? ? ? ?", logParams));
}