Inheritance diagram for com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction:

Collaboration diagram for com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction:

Public Member Functions
List< String >	getParamNames ()

List< FunctionParameter >	getParameters ()

SqlReturnTypeInference	getRowTypeInference ()

Set< RelColumnMapping >	getColumnMappings ()

String	getExtendedSignature ()

List< String >	getExtendedParamNames ()

int	hashCode ()

boolean	equals (final Object obj)

String	toString ()

Map< String, List < ExtArgumentType > >	getCursorFieldTypes ()

List< ExtArgumentType >	getArgTypes ()

boolean	supportsDefaultArguments ()

boolean	isArgumentOptional (int i)

int	getNumOptionalArguments ()

SqlCall	rewriteCallWithDefaultArguments (SqlCall permutedCall)

boolean	checkOperandTypes (SqlCallBinding callBinding, boolean throwOnFailure)

Package Functions
	ExtTableFunction (final String name, final ExtensionFunction sig)

Map< String, Comparable<?> >	getDefaultValues ()

SqlLiteral	createLiteralForDefaultValue (Comparable<?> value, SqlParserPos pos)

Private Member Functions
void	debugPrint (String msg, Boolean debugMode)

Private Attributes
final List< ExtArgumentType >	arg_types

final List< ExtArgumentType >	outs

final List< String >	arg_names

final List< String >	pretty_arg_names

final List< String >	out_names

final Map< String, String >	options

final Map< String, List < ExtArgumentType > >	cursor_field_types

final Map< String, Comparable<?> >	default_values

Detailed Description

Definition at line 3123 of file HeavyDBSqlOperatorTable.java.

Constructor & Destructor Documentation

com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.ExtTableFunction	(	final String	name,
		final ExtensionFunction	sig
	)

inlinepackage

Definition at line 3124 of file HeavyDBSqlOperatorTable.java.

                                                                      {
       super(name,
               SqlKind.OTHER_FUNCTION,
               ReturnTypes.CURSOR,
               null,
               new ExtTableFunctionTypeChecker(HeavyDBSqlOperatorTable.this),
               SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION);
       arg_types = sig.getArgs();
       outs = sig.getOuts();
       out_names = sig.getOutNames();
       arg_names = sig.getArgNames();
       // pretty_arg_names will be same as arg_names, except with
       // arg names for cursors stripped of array elements, i.e
       // my_cursor_input[x, y, z] => my_cursor_input
       pretty_arg_names = sig.getPrettyArgNames();
       options = sig.getOptions();
       cursor_field_types = sig.getCursorFieldTypes();
       default_values = sig.getDefaultValues();
     }

Member Function Documentation

boolean com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.checkOperandTypes	(	SqlCallBinding	callBinding,
		boolean	throwOnFailure
	)

inline

Definition at line 3462 of file HeavyDBSqlOperatorTable.java.

                                                                                          {
       // We need to override this because the default Calcite implementation adds logic to
       // handle default values before deferring typechecking to the operator's own
       // SqlOperandTypeChecker. Since we want to handle default values differently for
       // UDTFs, this method bypasses that logic and simply calls the type checker
       // directly.
       return getOperandTypeChecker().checkOperandTypes(callBinding, throwOnFailure);
     }

SqlLiteral com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.createLiteralForDefaultValue	(	Comparable<?>	value,
		SqlParserPos	pos
	)

inlinepackage

Definition at line 3447 of file HeavyDBSqlOperatorTable.java.

References Double, Float, and Integer.

                                                                                    {
       if (value instanceof Integer || value instanceof Long || value instanceof Float
               || value instanceof Double) {
         return SqlLiteral.createExactNumeric(value.toString(), pos);
       } else if (value instanceof Boolean) {
         Boolean asBool = (Boolean) value;
         return SqlLiteral.createBoolean(asBool.booleanValue(), pos);
       } else if (value instanceof String) {
         return SqlLiteral.createCharString(value.toString(), pos);
       } else {
         return null;
       }
     }

