Inheritance diagram for com.mapd.parser.server.CalciteServerHandler:

Collaboration diagram for com.mapd.parser.server.CalciteServerHandler:

Public Member Functions
	CalciteServerHandler (int dbPort, String dataDir, String extensionFunctionsAstFile, SockTransportProperties skT, String udfAstFile)

void	ping () throws TException

TPlanResult	process (String user, String session, String catalog, String queryText, TQueryParsingOption queryParsingOption, TOptimizationOption optimizationOption, List< TRestriction > trestrictions) throws InvalidParseRequest, TException

void	shutdown () throws TException

String	getExtensionFunctionWhitelist ()

String	getUserDefinedFunctionWhitelist ()

String	getRuntimeExtensionFunctionWhitelist ()

void	updateMetadata (String catalog, String table) throws TException

List< TCompletionHint >	getCompletionHints (String user, String session, String catalog, List< String > visible_tables, String sql, int cursor) throws TException

void	setRuntimeExtensionFunctions (List< TUserDefinedFunction > udfs, List< TUserDefinedTableFunction > udtfs, boolean isruntime)

Package Functions
void	setServer (TServer s)

Package Attributes
Map< String, ExtensionFunction >	udfRTSigs = null

Map< String, ExtensionFunction >	udtfSigs = null

Static Package Attributes
static final Logger	HEAVYDBLOGGER = LoggerFactory.getLogger(CalciteServerHandler.class)

Static Private Member Functions
static ExtensionFunction	toExtensionFunction (TUserDefinedFunction udf, boolean isruntime)

static ExtensionFunction	toExtensionFunction (TUserDefinedTableFunction udtf, boolean isruntime)

static ExtensionFunction.ExtArgumentType	toExtArgumentType (TExtArgumentType type)

static TCompletionHintType	hintTypeToThrift (final SqlMonikerType type)

Private Attributes
TServer	server

final int	dbPort

volatile long	callCount

final GenericObjectPool	parserPool

final CalciteParserFactory	calciteParserFactory

final String	extSigsJson

final String	udfSigsJson

String	udfRTSigsJson = ""

SockTransportProperties	skT

Map< String, ExtensionFunction >	extSigs = null

String	dataDir

Detailed Description

Definition at line 67 of file CalciteServerHandler.java.

Constructor & Destructor Documentation

com.mapd.parser.server.CalciteServerHandler.CalciteServerHandler	(	int	dbPort,
		String	dataDir,
		String	extensionFunctionsAstFile,
		SockTransportProperties	skT,
		String	udfAstFile
	)

inline

Definition at line 94 of file CalciteServerHandler.java.

References com.mapd.parser.server.CalciteServerHandler.calciteParserFactory, com.mapd.parser.server.CalciteServerHandler.dataDir, com.mapd.parser.server.CalciteServerHandler.dbPort, com.mapd.parser.server.CalciteServerHandler.extSigs, com.mapd.parser.server.CalciteServerHandler.extSigsJson, and com.mapd.parser.server.CalciteServerHandler.udfSigsJson.

                              {
     this.dbPort = dbPort;
     this.dataDir = dataDir;
 
     Map<String, ExtensionFunction> udfSigs = null;
 
     try {
       extSigs = ExtensionFunctionSignatureParser.parse(extensionFunctionsAstFile);
     } catch (IOException ex) {
       HEAVYDBLOGGER.error(
               "Could not load extension function signatures: " + ex.getMessage(), ex);
     }
     extSigsJson = ExtensionFunctionSignatureParser.signaturesToJson(extSigs);
 
     try {
       if (!udfAstFile.isEmpty()) {
         udfSigs = ExtensionFunctionSignatureParser.parseUdfAst(udfAstFile);
       }
     } catch (IOException ex) {
       HEAVYDBLOGGER.error(
               "Could not load udf function signatures: " + ex.getMessage(), ex);
     }
     udfSigsJson = ExtensionFunctionSignatureParser.signaturesToJson(udfSigs);
 
     // Put all the udf functions signatures in extSigs so Calcite has a view of
     // extension functions and udf functions
     if (!udfAstFile.isEmpty()) {
       extSigs.putAll(udfSigs);
     }
 
     calciteParserFactory = new CalciteParserFactory(dataDir, extSigs, dbPort, skT);
 
     // GenericObjectPool::setFactory is deprecated
     this.parserPool = new GenericObjectPool(calciteParserFactory);
   }

