public F getFunction() { if (function != null) { return function; } if (dynamicFunction == null) { final Invokable x = compile(); //noinspection unchecked dynamicFunction = (F) Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Types.toClass(type)}, (proxy, method, args) -> x.dynamicInvoke(args)); } return dynamicFunction; }
/** * Creates a FunctionExpression from an actual function. */ public static <F extends Function<?>> FunctionExpression<F> lambda( F function) { // REVIEW: Check that that function class is non-inner, has a public // default constructor, etc.? //noinspection unchecked return new FunctionExpression<>(function); }
private String getAbstractMethodName() { final Method abstractMethod = getAbstractMethod(); assert abstractMethod != null; return abstractMethod.getName(); }
public <TKey, TElement, TResult> Queryable<TResult> groupBy( FunctionExpression<Function1<T, TKey>> keySelector, FunctionExpression<Function1<T, TElement>> elementSelector, FunctionExpression<Function2<TKey, Enumerable<TElement>, TResult>> resultSelector, EqualityComparer<TKey> comparer) { return EnumerableDefaults.groupBy(getThis(), keySelector.getFunction(), elementSelector.getFunction(), resultSelector.getFunction(), comparer) .asQueryable(); }
resultType2 = body.getType(); String methodName = getAbstractMethodName(); writer.append("new ") .append(type) isAbstractMethodPrimitive() ? Types.className(bridgeResultType) : Types.boxClassName(bridgeResultType);
public <TInner, TKey, TResult> Queryable<TResult> groupJoin( Enumerable<TInner> inner, FunctionExpression<Function1<T, TKey>> outerKeySelector, FunctionExpression<Function1<TInner, TKey>> innerKeySelector, FunctionExpression<Function2<T, Enumerable<TInner>, TResult>> resultSelector, EqualityComparer<TKey> comparer) { return EnumerableDefaults.groupJoin(getThis(), inner, outerKeySelector.getFunction(), innerKeySelector.getFunction(), resultSelector.getFunction(), comparer).asQueryable(); }
public <TKey, TElement, TResult> Queryable<TResult> groupBy( FunctionExpression<Function1<T, TKey>> keySelector, FunctionExpression<Function1<T, TElement>> elementSelector, FunctionExpression<Function2<TKey, Enumerable<TElement>, TResult>> resultSelector) { return EnumerableDefaults.groupBy(getThis(), keySelector.getFunction(), elementSelector.getFunction(), resultSelector.getFunction()) .asQueryable(); }
private static Object coerce(Object o, RelDataType type) { if (o == null) { return null; } if (!(type instanceof RelDataTypeFactoryImpl.JavaType)) { return null; } final RelDataTypeFactoryImpl.JavaType javaType = (RelDataTypeFactoryImpl.JavaType) type; final Class clazz = javaType.getJavaClass(); //noinspection unchecked if (clazz.isAssignableFrom(o.getClass())) { return o; } if (clazz == String.class && o instanceof NlsString) { return ((NlsString) o).getValue(); } // We need optimization here for constant folding. // Not all the expressions can be interpreted (e.g. ternary), so // we rely on optimization capabilities to fold non-interpretable // expressions. BlockBuilder bb = new BlockBuilder(); final Expression expr = RexToLixTranslator.convert(Expressions.constant(o), clazz); bb.add(Expressions.return_(null, expr)); final FunctionExpression convert = Expressions.lambda(bb.toBlock(), Collections.emptyList()); return convert.compile().dynamicInvoke(); }
/** * Creates a LambdaExpression by first constructing a delegate * type. * * <p>It can be used when the delegate type is not known at compile time. */ public static <T, F extends Function<? extends T>> FunctionExpression<F> lambda(Class<F> type, BlockStatement body, Iterable<? extends ParameterExpression> parameters) { return new FunctionExpression<>(type, body, toList(parameters)); }
private boolean isAbstractMethodPrimitive() { Method method = getAbstractMethod(); return method != null && Primitive.is(method.getReturnType()); }
public <TInner, TKey, TResult> Queryable<TResult> join( Enumerable<TInner> inner, FunctionExpression<Function1<T, TKey>> outerKeySelector, FunctionExpression<Function1<TInner, TKey>> innerKeySelector, FunctionExpression<Function2<T, TInner, TResult>> resultSelector, EqualityComparer<TKey> comparer) { return EnumerableDefaults.join(getThis(), inner, outerKeySelector.getFunction(), innerKeySelector.getFunction(), resultSelector.getFunction(), comparer).asQueryable(); }
private static Object coerce(Object o, RelDataType type) { if (o == null) { return null; } if (!(type instanceof RelDataTypeFactoryImpl.JavaType)) { return null; } final RelDataTypeFactoryImpl.JavaType javaType = (RelDataTypeFactoryImpl.JavaType) type; final Class clazz = javaType.getJavaClass(); //noinspection unchecked if (clazz.isAssignableFrom(o.getClass())) { return o; } if (clazz == String.class && o instanceof NlsString) { return ((NlsString) o).getValue(); } // We need optimization here for constant folding. // Not all the expressions can be interpreted (e.g. ternary), so // we rely on optimization capabilities to fold non-interpretable // expressions. BlockBuilder bb = new BlockBuilder(); final Expression expr = RexToLixTranslator.convert(Expressions.constant(o), clazz); bb.add(Expressions.return_(null, expr)); final FunctionExpression convert = Expressions.lambda(bb.toBlock(), Collections.emptyList()); return convert.compile().dynamicInvoke(); }
/** * Creates a LambdaExpression by first constructing a delegate * type. */ public static <F extends Function<?>> FunctionExpression<F> lambda( BlockStatement body, Iterable<? extends ParameterExpression> parameters) { final List<ParameterExpression> parameterList = toList(parameters); @SuppressWarnings("unchecked") Class<F> type = deduceType(parameterList, body.getType()); return new FunctionExpression<>(type, body, parameterList); }
public <TAccumulate, TResult> TResult aggregate(TAccumulate seed, FunctionExpression<Function2<TAccumulate, T, TAccumulate>> func, FunctionExpression<Function1<TAccumulate, TResult>> selector) { return EnumerableDefaults.aggregate(getThis(), seed, func.getFunction(), selector.getFunction()); }
public <TKey, TResult> Queryable<TResult> groupByK( FunctionExpression<Function1<T, TKey>> keySelector, FunctionExpression<Function2<TKey, Enumerable<T>, TResult>> resultSelector) { return EnumerableDefaults.groupBy(getThis(), keySelector.getFunction(), resultSelector.getFunction()).asQueryable(); }
public <TCollection, TResult> Queryable<TResult> selectManyN( FunctionExpression<Function1<T, Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T, TCollection, TResult>> resultSelector) { return EnumerableDefaults.selectMany(getThis(), collectionSelector.getFunction(), resultSelector.getFunction()) .asQueryable(); }
public <TKey, TElement> Queryable<Grouping<TKey, TElement>> groupBy( FunctionExpression<Function1<T, TKey>> keySelector, FunctionExpression<Function1<T, TElement>> elementSelector, EqualityComparer<TKey> comparer) { return EnumerableDefaults.groupBy(getThis(), keySelector.getFunction(), elementSelector.getFunction(), comparer).asQueryable(); }
public <TKey, TResult> Queryable<TResult> groupByK( FunctionExpression<Function1<T, TKey>> keySelector, FunctionExpression<Function2<TKey, Enumerable<T>, TResult>> resultSelector, EqualityComparer<TKey> comparer) { return EnumerableDefaults.groupBy(getThis(), keySelector.getFunction(), resultSelector.getFunction(), comparer).asQueryable(); }
public <TCollection, TResult> Queryable<TResult> selectMany( FunctionExpression<Function2<T, Integer, Enumerable<TCollection>>> collectionSelector, FunctionExpression<Function2<T, TCollection, TResult>> resultSelector) { return EnumerableDefaults.selectMany(getThis(), collectionSelector.getFunction(), resultSelector.getFunction()) .asQueryable(); }
public <TKey, TElement> Queryable<Grouping<TKey, TElement>> groupBy( FunctionExpression<Function1<T, TKey>> keySelector, FunctionExpression<Function1<T, TElement>> elementSelector) { return EnumerableDefaults.groupBy(getThis(), keySelector.getFunction(), elementSelector.getFunction()).asQueryable(); }