/**
* Sets up projection that will transfer all of the columns in batch, and also populate the
* partition column based on which partition a record falls into in the partition table
*
* @param batch
* @throws SchemaChangeException
*/
protected void setupNewSchema(VectorAccessible batch) throws SchemaChangeException {
container.clear();
final ErrorCollector collector = new ErrorCollectorImpl();
final List<TransferPair> transfers = Lists.newArrayList();
final ClassGenerator<OrderedPartitionProjector> cg =
CodeGenerator.getRoot(
OrderedPartitionProjector.TEMPLATE_DEFINITION, context.getFunctionRegistry());
for (VectorWrapper<?> vw : batch) {
TransferPair tp = vw.getValueVector().getTransferPair();
transfers.add(tp);
container.add(tp.getTo());
}
cg.setMappingSet(mainMapping);
int count = 0;
for (Ordering od : popConfig.getOrderings()) {
final LogicalExpression expr =
ExpressionTreeMaterializer.materialize(
od.getExpr(), batch, collector, context.getFunctionRegistry());
if (collector.hasErrors())
throw new SchemaChangeException(
"Failure while materializing expression. " + collector.toErrorString());
cg.setMappingSet(incomingMapping);
ClassGenerator.HoldingContainer left = cg.addExpr(expr, false);
cg.setMappingSet(partitionMapping);
ClassGenerator.HoldingContainer right =
cg.addExpr(
new ValueVectorReadExpression(new TypedFieldId(expr.getMajorType(), count++)), false);
cg.setMappingSet(mainMapping);
LogicalExpression fh =
FunctionGenerationHelper.getComparator(left, right, context.getFunctionRegistry());
ClassGenerator.HoldingContainer out = cg.addExpr(fh, false);
JConditional jc = cg.getEvalBlock()._if(out.getValue().ne(JExpr.lit(0)));
if (od.getDirection() == Direction.ASCENDING) {
jc._then()._return(out.getValue());
} else {
jc._then()._return(out.getValue().minus());
}
}
cg.getEvalBlock()._return(JExpr.lit(0));
container.add(this.partitionKeyVector);
container.buildSchema(batch.getSchema().getSelectionVectorMode());
try {
this.projector = context.getImplementationClass(cg);
projector.setup(
context, batch, this, transfers, partitionVectors, partitions, popConfig.getRef());
} catch (ClassTransformationException | IOException e) {
throw new SchemaChangeException("Failure while attempting to load generated class", e);
}
}
private MSorter createNewMSorter(
FragmentContext context,
List<Ordering> orderings,
VectorAccessible batch,
MappingSet mainMapping,
MappingSet leftMapping,
MappingSet rightMapping)
throws ClassTransformationException, IOException, SchemaChangeException {
CodeGenerator<MSorter> cg =
CodeGenerator.get(
MSorter.TEMPLATE_DEFINITION, context.getFunctionRegistry(), context.getOptions());
ClassGenerator<MSorter> g = cg.getRoot();
g.setMappingSet(mainMapping);
for (Ordering od : orderings) {
// first, we rewrite the evaluation stack for each side of the comparison.
ErrorCollector collector = new ErrorCollectorImpl();
final LogicalExpression expr =
ExpressionTreeMaterializer.materialize(
od.getExpr(), batch, collector, context.getFunctionRegistry());
if (collector.hasErrors()) {
throw new SchemaChangeException(
"Failure while materializing expression. " + collector.toErrorString());
}
g.setMappingSet(leftMapping);
HoldingContainer left = g.addExpr(expr, ClassGenerator.BlkCreateMode.FALSE);
g.setMappingSet(rightMapping);
HoldingContainer right = g.addExpr(expr, ClassGenerator.BlkCreateMode.FALSE);
g.setMappingSet(mainMapping);
// next we wrap the two comparison sides and add the expression block for the comparison.
LogicalExpression fh =
FunctionGenerationHelper.getOrderingComparator(
od.nullsSortHigh(), left, right, context.getFunctionRegistry());
HoldingContainer out = g.addExpr(fh, ClassGenerator.BlkCreateMode.FALSE);
JConditional jc = g.getEvalBlock()._if(out.getValue().ne(JExpr.lit(0)));
if (od.getDirection() == Direction.ASCENDING) {
jc._then()._return(out.getValue());
} else {
jc._then()._return(out.getValue().minus());
}
g.rotateBlock();
}
g.rotateBlock();
g.getEvalBlock()._return(JExpr.lit(0));
return context.getImplementationClass(cg);
}
private void generateCollectionAccessor(final DefinedPropertyOutline fieldOutline) {
final JFieldVar fieldVar = fieldOutline.getFieldVar();
if (fieldVar != null) {
final JMethod modifier =
this.modifierClass.method(
JMod.PUBLIC,
fieldVar.type(),
ModifierGenerator.GETTER_PREFIX + fieldOutline.getBaseName());
if (this.implement) {
final JFieldRef fieldRef =
new NestedThisRef(this.classOutline.getImplClass()).ref(fieldVar);
final JConditional ifNull = modifier.body()._if(fieldRef.eq(JExpr._null()));
ifNull
._then()
.assign(
fieldRef,
JExpr._new(
this.classOutline
.getImplClass()
.owner()
.ref(ArrayList.class)
.narrow(fieldOutline.getElementType())));
modifier.body()._return(fieldRef);
}
}
}
private ModifierGenerator(
final PluginContext pluginContext,
final DefinedTypeOutline classOutline,
final String modifierClassName,
final String modifierInterfaceName,
final Collection<TypeOutline> interfaces,
final String modifierMethodName,
final boolean implement)
throws JClassAlreadyExistsException {
this.classOutline = classOutline;
final JDefinedClass definedClass = classOutline.getImplClass();
this.implement = implement;
this.modifierClass =
definedClass._class(
JMod.PUBLIC, modifierClassName, classOutline.getImplClass().getClassType());
if (interfaces != null) {
for (final TypeOutline interfaceOutline : interfaces) {
this.modifierClass._implements(
pluginContext.ref(interfaceOutline.getImplClass(), modifierInterfaceName, true));
}
}
final JFieldRef cachedModifierField;
if (!"java.lang.Object".equals(definedClass._extends().fullName())) {
this.modifierClass._extends(
pluginContext.ref(definedClass._extends(), modifierClassName, false));
cachedModifierField = JExpr.refthis(ModifierGenerator.MODIFIER_CACHE_FIELD_NAME);
} else {
if (implement) {
cachedModifierField =
JExpr._this()
.ref(
definedClass.field(
JMod.PROTECTED | JMod.TRANSIENT,
this.modifierClass,
ModifierGenerator.MODIFIER_CACHE_FIELD_NAME));
} else {
cachedModifierField = null;
}
}
final JDefinedClass typeDefinition =
classOutline.isInterface()
&& ((DefinedInterfaceOutline) classOutline).getSupportInterface() != null
? ((DefinedInterfaceOutline) classOutline).getSupportInterface()
: definedClass;
final JMethod modifierMethod =
typeDefinition.method(JMod.PUBLIC, this.modifierClass, modifierMethodName);
if (this.implement) {
final JConditional ifCacheNull =
modifierMethod.body()._if(JExpr._null().eq(cachedModifierField));
ifCacheNull._then().assign(cachedModifierField, JExpr._new(this.modifierClass));
modifierMethod.body()._return(JExpr.cast(this.modifierClass, cachedModifierField));
}
}
protected HoldingContainer generateEvalBody(
ClassGenerator<?> g, HoldingContainer[] inputVariables, String body, JVar[] workspaceJVars) {
// g.getBlock().directStatement(String.format("//---- start of eval portion of %s function.
// ----//", functionName));
JBlock sub = new JBlock(true, true);
JBlock topSub = sub;
HoldingContainer out = null;
MajorType returnValueType = returnValue.type;
// add outside null handling if it is defined.
if (nullHandling == NullHandling.NULL_IF_NULL) {
JExpression e = null;
for (HoldingContainer v : inputVariables) {
if (v.isOptional()) {
if (e == null) {
e = v.getIsSet();
} else {
e = e.mul(v.getIsSet());
}
}
}
if (e != null) {
// if at least one expression must be checked, set up the conditional.
returnValueType = returnValue.type.toBuilder().setMode(DataMode.OPTIONAL).build();
out = g.declare(returnValueType);
e = e.eq(JExpr.lit(0));
JConditional jc = sub._if(e);
jc._then().assign(out.getIsSet(), JExpr.lit(0));
sub = jc._else();
}
}
if (out == null) out = g.declare(returnValueType);
// add the subblock after the out declaration.
g.getEvalBlock().add(topSub);
JVar internalOutput =
sub.decl(
JMod.FINAL,
g.getHolderType(returnValueType),
returnValue.name,
JExpr._new(g.getHolderType(returnValueType)));
addProtectedBlock(g, sub, body, inputVariables, workspaceJVars, false);
if (sub != topSub)
sub.assign(internalOutput.ref("isSet"), JExpr.lit(1)); // Assign null if NULL_IF_NULL mode
sub.assign(out.getHolder(), internalOutput);
if (sub != topSub)
sub.assign(internalOutput.ref("isSet"), JExpr.lit(1)); // Assign null if NULL_IF_NULL mode
return out;
}
private void generateComparisons(ClassGenerator<?> g, VectorAccessible batch)
throws SchemaChangeException {
g.setMappingSet(MAIN_MAPPING);
for (Ordering od : popConfig.getOrderings()) {
// first, we rewrite the evaluation stack for each side of the comparison.
ErrorCollector collector = new ErrorCollectorImpl();
final LogicalExpression expr =
ExpressionTreeMaterializer.materialize(
od.getExpr(), batch, collector, context.getFunctionRegistry());
if (collector.hasErrors()) {
throw new SchemaChangeException(
"Failure while materializing expression. " + collector.toErrorString());
}
g.setMappingSet(LEFT_MAPPING);
HoldingContainer left = g.addExpr(expr, ClassGenerator.BlkCreateMode.FALSE);
g.setMappingSet(RIGHT_MAPPING);
HoldingContainer right = g.addExpr(expr, ClassGenerator.BlkCreateMode.FALSE);
g.setMappingSet(MAIN_MAPPING);
// next we wrap the two comparison sides and add the expression block for the comparison.
LogicalExpression fh =
FunctionGenerationHelper.getOrderingComparator(
od.nullsSortHigh(), left, right, context.getFunctionRegistry());
HoldingContainer out = g.addExpr(fh, ClassGenerator.BlkCreateMode.FALSE);
JConditional jc = g.getEvalBlock()._if(out.getValue().ne(JExpr.lit(0)));
if (od.getDirection() == Direction.ASCENDING) {
jc._then()._return(out.getValue());
} else {
jc._then()._return(out.getValue().minus());
}
g.rotateBlock();
}
g.rotateBlock();
g.getEvalBlock()._return(JExpr.lit(0));
}
/**
* Add the pre-check to see if we are already in the UI thread.
*
* @param delegatingMethod
* @param holder
* @throws JClassAlreadyExistsException
*/
private void addUIThreadCheck(
JMethod delegatingMethod, JBlock previousBody, EComponentHolder holder)
throws JClassAlreadyExistsException {
// Get the Thread and Looper class.
JClass tClass = holder.classes().THREAD;
JClass lClass = holder.classes().LOOPER;
// invoke the methods.
JExpression lhs = tClass.staticInvoke(METHOD_CUR_THREAD);
JExpression rhs = lClass.staticInvoke(METHOD_MAIN_LOOPER).invoke(METHOD_GET_THREAD);
// create the conditional and the block.
JConditional con = delegatingMethod.body()._if(JOp.eq(lhs, rhs));
JBlock thenBlock = con._then().add(previousBody);
thenBlock._return();
}