Member Function Documentation

List<TCompletionHint> com.mapd.parser.server.CalciteServerHandler.getCompletionHints	(	String	user,
		String	session,
		String	catalog,
		List< String >	visible_tables,
		String	sql,
		int	cursor
	)		throws TException

inline

Definition at line 340 of file CalciteServerHandler.java.

References com.mapd.parser.server.CalciteServerHandler.callCount, com.mapd.parser.server.CalciteServerHandler.dbPort, com.mapd.parser.server.CalciteServerHandler.hintTypeToThrift(), run_benchmark_import.parser, com.mapd.parser.server.CalciteServerHandler.parserPool, and run_benchmark_import.result.

                                         {
     callCount++;
     HeavyDBParser parser;
     try {
       parser = (HeavyDBParser) parserPool.borrowObject();
     } catch (Exception ex) {
       String msg = "Could not get Parse Item from pool: " + ex.getMessage();
       HEAVYDBLOGGER.error(msg, ex);
       throw new TException(msg);
     }
     HeavyDBUser dbUser = new HeavyDBUser(user, session, catalog, dbPort, null);
     HEAVYDBLOGGER.debug("getCompletionHints was called User: " + user
             + " Catalog: " + catalog + " sql: " + sql);
     parser.setUser(dbUser);
     CURRENT_PARSER.set(parser);
 
     HeavyDBPlanner.CompletionResult completion_result;
     try {
       completion_result = parser.getCompletionHints(sql, cursor, visible_tables);
     } catch (Exception ex) {
       String msg = "Could not retrieve completion hints: " + ex.getMessage();
       HEAVYDBLOGGER.error(msg, ex);
       return new ArrayList<>();
     } finally {
       CURRENT_PARSER.set(null);
       try {
         // put parser object back in pool for others to use
         parserPool.returnObject(parser);
       } catch (Exception ex) {
         String msg = "Could not return parse object: " + ex.getMessage();
         HEAVYDBLOGGER.error(msg, ex);
         throw new InvalidParseRequest(-4, msg);
       }
     }
     List<TCompletionHint> result = new ArrayList<>();
     for (final SqlMoniker hint : completion_result.hints) {
       result.add(new TCompletionHint(hintTypeToThrift(hint.getType()),
               hint.getFullyQualifiedNames(),
               completion_result.replaced));
     }
     return result;
   }

Here is the call graph for this function:

String com.mapd.parser.server.CalciteServerHandler.getExtensionFunctionWhitelist ( )

inline

Definition at line 290 of file CalciteServerHandler.java.

                                                 {
     return this.extSigsJson;
   }

String com.mapd.parser.server.CalciteServerHandler.getRuntimeExtensionFunctionWhitelist ( )

inline

Definition at line 300 of file CalciteServerHandler.java.

                                                        {
     return this.udfRTSigsJson;
   }

String com.mapd.parser.server.CalciteServerHandler.getUserDefinedFunctionWhitelist ( )

inline

Definition at line 295 of file CalciteServerHandler.java.

                                                   {
     return this.udfSigsJson;
   }

static TCompletionHintType com.mapd.parser.server.CalciteServerHandler.hintTypeToThrift ( final SqlMonikerType type )

inlinestaticprivate

Definition at line 650 of file CalciteServerHandler.java.

