congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
SqlQuery
Code IndexAdd Tabnine to your IDE (free)

How to use
SqlQuery
in
org.jetbrains.dekaf.sql

Best Java code snippets using org.jetbrains.dekaf.sql.SqlQuery (Showing top 20 results out of 315)

origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

 @Override
 public String toString() {
  return getDisplayName();
 }
}
origin: JetBrains/dekaf

@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;
}
origin: JetBrains/dekaf

@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;
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

public String getDisplayName() {
 if (myDisplayName == null) {
  prepareDisplayName();
 }
 return myDisplayName;
}
origin: JetBrains/dekaf

@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
 );
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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");
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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);
}
origin: JetBrains/dekaf

@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();
}
origin: JetBrains/dekaf

@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});
}
origin: JetBrains/dekaf

@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);
}
org.jetbrains.dekaf.sqlSqlQuery

Javadoc

A SQL query that returns a list of rows.

Most used methods

  • <init>
  • getDisplayName
  • getLayout
  • getSourceText
  • prepareDisplayName
  • rewrite
  • setDisplayName

Popular in Java

  • Reading from database using SQL prepared statement
  • runOnUiThread (Activity)
  • getResourceAsStream (ClassLoader)
  • getSystemService (Context)
  • IOException (java.io)
    Signals a general, I/O-related error. Error details may be specified when calling the constructor, a
  • PrintWriter (java.io)
    Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
  • BlockingQueue (java.util.concurrent)
    A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
  • Handler (java.util.logging)
    A Handler object accepts a logging request and exports the desired messages to a target, for example
  • Modifier (javassist)
    The Modifier class provides static methods and constants to decode class and member access modifiers
  • Options (org.apache.commons.cli)
    Main entry-point into the library. Options represents a collection of Option objects, which describ
  • 14 Best Plugins for Eclipse
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now