FunctionListBuilder builder = new FunctionListBuilder() .window(RowNumberFunction.class) .window(RankFunction.class) .window(DenseRankFunction.class) .window(PercentRankFunction.class) .window(CumulativeDistributionFunction.class) .window(NTileFunction.class) .window(FirstValueFunction.class) .window(LastValueFunction.class) .window(NthValueFunction.class) .window(LagFunction.class) .window(LeadFunction.class) .aggregate(ApproximateCountDistinctAggregation.class) .aggregate(DefaultApproximateCountDistinctAggregation.class) .aggregate(SumDataSizeForStats.class) .aggregate(MaxDataSizeForStats.class) .aggregates(CountAggregation.class) .aggregates(VarianceAggregation.class) .aggregates(CentralMomentsAggregation.class) .aggregates(ApproximateLongPercentileAggregations.class) .aggregates(ApproximateLongPercentileArrayAggregations.class) .aggregates(ApproximateDoublePercentileAggregations.class) .aggregates(ApproximateDoublePercentileArrayAggregations.class) .aggregates(ApproximateRealPercentileAggregations.class) .aggregates(ApproximateRealPercentileArrayAggregations.class) .aggregates(CountIfAggregation.class) .aggregates(BooleanAndAggregation.class) .aggregates(BooleanOrAggregation.class) .aggregates(DoubleSumAggregation.class)
private static void extractParametricScalar(Class<?> clazz) { new FunctionListBuilder().scalar(clazz); }
private static void extractScalars(Class<?> clazz) { new FunctionListBuilder().scalars(clazz); } }
public FunctionAssertions addScalarFunctions(Class<?> clazz) { metadata.addFunctions(new FunctionListBuilder().scalars(clazz).getFunctions()); return this; }
protected void registerParametricScalar(Class<?> clazz) { Metadata metadata = functionAssertions.getMetadata(); List<SqlFunction> functions = new FunctionListBuilder() .scalar(clazz) .getFunctions(); metadata.getFunctionRegistry().addFunctions(functions); }
FunctionListBuilder builder = new FunctionListBuilder(typeManager) .window("row_number", BIGINT, ImmutableList.<Type>of(), RowNumberFunction.class) .window("rank", BIGINT, ImmutableList.<Type>of(), RankFunction.class) .window("dense_rank", BIGINT, ImmutableList.<Type>of(), DenseRankFunction.class) .window("percent_rank", DOUBLE, ImmutableList.<Type>of(), PercentRankFunction.class) .window("cume_dist", DOUBLE, ImmutableList.<Type>of(), CumulativeDistributionFunction.class) .window("ntile", BIGINT, ImmutableList.<Type>of(BIGINT), NTileFunction.class) .window("first_value", FirstValueFunction.class, "T", "T") .window("last_value", LastValueFunction.class, "T", "T") .window("nth_value", NthValueFunction.class, "T", "T", "bigint") .window("lag", LagFunction.class, "T", "T") .window("lag", LagFunction.class, "T", "T", "bigint") .window("lag", LagFunction.class, "T", "T", "bigint", "T") .window("lead", LeadFunction.class, "T", "T") .window("lead", LeadFunction.class, "T", "T", "bigint") .window("lead", LeadFunction.class, "T", "T", "bigint", "T") .aggregate(CountAggregation.class) .aggregate(VarianceAggregation.class) .aggregate(ApproximateLongPercentileAggregations.class) .aggregate(ApproximateLongPercentileArrayAggregations.class) .aggregate(ApproximateDoublePercentileAggregations.class) .aggregate(ApproximateDoublePercentileArrayAggregations.class) .aggregate(CountIfAggregation.class) .aggregate(BooleanAndAggregation.class) .aggregate(BooleanOrAggregation.class) .aggregate(DoubleSumAggregation.class) .aggregate(LongSumAggregation.class) .aggregate(AverageAggregations.class) .aggregate(GeometricMeanAggregations.class)
public static GenericAggregationFunctionFactory fromAggregationDefinition(Class<?> clazz, TypeManager typeManager) { FunctionListBuilder builder = new FunctionListBuilder(typeManager); for (InternalAggregationFunction aggregation : new AggregationCompiler(typeManager).generateAggregationFunctions(clazz)) { builder.aggregate(aggregation); } return new GenericAggregationFunctionFactory(builder.getFunctions()); }
if (SqlAggregationFunction.class.isAssignableFrom(clazz)) { try { builder.function((SqlAggregationFunction) clazz.newInstance()); if (clazz.getName().startsWith("com.qubole.presto.udfs.scalar")) { try { builder.scalar(clazz); builder.aggregate(clazz); try { WindowFunctionDefinition def = (WindowFunctionDefinition) clazz.newInstance(); builder.window((Class<? extends WindowFunction>) clazz); builder.function((SqlFunction) clazz.newInstance());
@BeforeClass public void setup() { functionRegistry.addFunctions(new FunctionListBuilder().aggregates(CountNull.class).getFunctions()); }
@Setup public void setup() { MetadataManager metadata = MetadataManager.createTestMetadataManager(); metadata.addFunctions(new FunctionListBuilder().function(EXACT_ARRAY_FILTER_FUNCTION).getFunctions()); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); ImmutableList.Builder<RowExpression> projectionsBuilder = ImmutableList.builder(); Block[] blocks = new Block[TYPES.size()]; for (int i = 0; i < TYPES.size(); i++) { Type elementType = TYPES.get(i); ArrayType arrayType = new ArrayType(elementType); Signature signature = new Signature(name, FunctionKind.SCALAR, arrayType.getTypeSignature(), arrayType.getTypeSignature(), parseTypeSignature("function(bigint,boolean)")); Signature greaterThan = new Signature("$operator$" + GREATER_THAN.name(), FunctionKind.SCALAR, BOOLEAN.getTypeSignature(), BIGINT.getTypeSignature(), BIGINT.getTypeSignature()); projectionsBuilder.add(new CallExpression(signature, arrayType, ImmutableList.of( field(0, arrayType), new LambdaDefinitionExpression( ImmutableList.of(BIGINT), ImmutableList.of("x"), new CallExpression(greaterThan, BOOLEAN, ImmutableList.of(new VariableReferenceExpression("x", BIGINT), constant(0L, BIGINT))))))); blocks[i] = createChannel(POSITIONS, ARRAY_SIZE, arrayType); } ImmutableList<RowExpression> projections = projectionsBuilder.build(); pageProcessor = compiler.compilePageProcessor(Optional.empty(), projections).get(); page = new Page(blocks); }
checkValidMethod(method); Optional<MethodHandle> instanceFactory = getInstanceFactory(method); MethodHandle methodHandle = lookup().unreflect(method); String name = scalarFunction.value(); if (name.isEmpty()) { name = camelToSnake(method.getName()); SCALAR, parseTypeSignature(returnTypeAnnotation.value(), literalParameters), parameterTypeSignatures(method, literalParameters)); verifyMethodSignature(method, signature.getReturnType(), signature.getArgumentTypes(), typeManager); List<Boolean> nullableArguments = getNullableArguments(method); scalar( signature, methodHandle, instanceFactory, scalarFunction.deterministic(), getDescription(method), scalarFunction.hidden(), method.isAnnotationPresent(Nullable.class), literalParameters); for (String alias : scalarFunction.alias()) { scalar(signature.withAlias(alias.toLowerCase(ENGLISH)), methodHandle, instanceFactory,
public Set<SqlFunction> listFunctions() { FunctionListBuilder builder = new FunctionListBuilder(); try { List<Class<?>> classes = getFunctionClasses(); addFunctions(builder, classes); } catch (IOException e) { System.out.println("Could not load classes from jar file: " + e); return Sets.newHashSet(); } return Sets.newHashSet(builder.getFunctions()); }
public FunctionListBuilder functions(SqlFunction... sqlFunctions) { for (SqlFunction sqlFunction : sqlFunctions) { function(sqlFunction); } return this; }
public FunctionListBuilder aggregate(List<InternalAggregationFunction> functions) { for (InternalAggregationFunction function : functions) { aggregate(function); } return this; }
metadata.addFunctions(new FunctionListBuilder().scalar(BenchmarkOldArrayHash.class).getFunctions()); metadata.addFunctions(new FunctionListBuilder().scalar(BenchmarkAnotherArrayHash.class).getFunctions()); ExpressionCompiler compiler = new ExpressionCompiler(metadata, new PageFunctionCompiler(metadata, 0)); ImmutableList.Builder<RowExpression> projectionsBuilder = ImmutableList.builder();
protected void registerScalar(Class<?> clazz) { Metadata metadata = functionAssertions.getMetadata(); List<SqlFunction> functions = new FunctionListBuilder() .scalars(clazz) .getFunctions(); metadata.getFunctionRegistry().addFunctions(functions); }
@BeforeClass public void setup() { InternalAggregationFunction function = new AggregationCompiler().generateAggregationFunction(CountNull.class); functionRegistry.addFunctions(new FunctionListBuilder(new TypeRegistry()).aggregate(function).getFunctions()); }
private static void extractScalars(Class<?> clazz) { new FunctionListBuilder().scalars(clazz); } }
public FunctionListBuilder functions(SqlFunction... sqlFunctions) { for (SqlFunction sqlFunction : sqlFunctions) { function(sqlFunction); } return this; }
public FunctionAssertions addScalarFunctions(Class<?> clazz) { metadata.addFunctions(new FunctionListBuilder(metadata.getTypeManager()).scalar(clazz).getFunctions()); return this; }