void com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.debugPrint	(	String	msg,
		Boolean	debugMode
	)

inlineprivate

Definition at line 3219 of file HeavyDBSqlOperatorTable.java.

                                                            {
       if (debugMode) {
         System.out.println(msg);
       }
     }

boolean com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.equals ( final Object obj )

inline

Definition at line 3336 of file HeavyDBSqlOperatorTable.java.

References com.mapd.parser.server.ExtensionFunction.ExtArgumentType.Cursor.

                                             {
       if (obj == null) {
         return false;
       }
 
       if (getClass() != obj.getClass()) {
         return false;
       }
 
       if (this == obj) {
         return true;
       }
 
       final ExtTableFunction other = (ExtTableFunction) obj;
       if (!this.getName().equals(other.getName())) {
         return false;
       }
       if (arg_types.size() != other.arg_types.size()) {
         return false;
       }
 
       for (int i = 0; i < arg_types.size(); i++) {
         if (arg_types.get(i) != other.arg_types.get(i)) {
           return false;
         }
         if (arg_types.get(i) == ExtArgumentType.Cursor) {
           String paramName = this.arg_names.get(i);
           String otherParamName = other.getExtendedParamNames().get(i);
           if (!paramName.equals(otherParamName)) {
             return false;
           }
 
           List<ExtArgumentType> field_types = this.getCursorFieldTypes().get(paramName);
           List<ExtArgumentType> other_field_types =
                   other.getCursorFieldTypes().get(paramName);
           if (field_types.size() != other_field_types.size()) {
             return false;
           }
           for (int j = 0; j < field_types.size(); j++) {
             if (field_types.get(j) != other_field_types.get(j)) {
               return false;
             }
           }
         }
       }
       return true;
     }

List<ExtArgumentType> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getArgTypes ( )

inline

Definition at line 3393 of file HeavyDBSqlOperatorTable.java.

Referenced by com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateScoreForCursorOperand().

                                                {
       return arg_types;
     }

Here is the caller graph for this function:

Set<RelColumnMapping> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getColumnMappings ( )

inline

Definition at line 3225 of file HeavyDBSqlOperatorTable.java.

References Integer.

                                                      {
       final Boolean debugMode = false;
       Set<RelColumnMapping> s = new HashSet<RelColumnMapping>();
       debugPrint("getNameAsId() -> " + getNameAsId() + ", arg_names=" + arg_names
                       + ", out_names=" + out_names,
               debugMode);
       if (Integer.valueOf(options.getOrDefault("filter_table_function_transpose", "0"))
               == 1) {
         debugPrint("getNameAsId() -> " + getNameAsId(), debugMode);
         int rel_idx = -1;
         for (int arg_idx = 0; arg_idx < arg_names.size(); ++arg_idx) {
           String arg_name = arg_names.get(arg_idx);
           String[] fields;
           int start = arg_name.indexOf("[");
           if (start != -1) {
             rel_idx += 1;
             int end = arg_name.lastIndexOf("]");
             fields = arg_name.substring(start + 1, end)
                              .replaceAll("\\s+", "")
                              .split(",", 0);
           } else {
             fields = new String[] {arg_name};
           }
           debugPrint("fields=" + Arrays.toString(fields), debugMode);
           for (int field_idx = 0; field_idx < fields.length; ++field_idx) {
             int out_idx = out_names.indexOf(fields[field_idx]);
             if (out_idx >= 0) {
               s.add(new RelColumnMapping(out_idx, rel_idx, field_idx, false));
               debugPrint("out_idx, arg_idx/rel_idx, field_idx=" + out_idx + ", " + arg_idx
                               + "/" + rel_idx + ", " + field_idx,
                       debugMode);
             }
           }
         }
       }
       return s;
     }

Map<String, List<ExtArgumentType> > com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getCursorFieldTypes ( )

inline