Referenced by com.mapd.parser.server.CalciteServerHandler.getCompletionHints().

                                                                                  {
     switch (type) {
       case COLUMN:
         return TCompletionHintType.COLUMN;
       case TABLE:
         return TCompletionHintType.TABLE;
       case VIEW:
         return TCompletionHintType.VIEW;
       case SCHEMA:
         return TCompletionHintType.SCHEMA;
       case CATALOG:
         return TCompletionHintType.CATALOG;
       case REPOSITORY:
         return TCompletionHintType.REPOSITORY;
       case FUNCTION:
         return TCompletionHintType.FUNCTION;
       case KEYWORD:
         return TCompletionHintType.KEYWORD;
       default:
         return null;
     }
   }

Here is the caller graph for this function:

void com.mapd.parser.server.CalciteServerHandler.ping ( ) throws TException

inline

Definition at line 135 of file CalciteServerHandler.java.

                                        {
     HEAVYDBLOGGER.debug("Ping hit");
   }

TPlanResult com.mapd.parser.server.CalciteServerHandler.process	(	String	user,
		String	session,
		String	catalog,
		String	queryText,
		TQueryParsingOption	queryParsingOption,
		TOptimizationOption	optimizationOption,
		List< TRestriction >	trestrictions
	)		throws InvalidParseRequest, TException

inline

Definition at line 140 of file CalciteServerHandler.java.

