/** * Returns elements from a sequence as long as a * specified condition is true. The element's index is used in the * logic of the predicate function. */ public static <T> Queryable<T> takeWhileN(final Queryable<T> source, final FunctionExpression<Predicate2<T, Integer>> predicate) { return new BaseQueryable<T>(source.getProvider(), source.getElementType(), source.getExpression()) { public Enumerator<T> enumerator() { return new EnumerableDefaults.TakeWhileEnumerator<>( source.enumerator(), predicate.getFunction()); } }; }
public static <T> Queryable<T> stringUnion( Queryable<T> q0, Queryable<T> q1) { return q0.concat(q1); }
/** * <p>Analogous to LINQ's Enumerable.Cast extension method.</p> * * @param clazz Target type * @param <T2> Target type * * @return Collection of T2 */ public static <T, T2> Queryable<T2> cast(final Queryable<T> source, final Class<T2> clazz) { return new BaseQueryable<T2>(source.getProvider(), clazz, source.getExpression()) { public Enumerator<T2> enumerator() { return new EnumerableDefaults.CastingEnumerator<>(source.enumerator(), clazz); } }; }
"asQueryable"), Employee.class) .where( Expressions.lambda( Expressions.lessThan( Expressions.constant(160)), e)) .where( Expressions.lambda( Expressions.greaterThan( Expressions.constant(140)), e)) .select( Expressions.<Function1<Employee, Object[]>>lambda( Expressions.new_( "toUpperCase")), e)) .toList(); assertEquals(1, list.size()); assertEquals(2, list.get(0).length);
@Test public void testQueryProviderSingleColumn() throws Exception { Connection connection = CalciteAssert .that(CalciteAssert.Config.REGULAR).connect(); QueryProvider queryProvider = connection.unwrap(QueryProvider.class); ParameterExpression e = Expressions.parameter(Employee.class, "e"); // "Enumerable<T> asEnumerable(final T[] ts)" List<Integer> list = queryProvider.createQuery( Expressions.call( Expressions.call( Types.of(Enumerable.class, Employee.class), null, LINQ4J_AS_ENUMERABLE_METHOD, Expressions.constant(new JdbcTest.HrSchema().emps)), "asQueryable"), Employee.class) .select( Expressions.<Function1<Employee, Integer>>lambda( Expressions.field(e, "empid"), e)) .toList(); assertEquals(Arrays.asList(100, 200, 150, 110), list); }
public Type getElementType() { return original.getElementType(); }
@Test public void testTableWhere() throws SQLException, ClassNotFoundException { final Connection connection = CalciteAssert.that(CalciteAssert.Config.JDBC_FOODMART).connect(); final CalciteConnection calciteConnection = connection.unwrap(CalciteConnection.class); final SchemaPlus rootSchema = calciteConnection.getRootSchema(); ParameterExpression c = Expressions.parameter(JdbcTest.Customer.class, "c"); String s = Schemas.queryable(Schemas.createDataContext(connection, rootSchema), rootSchema.getSubSchema("foodmart"), JdbcTest.Customer.class, "customer") .where( Expressions.lambda( Expressions.lessThan( Expressions.field(c, "customer_id"), Expressions.constant(5)), c)) .toList() .toString(); Util.discard(s); } }
rowEnumerable = queryable.select(o -> { final Object[] values = new Object[fields.size()]; for (int i = 0; i < fields.size(); i++) {
public Expression getExpression() { return original.getExpression(); }
/** * Returns a specified number of contiguous elements * from the start of a sequence. */ public static <T> Queryable<T> take(Queryable<T> source, int count) { return EnumerableDefaults.take(source.asEnumerable(), count).asQueryable(); }
"asQueryable"), Employee.class) .where( Expressions.lambda( Expressions.lessThan( Expressions.constant(160)), e)) .where( Expressions.lambda( Expressions.greaterThan( Expressions.constant(140)), e)) .select( Expressions.<Function1<Employee, Object[]>>lambda( Expressions.new_( "toUpperCase")), e)) .toList(); assertEquals(1, list.size()); assertEquals(2, list.get(0).length);
@Test public void testQueryProviderSingleColumn() throws Exception { Connection connection = CalciteAssert .that(CalciteAssert.Config.REGULAR).connect(); QueryProvider queryProvider = connection.unwrap(QueryProvider.class); ParameterExpression e = Expressions.parameter(Employee.class, "e"); // "Enumerable<T> asEnumerable(final T[] ts)" List<Integer> list = queryProvider.createQuery( Expressions.call( Expressions.call( Types.of(Enumerable.class, Employee.class), null, LINQ4J_AS_ENUMERABLE_METHOD, Expressions.constant(new JdbcTest.HrSchema().emps)), "asQueryable"), Employee.class) .select( Expressions.<Function1<Employee, Integer>>lambda( Expressions.field(e, "empid"), e)) .toList(); assertEquals(Arrays.asList(100, 200, 150, 110), list); }
public <T> CalciteSignature<T> prepareQueryable( Context context, Queryable<T> queryable) { return prepare_(context, Query.of(queryable), queryable.getElementType(), -1); }
/** * Projects each element of a sequence into a new form. */ public static <T, TResult> Queryable<TResult> select(Queryable<T> source, FunctionExpression<Function1<T, TResult>> selector) { return source.getProvider().createQuery( Expressions.call(source.getExpression(), "select", selector), functionResultType(selector)); }
@Test public void testTableWhere() throws SQLException, ClassNotFoundException { final Connection connection = CalciteAssert.that(CalciteAssert.Config.JDBC_FOODMART).connect(); final CalciteConnection calciteConnection = connection.unwrap(CalciteConnection.class); final SchemaPlus rootSchema = calciteConnection.getRootSchema(); ParameterExpression c = Expressions.parameter(JdbcTest.Customer.class, "c"); String s = Schemas.queryable(Schemas.createDataContext(connection, rootSchema), rootSchema.getSubSchema("foodmart"), JdbcTest.Customer.class, "customer") .where( Expressions.lambda( Expressions.lessThan( Expressions.field(c, "customer_id"), Expressions.constant(5)), c)) .toList() .toString(); Util.discard(s); } }
rowEnumerable = queryable.select(o -> { final Object[] values = new Object[fields.size()]; for (int i = 0; i < fields.size(); i++) {
RelNode toRel(Queryable<T> queryable) { if (queryable instanceof QueryableDefaults.Replayable) { //noinspection unchecked ((QueryableDefaults.Replayable) queryable).replay(this); return rel; } if (queryable instanceof AbstractTableQueryable) { final AbstractTableQueryable tableQueryable = (AbstractTableQueryable) queryable; final QueryableTable table = tableQueryable.table; final CalciteSchema.TableEntry tableEntry = CalciteSchema.from(tableQueryable.schema) .add(tableQueryable.tableName, tableQueryable.table); final RelOptTableImpl relOptTable = RelOptTableImpl.create(null, table.getRowType(translator.typeFactory), tableEntry, null); if (table instanceof TranslatableTable) { return ((TranslatableTable) table).toRel(translator, relOptTable); } else { return LogicalTableScan.create(translator.cluster, relOptTable); } } return translator.translate(queryable.getExpression()); }
/** * Bypasses a specified number of elements in a * sequence and then returns the remaining elements. */ public static <T> Queryable<T> skip(Queryable<T> source, int count) { return EnumerableDefaults.skip(source.asEnumerable(), count).asQueryable(); }
/** * Bypasses elements in a sequence as long as a * specified condition is true and then returns the remaining * elements. The element's index is used in the logic of the * predicate function. */ public static <T> Queryable<T> skipWhileN(final Queryable<T> source, final FunctionExpression<Predicate2<T, Integer>> predicate) { return new BaseQueryable<T>(source.getProvider(), source.getElementType(), source.getExpression()) { public Enumerator<T> enumerator() { return new EnumerableDefaults.SkipWhileEnumerator<>( source.enumerator(), predicate.getFunction()); } }; }
public <T> CalciteSignature<T> prepareQueryable( Context context, Queryable<T> queryable) { return prepare_(context, Query.of(queryable), queryable.getElementType(), -1); }