Definition at line 3389 of file HeavyDBSqlOperatorTable.java.

                                                                     {
       return cursor_field_types;
     }

Map<String, Comparable<?> > com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getDefaultValues ( )

inlinepackage

Definition at line 3397 of file HeavyDBSqlOperatorTable.java.

                                                   {
       return default_values;
     }

List<String> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getExtendedParamNames ( )

inline

Definition at line 3322 of file HeavyDBSqlOperatorTable.java.

                                                 {
       return this.arg_names;
     }

String com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getExtendedSignature ( )

inline

Definition at line 3272 of file HeavyDBSqlOperatorTable.java.

References File_Namespace.append(), com.mapd.parser.server.ExtensionFunction.ExtArgumentType.Cursor, and run_benchmark_import.type.

                                          {
       StringBuilder ret = new StringBuilder();
       ret.append("'");
       ret.append(this.getName());
       ret.append("(");
 
       for (int i = 0; i < this.arg_types.size(); i++) {
         if (i > 0) {
           ret.append(", ");
         }
 
         ExtArgumentType type = arg_types.get(i);
         String paramName = arg_names.get(i);
         ret.append(paramName).append(" => ");
 
         final String t = type.toString().toUpperCase(Locale.ROOT);
         ret.append("<").append(t);
         if (type == ExtArgumentType.Cursor) {
           List<ExtensionFunction.ExtArgumentType> field_types =
                   cursor_field_types.get(paramName);
           ret.append("[");
           for (int j = 0; j < field_types.size(); j++) {
             if (j > 0) {
               ret.append(",");
             }
             ExtArgumentType field_type = field_types.get(j);
             ret.append(toSqlTypeName(field_type));
             if (isColumnListType(field_type)) {
               ExtArgumentType subtype = getValueType(field_type);
               ret.append("[");
               ret.append(toSqlTypeName(subtype));
               ret.append("]");
             } else if (isColumnArrayType(field_type) || isArrayType(field_type)) {
               ExtArgumentType subtype = getValueType(getValueType(field_type));
               ret.append("[");
               ret.append(toSqlTypeName(subtype));
               ret.append("]");
             }
           }
           ret.append("]");
         }
         ret.append(">");
       }
       ret.append(")'");
 
       return ret.toString();
     }

Here is the call graph for this function:

int com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getNumOptionalArguments ( )

inline

Definition at line 3413 of file HeavyDBSqlOperatorTable.java.

                                          {
       return getDefaultValues().size();
     }

List<FunctionParameter> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getParameters ( )

inline

Definition at line 3164 of file HeavyDBSqlOperatorTable.java.

References run_benchmark_import.type.

                                                    {
       final Boolean has_names = this.pretty_arg_names != null
               && this.pretty_arg_names.size() == this.arg_types.size();
       final List<FunctionParameter> parameters = new java.util.ArrayList<>();
       for (int i = 0; i < this.arg_types.size(); i++) {
         final int arg_idx = i;
         parameters.add(new FunctionParameter() {
           public int getOrdinal() {
             return arg_idx;
           }
 
           public String getName() {
             if (has_names) {
               return pretty_arg_names.get(arg_idx);
             }
             return "arg" + arg_idx;
           }
 
           public RelDataType getType(RelDataTypeFactory typeFactory) {
             SqlTypeFamily type = toSqlTypeName(arg_types.get(arg_idx)).getFamily();
             return type.getDefaultConcreteType(typeFactory);
           }
 
           public boolean isOptional() {
             return false;
           }
         });
       }
       return parameters;
     }

List<String> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getParamNames ( )

inline

Definition at line 3150 of file HeavyDBSqlOperatorTable.java.

                                         {
       return pretty_arg_names;
     }

SqlReturnTypeInference com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getRowTypeInference ( )

inline

Definition at line 3196 of file HeavyDBSqlOperatorTable.java.