References com.mapd.parser.server.CalciteServerHandler.callCount, com.mapd.parser.server.CalciteServerHandler.dbPort, run_benchmark_import.parser, com.mapd.parser.server.CalciteServerHandler.parserPool, run_benchmark_import.res, run_benchmark_import.result, and toString().

                                                                                    {
     long timer = System.currentTimeMillis();
     callCount++;
 
     HeavyDBParser parser;
     try {
       parser = (HeavyDBParser) parserPool.borrowObject();
       parser.clearMemo();
     } catch (Exception ex) {
       String msg = "Could not get Parse Item from pool: " + ex.getMessage();
       HEAVYDBLOGGER.error(msg, ex);
       throw new InvalidParseRequest(-1, msg);
     }
     List<Restriction> rests = null;
     if (trestrictions != null && !trestrictions.isEmpty()) {
       rests = new ArrayList<>();
       for (TRestriction trestriction : trestrictions) {
         Restriction rest = null;
         rest = new Restriction(trestriction.database,
                 trestriction.table,
                 trestriction.column,
                 trestriction.values);
         rests.add(rest);
       }
     }
     HeavyDBUser dbUser = new HeavyDBUser(user, session, catalog, dbPort, rests);
     HEAVYDBLOGGER.debug("process was called User: " + user + " Catalog: " + catalog
             + " sql: " + queryText);
     parser.setUser(dbUser);
     CURRENT_PARSER.set(parser);
 
     // this code path is introduced to execute a query for intel-modin project
     // they appended a special prefix "execute calcite" to distinguish their usage
     boolean buildRATreeFromRAString = false;
     if (queryText.startsWith("execute calcite")) {
       queryText = queryText.replaceFirst("execute calcite", "");
       buildRATreeFromRAString = true;
     }
 
     // need to trim the sql string as it seems it is not trimed prior to here
     queryText = queryText.trim();
     // remove last charcter if it is a ;
     if (queryText.length() > 0 && queryText.charAt(queryText.length() - 1) == ';') {
       queryText = queryText.substring(0, queryText.length() - 1);
     }
     String jsonResult;
     SqlIdentifierCapturer capturer;
     TAccessedQueryObjects primaryAccessedObjects = new TAccessedQueryObjects();
     TAccessedQueryObjects resolvedAccessedObjects = new TAccessedQueryObjects();
     try {
       final List<HeavyDBParserOptions.FilterPushDownInfo> filterPushDownInfo =
               new ArrayList<>();
       for (final TFilterPushDownInfo req : optimizationOption.filter_push_down_info) {
         filterPushDownInfo.add(new HeavyDBParserOptions.FilterPushDownInfo(
                 req.input_prev, req.input_start, req.input_next));
       }
       HeavyDBParserOptions parserOptions = new HeavyDBParserOptions(filterPushDownInfo,
               queryParsingOption.legacy_syntax,
               queryParsingOption.is_explain,
               optimizationOption.is_view_optimize,
               optimizationOption.enable_watchdog,
               optimizationOption.distributed_mode);
 
       if (!buildRATreeFromRAString) {
         Pair<String, SqlIdentifierCapturer> res;
         SqlNode node;
 
         res = parser.process(queryText, parserOptions);
         jsonResult = res.left;
         capturer = res.right;
 
         primaryAccessedObjects.tables_selected_from = new ArrayList<>(capturer.selects);
         primaryAccessedObjects.tables_inserted_into = new ArrayList<>(capturer.inserts);
         primaryAccessedObjects.tables_updated_in = new ArrayList<>(capturer.updates);
         primaryAccessedObjects.tables_deleted_from = new ArrayList<>(capturer.deletes);
 
         // also resolve all the views in the select part
         // resolution of the other parts is not
         // necessary as these cannot be views
         resolvedAccessedObjects.tables_selected_from =
                 new ArrayList<>(parser.resolveSelectIdentifiers(capturer));
         resolvedAccessedObjects.tables_inserted_into = new ArrayList<>(capturer.inserts);
         resolvedAccessedObjects.tables_updated_in = new ArrayList<>(capturer.updates);
         resolvedAccessedObjects.tables_deleted_from = new ArrayList<>(capturer.deletes);
 
       } else {
         // exploit Calcite's query optimization rules for RA string
         jsonResult =
                 parser.buildRATreeAndPerformQueryOptimization(queryText, parserOptions);
       }
     } catch (SqlParseException ex) {
       String msg = "SQL Error: " + ex.getMessage();
       HEAVYDBLOGGER.error(msg);
       throw new InvalidParseRequest(-2, msg);
     } catch (org.apache.calcite.tools.ValidationException ex) {
       String msg = "SQL Error: " + ex.getMessage();
       if (ex.getCause() != null
               && (ex.getCause().getClass() == CalciteContextException.class)) {
         msg = "SQL Error: " + ex.getCause().getMessage();
       }
       HEAVYDBLOGGER.error(msg);
       throw new InvalidParseRequest(-3, msg);
     } catch (CalciteContextException ex) {
       String msg = ex.getMessage();
       HEAVYDBLOGGER.error(msg);
       throw new InvalidParseRequest(-6, msg);
     } catch (RelConversionException ex) {
       String msg = "Failed to generate relational algebra for query " + ex.getMessage();
       HEAVYDBLOGGER.error(msg, ex);
       throw new InvalidParseRequest(-5, msg);
     } catch (Throwable ex) {
       HEAVYDBLOGGER.error(ex.getClass().toString());
       String msg = ex.getMessage();
       HEAVYDBLOGGER.error(msg, ex);
       throw new InvalidParseRequest(-4, msg);
     } finally {
       CURRENT_PARSER.set(null);
       try {
         // put parser object back in pool for others to use
         parserPool.returnObject(parser);
       } catch (Exception ex) {
         String msg = "Could not return parse object: " + ex.getMessage();
         HEAVYDBLOGGER.error(msg, ex);
         throw new InvalidParseRequest(-7, msg);
       }
     }
 
     TPlanResult result = new TPlanResult();
     result.primary_accessed_objects = primaryAccessedObjects;
     result.resolved_accessed_objects = resolvedAccessedObjects;
     result.plan_result = jsonResult;
     result.execution_time_ms = System.currentTimeMillis() - timer;
 
     return result;
   }

Here is the call graph for this function:

void com.mapd.parser.server.CalciteServerHandler.setRuntimeExtensionFunctions	(	List< TUserDefinedFunction >	udfs,
		List< TUserDefinedTableFunction >	udtfs,
		boolean	isruntime
	)

inline

Definition at line 389 of file CalciteServerHandler.java.

