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 ()

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

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

List< ExtArgumentType >	getArgTypes ()

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

Detailed Description

Definition at line 2706 of file HeavyDBSqlOperatorTable.java.

Constructor & Destructor Documentation

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

inlinepackage

Definition at line 2707 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();
     }

Member Function Documentation

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

inlineprivate

Definition at line 2801 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 2918 of file HeavyDBSqlOperatorTable.java.

References 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 ( )

inlinepackage

Definition at line 2980 of file HeavyDBSqlOperatorTable.java.

Referenced by com.mapd.calcite.parser.ExtTableFunctionTypeChecker.doesOperandTypeMatch().

                                         {
       return arg_types;
     }

Here is the caller graph for this function:

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

inline

Definition at line 2807 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 ( )

inlinepackage

Definition at line 2976 of file HeavyDBSqlOperatorTable.java.

                                                              {
       return cursor_field_types;
     }

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

inline

Definition at line 2904 of file HeavyDBSqlOperatorTable.java.

                                                 {
       return this.arg_names;
     }

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

inline

Definition at line 2854 of file HeavyDBSqlOperatorTable.java.

References File_Namespace.append(), 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:

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

inline

Definition at line 2746 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 2732 of file HeavyDBSqlOperatorTable.java.

                                         {
       return pretty_arg_names;
     }

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

inline

Definition at line 2778 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 2910 of file HeavyDBSqlOperatorTable.java.

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

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

inline

Definition at line 2967 of file HeavyDBSqlOperatorTable.java.

                              {
       return new String(getName() + "("
               + String.join(",",
                       this.arg_types.stream()
                               .map(s -> s.toString())
                               .collect(Collectors.toList()))
               + ")");
     }

Member Data Documentation

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

private

Definition at line 2986 of file HeavyDBSqlOperatorTable.java.

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

private

Definition at line 2984 of file HeavyDBSqlOperatorTable.java.

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

private

Definition at line 2990 of file HeavyDBSqlOperatorTable.java.

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

private

Definition at line 2989 of file HeavyDBSqlOperatorTable.java.

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

private

Definition at line 2988 of file HeavyDBSqlOperatorTable.java.

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

private

Definition at line 2985 of file HeavyDBSqlOperatorTable.java.

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

private

Definition at line 2987 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