private static InternalAggregationFunction generateAggregation(Type type) { DynamicClassLoader classLoader = new DynamicClassLoader(ChecksumAggregationFunction.class.getClassLoader()); List<Type> inputTypes = ImmutableList.of(type); AggregationMetadata metadata = new AggregationMetadata( generateAggregationName(NAME, type.getTypeSignature(), inputTypes.stream().map(Type::getTypeSignature).collect(toImmutableList())), createInputParameterMetadata(type), INPUT_FUNCTION.bindTo(type), COMBINE_FUNCTION, OUTPUT_FUNCTION, ImmutableList.of(new AccumulatorStateDescriptor( NullableLongState.class, StateCompiler.generateStateSerializer(NullableLongState.class, classLoader), StateCompiler.generateStateFactory(NullableLongState.class, classLoader))), VARBINARY); GenericAccumulatorFactoryBinder factory = AccumulatorCompiler.generateAccumulatorFactoryBinder(metadata, classLoader); return new InternalAggregationFunction(NAME, inputTypes, ImmutableList.of(BIGINT), VARBINARY, true, false, factory); }
Set<Class<?>> supportedClasses = getSupportedFieldTypes(); for (Method method : clazz.getMethods()) { if (method.getName().equals("getEstimatedSize")) { checkArgument(supportedClasses.contains(type), type.getName() + " is not supported"); String name = method.getName().substring(3); builder.add(new StateField(name, type, getInitialValue(method), method.getName(), Optional.ofNullable(fieldTypes.get(name)))); checkArgument(type == boolean.class, "Only boolean is support for 'is' methods"); String name = method.getName().substring(2); builder.add(new StateField(name, type, getInitialValue(method), method.getName(), Optional.of(BOOLEAN))); checkInterface(clazz, fields);
public static <T> AccumulatorStateSerializer<T> generateStateSerializer(Class<T> clazz, Map<String, Type> fieldTypes, DynamicClassLoader classLoader) AccumulatorStateMetadata metadata = getMetadataAnnotation(clazz); if (metadata != null && metadata.stateSerializerClass() != void.class) { try { List<StateField> fields = enumerateFields(clazz, fieldTypes); generateGetSerializedType(definition, fields, callSiteBinder); generateSerialize(definition, callSiteBinder, clazz, fields); generateDeserialize(definition, callSiteBinder, clazz, fields);
private static InternalAggregationFunction generateAggregation(Type type) { DynamicClassLoader classLoader = new DynamicClassLoader(ChecksumAggregationFunction.class.getClassLoader()); List<Type> inputTypes = ImmutableList.of(type); AggregationMetadata metadata = new AggregationMetadata( generateAggregationName(NAME, type, inputTypes), createInputParameterMetadata(type), INPUT_FUNCTION.bindTo(type), null, null, COMBINE_FUNCTION, OUTPUT_FUNCTION, NullableLongState.class, new StateCompiler().generateStateSerializer(NullableLongState.class, classLoader), new StateCompiler().generateStateFactory(NullableLongState.class, classLoader), VARBINARY, false); GenericAccumulatorFactoryBinder factory = new AccumulatorCompiler().generateAccumulatorFactoryBinder(metadata, classLoader); return new InternalAggregationFunction(NAME, inputTypes, BIGINT, VARBINARY, true, false, factory); }
public static <T> AccumulatorStateSerializer<T> generateStateSerializer(Class<T> clazz, DynamicClassLoader classLoader) { return generateStateSerializer(clazz, ImmutableMap.of(), classLoader); }
public static <T> AccumulatorStateFactory<T> generateStateFactory(Class<T> clazz, DynamicClassLoader classLoader) { return generateStateFactory(clazz, ImmutableMap.of(), classLoader); }
public static <T> AccumulatorStateFactory<T> generateStateFactory(Class<T> clazz, Map<String, Type> fieldTypes, DynamicClassLoader classLoader) AccumulatorStateMetadata metadata = getMetadataAnnotation(clazz); if (metadata != null && metadata.stateFactoryClass() != void.class) { try { Class<? extends T> singleStateClass = generateSingleStateClass(clazz, fieldTypes, classLoader); Class<? extends T> groupedStateClass = generateGroupedStateClass(clazz, fieldTypes, classLoader);
@Test public void testGetSerializedType() { StateCompiler compiler = new StateCompiler(); AccumulatorStateSerializer<LongState> serializer = compiler.generateStateSerializer(LongState.class); assertEquals(serializer.getSerializedType(), BIGINT); }
private static <T> Class<? extends T> generateSingleStateClass(Class<T> clazz, Map<String, Type> fieldTypes, DynamicClassLoader classLoader) { ClassDefinition definition = new ClassDefinition( a(PUBLIC, FINAL), makeClassName("Single" + clazz.getSimpleName()), type(Object.class), type(clazz)); FieldDefinition instanceSize = generateInstanceSize(definition); // Add getter for class size definition.declareMethod(a(PUBLIC), "getEstimatedSize", type(long.class)) .getBody() .getStaticField(instanceSize) .retLong(); // Generate constructor MethodDefinition constructor = definition.declareConstructor(a(PUBLIC)); constructor.getBody() .append(constructor.getThis()) .invokeConstructor(Object.class); // Generate fields List<StateField> fields = enumerateFields(clazz, fieldTypes); for (StateField field : fields) { generateField(definition, constructor, field); } constructor.getBody() .ret(); return defineClass(definition, clazz, classLoader); }
type(GroupedAccumulator.class)); FieldDefinition instanceSize = generateInstanceSize(definition); List<StateField> fields = enumerateFields(clazz, fieldTypes); fieldDefinitions.add(generateGroupedField(definition, constructor, ensureCapacity, field));
checkArgument(supportedClasses.contains(type), type.getName() + " is not supported"); String name = method.getName().substring(3); builder.add(new StateField(name, type, getInitialValue(method))); checkArgument(type == boolean.class, "Only boolean is support for 'is' methods"); String name = method.getName().substring(2); builder.add(new StateField(name, type, getInitialValue(method), method.getName())); checkInterface(clazz, fields);
type(GroupedAccumulator.class)); List<StateField> fields = enumerateFields(clazz); fieldDefinitions.add(generateGroupedField(definition, constructor, ensureCapacity, field));
List<StateField> fields = enumerateFields(clazz); for (StateField field : fields) { generateField(definition, constructor, field);
/** * Computes the size in bytes that this state will occupy, when serialized as a Slice */ private static int serializedSizeOf(Class<?> stateClass) { List<StateField> fields = enumerateFields(stateClass); int size = 0; for (StateField field : fields) { size += field.sizeOfType(); } return size; }
private static InternalAggregationFunction generateAggregation(Type type) { DynamicClassLoader classLoader = new DynamicClassLoader(CountColumn.class.getClassLoader()); AccumulatorStateSerializer<LongState> stateSerializer = new StateCompiler().generateStateSerializer(LongState.class, classLoader); AccumulatorStateFactory<LongState> stateFactory = new StateCompiler().generateStateFactory(LongState.class, classLoader); Type intermediateType = stateSerializer.getSerializedType(); List<Type> inputTypes = ImmutableList.of(type); AggregationMetadata metadata = new AggregationMetadata( generateAggregationName(NAME, BIGINT, inputTypes), createInputParameterMetadata(type), INPUT_FUNCTION, null, null, COMBINE_FUNCTION, OUTPUT_FUNCTION, LongState.class, stateSerializer, stateFactory, BIGINT, false); GenericAccumulatorFactoryBinder factory = new AccumulatorCompiler().generateAccumulatorFactoryBinder(metadata, classLoader); return new InternalAggregationFunction(NAME, inputTypes, intermediateType, BIGINT, true, false, factory); }
public static <T> AccumulatorStateSerializer<T> generateStateSerializer(Class<T> clazz) { return generateStateSerializer(clazz, new DynamicClassLoader(clazz.getClassLoader())); }
public static <T> AccumulatorStateFactory<T> generateStateFactory(Class<T> clazz) { return generateStateFactory(clazz, new DynamicClassLoader(clazz.getClassLoader())); }
public <T> AccumulatorStateFactory<T> generateStateFactory(Class<T> clazz, DynamicClassLoader classLoader) AccumulatorStateMetadata metadata = getMetadataAnnotation(clazz); if (metadata != null && metadata.stateFactoryClass() != void.class) { try { Class<? extends T> singleStateClass = generateSingleStateClass(clazz, classLoader); Class<? extends T> groupedStateClass = generateGroupedStateClass(clazz, classLoader);
private static InternalAggregationFunction generateAggregation(Type type) { DynamicClassLoader classLoader = new DynamicClassLoader(CountColumn.class.getClassLoader()); AccumulatorStateSerializer<LongState> stateSerializer = StateCompiler.generateStateSerializer(LongState.class, classLoader); AccumulatorStateFactory<LongState> stateFactory = StateCompiler.generateStateFactory(LongState.class, classLoader); Type intermediateType = stateSerializer.getSerializedType(); List<Type> inputTypes = ImmutableList.of(type); AggregationMetadata metadata = new AggregationMetadata( generateAggregationName(NAME, BIGINT.getTypeSignature(), inputTypes.stream().map(Type::getTypeSignature).collect(toImmutableList())), createInputParameterMetadata(type), INPUT_FUNCTION, COMBINE_FUNCTION, OUTPUT_FUNCTION, ImmutableList.of(new AccumulatorStateDescriptor( LongState.class, stateSerializer, stateFactory)), BIGINT); GenericAccumulatorFactoryBinder factory = AccumulatorCompiler.generateAccumulatorFactoryBinder(metadata, classLoader); return new InternalAggregationFunction(NAME, inputTypes, ImmutableList.of(intermediateType), BIGINT, true, false, factory); }
AccumulatorStateSerializer<?> stateSerializer = new StateCompiler().generateStateSerializer(stateClass, classLoader); Type intermediateType = stateSerializer.getSerializedType(); Method intermediateInputFunction = getIntermediateInputFunction(clazz, stateClass); Method combineFunction = getCombineFunction(clazz, stateClass); AccumulatorStateFactory<?> stateFactory = new StateCompiler().generateStateFactory(stateClass, classLoader);