References com.mapd.parser.server.CalciteServerHandler.extSigs, setup.name, com.mapd.parser.server.CalciteServerHandler.toExtensionFunction(), com.mapd.parser.server.CalciteServerHandler.udfRTSigs, com.mapd.parser.server.CalciteServerHandler.udfRTSigsJson, and com.mapd.parser.server.CalciteServerHandler.udtfSigs.

                              {
     if (isruntime) {
       // Clean up previously defined Runtime UDFs
       if (udfRTSigs != null) {
         for (String name : udfRTSigs.keySet()) extSigs.remove(name);
         udfRTSigsJson = "";
         udfRTSigs.clear();
       } else {
         udfRTSigs = new HashMap<String, ExtensionFunction>();
       }
 
       for (TUserDefinedFunction udf : udfs) {
         udfRTSigs.put(udf.name, toExtensionFunction(udf, isruntime));
       }
 
       for (TUserDefinedTableFunction udtf : udtfs) {
         udfRTSigs.put(udtf.name, toExtensionFunction(udtf, isruntime));
       }
 
       // Avoid overwritting compiled and Loadtime UDFs:
       for (String name : udfRTSigs.keySet()) {
         if (extSigs.containsKey(name)) {
           HEAVYDBLOGGER.error("Extension function `" + name
                   + "` exists. Skipping runtime extenension function with the same name.");
           udfRTSigs.remove(name);
         }
       }
       // udfRTSigsJson will contain only the signatures of UDFs:
       udfRTSigsJson = ExtensionFunctionSignatureParser.signaturesToJson(udfRTSigs);
       // Expose RT UDFs to Calcite server:
       extSigs.putAll(udfRTSigs);
     } else {
       // currently only LoadTime UDTFs can be registered via calcite thrift interface
       if (udtfSigs == null) {
         udtfSigs = new HashMap<String, ExtensionFunction>();
       }
 
       for (TUserDefinedTableFunction udtf : udtfs) {
         udtfSigs.put(udtf.name, toExtensionFunction(udtf, isruntime));
       }
 
       extSigs.putAll(udtfSigs);
     }
 
     calciteParserFactory.updateOperatorTable();
   }

Here is the call graph for this function:

void com.mapd.parser.server.CalciteServerHandler.setServer ( TServer s )

inlinepackage

Definition at line 304 of file CalciteServerHandler.java.

References com.mapd.parser.server.CalciteServerHandler.server.

                             {
     server = s;
   }

void com.mapd.parser.server.CalciteServerHandler.shutdown ( ) throws TException

inline

Definition at line 283 of file CalciteServerHandler.java.

                                            {
     // received request to shutdown
     HEAVYDBLOGGER.debug("Shutdown calcite java server");
     server.stop();
   }

static ExtensionFunction.ExtArgumentType com.mapd.parser.server.CalciteServerHandler.toExtArgumentType ( TExtArgumentType type )

inlinestaticprivate

Definition at line 505 of file CalciteServerHandler.java.

References ArrayBool, ArrayDouble, ArrayFloat, ArrayInt16, ArrayInt32, ArrayInt64, ArrayInt8, ArrayTextEncodingDict, Bool, ColumnArrayBool, ColumnArrayDouble, ColumnArrayFloat, ColumnArrayInt16, ColumnArrayInt32, ColumnArrayInt64, ColumnArrayInt8, ColumnArrayTextEncodingDict, ColumnBool, ColumnDouble, ColumnFloat, ColumnInt16, ColumnInt32, ColumnInt64, ColumnInt8, ColumnListArrayBool, ColumnListArrayDouble, ColumnListArrayFloat, ColumnListArrayInt16, ColumnListArrayInt32, ColumnListArrayInt64, ColumnListArrayInt8, ColumnListArrayTextEncodingDict, ColumnListBool, ColumnListDouble, ColumnListFloat, ColumnListInt16, ColumnListInt32, ColumnListInt64, ColumnListInt8, ColumnListTextEncodingDict, ColumnTextEncodingDict, ColumnTimestamp, Cursor, Double, Float, Int16, Int32, Int64, Int8, PBool, PDouble, PFloat, PInt16, PInt32, PInt64, PInt8, run_benchmark_import.type, and Void.

