public JMethod createCreateBeanMethod(final JDefinedClass bean) { final JMethod method = bean.method(JMod.PRIVATE | JMod.STATIC, bean, "_createBean"); final JVar param = method.param( _classByNames(java.lang.Class.class.getName(), MessageFormat.format("? extends {0}", bean.name())), "clazz"); final JClass invokerClass = _classByNames( "net.anwiba.commons.reflection.ReflectionConstructorInvoker", bean.name()); final JTryBlock _try = method.body()._try(); final JVar invoker = _try.body().decl(invokerClass, "invoker", JExpr._new(invokerClass).arg(param)); //$NON-NLS-1$ _try.body()._return(invoker.invoke("invoke")); final JCatchBlock _catch = _try._catch(_classByNames(java.lang.reflect.InvocationTargetException.class.getName())); final JVar exception = _catch.param("exception"); //$NON-NLS-1$ _catch.body()._throw(JExpr._new(_classByNames(java.lang.RuntimeException.class.getName())).arg(exception)); return method; }
/** * The code generator creates a method called __DRILL_INIT__ which takes the * place of the constructor when the code goes though the byte code merge. * For Plain-old Java, we call the method from a constructor created for * that purpose. (Generated code, fortunately, never includes a constructor, * so we can create one.) Since the init block throws an exception (which * should never occur), the generated constructor converts the checked * exception into an unchecked one so as to not require changes to the * various places that create instances of the generated classes. * * Example:<code><pre> * public StreamingAggregatorGen1() { * try { * __DRILL_INIT__(); * } catch (SchemaChangeException e) { * throw new UnsupportedOperationException(e); * } * }</pre></code> * * Note: in Java 8 we'd use the <tt>Parameter</tt> class defined in Java's * introspection package. But, Drill prefers Java 7 which only provides * parameter types. */ private void addCtor(Class<?>[] parameters) { JMethod ctor = clazz.constructor(JMod.PUBLIC); JBlock body = ctor.body(); // If there are parameters, need to pass them to the super class. if (parameters.length > 0) { JInvocation superCall = JExpr.invoke("super"); // This case only occurs for nested classes, and all nested classes // in Drill are inner classes. Don't pass along the (hidden) // this$0 field. for (int i = 1; i < parameters.length; i++) { Class<?> p = parameters[i]; superCall.arg(ctor.param(model._ref(p), "arg" + i)); } body.add(superCall); } JTryBlock tryBlock = body._try(); tryBlock.body().invoke(SignatureHolder.DRILL_INIT_METHOD); JCatchBlock catchBlock = tryBlock._catch(model.ref(SchemaChangeException.class)); catchBlock.body()._throw(JExpr._new(model.ref(UnsupportedOperationException.class)).arg(catchBlock.param("e"))); }
@SuppressWarnings("unchecked") JBlock catchCloneNotSupported(final JBlock body, final JClass elementType) { final Class<? extends Cloneable> elementRuntimeClass; try { elementRuntimeClass = (Class<? extends Cloneable>) Class.forName(elementType.binaryName()); } catch (final ClassNotFoundException e) { return body; } if (!cloneThrows(elementRuntimeClass)) { return body; } else { final JTryBlock tryBlock = body._try(); final JCatchBlock catchBlock = tryBlock._catch(this.codeModel.ref(CloneNotSupportedException.class)); final JVar exceptionVar = catchBlock.param("e"); catchBlock.body()._throw(JExpr._new(this.codeModel.ref(RuntimeException.class)).arg(exceptionVar)); return tryBlock.body(); } }
private void generateSetup(ClassGenerator<?> g, JVar[] workspaceJVars) { JCodeModel m = g.getModel(); JBlock sub = new JBlock(true, true); // declare and instantiate argument ObjectInspector's JVar oiArray = sub.decl( m._ref(ObjectInspector[].class), "argOIs", JExpr.newArray(m._ref(ObjectInspector.class), argTypes.length)); JClass oih = m.directClass(ObjectInspectorHelper.class.getCanonicalName()); JClass mt = m.directClass(TypeProtos.MinorType.class.getCanonicalName()); JClass mode = m.directClass(DataMode.class.getCanonicalName()); for(int i=0; i<argTypes.length; i++) { sub.assign( oiArray.component(JExpr.lit(i)), oih.staticInvoke("getDrillObjectInspector") .arg(mode.staticInvoke("valueOf").arg(JExpr.lit(argTypes[i].getMode().getNumber()))) .arg(mt.staticInvoke("valueOf").arg(JExpr.lit(argTypes[i].getMinorType().getNumber())))); } // declare and instantiate DeferredObject array sub.assign(workspaceJVars[2], JExpr.newArray(m._ref(DrillDeferredObject.class), argTypes.length)); for(int i=0; i<argTypes.length; i++) { sub.assign( workspaceJVars[2].component(JExpr.lit(i)), JExpr._new(m.directClass(DrillDeferredObject.class.getCanonicalName()))); } // declare empty array for argument deferred objects sub.assign(workspaceJVars[3], JExpr.newArray(m._ref(DrillDeferredObject.class), argTypes.length)); // create new instance of the UDF class sub.assign(workspaceJVars[1], getUDFInstance(m)); // create try..catch block to initialize the UDF instance with argument OIs JTryBlock udfInitTry = sub._try(); udfInitTry.body().assign( workspaceJVars[0], workspaceJVars[1].invoke("initialize") .arg(oiArray)); JCatchBlock udfInitCatch = udfInitTry._catch(m.directClass(Exception.class.getCanonicalName())); JVar exVar = udfInitCatch.param("ex"); udfInitCatch.body() ._throw(JExpr._new(m.directClass(RuntimeException.class.getCanonicalName())) .arg(JExpr.lit(String.format("Failed to initialize GenericUDF"))).arg(exVar)); sub.add(ObjectInspectorHelper.initReturnValueHolder(g, m, workspaceJVars[4], returnOI, returnType.getMinorType())); // now add it to the doSetup block in Generated class JBlock setup = g.getBlock(ClassGenerator.BlockType.SETUP); setup.directStatement(String.format("/** start %s for function %s **/ ", ClassGenerator.BlockType.SETUP.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); setup.add(sub); setup.directStatement(String.format("/** end %s for function %s **/ ", ClassGenerator.BlockType.SETUP.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); }
private HoldingContainer generateEval(ClassGenerator<?> g, HoldingContainer[] inputVariables, JVar[] workspaceJVars) { HoldingContainer out = g.declare(returnType); JCodeModel m = g.getModel(); JBlock sub = new JBlock(true, true); // initialize DeferredObject's. For an optional type, assign the value holder only if it is not null for(int i=0; i<argTypes.length; i++) { if (inputVariables[i].isOptional()) { sub.assign(workspaceJVars[3].component(JExpr.lit(i)), workspaceJVars[2].component(JExpr.lit(i))); JBlock conditionalBlock = new JBlock(false, false); JConditional jc = conditionalBlock._if(inputVariables[i].getIsSet().ne(JExpr.lit(0))); jc._then().assign(JExpr.ref(workspaceJVars[3].component(JExpr.lit(i)), "valueHolder"), inputVariables[i].getHolder()); jc._else().assign(JExpr.ref(workspaceJVars[3].component(JExpr.lit(i)), "valueHolder"), JExpr._null()); sub.add(conditionalBlock); } else { sub.assign(workspaceJVars[3].component(JExpr.lit(i)), workspaceJVars[2].component(JExpr.lit(i))); sub.assign(JExpr.ref(workspaceJVars[3].component(JExpr.lit(i)), "valueHolder"), inputVariables[i].getHolder()); } } // declare generic object for storing return value from GenericUDF.evaluate JVar retVal = sub.decl(m._ref(Object.class), "ret"); // create try..catch block to call the GenericUDF instance with given input JTryBlock udfEvalTry = sub._try(); udfEvalTry.body().assign(retVal, workspaceJVars[1].invoke("evaluate").arg(workspaceJVars[3])); JCatchBlock udfEvalCatch = udfEvalTry._catch(m.directClass(Exception.class.getCanonicalName())); JVar exVar = udfEvalCatch.param("ex"); udfEvalCatch.body() ._throw(JExpr._new(m.directClass(RuntimeException.class.getCanonicalName())) .arg(JExpr.lit(String.format("GenericUDF.evaluate method failed"))).arg(exVar)); // get the ValueHolder from retVal and return ObjectInspector sub.add(ObjectInspectorHelper.getDrillObject(m, returnOI, workspaceJVars[0], workspaceJVars[4], retVal)); sub.assign(out.getHolder(), workspaceJVars[4]); // now add it to the doEval block in Generated class JBlock setup = g.getBlock(ClassGenerator.BlockType.EVAL); setup.directStatement(String.format("/** start %s for function %s **/ ", ClassGenerator.BlockType.EVAL.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); setup.add(sub); setup.directStatement(String.format("/** end %s for function %s **/ ", ClassGenerator.BlockType.EVAL.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); return out; }
private void generateSetup(ClassGenerator<?> g, JVar[] workspaceJVars) { JCodeModel m = g.getModel(); JBlock sub = new JBlock(true, true); // declare and instantiate argument ObjectInspector's JVar oiArray = sub.decl( m._ref(ObjectInspector[].class), "argOIs", JExpr.newArray(m._ref(ObjectInspector.class), argTypes.length)); JClass oih = m.directClass(ObjectInspectorHelper.class.getCanonicalName()); JClass mt = m.directClass(MinorType.class.getCanonicalName()); JClass mode = m.directClass(DataMode.class.getCanonicalName()); for(int i=0; i<argTypes.length; i++) { sub.assign( oiArray.component(JExpr.lit(i)), oih.staticInvoke("getObjectInspector") .arg(mode.staticInvoke("valueOf").arg(JExpr.lit("OPTIONAL"))) .arg(mt.staticInvoke("valueOf").arg(JExpr.lit(argTypes[i].toMinorType().name()))) .arg((((PrimitiveObjectInspector) returnOI).getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.STRING) ? JExpr.lit(true) : JExpr.lit(false))); } // declare and instantiate DeferredObject array sub.assign(workspaceJVars[2], JExpr.newArray(m._ref(DeferredObject.class), argTypes.length)); for(int i=0; i<argTypes.length; i++) { sub.assign( workspaceJVars[2].component(JExpr.lit(i)), JExpr._new(m.directClass(DeferredObject.class.getCanonicalName()))); } // declare empty array for argument deferred objects sub.assign(workspaceJVars[3], JExpr.newArray(m._ref(DeferredObject.class), argTypes.length)); // create new instance of the UDF class sub.assign(workspaceJVars[1], getUDFInstance(m)); // create try..catch block to initialize the UDF instance with argument OIs JTryBlock udfInitTry = sub._try(); udfInitTry.body().assign( workspaceJVars[0], workspaceJVars[1].invoke("initialize") .arg(oiArray)); JCatchBlock udfInitCatch = udfInitTry._catch(m.directClass(Exception.class.getCanonicalName())); JVar exVar = udfInitCatch.param("ex"); udfInitCatch.body() ._throw(JExpr._new(m.directClass(RuntimeException.class.getCanonicalName())) .arg(JExpr.lit(String.format("Failed to initialize GenericUDF"))).arg(exVar)); sub.add(ObjectInspectorHelper.initReturnValueHolder(g, m, workspaceJVars[4], returnOI, returnType.toMinorType())); // now add it to the doSetup block in Generated class JBlock setup = g.getBlock(ClassGenerator.BlockType.SETUP); setup.directStatement(String.format("/** start %s for function %s **/ ", ClassGenerator.BlockType.SETUP.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); setup.add(sub); setup.directStatement(String.format("/** end %s for function %s **/ ", ClassGenerator.BlockType.SETUP.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); }
private HoldingContainer generateEval(ClassGenerator<?> g, HoldingContainer[] inputVariables, JVar[] workspaceJVars) { HoldingContainer out = g.declare(returnType); JCodeModel m = g.getModel(); JBlock sub = new JBlock(true, true); // initialize DeferredObject's. For an optional type, assign the value holder only if it is not null for(int i=0; i<argTypes.length; i++) { sub.assign(workspaceJVars[3].component(JExpr.lit(i)), workspaceJVars[2].component(JExpr.lit(i))); JBlock conditionalBlock = new JBlock(false, false); JConditional jc = conditionalBlock._if(inputVariables[i].getIsSet().ne(JExpr.lit(0))); jc._then().assign(JExpr.ref(workspaceJVars[3].component(JExpr.lit(i)), "valueHolder"), inputVariables[i].getHolder()); jc._else().assign(JExpr.ref(workspaceJVars[3].component(JExpr.lit(i)), "valueHolder"), JExpr._null()); sub.add(conditionalBlock); } // declare generic object for storing return value from GenericUDF.evaluate JVar retVal = sub.decl(m._ref(Object.class), "ret"); // create try..catch block to call the GenericUDF instance with given input JTryBlock udfEvalTry = sub._try(); udfEvalTry.body().assign(retVal, workspaceJVars[1].invoke("evaluate").arg(workspaceJVars[3])); JCatchBlock udfEvalCatch = udfEvalTry._catch(m.directClass(Exception.class.getCanonicalName())); JVar exVar = udfEvalCatch.param("ex"); udfEvalCatch.body() ._throw(JExpr._new(m.directClass(RuntimeException.class.getCanonicalName())) .arg(JExpr.lit(String.format("GenericUDF.evaluate method failed"))).arg(exVar)); // get the ValueHolder from retVal and return ObjectInspector sub.add(ObjectInspectorHelper.getObject(m, returnOI, workspaceJVars[0], workspaceJVars[4], retVal)); sub.assign(out.getHolder(), workspaceJVars[4]); // now add it to the doEval block in Generated class JBlock setup = g.getBlock(ClassGenerator.BlockType.EVAL); setup.directStatement(String.format("/** start %s for function %s **/ ", ClassGenerator.BlockType.EVAL.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); setup.add(sub); setup.directStatement(String.format("/** end %s for function %s **/ ", ClassGenerator.BlockType.EVAL.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); return out; }
private void generateSetup(ClassGenerator<?> g, JVar[] workspaceJVars) { JCodeModel m = g.getModel(); JBlock sub = new JBlock(true, true); // declare and instantiate argument ObjectInspector's JVar oiArray = sub.decl( m._ref(ObjectInspector[].class), "argOIs", JExpr.newArray(m._ref(ObjectInspector.class), argTypes.length)); JClass oih = m.directClass(ObjectInspectorHelper.class.getCanonicalName()); JClass mt = m.directClass(TypeProtos.MinorType.class.getCanonicalName()); JClass mode = m.directClass(DataMode.class.getCanonicalName()); for(int i=0; i<argTypes.length; i++) { sub.assign( oiArray.component(JExpr.lit(i)), oih.staticInvoke("getDrillObjectInspector") .arg(mode.staticInvoke("valueOf").arg(JExpr.lit(argTypes[i].getMode().getNumber()))) .arg(mt.staticInvoke("valueOf").arg(JExpr.lit(argTypes[i].getMinorType().getNumber()))) .arg((((PrimitiveObjectInspector) returnOI).getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.STRING) ? JExpr.lit(true) : JExpr.lit(false))); } // declare and instantiate DeferredObject array sub.assign(workspaceJVars[2], JExpr.newArray(m._ref(DrillDeferredObject.class), argTypes.length)); for(int i=0; i<argTypes.length; i++) { sub.assign( workspaceJVars[2].component(JExpr.lit(i)), JExpr._new(m.directClass(DrillDeferredObject.class.getCanonicalName()))); } // declare empty array for argument deferred objects sub.assign(workspaceJVars[3], JExpr.newArray(m._ref(DrillDeferredObject.class), argTypes.length)); // create new instance of the UDF class sub.assign(workspaceJVars[1], getUDFInstance(m)); // create try..catch block to initialize the UDF instance with argument OIs JTryBlock udfInitTry = sub._try(); udfInitTry.body().assign( workspaceJVars[0], workspaceJVars[1].invoke("initialize") .arg(oiArray)); JCatchBlock udfInitCatch = udfInitTry._catch(m.directClass(Exception.class.getCanonicalName())); JVar exVar = udfInitCatch.param("ex"); udfInitCatch.body() ._throw(JExpr._new(m.directClass(RuntimeException.class.getCanonicalName())) .arg(JExpr.lit(String.format("Failed to initialize GenericUDF"))).arg(exVar)); sub.add(ObjectInspectorHelper.initReturnValueHolder(g, m, workspaceJVars[4], returnOI, returnType.getMinorType())); // now add it to the doSetup block in Generated class JBlock setup = g.getBlock(ClassGenerator.BlockType.SETUP); setup.directStatement(String.format("/** start %s for function %s **/ ", ClassGenerator.BlockType.SETUP.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); setup.add(sub); setup.directStatement(String.format("/** end %s for function %s **/ ", ClassGenerator.BlockType.SETUP.name(), genericUdfClazz.getName() + (!isGenericUDF ? "("+udfName+")" : ""))); }
