How to use

SqlQuery

in

org.jetbrains.dekaf.sql

@NotNull
@Override
public synchronized  <S> BaseQueryRunner<S> query(@NotNull final String queryText,
                         @NotNull final ResultLayout<S> layout) {
 SqlQuery<S> query = new SqlQuery<S>(queryText, layout);
 return this.query(query);
}

 @Override
 public String toString() {
  return getDisplayName();
 }
}

@NotNull
@Override
public synchronized <S> BaseQueryRunner<S> query(@NotNull final SqlQuery<S> query) {
 final IntegralIntermediateSeance interSeance =
     myInterSession.openSeance(query.getSourceText(), null);
 BaseQueryRunner<S> queryRunner = new BaseQueryRunner<S>(interSeance, query.getLayout());
 myRunners.add(queryRunner);
 return queryRunner;
}

@NotNull
public final <S> SqlQuery<S> query(@NotNull final String name,
                  @NotNull final ResultLayout<S> layout) {
 TextFileFragment fragment = getText(name);
 fragment = stripSingleStatement(fragment);
 final SqlQuery<S> query = new SqlQuery<S>(fragment, layout);
 query.setDisplayName(fragment.getFragmentName());
 return query;
}

@Test
public void query_calendar_values_now() {
 String queryText =
   "select NOW as javaDate, NOW as sqlDate, NOW as sqlTimestamp, NOW as sqlTime";
 if (isOracle) queryText += " from dual";
 SqlQuery<CalendarValues> query =
   new SqlQuery<CalendarValues>(queryText, rowOf(structOf(CalendarValues.class)))
    .rewrite(Rewriters.replace("NOW", sqlNow()));
 CalendarValues cv = query(query);
 assertThat(cv.javaDate)    .isExactlyInstanceOf(java.util.Date.class);
 assertThat(cv.sqlDate)     .isExactlyInstanceOf(java.sql.Date.class);
 assertThat(cv.sqlTimestamp).isExactlyInstanceOf(java.sql.Timestamp.class);
 assertThat(cv.sqlTime)     .isExactlyInstanceOf(java.sql.Time.class);
}

public String getDisplayName() {
 if (myDisplayName == null) {
  prepareDisplayName();
 }
 return myDisplayName;
}

@NotNull
@Override
public SqlQuery<S> rewrite(@NotNull final StringOperator operator) {
 String transformedSourceText = operator.apply(mySourceText);
 return new SqlQuery<S>(
   myRow,
   transformedSourceText,
   myName,
   myDescription,
   myLayout,
   myDescription
 );
}

@Nullable
private <S> S queryForStruct(final String queryText, final Class<S> structClass) {
 final SqlQuery<S> query = new SqlQuery<S>(queryText, rowOf(structOf(structClass)));
 return query(query);
}

@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 query_calendar_values_parameters() {
 String queryText =
   queryCalendarValuesFromParameters();
 if (isOracle) queryText += " from dual";
 SqlQuery<CalendarValues> query =
   new SqlQuery<CalendarValues>(queryText, rowOf(structOf(CalendarValues.class)));
 CalendarValues cv = query(query,
              new java.sql.Timestamp(System.currentTimeMillis()),
              new java.sql.Timestamp(System.currentTimeMillis()),
              new java.sql.Timestamp(System.currentTimeMillis()),
              new java.sql.Timestamp(System.currentTimeMillis())/*,
              new java.sql.Time(System.currentTimeMillis())*/
 );
 assertThat(cv.javaDate)    .isExactlyInstanceOf(java.util.Date.class);
 assertThat(cv.sqlDate)     .isExactlyInstanceOf(java.sql.Date.class);
 assertThat(cv.sqlTimestamp).isExactlyInstanceOf(java.sql.Timestamp.class);
 assertThat(cv.sqlTime)     .isExactlyInstanceOf(java.sql.Time.class);
}

@Test
public void million_of_longs() {
 SqlQuery<long[]> query =
   new SqlQuery<long[]>("select cast(X as bigint) from system_range(1,1000000)", columnOfLongs(1000));
 long[] array = query(query);
 assertThat(array).hasSize(1000000);
 assertThat(array[0]).isEqualTo(1L);
 assertThat(array[999999]).isEqualTo(1000000L);
}

@Test
public void million_of_ints() {
 SqlQuery<int[]> query =
   new SqlQuery<int[]>("select cast(X as int) from system_range(1,1000000)", columnOfInts(1000));
 int[] array = query(query);
 assertThat(array).hasSize(1000000);
 assertThat(array[0]).isEqualTo(1);
 assertThat(array[999999]).isEqualTo(1000000);
}

@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_boxed_numbers_positive() {
 final String queryText =
   "select 127 as B, 32767 as S, 2147483647 as I, 9223372036854775807 as L from X1";
 final SqlQuery<BoxedNumbers> query =
   new SqlQuery<BoxedNumbers>(queryText, rowOf(structOf(BoxedNumbers.class)));
 BoxedNumbers bn = query(query);
 assertThat(bn.B).isEqualTo((byte) 127);
 assertThat(bn.S).isEqualTo((short)32767);
 assertThat(bn.I).isEqualTo(2147483647);
 assertThat(bn.L).isEqualTo(9223372036854775807L);
}

@Test
public void query_primitive_numbers_negative() {
 final String queryText =
   "select -128 as B, -32768 as S, -2147483648 as I, -9223372036854775808 as L from X1";
 final SqlQuery<PrimitiveNumbers> query =
   new SqlQuery<PrimitiveNumbers>(queryText, rowOf(structOf(PrimitiveNumbers.class)));
 PrimitiveNumbers pn = query(query);
 assertThat(pn.B).isEqualTo((byte)-128);
 assertThat(pn.S).isEqualTo((short)-32768);
 assertThat(pn.I).isEqualTo(-2147483648);
 assertThat(pn.L).isEqualTo(-9223372036854775808L);
}

@Test
public void query_primitive_numbers_positive() {
 final String queryText =
   "select 127 as B, 32767 as S, 2147483647 as I, 9223372036854775807 as L from X1";
 final SqlQuery<PrimitiveNumbers> query =
   new SqlQuery<PrimitiveNumbers>(queryText, rowOf(structOf(PrimitiveNumbers.class)));
 PrimitiveNumbers pn = query(query);
 assertThat(pn.B).isEqualTo((byte)127);
 assertThat(pn.S).isEqualTo((short)32767);
 assertThat(pn.I).isEqualTo(2147483647);
 assertThat(pn.L).isEqualTo(9223372036854775807L);
}

@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 query_existence_1() {
 String queryText = "select 1 "+(isOracle ? "from dual" : "");
 SqlQuery<Boolean> q = new SqlQuery<Boolean>(queryText, existence());
 final Boolean b = query(q);
 assertThat(b).isNotNull()
        .isTrue();
}

@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 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);
}