Referenced by com.mapd.parser.server.CalciteServerHandler.toExtensionFunction().

                                  {
     switch (type) {
       case Int8:
         return ExtensionFunction.ExtArgumentType.Int8;
       case Int16:
         return ExtensionFunction.ExtArgumentType.Int16;
       case Int32:
         return ExtensionFunction.ExtArgumentType.Int32;
       case Int64:
         return ExtensionFunction.ExtArgumentType.Int64;
       case Float:
         return ExtensionFunction.ExtArgumentType.Float;
       case Double:
         return ExtensionFunction.ExtArgumentType.Double;
       case Void:
         return ExtensionFunction.ExtArgumentType.Void;
       case PInt8:
         return ExtensionFunction.ExtArgumentType.PInt8;
       case PInt16:
         return ExtensionFunction.ExtArgumentType.PInt16;
       case PInt32:
         return ExtensionFunction.ExtArgumentType.PInt32;
       case PInt64:
         return ExtensionFunction.ExtArgumentType.PInt64;
       case PFloat:
         return ExtensionFunction.ExtArgumentType.PFloat;
       case PDouble:
         return ExtensionFunction.ExtArgumentType.PDouble;
       case PBool:
         return ExtensionFunction.ExtArgumentType.PBool;
       case Bool:
         return ExtensionFunction.ExtArgumentType.Bool;
       case ArrayInt8:
         return ExtensionFunction.ExtArgumentType.ArrayInt8;
       case ArrayInt16:
         return ExtensionFunction.ExtArgumentType.ArrayInt16;
       case ArrayInt32:
         return ExtensionFunction.ExtArgumentType.ArrayInt32;
       case ArrayInt64:
         return ExtensionFunction.ExtArgumentType.ArrayInt64;
       case ArrayFloat:
         return ExtensionFunction.ExtArgumentType.ArrayFloat;
       case ArrayDouble:
         return ExtensionFunction.ExtArgumentType.ArrayDouble;
       case ArrayBool:
         return ExtensionFunction.ExtArgumentType.ArrayBool;
       case ArrayTextEncodingDict:
         return ExtensionFunction.ExtArgumentType.ArrayTextEncodingDict;
       case ColumnInt8:
         return ExtensionFunction.ExtArgumentType.ColumnInt8;
       case ColumnInt16:
         return ExtensionFunction.ExtArgumentType.ColumnInt16;
       case ColumnInt32:
         return ExtensionFunction.ExtArgumentType.ColumnInt32;
       case ColumnInt64:
         return ExtensionFunction.ExtArgumentType.ColumnInt64;
       case ColumnFloat:
         return ExtensionFunction.ExtArgumentType.ColumnFloat;
       case ColumnDouble:
         return ExtensionFunction.ExtArgumentType.ColumnDouble;
       case ColumnBool:
         return ExtensionFunction.ExtArgumentType.ColumnBool;
       case ColumnTextEncodingDict:
         return ExtensionFunction.ExtArgumentType.ColumnTextEncodingDict;
       case ColumnTimestamp:
         return ExtensionFunction.ExtArgumentType.ColumnTimestamp;
       case GeoPoint:
         return ExtensionFunction.ExtArgumentType.GeoPoint;
       case GeoMultiPoint:
         return ExtensionFunction.ExtArgumentType.GeoMultiPoint;
       case GeoLineString:
         return ExtensionFunction.ExtArgumentType.GeoLineString;
       case GeoMultiLineString:
         return ExtensionFunction.ExtArgumentType.GeoMultiLineString;
       case Cursor:
         return ExtensionFunction.ExtArgumentType.Cursor;
       case GeoPolygon:
         return ExtensionFunction.ExtArgumentType.GeoPolygon;
       case GeoMultiPolygon:
         return ExtensionFunction.ExtArgumentType.GeoMultiPolygon;
       case TextEncodingNone:
         return ExtensionFunction.ExtArgumentType.TextEncodingNone;
       case TextEncodingDict:
         return ExtensionFunction.ExtArgumentType.TextEncodingDict;
       case Timestamp:
         return ExtensionFunction.ExtArgumentType.Timestamp;
       case ColumnListInt8:
         return ExtensionFunction.ExtArgumentType.ColumnListInt8;
       case ColumnListInt16:
         return ExtensionFunction.ExtArgumentType.ColumnListInt16;
       case ColumnListInt32:
         return ExtensionFunction.ExtArgumentType.ColumnListInt32;
       case ColumnListInt64:
         return ExtensionFunction.ExtArgumentType.ColumnListInt64;
       case ColumnListFloat:
         return ExtensionFunction.ExtArgumentType.ColumnListFloat;
       case ColumnListDouble:
         return ExtensionFunction.ExtArgumentType.ColumnListDouble;
       case ColumnListBool:
         return ExtensionFunction.ExtArgumentType.ColumnListBool;
       case ColumnListTextEncodingDict:
         return ExtensionFunction.ExtArgumentType.ColumnListTextEncodingDict;
       case ColumnArrayInt8:
         return ExtensionFunction.ExtArgumentType.ColumnArrayInt8;
       case ColumnArrayInt16:
         return ExtensionFunction.ExtArgumentType.ColumnArrayInt16;
       case ColumnArrayInt32:
         return ExtensionFunction.ExtArgumentType.ColumnArrayInt32;
       case ColumnArrayInt64:
         return ExtensionFunction.ExtArgumentType.ColumnArrayInt64;
       case ColumnArrayFloat:
         return ExtensionFunction.ExtArgumentType.ColumnArrayFloat;
       case ColumnArrayDouble:
         return ExtensionFunction.ExtArgumentType.ColumnArrayDouble;
       case ColumnArrayBool:
         return ExtensionFunction.ExtArgumentType.ColumnArrayBool;
       case ColumnArrayTextEncodingDict:
         return ExtensionFunction.ExtArgumentType.ColumnArrayTextEncodingDict;
       case ColumnListArrayInt8:
         return ExtensionFunction.ExtArgumentType.ColumnListArrayInt8;
       case ColumnListArrayInt16:
         return ExtensionFunction.ExtArgumentType.ColumnListArrayInt16;
       case ColumnListArrayInt32:
         return ExtensionFunction.ExtArgumentType.ColumnListArrayInt32;
       case ColumnListArrayInt64:
         return ExtensionFunction.ExtArgumentType.ColumnListArrayInt64;
       case ColumnListArrayFloat:
         return ExtensionFunction.ExtArgumentType.ColumnListArrayFloat;
       case ColumnListArrayDouble:
         return ExtensionFunction.ExtArgumentType.ColumnListArrayDouble;
       case ColumnListArrayBool:
         return ExtensionFunction.ExtArgumentType.ColumnListArrayBool;
       case ColumnListArrayTextEncodingDict:
         return ExtensionFunction.ExtArgumentType.ColumnListArrayTextEncodingDict;
       case DayTimeInterval:
         return ExtensionFunction.ExtArgumentType.DayTimeInterval;
       case YearMonthTimeInterval:
         return ExtensionFunction.ExtArgumentType.YearMonthTimeInterval;
       default:
         HEAVYDBLOGGER.error("toExtArgumentType: unknown type " + type);
         return null;
     }
   }

