org.apache.calcite.adapter.enumerable.CallImplementor Java Examples

@Override
public CallImplementor getImplementor() {
  return RexImpTable.createImplementor((translator, call, translatedOperands) -> {
    final Expression sqlContext = Expressions.parameter(SamzaSqlExecutionContext.class, "sqlContext");
    final Expression samzaContext = Expressions.parameter(SamzaSqlExecutionContext.class, "context");
    final Expression getUdfInstance = Expressions.call(ScalarUdf.class, sqlContext, getUdfMethod,
        Expressions.constant(udfMethod.getDeclaringClass().getName()), Expressions.constant(udfName), samzaContext);

    List<Expression> convertedOperands = new ArrayList<>();
    // SAMZA: 2230 To allow UDFS to accept Untyped arguments.
    // We explicitly Convert the untyped arguments to type that the UDf expects.
    for (int index = 0; index < translatedOperands.size(); index++) {
      if (!udfMetadata.isDisableArgCheck() && translatedOperands.get(index).type == Object.class
          && udfMethod.getParameters()[index].getType() != Object.class) {
        convertedOperands.add(Expressions.convert_(translatedOperands.get(index), udfMethod.getParameters()[index].getType()));
      } else {
        convertedOperands.add(translatedOperands.get(index));
      }
    }

    final Expression callExpression = Expressions.call(Expressions.convert_(getUdfInstance, udfMethod.getDeclaringClass()), udfMethod,
        convertedOperands);
    return callExpression;
  }, NullPolicy.NONE, false);
}
 

/** Creates a {@link TableFunctionImpl} from a method. */
public static TableFunction create(final Method method) {
  if (!Modifier.isStatic(method.getModifiers())) {
    Class clazz = method.getDeclaringClass();
    if (!classHasPublicZeroArgsConstructor(clazz)) {
      throw RESOURCE.requireDefaultConstructor(clazz.getName()).ex();
    }
  }
  final Class<?> returnType = method.getReturnType();
  if (!QueryableTable.class.isAssignableFrom(returnType)
      && !ScannableTable.class.isAssignableFrom(returnType)) {
    return null;
  }
  CallImplementor implementor = createImplementor(method);
  return new TableFunctionImpl(method, implementor);
}
 

private static CallImplementor createImplementor(final Method method) {
  return RexImpTable.createImplementor(
      new ReflectiveCallNotNullImplementor(method) {
        public Expression implement(RexToLixTranslator translator,
            RexCall call, List<Expression> translatedOperands) {
          Expression expr = super.implement(translator, call,
              translatedOperands);
          final Class<?> returnType = method.getReturnType();
          if (QueryableTable.class.isAssignableFrom(returnType)) {
            Expression queryable = Expressions.call(
                Expressions.convert_(expr, QueryableTable.class),
                BuiltInMethod.QUERYABLE_TABLE_AS_QUERYABLE.method,
                Expressions.call(DataContext.ROOT,
                    BuiltInMethod.DATA_CONTEXT_GET_QUERY_PROVIDER.method),
                Expressions.constant(null, SchemaPlus.class),
                Expressions.constant(call.getOperator().getName(), String.class));
            expr = Expressions.call(queryable,
                BuiltInMethod.QUERYABLE_AS_ENUMERABLE.method);
          } else {
            expr = Expressions.call(expr,
                BuiltInMethod.SCANNABLE_TABLE_SCAN.method, DataContext.ROOT);
          }
          return expr;
        }
      }, NullPolicy.NONE, false);
}
 

private void defineImplementors() {
  //define implementors for hive operators
  final List<SqlOperator> operatorList = getOperatorList();
  RexImpTable.INSTANCE.defineImplementors((map, aggMap, winAggMap) -> {
    for (SqlOperator sqlOperator : operatorList) {
      if (sqlOperator instanceof HiveSqlAggFunction) {
        HiveSqlAggFunction aggFunction = (HiveSqlAggFunction) sqlOperator;
        aggMap.put(aggFunction, () -> new HiveUDAFImplementor(aggFunction));
      } else {
        /**since SqlOperator is identified by name and kind ,see
         *  {@link SqlOperator#equals(Object)} and
         *  {@link SqlOperator#hashCode()},
         *  we can override implementors of operators that declared in
         *  SqlStdOperatorTable
         *  */
        CallImplementor callImplementor;
        if (sqlOperator.getName().equals("NOT RLIKE") || sqlOperator.getName()
            .equals("NOT REGEXP")) {
          callImplementor =
              RexImpTable.createImplementor(
                  RexImpTable.NotImplementor.of(
                      new HiveUDFImplementor()), NullPolicy.STRICT, false);
        } else {
          callImplementor =
              RexImpTable.createImplementor(
                  new HiveUDFImplementor(), NullPolicy.NONE, false);
        }
        map.put(sqlOperator, callImplementor);

      }

    }
    // directly override some implementors of SqlOperator that declared in
    // SqlStdOperatorTable
    map.put(SqlStdOperatorTable.ITEM,
        new RexImpTable.ItemImplementor(true));
  });


}
 

/**
 * Creates {@link org.apache.calcite.schema.ScalarFunction} from given method.
 * When {@code eval} method does not suit, {@code null} is returned.
 *
 * @param method method that is used to implement the function
 * @return created {@link ScalarFunction} or null
 */
public static ScalarFunction create(Method method) {
  if (!Modifier.isStatic(method.getModifiers())) {
    Class clazz = method.getDeclaringClass();
    if (!classHasPublicZeroArgsConstructor(clazz)) {
      throw RESOURCE.requireDefaultConstructor(clazz.getName()).ex();
    }
  }
  CallImplementor implementor = createImplementor(method);
  return new ScalarFunctionImpl(method, implementor);
}
 

@Override public CallImplementor getImplementor() {
  return (translator, call, nullAs) -> {
    Method lookupMethod =
        Types.lookupMethod(Smalls.AllTypesFunction.class,
            "arrayAppendFun", List.class, Integer.class);
    return Expressions.call(lookupMethod,
        translator.translateList(call.getOperands(), nullAs));
  };
}
 

@Override
public CallImplementor getImplementor() {
    return implementor;
}
 

public CallImplementor getImplementor() {
  return IMPLEMENTOR;
}
 

public CallImplementor getImplementor() {
  return IMPLEMENTOR;
}
 

/** Private constructor. */
private ScalarFunctionImpl(Method method, CallImplementor implementor) {
  super(method);
  this.implementor = implementor;
}
 

public CallImplementor getImplementor() {
  return implementor;
}
 

private static CallImplementor createImplementor(final Method method) {
  final NullPolicy nullPolicy = getNullPolicy(method);
  return RexImpTable.createImplementor(
      new ReflectiveCallNotNullImplementor(method), nullPolicy, false);
}
 

/** Private constructor; use {@link #create}. */
private TableFunctionImpl(Method method, CallImplementor implementor) {
  super(method);
  this.implementor = implementor;
}
 

public CallImplementor getImplementor() {
  return implementor;
}
 

/**
 * Returns implementor that translates the function to linq4j expression.
 * @return implementor that translates the function to linq4j expression.
 */
CallImplementor getImplementor();
 

/**
 * Creates unsafe version of {@link ScalarFunction} from any method. The method
 * does not need to be static or belong to a class with default constructor. It is
 * the responsibility of the underlying engine to initialize the UDF object that
 * contain the method.
 *
 * @param method method that is used to implement the function
 */
public static ScalarFunction createUnsafe(Method method) {
  CallImplementor implementor = createImplementor(method);
  return new ScalarFunctionImpl(method, implementor);
}