public static <K extends Comparable<K>, V> ResultLayout<SortedMap<K,V>> sortedMapOf(@NotNull final Class<K> keyClass, @NotNull final Class<V> valueClass) { return new ResultLayout<SortedMap<K,V>>(ResultLayout.Kind.MAP, true, Layouts.arrayOf(keyClass, valueClass)); }
public static <K,V> ResultLayout<Map<K,V>> hashMapOf(@NotNull final Class<K> keyClass, @NotNull final Class<V> valueClass) { return new ResultLayout<Map<K,V>>(ResultLayout.Kind.MAP, false, Layouts.arrayOf(keyClass, valueClass)); }
/** * A simple internal function that performs a simple query without parameters * and returns the first row as an array. * @param queryText the query text. * @param columnCount count of columns. * @param columnClass class of columns. * @param <V> type of columns. * @return the first row, or null if no rows. */ @Nullable public <V> V[] queryOneRow(@NotNull final String queryText, final int columnCount, @NotNull final Class<V> columnClass) { JdbcIntermediateSeance seance1 = this.openSeance(queryText, null); try { seance1.execute(); JdbcIntermediateCursor<V[]> cursor1 = seance1.openDefaultCursor(rowOf(arrayOf(columnCount, columnClass))); try { if (cursor1.hasRows()) return cursor1.fetch(); else return null; } finally { cursor1.close(); } } finally { seance1.close(); } }
@Test public void array_row_basic() { SqlQuery<Integer[]> query = new SqlQuery<Integer[]>("select 11, 22, 33", rowOf(arrayOf(3, Integer.class))); Integer[] array = query(query); assertThat(array).isEqualTo(new Integer[] {11, 22, 33}); }
@Test public void return_array_of_basic_struct() { final SqlQuery<IntAndString[]> query = new SqlQuery<IntAndString[]>(QUERY_RETURNS_TWO_BASIC_STRUCT_ROWS, arrayOf(structOf(IntAndString.class))); myFacade.inTransaction(new InTransactionNoResult() { @Override public void run(@NotNull final DBTransaction tran) { IntAndString[] bs = tran.query(query).run(); assertThat(bs).isNotNull() .hasSize(2); assertThat(bs[0].the_int_value).isEqualTo(11); assertThat(bs[0].the_string_value).isEqualTo("one"); assertThat(bs[1].the_int_value).isEqualTo(22); assertThat(bs[1].the_string_value).isEqualTo("two"); } }); }
@Test public void query_matrix_of_Integers() { String queryText = "select min(111), min(222), min(333) \n" + "union all \n" + "select min(444), min(555), min(666) \n" + "union all \n" + "select min(777), min(888), min(999) \n"; JdbcIntermediateSeance seance = query(queryText); JdbcIntermediateCursor<Integer[][]> cursor = seance.openDefaultCursor(arrayOf(arrayOf(3, Integer.class))); assertThat(cursor.isOpened()).isTrue(); Integer[][] matrix = cursor.fetch(); assertThat(matrix).isNotNull() .hasSize(3); assertThat(matrix[0]).isNotNull().hasSize(3); assertThat(matrix[1]).isNotNull().hasSize(3); assertThat(matrix[2]).isNotNull().hasSize(3); }
@Test public void query_number_basic() { final String[] createTable = new String[] { "create table basic_numbers_table (B tinyint, S smallint, I integer, L bigint)", "insert into basic_numbers_table values (10, 1000, 1000000, 1000000000000)" }; final String query = "select * from basic_numbers_table"; JdbcIntermediateSession session = openSession(); performStatements(session, createTable); JdbcIntermediateSeance seance = session.openSeance(query, null); seance.execute(); JdbcIntermediateCursor<Number[]> cursor = seance.openDefaultCursor(Layouts.rowOf(arrayOf(4, Number.class))); Number[] row = cursor.fetch(); seance.close(); assertThat(row).isNotNull() .hasSize(4); assertThat(row[0]).isInstanceOf(Byte.class).isEqualTo((byte) 10); assertThat(row[1]).isInstanceOf(Short.class).isEqualTo((short) 1000); assertThat(row[2]).isInstanceOf(Integer.class).isEqualTo(1000000); assertThat(row[3]).isInstanceOf(Long.class).isEqualTo(1000000000000L); }
@Test public void query_single_row_array_of_Integers() { String queryText = "select 123, 456, 789"; JdbcIntermediateSeance seance = query(queryText); JdbcIntermediateCursor<Integer[]> cursor = seance.openDefaultCursor(rowOf(arrayOf(3, Integer.class))); assertThat(cursor.isOpened()).isTrue(); Integer[] array = cursor.fetch(); assertThat(array).isNotNull() .containsExactly(123, 456, 789); assertThat(cursor.isOpened()).isFalse(); }
@Test public void query_floats() { final String[] createTable = new String[] { "create table float_numbers_table (F float, D double, R real)", "insert into float_numbers_table values (3.1415, 2.718281828, 26.74)" }; final String query = "select * from float_numbers_table"; JdbcIntermediateSession session = openSession(); performStatements(session, createTable); JdbcIntermediateSeance seance = session.openSeance(query, null); seance.execute(); JdbcIntermediateCursor<Object[]> cursor = seance.openDefaultCursor(Layouts.rowOf(arrayOf(Float.class, Double.class, Number.class))); Object[] row = cursor.fetch(); seance.close(); assertThat(row).isNotNull() .hasSize(3); assertThat(row[0]).isInstanceOf(Float.class).isEqualTo(3.1415f); assertThat(row[1]).isInstanceOf(Double.class).isEqualTo(2.718281828d); assertThat(row[2]).isInstanceOfAny(Float.class, Double.class); }
@Test public void query_decimals() { final String[] createTable = new String[] { "create table decimal_numbers_table (D1 decimal(24), D2 decimal(36,6))", "insert into decimal_numbers_table values (123456781234567812345678, 123456789012345678901234567890.666666)" }; final String query = "select * from decimal_numbers_table"; JdbcIntermediateSession session = openSession(); performStatements(session, createTable); JdbcIntermediateSeance seance = session.openSeance(query, null); seance.execute(); JdbcIntermediateCursor<BigDecimal[]> cursor = seance.openDefaultCursor(Layouts.rowOf(arrayOf(2, BigDecimal.class))); BigDecimal[] row = cursor.fetch(); seance.close(); assertThat(row).isNotNull() .hasSize(2); assertThat(row[0]).isInstanceOf(BigDecimal.class).isEqualTo(new BigDecimal("123456781234567812345678")); assertThat(row[1]).isInstanceOf(BigDecimal.class).isEqualTo(new BigDecimal("123456789012345678901234567890.666666")); }