Here is the caller graph for this function:

static ExtensionFunction com.mapd.parser.server.CalciteServerHandler.toExtensionFunction	(	TUserDefinedFunction	udf,
		boolean	isruntime
	)

inlinestaticprivate

Definition at line 438 of file CalciteServerHandler.java.

References com.mapd.parser.server.ExtensionFunction.annotations, run_benchmark_import.args, and com.mapd.parser.server.CalciteServerHandler.toExtArgumentType().

Referenced by com.mapd.parser.server.CalciteServerHandler.setRuntimeExtensionFunctions().

                                                        {
     List<ExtensionFunction.ExtArgumentType> args =
             new ArrayList<ExtensionFunction.ExtArgumentType>();
     for (TExtArgumentType atype : udf.argTypes) {
       final ExtensionFunction.ExtArgumentType arg_type = toExtArgumentType(atype);
       if (arg_type != ExtensionFunction.ExtArgumentType.Void) {
         args.add(arg_type);
       }
     }
     return new ExtensionFunction(args, toExtArgumentType(udf.retType), udf.annotations);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static ExtensionFunction com.mapd.parser.server.CalciteServerHandler.toExtensionFunction	(	TUserDefinedTableFunction	udtf,
		boolean	isruntime
	)

inlinestaticprivate

Definition at line 451 of file CalciteServerHandler.java.

References run_benchmark_import.args, setup.name, and com.mapd.parser.server.CalciteServerHandler.toExtArgumentType().

                                                              {
     int sqlInputArgIdx = 0;
     int inputArgIdx = 0;
     int outputArgIdx = 0;
     List<String> names = new ArrayList<String>();
     List<ExtensionFunction.ExtArgumentType> args = new ArrayList<>();
     Map<String, List<ExtensionFunction.ExtArgumentType>> cursor_field_types =
             new HashMap<>();
     for (TExtArgumentType atype : udtf.sqlArgTypes) {
       args.add(toExtArgumentType(atype));
       Map<String, String> annot = udtf.annotations.get(sqlInputArgIdx);
       String name = annot.getOrDefault("name", "inp" + sqlInputArgIdx);
       if (atype == TExtArgumentType.Cursor) {
         String field_names_annot = annot.getOrDefault("fields", "");
         List<ExtensionFunction.ExtArgumentType> field_types = new ArrayList<>();
         if (field_names_annot.length() > 0) {
           String[] field_names =
                   field_names_annot.substring(1, field_names_annot.length() - 1)
                           .split(",");
           for (int i = 0; i < field_names.length; i++) {
             field_types.add(
                     toExtArgumentType(udtf.getInputArgTypes().get(inputArgIdx++)));
           }
         } else {
           if (!isruntime) {
             field_types.add(
                     toExtArgumentType(udtf.getInputArgTypes().get(inputArgIdx++)));
           }
         }
         name = name + field_names_annot;
         cursor_field_types.put(name, field_types);
       } else {
         inputArgIdx++;
       }
       names.add(name);
       sqlInputArgIdx++;
     }
 
     List<ExtensionFunction.ExtArgumentType> outs = new ArrayList<>();
     for (TExtArgumentType otype : udtf.outputArgTypes) {
       outs.add(toExtArgumentType(otype));
       Map<String, String> annot = udtf.annotations.get(sqlInputArgIdx);
       names.add(annot.getOrDefault("name", "out" + outputArgIdx));
       sqlInputArgIdx++;
       outputArgIdx++;
     }
     return new ExtensionFunction(args,
             outs,
             names,
             udtf.annotations.get(udtf.annotations.size() - 1),
             cursor_field_types);
   }

Here is the call graph for this function:

void com.mapd.parser.server.CalciteServerHandler.updateMetadata	(	String	catalog,
		String	table
	)		throws TException

inline

Definition at line 310 of file CalciteServerHandler.java.

References com.mapd.parser.server.CalciteServerHandler.callCount, run_benchmark_import.parser, and com.mapd.parser.server.CalciteServerHandler.parserPool.

                                                                              {
     HEAVYDBLOGGER.debug(
             "Received invalidation from server for " + catalog + " : " + table);
     long timer = System.currentTimeMillis();
     callCount++;
     HeavyDBParser parser;
     try {
       parser = (HeavyDBParser) parserPool.borrowObject();
     } catch (Exception ex) {
       String msg = "Could not get Parse Item from pool: " + ex.getMessage();
       HEAVYDBLOGGER.error(msg, ex);
       return;
     }
     CURRENT_PARSER.set(parser);
     try {
       parser.updateMetaData(catalog, table);
     } finally {
       CURRENT_PARSER.set(null);
       try {
         // put parser object back in pool for others to use
         HEAVYDBLOGGER.debug("Returning object to pool");
         parserPool.returnObject(parser);
       } catch (Exception ex) {
         String msg = "Could not return parse object: " + ex.getMessage();
         HEAVYDBLOGGER.error(msg, ex);
       }
     }
   }