References com.mapd.parser.server.ExtensionFunction.isColumnArrayType(), and run_benchmark_import.type.

                                                         {
       return opBinding -> {
         RelDataTypeFactory fact = opBinding.getTypeFactory();
         FieldInfoBuilder ret = fact.builder();
         for (int out_idx = 0; out_idx < outs.size(); ++out_idx) {
           RelDataType type;
           if (toSqlTypeName(outs.get(out_idx)) == SqlTypeName.ARRAY) {
             ExtArgumentType extSubType = getValueType(outs.get(out_idx));
             if (ExtensionFunction.isColumnArrayType(outs.get(out_idx))) {
               extSubType = getValueType(extSubType);
             }
             RelDataType subtype = fact.createSqlType(toSqlTypeName(extSubType));
             type = fact.createArrayType(subtype, -1);
           } else {
             type = fact.createSqlType(toSqlTypeName(outs.get(out_idx)));
           }
           ret = ret.add(out_names.get(out_idx), type);
           ret = ret.nullable(true);
         }
         return ret.build();
       };
     }

Here is the call graph for this function:

int com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.hashCode ( )

inline

Definition at line 3328 of file HeavyDBSqlOperatorTable.java.

                           {
       return this.getExtendedSignature().hashCode();
     }

boolean com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.isArgumentOptional ( int i )

inline

Definition at line 3408 of file HeavyDBSqlOperatorTable.java.

                                              {
       String paramName = getParamNames().get(i);
       return getDefaultValues().get(paramName) != null;
     }

SqlCall com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.rewriteCallWithDefaultArguments ( SqlCall permutedCall )

inline

Definition at line 3430 of file HeavyDBSqlOperatorTable.java.

                                                                          {
       for (Ord<SqlNode> operand : Ord.zip(permutedCall.getOperandList())) {
         if (operand.e.getClass() == SqlBasicCall.class) {
           SqlBasicCall operandAsCall = (SqlBasicCall) operand.e;
           if (operandAsCall.getOperator().getName() == "DEFAULT") {
             ExtTableFunction tf = (ExtTableFunction) permutedCall.getOperator();
             String paramName = tf.getExtendedParamNames().get(operand.i);
             Comparable<?> defaultVal = tf.getDefaultValues().get(paramName);
             SqlLiteral newOperand = createLiteralForDefaultValue(
                     defaultVal, operand.e.getParserPosition());
             permutedCall.setOperand(operand.i, newOperand);
           }
         }
       }
       return permutedCall;
     }

boolean com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.supportsDefaultArguments ( )

inline

Definition at line 3401 of file HeavyDBSqlOperatorTable.java.

                                               {
       return (default_values.size() > 0);
     }

String com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.toString ( )

inline

Definition at line 3385 of file HeavyDBSqlOperatorTable.java.

                              {
       return getExtendedSignature();
     }

Member Data Documentation

final List<String> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.arg_names

private

Definition at line 3473 of file HeavyDBSqlOperatorTable.java.

final List<ExtArgumentType> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.arg_types

private

Definition at line 3471 of file HeavyDBSqlOperatorTable.java.

final Map<String, List<ExtArgumentType> > com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.cursor_field_types

private

Definition at line 3477 of file HeavyDBSqlOperatorTable.java.

final Map<String, Comparable<?> > com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.default_values

private

Definition at line 3478 of file HeavyDBSqlOperatorTable.java.

final Map<String, String> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.options

private

Definition at line 3476 of file HeavyDBSqlOperatorTable.java.

final List<String> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.out_names

private

Definition at line 3475 of file HeavyDBSqlOperatorTable.java.

final List<ExtArgumentType> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.outs

private

Definition at line 3472 of file HeavyDBSqlOperatorTable.java.

final List<String> com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.pretty_arg_names

private

Definition at line 3474 of file HeavyDBSqlOperatorTable.java.

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/java/calcite/src/main/java/com/mapd/calcite/parser/HeavyDBSqlOperatorTable.java

Public Member Functions

Package Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation