@Test
  public void testEmptyCommit() throws SQLException {
    // Empty auto commit commit
    connection.setAutoCommit(true);
    connection.commit();

    // Empty commit
    connection.setAutoCommit(false);
    connection.commit();
  }
Example #2
0
  @Test
  public void testUpsertValuesWithExpression() throws Exception {
    long ts = nextTimestamp();
    ensureTableCreated(getUrl(), "IntKeyTest", null, ts - 2);
    Properties props = new Properties();
    props.setProperty(
        PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 1)); // Execute at timestamp 1
    Connection conn = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
    String upsert = "UPSERT INTO IntKeyTest VALUES(-1)";
    PreparedStatement upsertStmt = conn.prepareStatement(upsert);
    int rowsInserted = upsertStmt.executeUpdate();
    assertEquals(1, rowsInserted);
    upsert = "UPSERT INTO IntKeyTest VALUES(1+2)";
    upsertStmt = conn.prepareStatement(upsert);
    rowsInserted = upsertStmt.executeUpdate();
    assertEquals(1, rowsInserted);
    conn.commit();
    conn.close();

    props.setProperty(
        PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 2)); // Execute at timestamp 1
    conn = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
    String select = "SELECT i FROM IntKeyTest";
    ResultSet rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(-1, rs.getInt(1));
    assertTrue(rs.next());
    assertEquals(3, rs.getInt(1));
    assertFalse(rs.next());
  }
Example #3
0
  @Test
  public void testUpsertDateValues() throws Exception {
    long ts = nextTimestamp();
    Date now = new Date(System.currentTimeMillis());
    ensureTableCreated(getUrl(), TestUtil.PTSDB_NAME, null, ts - 2);
    Properties props = new Properties();
    props.setProperty(
        PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 1)); // Execute at timestamp 1
    Connection conn = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
    String dateString = "1999-01-01 02:00:00";
    PreparedStatement upsertStmt =
        conn.prepareStatement(
            "upsert into ptsdb(inst,host,date) values('aaa','bbb',to_date('" + dateString + "'))");
    int rowsInserted = upsertStmt.executeUpdate();
    assertEquals(1, rowsInserted);
    upsertStmt =
        conn.prepareStatement(
            "upsert into ptsdb(inst,host,date) values('ccc','ddd',current_date())");
    rowsInserted = upsertStmt.executeUpdate();
    assertEquals(1, rowsInserted);
    conn.commit();

    props.setProperty(
        PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 2)); // Execute at timestamp 1
    conn = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
    String select = "SELECT date,current_date() FROM ptsdb";
    ResultSet rs = conn.createStatement().executeQuery(select);
    Date then = new Date(System.currentTimeMillis());
    assertTrue(rs.next());
    Date date = DateUtil.parseDate(dateString);
    assertEquals(date, rs.getDate(1));
    assertTrue(rs.next());
    assertTrue(rs.getDate(1).after(now) && rs.getDate(1).before(then));
    assertFalse(rs.next());
  }
Example #4
0
  @Test
  public void testUpsertValuesWithDate() throws Exception {
    long ts = nextTimestamp();
    Properties props = new Properties();
    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts));
    Connection conn = DriverManager.getConnection(getUrl(), props);
    conn.createStatement()
        .execute("create table UpsertDateTest (k VARCHAR not null primary key,date DATE)");
    conn.close();

    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 5));
    conn = DriverManager.getConnection(getUrl(), props);
    conn.createStatement()
        .execute("upsert into UpsertDateTest values ('a',to_date('2013-06-08 00:00:00'))");
    conn.commit();
    conn.close();

    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 10));
    conn = DriverManager.getConnection(getUrl(), props);
    ResultSet rs =
        conn.createStatement().executeQuery("select k,to_char(date) from UpsertDateTest");
    assertTrue(rs.next());
    assertEquals("a", rs.getString(1));
    assertEquals("2013-06-08 00:00:00", rs.getString(2));
  }
Example #5
0
  @Test
  public void testExecuteAndFetchWithNulls() {
    String sql =
        "create table testExecWithNullsTbl ("
            + "id int identity primary key, "
            + "text varchar(255), "
            + "aNumber int, "
            + "aLongNumber bigint)";
    sql2o.createQuery(sql, "testExecuteAndFetchWithNulls").executeUpdate();

    Connection connection = sql2o.beginTransaction();
    Query insQuery =
        connection.createQuery(
            "insert into testExecWithNullsTbl (text, aNumber, aLongNumber) values(:text, :number, :lnum)");
    insQuery
        .addParameter("text", "some text")
        .addParameter("number", 2)
        .addParameter("lnum", 10L)
        .executeUpdate();
    insQuery
        .addParameter("text", "some text")
        .addParameter("number", (Integer) null)
        .addParameter("lnum", 10L)
        .executeUpdate();
    insQuery
        .addParameter("text", (String) null)
        .addParameter("number", 21)
        .addParameter("lnum", (Long) null)
        .executeUpdate();
    insQuery
        .addParameter("text", "some text")
        .addParameter("number", 1221)
        .addParameter("lnum", 10)
        .executeUpdate();
    insQuery
        .addParameter("text", "some text")
        .addParameter("number", 2311)
        .addParameter("lnum", 12)
        .executeUpdate();
    connection.commit();

    List<Entity> fetched =
        sql2o.createQuery("select * from testExecWithNullsTbl").executeAndFetch(Entity.class);

    assertTrue(fetched.size() == 5);
    assertNull(fetched.get(2).text);
    assertNotNull(fetched.get(3).text);

    assertNull(fetched.get(1).aNumber);
    assertNotNull(fetched.get(2).aNumber);

    assertNull(fetched.get(2).aLongNumber);
    assertNotNull(fetched.get(3).aLongNumber);
  }
Example #6
0
  @Test
  public void testUpsertVarCharWithMaxLength() throws Exception {
    long ts = nextTimestamp();
    Properties props = new Properties();
    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts));
    Connection conn = DriverManager.getConnection(getUrl(), props);
    conn.createStatement()
        .execute(
            "create table phoenix_uuid_mac (mac_md5 VARCHAR not null primary key,raw_mac VARCHAR)");
    conn.close();

    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 5));
    conn = DriverManager.getConnection(getUrl(), props);
    conn.createStatement().execute("upsert into phoenix_uuid_mac values ('00000000591','a')");
    conn.createStatement().execute("upsert into phoenix_uuid_mac values ('000000005919','b')");
    conn.commit();
    conn.close();

    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 10));
    conn = DriverManager.getConnection(getUrl(), props);
    ResultSet rs = conn.createStatement().executeQuery("select max(mac_md5) from phoenix_uuid_mac");
    assertTrue(rs.next());
    assertEquals("000000005919", rs.getString(1));
    conn.close();

    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 15));
    conn = DriverManager.getConnection(getUrl(), props);
    conn.createStatement()
        .execute(
            "upsert into phoenix_uuid_mac values ('000000005919adfasfasfsafdasdfasfdasdfdasfdsafaxxf1','b')");
    conn.commit();
    conn.close();

    props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts + 20));
    conn = DriverManager.getConnection(getUrl(), props);
    rs = conn.createStatement().executeQuery("select max(mac_md5) from phoenix_uuid_mac");
    assertTrue(rs.next());
    assertEquals("000000005919adfasfasfsafdasdfasfdasdfdasfdsafaxxf1", rs.getString(1));
    conn.close();
  }
Example #7
0
 private void loadData(long ts) throws SQLException {
   Properties props = new Properties(TEST_PROPERTIES);
   props.setProperty(PhoenixRuntime.CURRENT_SCN_ATTRIB, Long.toString(ts));
   Connection conn = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
   insertRow(conn, "Report1", 10);
   insertRow(conn, "Report2", 10);
   insertRow(conn, "Report3", 30);
   insertRow(conn, "Report4", 30);
   insertRow(conn, "SOQL1", 10);
   insertRow(conn, "SOQL2", 10);
   insertRow(conn, "SOQL3", 30);
   insertRow(conn, "SOQL4", 30);
   conn.commit();
   conn.close();
 }
Example #8
0
  @Test
  public void insert1000() throws SQLException {
    stat.executeUpdate("create table in1000 (a);");
    PreparedStatement prep = conn.prepareStatement("insert into in1000 values (?);");
    conn.setAutoCommit(false);
    for (int i = 0; i < 1000; i++) {
      prep.setInt(1, i);
      prep.executeUpdate();
    }
    conn.commit();

    ResultSet rs = stat.executeQuery("select count(a) from in1000;");
    assertTrue(rs.next());
    assertEquals(1000, rs.getInt(1));
    rs.close();
  }
  @Test
  public void testFailedTransactionRollback() throws SQLException {
    connection.setAutoCommit(false);

    // Failed statement
    mockConnection.setError(42, "bad");
    Statement s = connection.createStatement();
    try {
      s.executeUpdate("DELETE bad");
      fail("expected exception");
    } catch (SQLException e) {
    }
    assertNull(mockConnection.lastFinish);

    // All future statements should also fail
    mockConnection.setUpdateCount(42);
    try {
      s.executeUpdate("DELETE good");
      fail("expected exception");
    } catch (SQLException e) {
    }

    connection.enableStrictMode(true);
    try {
      connection.commit();
      fail("expected exception");
    } catch (SQLException e) {
    }

    // rollback this transaction
    connection.rollback();
    assertNull(mockConnection.lastFinish);
    try {
      // Can't rollback: no transaction!
      connection.rollback();
      fail("expected exception");
    } catch (SQLException e) {
    }

    assertEquals(42, s.executeUpdate("DELETE good"));
  }
  @Test
  public void createEncrypted() throws SQLException, IOException {
    File tmp = File.createTempFile("sqlitetest", ".db");
    tmp.deleteOnExit();
    String url = "jdbc:sqlite:" + tmp.getAbsolutePath();

    Properties props = new Properties();
    final String password = "******"dog";
    props.put("key", password);
    Connection conn = DriverManager.getConnection(url, props);
    conn.setAutoCommit(false);

    Statement st = conn.createStatement();
    st.executeUpdate("create table ants (col int)");
    st.executeUpdate("insert into ants values( 300 )");
    st.executeUpdate("insert into ants values( 400 )");
    st.close();
    conn.commit();
    conn.close();

    // Try reading without key.
    props.remove("key");
    conn = DriverManager.getConnection(url, props);

    try {
      st = conn.createStatement();
      ResultSet rs = st.executeQuery("select count(*) from ants");
      fail("Database not encrypted.");
    } catch (SQLException ignore) {
    }

    conn.close();
    props.put("key", password);
    conn = DriverManager.getConnection(url, props);

    st = conn.createStatement();
    ResultSet rs = st.executeQuery("select count(*) from ants");
    assertTrue(rs.next());
    assertEquals(2, rs.getInt(1));
    conn.close();
  }
Example #11
0
  @Test
  public void testBatch() {
    sql2o
        .createQuery(
            "create table User(\n"
                + "id int identity primary key,\n"
                + "name varchar(20),\n"
                + "email varchar(255),\n"
                + "text varchar(100))")
        .executeUpdate();

    String insQuery = "insert into User(name, email, text) values (:name, :email, :text)";

    Connection con = sql2o.beginTransaction();
    int[] inserted =
        con.createQuery(insQuery)
            .addParameter("name", "test")
            .addParameter("email", "*****@*****.**")
            .addParameter("text", "something exciting")
            .addToBatch()
            .addParameter("name", "test2")
            .addParameter("email", "*****@*****.**")
            .addParameter("text", "something exciting too")
            .addToBatch()
            .addParameter("name", "test3")
            .addParameter("email", "*****@*****.**")
            .addParameter("text", "blablabla")
            .addToBatch()
            .executeBatch()
            .getBatchResult();
    con.commit();

    assertEquals(3, inserted.length);
    for (int i : inserted) {
      assertEquals(1, i);
    }

    deleteUserTable();
  }
  @Test
  public void testIntegerPK() throws Exception {
    int[] testNumbers = {
      Integer.MIN_VALUE,
      Integer.MIN_VALUE + 1,
      -2,
      -1,
      0,
      1,
      2,
      Integer.MAX_VALUE - 1,
      Integer.MAX_VALUE
    };
    ensureTableCreated(getUrl(), "PKIntValueTest");
    Properties props = new Properties();
    Connection conn = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
    String upsert = "UPSERT INTO PKIntValueTest VALUES(?)";
    PreparedStatement stmt = conn.prepareStatement(upsert);
    for (int i = 0; i < testNumbers.length; i++) {
      stmt.setInt(1, testNumbers[i]);
      stmt.execute();
    }
    conn.commit();
    conn.close();

    String select = "SELECT COUNT(*) from PKIntValueTest";
    ResultSet rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());

    select = "SELECT count(*) FROM PKIntValueTest where pk >= " + Integer.MIN_VALUE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT pk FROM PKIntValueTest where pk >= "
            + Integer.MIN_VALUE
            + " GROUP BY pk ORDER BY pk ASC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = 0; i < testNumbers.length; i++) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());

    // NOTE: This case currently fails with an error message:
    // "Overflow trying to get next key for [-1, -1, -1, -1]"
    select = "SELECT count(*) FROM PKIntValueTest where pk <= " + Integer.MAX_VALUE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT pk FROM PKIntValueTest where pk <= "
            + Integer.MAX_VALUE
            + " GROUP BY pk ORDER BY pk DESC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = testNumbers.length - 1; i >= 0; i--) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());

    // NOTE: This case currently fails since it is not retrieving the negative values.
    select = "SELECT count(*) FROM PKIntValueTest where pk >= " + INTEGER_MIN_MINUS_ONE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT pk FROM PKIntValueTest where pk >= "
            + INTEGER_MIN_MINUS_ONE
            + " GROUP BY pk ORDER BY pk ASC NULLS LAST ";
    rs = conn.createStatement().executeQuery(select);
    for (int i = 0; i < testNumbers.length; i++) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());

    // NOTE: This test case fails because it is not retrieving positive values.
    select = "SELECT count(*) FROM PKIntValueTest where pk <= " + INTEGER_MAX_PLUS_ONE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT pk FROM PKIntValueTest where pk <= "
            + INTEGER_MAX_PLUS_ONE
            + " GROUP BY pk ORDER BY pk DESC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = testNumbers.length - 1; i >= 0; i--) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());
  }
  @Test
  public void testBigIntKV() throws Exception {
    // NOTE: Due to how we parse negative long, -9223372036854775808L, the minimum value of
    // bigint is not recognizable in the current version. As a result, we start with
    // Long.MIN_VALUE+1 as the smallest value.
    long[] testNumbers = {
      Long.MIN_VALUE + 1,
      Long.MIN_VALUE + 2,
      -2L,
      -1L,
      0L,
      1L,
      2L,
      Long.MAX_VALUE - 1,
      Long.MAX_VALUE
    };
    ensureTableCreated(getUrl(), "KVBigIntValueTest");
    Properties props = new Properties();
    Connection conn = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
    String upsert = "UPSERT INTO KVBigIntValueTest VALUES(?,?)";
    PreparedStatement stmt = conn.prepareStatement(upsert);
    for (int i = 0; i < testNumbers.length; i++) {
      stmt.setLong(1, i);
      stmt.setLong(2, testNumbers[i]);
      stmt.execute();
    }
    conn.commit();
    conn.close();

    String select = "SELECT COUNT(*) from KVBigIntValueTest";
    ResultSet rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());

    select = "SELECT count(*) FROM KVBigIntValueTest where kv >= " + (Long.MIN_VALUE + 1);
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT kv FROM KVBigIntValueTest WHERE kv >= "
            + (Long.MIN_VALUE + 1)
            + " GROUP BY kv ORDER BY kv ASC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = 0; i < testNumbers.length; i++) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getLong(1));
    }
    assertFalse(rs.next());

    select = "SELECT count(*) FROM KVBigIntValueTest where kv <= " + Long.MAX_VALUE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT kv FROM KVBigIntValueTest WHERE kv <= "
            + Long.MAX_VALUE
            + " GROUP BY kv ORDER BY kv DESC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = testNumbers.length - 1; i >= 0; i--) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getLong(1));
    }
    assertFalse(rs.next());

    /* NOTE: This section currently fails due to the fact that we cannot parse literal values
       that are bigger than Long.MAX_VALUE and Long.MIN_VALUE. We will need to fix the parse
       before enabling this section of the test.
    select = "SELECT count(*) FROM KVBigIntValueTest where kv >= " + LONG_MIN_MINUS_ONE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select = "SELECT kv FROM KVBigIntValueTest WHERE kv >= " + LONG_MIN_MINUS_ONE +
            " GROUP BY kv ORDER BY kv ASC NULLS LAST ";
    rs = conn.createStatement().executeQuery(select);
    for (int i = 0; i < testNumbers.length; i++) {
        assertTrue(rs.next());
        assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());

    select = "SELECT count(*) FROM KVBigIntValueTest where kv <= " + LONG_MAX_PLUS_ONE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select = "SELECT kv FROM KVBigIntValueTest WHERE kv <= " + LONG_MAX_PLUS_ONE +
            " GROUP BY kv ORDER BY kv DESC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = testNumbers.length-1; i >= 0; i--) {
        assertTrue(rs.next());
        assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());
    */
  }
  @Test
  public void testIntegerKV() throws Exception {
    int[] testNumbers = {
      Integer.MIN_VALUE,
      Integer.MIN_VALUE + 1,
      -2,
      -1,
      0,
      1,
      2,
      Integer.MAX_VALUE - 1,
      Integer.MAX_VALUE
    };
    ensureTableCreated(getUrl(), "KVIntValueTest");
    Properties props = new Properties();
    Connection conn = DriverManager.getConnection(PHOENIX_JDBC_URL, props);
    String upsert = "UPSERT INTO KVIntValueTest VALUES(?, ?)";
    PreparedStatement stmt = conn.prepareStatement(upsert);
    for (int i = 0; i < testNumbers.length; i++) {
      stmt.setInt(1, i);
      stmt.setInt(2, testNumbers[i]);
      stmt.execute();
    }
    conn.commit();
    conn.close();

    String select = "SELECT COUNT(*) from KVIntValueTest";
    ResultSet rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());

    select = "SELECT count(*) FROM KVIntValueTest where kv >= " + Integer.MIN_VALUE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT kv FROM KVIntValueTest WHERE kv >= "
            + Integer.MIN_VALUE
            + " GROUP BY kv ORDER BY kv ASC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = 0; i < testNumbers.length; i++) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());

    select = "SELECT count(*) FROM KVIntValueTest where kv <= " + Integer.MAX_VALUE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT kv FROM KVIntValueTest WHERE kv <= "
            + Integer.MAX_VALUE
            + " GROUP BY kv ORDER BY kv DESC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = testNumbers.length - 1; i >= 0; i--) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());

    select = "SELECT count(*) FROM KVIntValueTest where kv >= " + INTEGER_MIN_MINUS_ONE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT kv FROM KVIntValueTest WHERE kv >= "
            + INTEGER_MIN_MINUS_ONE
            + " GROUP BY kv ORDER BY kv ASC NULLS LAST ";
    rs = conn.createStatement().executeQuery(select);
    for (int i = 0; i < testNumbers.length; i++) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());

    select = "SELECT count(*) FROM KVIntValueTest where kv <= " + INTEGER_MAX_PLUS_ONE;
    rs = conn.createStatement().executeQuery(select);
    assertTrue(rs.next());
    assertEquals(testNumbers.length, rs.getInt(1));
    assertFalse(rs.next());
    select =
        "SELECT kv FROM KVIntValueTest WHERE kv <= "
            + INTEGER_MAX_PLUS_ONE
            + " GROUP BY kv ORDER BY kv DESC NULLS LAST";
    rs = conn.createStatement().executeQuery(select);
    for (int i = testNumbers.length - 1; i >= 0; i--) {
      assertTrue(rs.next());
      assertEquals(testNumbers[i], rs.getInt(1));
    }
    assertFalse(rs.next());
  }