@Override public int countTableRows(@NotNull final DBTransaction transaction, @NotNull final String tableName) { final String queryText = "select count(*) from " + tableName; try { return transaction.query(queryText, singleOf(Integer.class)).run(); } catch (NoTableOrViewException ntv) { return Integer.MIN_VALUE; } }
/** * 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 empty_cursor() { final SqlQuery<List<Tetra>> query = new SqlQuery<List<Tetra>>( "select 11,22,33,44 from information_schema.schemata where 1 is null", listOf(structOf(Tetra.class))); myFacade.inSession(new InSessionNoResult() { @Override public void run(@NotNull final DBSession session) { List<Tetra> result = session.query(query).run(); assertThat(result).isEmpty(); } }); }
public static <V> ResultLayout<V[]> columnOf(@NotNull final Class<V> valueClass) { return new ResultLayout<V[]>(ResultLayout.Kind.ARRAY, false, oneOf(valueClass)); }
@Test public void query_raw_strings() { final String queryText = "select 'C', 'String' from X1"; final SqlQuery<Object[]> query = new SqlQuery<Object[]>(queryText, rowOf(rawArray())); final Object[] strings = query(query); assertThat(strings).hasSize(2); assertThat(strings[0]).isInstanceOf(String.class); assertThat(strings[1]).isInstanceOf(String.class); assertThat(strings[0]).isEqualTo("C"); assertThat(strings[1]).isEqualTo("String"); }
@Test public void int_array_basic() { SqlQuery<int[]> query = new SqlQuery<int[]>("select 11, 22, 33", rowOf(arrayOfInts())); int[] array = query(query); assertThat(array).containsExactly(11,22,33); }
@Test public void long_array_basic() { SqlQuery<long[]> query = new SqlQuery<long[]>("select 11, 22, 33", rowOf(arrayOfLongs())); long[] array = query(query); assertThat(array).containsExactly(11L,22L,33L); }
@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"); } }); }
@Override public void run(@NotNull final DBTransaction tran) { tran.query("select * from unexistent_table", Layouts.existence()).run(); } });
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)); }
@Test public void return_list_of_basic_struct() { final SqlQuery<List<IntAndString>> query = new SqlQuery<List<IntAndString>>(QUERY_RETURNS_TWO_BASIC_STRUCT_ROWS, listOf(structOf(IntAndString.class))); myFacade.inTransaction(new InTransactionNoResult() { @Override public void run(@NotNull final DBTransaction tran) { List<IntAndString> bs = tran.query(query).run(); assertThat(bs).isNotNull() .hasSize(2); assertThat(bs.get(0).the_int_value).isEqualTo(11); assertThat(bs.get(0).the_string_value).isEqualTo("one"); assertThat(bs.get(1).the_int_value).isEqualTo(22); assertThat(bs.get(1).the_string_value).isEqualTo("two"); } }); }
public static ResultLayout<long[]> columnOfLongs(int initialCapacity) { return new ResultLayout<long[]>(ResultLayout.Kind.ARRAY_OF_PRIMITIVES, false, oneOf(long.class), initialCapacity); }
@Test public void query_raw_numbers() { final String queryText = "select 127 as B, 32767 as S, 2147483647 as I, 9223372036854775807 as L from X1"; final SqlQuery<Object[]> query = new SqlQuery<Object[]>(queryText, rowOf(rawArray())); final Object[] numbers = query(query); assertThat(numbers).hasSize(4); assertThat(numbers[0]).isInstanceOf(Number.class); assertThat(numbers[1]).isInstanceOf(Number.class); assertThat(numbers[2]).isInstanceOf(Number.class); assertThat(numbers[3]).isInstanceOf(Number.class); assertThat(((Number)numbers[0]).intValue()).isEqualTo(127); assertThat(((Number)numbers[1]).intValue()).isEqualTo(32767); assertThat(((Number)numbers[2]).intValue()).isEqualTo(2147483647); assertThat(((Number)numbers[3]).longValue()).isEqualTo(9223372036854775807L); }
@Test public void query_existence_0 () { String queryText = "select 1 from "+(isOracle ? "dual" : "X1")+" where 1 is null"; SqlQuery<Boolean> q = new SqlQuery<Boolean>(queryText, existence()); final Boolean b = query(q); assertThat(b).isNotNull() .isFalse(); }
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)); }
protected void performMetaQueryCommandsIterative(@NotNull final Scriptum scriptum, @NotNull final String metaQueryName, final int retries, final Object... params) { final SqlQuery<List<String>> metaQuery = scriptum.query(metaQueryName, listOf(oneOf(String.class))); db.inSession(new InSessionNoResult() { @Override public void run(@NotNull final DBSession session) { for (int i = 0; i < retries; ++i) { List<String> commands = session.query(metaQuery).withParams(params).run(); try { for (String command : commands) { if (command != null && command.length() > 0) { session.command(command).run(); } } i = retries + 1; } catch (DBException e) { if (i + 1 >= retries) throw e; } } } }); }
@Test public void return_one_basic_struct() { final String queryText = "select 44 as the_int_value, \n" + " 'million' as the_string_value \n"; final SqlQuery<IntAndString> query = new SqlQuery<IntAndString>(queryText, rowOf(structOf(IntAndString.class))); myFacade.inTransaction(new InTransactionNoResult() { @Override public void run(@NotNull final DBTransaction tran) { IntAndString bs = tran.query(query).run(); assertThat(bs).isNotNull(); assertThat(bs.the_int_value).isEqualTo(44); assertThat(bs.the_string_value).isEqualTo("million"); } }); }