| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: QueryCacheSt.cpp |
| * Description: |
| * |
| * |
| * Created: 3/19/2002 |
| * Language: C++ |
| * |
| ***************************************************************************** |
| */ |
| |
| #include "QueryCacheSt.h" |
| #include "QCache.h" |
| #include "CmpMain.h" |
| #include "Globals.h" |
| #include "Context.h" |
| |
| SP_STATUS QueryCacheStatStoredProcedure::sp_InputFormat(SP_FIELDDESC_STRUCT *inputFieldFormat, |
| Lng32 numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| if ( numFields != 2 ) |
| { |
| //accepts 2 input columns |
| error->error = arkcmpErrorISPWrongInputNum; |
| strcpy(error->optionalString[0], "QueryCache"); |
| error->optionalInteger[0] = 2; |
| return SP_FAIL; |
| } |
| |
| //column as input parameter for ISP, specifiy query cache of metadata or user context |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "instance char(16) not null"); |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "location char(16) not null"); |
| return SP_SUCCESS; |
| } |
| |
| SP_STATUS QueryCacheStatStoredProcedure::sp_NumOutputFields(Lng32 *numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| *numFields = 21; |
| return SP_SUCCESS; |
| } |
| |
| |
| // Specifies the columns of the QueryCache table and their types |
| SP_STATUS QueryCacheStatStoredProcedure::sp_OutputFormat(SP_FIELDDESC_STRUCT *format, |
| SP_KEYDESC_STRUCT keyFields[], |
| Lng32 *numKeyFields, |
| SP_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| strcpy(&((format++)->COLUMN_DEF[0]), "Avg_template_size INT UNSIGNED"); // 0 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Current_size INT UNSIGNED"); // 1 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Max_cache_size INT UNSIGNED"); // 2 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Max_num_victims INT UNSIGNED"); // 3 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_entries INT UNSIGNED"); // 4 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_plans INT UNSIGNED"); // 5 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_compiles INT UNSIGNED"); // 6 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_recompiles INT UNSIGNED"); // 7 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_retries INT UNSIGNED"); // 8 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_cacheable_parsing INT UNSIGNED"); // 9 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_cacheable_binding INT UNSIGNED"); // 10 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_cache_hits_parsing INT UNSIGNED"); // 11 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_cache_hits_binding INT UNSIGNED"); // 12 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_cacheable_too_large INT UNSIGNED"); // 13 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_displaced INT UNSIGNED"); // 14 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Optimization_level CHAR(10 BYTES) character set utf8"); // 15 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Text_cache_hits INT UNSIGNED"); // 16 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Avg_text_size INT UNSIGNED"); // 17 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Text_entries INT UNSIGNED"); // 18 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Displaced_texts INT UNSIGNED"); // 19 |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_lookups INT UNSIGNED"); // 20 |
| return SP_SUCCESS; |
| } |
| |
| // Copies information on the query cache by the interface provided in |
| // QueryCache.h and processes it |
| SP_STATUS |
| QueryCacheStatStoredProcedure::sp_Process(SP_PROCESS_ACTION action, |
| SP_ROW_DATA inputData, |
| SP_EXTRACT_FUNCPTR eFunc, |
| SP_ROW_DATA outputData, |
| SP_FORMAT_FUNCPTR fFunc, |
| SP_KEY_VALUE keys, |
| SP_KEYVALUE_FUNCPTR kFunc, |
| SP_PROCESS_HANDLE *spProcHandle, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| if (action == SP_PROC_OPEN) { |
| |
| QueryCacheStatsISPIterator * it = new (GetCliGlobals()->exCollHeap()) QueryCacheStatsISPIterator(inputData, eFunc, error, |
| GetCliGlobals()->currContext()->getCmpContextInfo(), GetCliGlobals()->exCollHeap()); |
| *spProcHandle = it; |
| |
| return SP_SUCCESS; |
| } |
| |
| if (action == SP_PROC_FETCH) { |
| QueryCacheStatsISPIterator* it = (QueryCacheStatsISPIterator *)(*spProcHandle); |
| |
| if (!it) { |
| return SP_FAIL; |
| } |
| |
| QueryCacheStats stats; |
| if(!it->getNext(stats)) |
| return SP_SUCCESS; |
| |
| ULong kBytes; |
| |
| kBytes = stats.avgPlanSize; |
| fFunc(0, outputData, sizeof(kBytes), &(kBytes), 0); |
| kBytes = stats.s.currentSize / 1024; |
| fFunc(1, outputData, sizeof(kBytes), &(kBytes), 0); |
| kBytes = stats.maxSize / 1024; |
| fFunc(2, outputData, sizeof(kBytes), &(kBytes), 0); |
| fFunc(3, outputData, sizeof(stats.maxVictims), &(stats.maxVictims), 0); |
| fFunc(4, outputData, sizeof(stats.nEntries), &(stats.nEntries), 0); |
| fFunc(5, outputData, sizeof(stats.nPlans), &(stats.nPlans), 0); |
| fFunc(6, outputData, sizeof(stats.nCompiles), &(stats.nCompiles), 0); |
| fFunc(7, outputData, sizeof(stats.s.nRecompiles), &(stats.s.nRecompiles), 0); |
| fFunc(8, outputData, sizeof(stats.nRetries), &(stats.nRetries), 0); |
| fFunc(9, outputData, sizeof(stats.s.nCacheableP), &(stats.s.nCacheableP), 0); |
| fFunc(10, outputData, sizeof(stats.s.nCacheableB), &(stats.s.nCacheableB), 0); |
| fFunc(11, outputData, sizeof(stats.s.nCacheHitsP), &(stats.s.nCacheHitsP), 0); |
| fFunc(12, outputData, sizeof(stats.s.nCacheHitsB), &(stats.s.nCacheHitsB), 0); |
| fFunc(13, outputData, sizeof(stats.nTooLarge), &(stats.nTooLarge), 0); |
| fFunc(14, outputData, sizeof(stats.nDisplaced), &(stats.nDisplaced), 0); |
| char optimizationLevel[8]; |
| switch (stats.optimLvl) { |
| case CompilerEnv::OPT_MINIMUM: |
| strcpy(optimizationLevel, "0 "); break; |
| case CompilerEnv::OPT_MEDIUM_LOW: |
| strcpy(optimizationLevel, "2 "); break; |
| case CompilerEnv::OPT_MEDIUM: |
| strcpy(optimizationLevel, "3 "); break; |
| case CompilerEnv::OPT_MAXIMUM: |
| strcpy(optimizationLevel, "5 "); break; |
| default: strcpy(optimizationLevel, "UNKNOWN"); break; |
| } |
| |
| fFunc(15,outputData,(Lng32)strlen(optimizationLevel),optimizationLevel,1); |
| fFunc(16,outputData,sizeof(stats.s.nCacheHitsPP),&(stats.s.nCacheHitsPP),0); |
| fFunc(17,outputData,sizeof(stats.avgTEntSize),&(stats.avgTEntSize),0); |
| fFunc(18,outputData,sizeof(stats.nTextEntries),&(stats.nTextEntries),0); |
| fFunc(19,outputData,sizeof(stats.nDispTEnts),&(stats.nDispTEnts),0); |
| fFunc(20,outputData,sizeof(stats.s.nLookups),&(stats.s.nLookups),0); |
| |
| return SP_MOREDATA; |
| } // if (action == SP_PROC_FETCH) |
| |
| if (action == SP_PROC_CLOSE) { |
| NADELETEBASIC((QueryCacheStatsISPIterator *)(*spProcHandle), GetCliGlobals()->exCollHeap()); |
| return SP_SUCCESS; |
| } |
| |
| return SP_SUCCESS; |
| } |
| |
| // Registers the QueryCache function |
| void QueryCacheStatStoredProcedure::Initialize(SP_REGISTER_FUNCPTR regFunc) |
| { |
| regFunc("QUERYCACHE", |
| sp_Compile, |
| sp_InputFormat, |
| 0, |
| sp_NumOutputFields, |
| sp_OutputFormat, |
| sp_Process, |
| 0, |
| CMPISPVERSION); |
| } |
| |
| SP_STATUS QueryCacheEntriesStoredProcedure::sp_InputFormat(SP_FIELDDESC_STRUCT *inputFieldFormat, |
| Lng32 numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| if ( numFields != 2 ) |
| { |
| //accepts 2 input columns |
| error->error = arkcmpErrorISPWrongInputNum; |
| strcpy(error->optionalString[0], "QueryCacheEntries"); |
| error->optionalInteger[0] = 2; |
| return SP_FAIL; |
| } |
| |
| //column as input parameter for ISP, specifiy query cache of metadata or user context |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "instance char(16) not null"); |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "location char(16) not null"); |
| return SP_SUCCESS; |
| } |
| |
| SP_STATUS |
| QueryCacheEntriesStoredProcedure::sp_NumOutputFields(Lng32 *numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| *numFields = 20; |
| return SP_SUCCESS; |
| } |
| |
| // Specifies the columns of the QueryCacheEntries table and their types |
| SP_STATUS QueryCacheEntriesStoredProcedure::sp_OutputFormat( |
| SP_FIELDDESC_STRUCT* format, |
| SP_KEYDESC_STRUCT* /*keyFields */, |
| Lng32* /*numKeyFields */, |
| SP_COMPILE_HANDLE cmpHandle, |
| SP_HANDLE /* spHandle */, |
| SP_ERROR_STRUCT* /* error */ ) |
| { |
| strcpy(&((format++)->COLUMN_DEF[0]), "Row_id INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Plan_id LARGEINT"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Text VARCHAR(4096 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Entry_size INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Plan_length INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_hits INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Phase CHAR(10 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Optimization_level CHAR(10 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Catalog_name CHAR(40 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Schema_name CHAR(40 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Num_params INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Param_types VARCHAR(1024 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Compilation_time INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Average_hit_time INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Shape VARCHAR(1024 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Isolation_level CHAR(20 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Isolation_level_For_Updates CHAR(20 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Access_mode CHAR(20 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Auto_commit CHAR(15 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "Rollback_mode CHAR(15 BYTES) character set utf8"); |
| return SP_SUCCESS; |
| } |
| |
| void |
| setIsolationLevelAsString(TransMode::IsolationLevel il, |
| char* buffer, Int32 bufLen) |
| { |
| memset(buffer, ' ', bufLen); |
| strcpy(buffer, getStrOfIsolationLevel(il, FALSE)); |
| } |
| |
| // Copies information on the query cache by the interface provided in |
| // QueryCache.h and processes it |
| SP_STATUS QueryCacheEntriesStoredProcedure::sp_Process(SP_PROCESS_ACTION action, |
| SP_ROW_DATA inputData , |
| SP_EXTRACT_FUNCPTR eFunc , |
| SP_ROW_DATA outputData , |
| SP_FORMAT_FUNCPTR fFunc, |
| SP_KEY_VALUE, |
| SP_KEYVALUE_FUNCPTR, |
| SP_PROCESS_HANDLE* spProcHandle, |
| SP_HANDLE /* spHandle */, |
| SP_ERROR_STRUCT* error ) |
| { |
| switch (action) { |
| case SP_PROC_OPEN: |
| { |
| QueryCacheEntriesISPIterator * it = new (GetCliGlobals()->exCollHeap()) QueryCacheEntriesISPIterator(inputData, eFunc, error, |
| GetCliGlobals()->currContext()->getCmpContextInfo(), GetCliGlobals()->exCollHeap()); |
| |
| *spProcHandle = it; |
| |
| return SP_SUCCESS; |
| } |
| break; |
| |
| case SP_PROC_FETCH: |
| { |
| QueryCacheEntriesISPIterator * it = (QueryCacheEntriesISPIterator *)(*spProcHandle); |
| if (!it) { |
| return SP_FAIL; |
| } |
| |
| QueryCacheDetails details; |
| if(!it->getNext(details)) |
| return SP_SUCCESS; |
| |
| fFunc(0, outputData, sizeof(Int32), &(it->counter()), 0); |
| fFunc(1, outputData, sizeof(details.planId), &(details.planId), 0); |
| fFunc(2,outputData,(Lng32)strlen(details.qryTxt),(void*)(details.qryTxt),1); |
| fFunc(3, outputData, sizeof(details.entrySize), &(details.entrySize), 0); |
| fFunc(4, outputData, sizeof(details.planLength), &(details.planLength), 0); |
| fFunc(5, outputData, sizeof(details.nOfHits), &(details.nOfHits), 0); |
| |
| char phase[11]; |
| |
| switch (details.phase) { |
| case CmpMain::PREPARSE: strcpy(phase, "PREPARSING"); break; |
| case CmpMain::PARSE: strcpy(phase, "PARSING "); break; |
| case CmpMain::BIND: strcpy(phase, "BINDING "); break; |
| default: strcpy(phase, "UNKNOWN "); break; |
| } |
| fFunc(6,outputData,(Lng32)strlen(phase),phase,1); |
| |
| char optimizationLevel[8]; |
| |
| switch (details.optLvl) { |
| case CompilerEnv::OPT_MINIMUM: strcpy(optimizationLevel, "0 "); break; |
| case CompilerEnv::OPT_MEDIUM_LOW: strcpy(optimizationLevel, "2 "); break; |
| case CompilerEnv::OPT_MEDIUM: strcpy(optimizationLevel, "3 "); break; |
| case CompilerEnv::OPT_MAXIMUM: strcpy(optimizationLevel, "5 "); break; |
| default: strcpy(optimizationLevel,"UNKNOWN"); break; |
| } |
| fFunc(7,outputData,(Lng32)strlen(optimizationLevel),optimizationLevel,1); |
| fFunc(8,outputData,(Lng32)strlen(details.catalog),(void*)(details.catalog),1); |
| fFunc(9,outputData,(Lng32)strlen(details.schema),(void*)(details.schema),1); |
| fFunc(10, outputData, sizeof(details.nParams), &(details.nParams), 0); |
| fFunc(11,outputData,(Lng32)strlen(details.paramTypes),(void*)(details.paramTypes),1); |
| |
| ULong time = details.compTime / 1000; |
| fFunc(12, outputData, sizeof(time), &(time), 0); |
| time = details.avgHitTime / 1000; |
| fFunc(13, outputData, sizeof(time), &(time), 0); |
| fFunc(14,outputData,(Lng32)strlen(details.reqdShape),(void*)(details.reqdShape),1); |
| |
| char isolationLevel[18]; |
| |
| setIsolationLevelAsString(details.isoLvl, isolationLevel, 18); |
| fFunc(15,outputData,(Lng32)strlen(isolationLevel),isolationLevel,1); |
| |
| setIsolationLevelAsString(details.isoLvlForUpdates, isolationLevel, 18); |
| fFunc(16,outputData,(Lng32)strlen(isolationLevel),isolationLevel,1); |
| |
| char accessMode[14]; |
| switch(details.accMode) { |
| case TransMode::READ_ONLY_: |
| case TransMode::READ_ONLY_SPECIFIED_BY_USER_: |
| strcpy(accessMode, "READ ONLY "); break; |
| case TransMode::READ_WRITE_: |
| strcpy(accessMode, "READ/WRITE "); break; |
| default: |
| strcpy(accessMode, "NOT SPECIFIED"); break; |
| } |
| fFunc(17,outputData,(Lng32)strlen(accessMode),accessMode,1); |
| |
| char autoCommit[14]; |
| switch(details.autoCmt) { |
| case TransMode::ON_: |
| strcpy(autoCommit, "ON "); break; |
| case TransMode::OFF_: |
| strcpy(autoCommit, "OFF "); break; |
| default: |
| strcpy(autoCommit, "NOT SPECIFIED"); break; |
| } |
| fFunc(18,outputData,(Lng32)strlen(autoCommit),autoCommit,1); |
| |
| char rollBackMode[14]; |
| switch(details.rbackMode) { |
| case TransMode::ROLLBACK_MODE_WAITED_: |
| strcpy(rollBackMode, "WAITED "); break; |
| case TransMode::ROLLBACK_MODE_NOWAITED_: |
| strcpy(rollBackMode, "NO WAITED "); break; |
| default: |
| strcpy(rollBackMode, "NOT SPECIFIED"); break; |
| } |
| fFunc(19,outputData,(Lng32)strlen(rollBackMode),rollBackMode,1); |
| |
| it->counter()++; |
| |
| return SP_MOREDATA; |
| } |
| break; |
| |
| case SP_PROC_CLOSE: { |
| NADELETEBASIC((QueryCacheEntriesISPIterator *)(*spProcHandle), GetCliGlobals()->exCollHeap()); |
| return SP_SUCCESS; |
| } |
| |
| default: break; |
| } // switch |
| return SP_SUCCESS; |
| } |
| |
| // Registers the QueryCache function |
| void QueryCacheEntriesStoredProcedure::Initialize(SP_REGISTER_FUNCPTR regFunc) |
| { |
| regFunc("QUERYCACHEENTRIES", |
| sp_Compile, |
| sp_InputFormat, |
| 0, |
| sp_NumOutputFields, |
| sp_OutputFormat, |
| sp_Process, |
| 0, |
| CMPISPVERSION); |
| } |
| |
| |
| //----------------------------------------------------------------------- |
| // QueryCacheDeleteStoredProcedure is a class that contains functions used |
| // to delete the contents of the QueryCache virtual table. The delete |
| // function is implemented as an internal stored procedure. |
| //----------------------------------------------------------------------- |
| |
| |
| SP_STATUS QueryCacheDeleteStoredProcedure::sp_Process( |
| SP_PROCESS_ACTION action, |
| SP_ROW_DATA inputData, |
| SP_EXTRACT_FUNCPTR eFunc, |
| SP_ROW_DATA outputData, |
| SP_FORMAT_FUNCPTR fFunc, |
| SP_KEY_VALUE keys, |
| SP_KEYVALUE_FUNCPTR kFunc, |
| SP_PROCESS_HANDLE *spProcHandle, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| SP_STATUS status = SP_SUCCESS; |
| switch (action) |
| { |
| case SP_PROC_OPEN: |
| { |
| QueryCacheDeleter* deleter = new (GetCliGlobals()->exCollHeap()) QueryCacheDeleter(inputData, eFunc, error, |
| GetCliGlobals()->currContext()->getCmpContextInfo(), GetCliGlobals()->exCollHeap()); |
| *spProcHandle = deleter; |
| } |
| break; |
| case SP_PROC_FETCH: |
| { |
| QueryCacheDeleter* deleter = (QueryCacheDeleter*)(*spProcHandle); |
| if (deleter == NULL ) |
| { |
| status = SP_FAIL; |
| break; |
| } |
| //clear all specified QueryCache |
| deleter->doDelete(); |
| } |
| break; |
| case SP_PROC_CLOSE: |
| NADELETEBASIC((QueryCacheDeleter *)(*spProcHandle), GetCliGlobals()->exCollHeap()); |
| break; |
| } |
| return status; |
| } |
| |
| void QueryCacheDeleteStoredProcedure::Initialize(SP_REGISTER_FUNCPTR regFunc) |
| { |
| regFunc("QUERYCACHEDELETE", |
| sp_Compile, |
| sp_InputFormat, |
| 0, |
| sp_NumOutputFields, |
| sp_OutputFormat, |
| sp_Process, |
| 0, |
| CMPISPVERSION); |
| } |
| |
| SP_STATUS QueryCacheDeleteStoredProcedure::sp_InputFormat(SP_FIELDDESC_STRUCT *inputFieldFormat, |
| Lng32 numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| if ( numFields != 2 ) |
| { |
| //accepts 2 input columns |
| error->error = arkcmpErrorISPWrongInputNum; |
| strcpy(error->optionalString[0], "QueryCacheDelete"); |
| error->optionalInteger[0] = 2; |
| return SP_FAIL; |
| } |
| |
| //column as input parameter for ISP, specifiy query cache of metadata or user context |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "instance char(16) not null"); |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "location char(16) not null"); |
| return SP_SUCCESS; |
| } |
| |
| //------------------------Hybrid Query Cache Stat--------------------------// |
| void HybridQueryCacheStatStoredProcedure::Initialize(SP_REGISTER_FUNCPTR regFunc) |
| { |
| regFunc("HYBRIDQUERYCACHE", |
| sp_Compile, |
| sp_InputFormat, |
| 0, |
| sp_NumOutputFields, |
| sp_OutputFormat, |
| sp_Process, |
| 0, |
| CMPISPVERSION); |
| } |
| |
| SP_STATUS HybridQueryCacheStatStoredProcedure::sp_InputFormat(SP_FIELDDESC_STRUCT *inputFieldFormat, |
| Lng32 numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| if ( numFields != 2 ) |
| { |
| //accepts 2 input columns |
| error->error = arkcmpErrorISPWrongInputNum; |
| strcpy(error->optionalString[0], "HybridQueryCache"); |
| error->optionalInteger[0] = 2; |
| return SP_FAIL; |
| } |
| |
| //column as input parameter for ISP, specifiy query cache of metadata or user context |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "instance char(16) not null"); |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "location char(16) not null"); |
| return SP_SUCCESS; |
| } |
| |
| SP_STATUS |
| HybridQueryCacheStatStoredProcedure::sp_NumOutputFields(Lng32 *numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| *numFields = 4; |
| return SP_SUCCESS; |
| } |
| |
| SP_STATUS HybridQueryCacheStatStoredProcedure::sp_OutputFormat( |
| SP_FIELDDESC_STRUCT* format, |
| SP_KEYDESC_STRUCT* /*keyFields */, |
| Lng32* /*numKeyFields */, |
| SP_COMPILE_HANDLE cmpHandle, |
| SP_HANDLE /* spHandle */, |
| SP_ERROR_STRUCT* /* error */ ) |
| { |
| strcpy(&((format++)->COLUMN_DEF[0]), "num_hkeys INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "num_skeys INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "num_max_values_per_key INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "num_hash_table_buckets INT UNSIGNED"); |
| return SP_SUCCESS; |
| } |
| |
| SP_STATUS HybridQueryCacheStatStoredProcedure::sp_Process(SP_PROCESS_ACTION action, |
| SP_ROW_DATA inputData , |
| SP_EXTRACT_FUNCPTR eFunc , |
| SP_ROW_DATA outputData , |
| SP_FORMAT_FUNCPTR fFunc, |
| SP_KEY_VALUE keys, |
| SP_KEYVALUE_FUNCPTR kFunc, |
| SP_PROCESS_HANDLE* spProcHandle, |
| SP_HANDLE spObj/* spHandle */, |
| SP_ERROR_STRUCT* error ) |
| { |
| switch (action) { |
| case SP_PROC_OPEN: |
| { |
| HybridQueryCacheStatsISPIterator * it = new (GetCliGlobals()->exCollHeap()) HybridQueryCacheStatsISPIterator(inputData, eFunc, error, |
| GetCliGlobals()->currContext()->getCmpContextInfo(), GetCliGlobals()->exCollHeap()); |
| *spProcHandle = it; |
| |
| return SP_SUCCESS; |
| } |
| break; |
| |
| case SP_PROC_FETCH: |
| { |
| HybridQueryCacheStatsISPIterator* it = (HybridQueryCacheStatsISPIterator *)(*spProcHandle); |
| if (!it) { |
| return SP_FAIL; |
| } |
| |
| HybridQueryCacheStats stats; |
| if(!it->getNext(stats)) |
| return SP_SUCCESS; |
| |
| fFunc(0, outputData, sizeof(stats.nHKeys), &(stats.nHKeys), 0); |
| fFunc(1, outputData, sizeof(stats.nSKeys), &(stats.nSKeys), 0); |
| fFunc(2, outputData, sizeof(stats.nMaxValuesPerKey), &(stats.nMaxValuesPerKey), 0); |
| fFunc(3, outputData, sizeof(stats.nHashTableBuckets), &(stats.nHashTableBuckets), 0); |
| |
| return SP_MOREDATA; |
| } |
| break; |
| |
| case SP_PROC_CLOSE: { |
| NADELETEBASIC((HybridQueryCacheStatsISPIterator *)(*spProcHandle), GetCliGlobals()->exCollHeap()); |
| return SP_SUCCESS; |
| } |
| break; |
| |
| default: break; |
| } // switch |
| return SP_SUCCESS; |
| } |
| |
| //------------------------Hybrid Query Cache Entries--------------------------// |
| void HybridQueryCacheEntriesStoredProcedure::Initialize(SP_REGISTER_FUNCPTR regFunc) |
| { |
| regFunc("HYBRIDQUERYCACHEENTRIES", |
| sp_Compile, |
| sp_InputFormat, |
| 0, |
| sp_NumOutputFields, |
| sp_OutputFormat, |
| sp_Process, |
| 0, |
| CMPISPVERSION); |
| } |
| |
| SP_STATUS HybridQueryCacheEntriesStoredProcedure::sp_InputFormat(SP_FIELDDESC_STRUCT *inputFieldFormat, |
| Lng32 numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| if ( numFields != 2 ) |
| { |
| //accepts 2 input columns |
| error->error = arkcmpErrorISPWrongInputNum; |
| strcpy(error->optionalString[0], "HybridQueryCacheEntries"); |
| error->optionalInteger[0] = 2; |
| return SP_FAIL; |
| } |
| |
| // Describe input columns |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "instance char(16) not null"); |
| strcpy(&((inputFieldFormat++)->COLUMN_DEF[0]), "location char(16) not null"); |
| return SP_SUCCESS; |
| } |
| |
| SP_STATUS |
| HybridQueryCacheEntriesStoredProcedure::sp_NumOutputFields(Lng32 *numFields, |
| SP_COMPILE_HANDLE spCompileObj, |
| SP_HANDLE spObj, |
| SP_ERROR_STRUCT *error) |
| { |
| *numFields = 8; |
| return SP_SUCCESS; |
| } |
| |
| SP_STATUS HybridQueryCacheEntriesStoredProcedure::sp_OutputFormat( |
| SP_FIELDDESC_STRUCT* format, |
| SP_KEYDESC_STRUCT* /*keyFields */, |
| Lng32* /*numKeyFields */, |
| SP_COMPILE_HANDLE cmpHandle, |
| SP_HANDLE /* spHandle */, |
| SP_ERROR_STRUCT* /* error */ ) |
| { |
| strcpy(&((format++)->COLUMN_DEF[0]), "plan_id LARGEINT"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "hkey VARCHAR(4096 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "skey VARCHAR(4096 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "num_hits INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "num_PLiterals INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "PLiterals VARCHAR(4096 BYTES) character set utf8"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "num_NPLiterals INT UNSIGNED"); |
| strcpy(&((format++)->COLUMN_DEF[0]), "NPLiterals VARCHAR(4096 BYTES) character set utf8"); |
| return SP_SUCCESS; |
| } |
| |
| |
| SP_STATUS HybridQueryCacheEntriesStoredProcedure::sp_Process(SP_PROCESS_ACTION action, |
| SP_ROW_DATA inputData , |
| SP_EXTRACT_FUNCPTR eFunc , |
| SP_ROW_DATA outputData , |
| SP_FORMAT_FUNCPTR fFunc, |
| SP_KEY_VALUE keys, |
| SP_KEYVALUE_FUNCPTR kFunc, |
| SP_PROCESS_HANDLE* spProcHandle, |
| SP_HANDLE spObj/* spHandle */, |
| SP_ERROR_STRUCT* error ) |
| { |
| switch (action) { |
| case SP_PROC_OPEN: |
| { |
| HybridQueryCacheEntriesISPIterator * it = new (GetCliGlobals()->exCollHeap()) HybridQueryCacheEntriesISPIterator(inputData, eFunc, error, |
| GetCliGlobals()->currContext()->getCmpContextInfo(), GetCliGlobals()->exCollHeap()); |
| |
| *spProcHandle = it; |
| |
| return SP_SUCCESS; |
| } |
| break; |
| |
| case SP_PROC_FETCH: |
| { |
| HybridQueryCacheEntriesISPIterator* it = (HybridQueryCacheEntriesISPIterator *)(*spProcHandle); |
| if (!it) |
| return SP_FAIL; |
| |
| //fill data field |
| HybridQueryCacheDetails details; |
| |
| if(!it->getNext(details)) |
| return SP_SUCCESS; |
| |
| fFunc(0, outputData, sizeof(details.planId), &(details.planId), 0); |
| |
| Lng32 len = (Lng32)details.hkeyTxt.length() < 2048 ? (Lng32)details.hkeyTxt.length() : 2048; |
| fFunc(1, outputData, len, (void*)(details.hkeyTxt.data()),1); |
| |
| len = (Lng32)details.skeyTxt.length() < 2048 ? (Lng32)details.skeyTxt.length() : 2048; |
| fFunc(2, outputData,(Lng32)details.skeyTxt.length(), (void*)(details.skeyTxt.data()),1); |
| |
| fFunc(3, outputData, sizeof(details.nHits), &(details.nHits), 0); |
| |
| fFunc(4, outputData, sizeof(details.nOfPConst), &(details.nOfPConst), 0); |
| |
| len = (Lng32)details.PConst.length() < 1024 ? (Lng32)details.PConst.length() : 1024; |
| fFunc(5, outputData,(Lng32)details.PConst.length(), (void*)(details.PConst.data()),1); |
| |
| fFunc(6, outputData, sizeof(details.nOfNPConst), &(details.nOfNPConst), 0); |
| |
| len = (Lng32)details.NPConst.length() < 1024 ? (Lng32)details.NPConst.length() : 1024; |
| fFunc(7, outputData,(Lng32)details.NPConst.length(), (void*)(details.NPConst.data()),1); |
| |
| return SP_MOREDATA; |
| } |
| break; |
| |
| case SP_PROC_CLOSE: { |
| NADELETEBASIC((HybridQueryCacheEntriesISPIterator *)(*spProcHandle), GetCliGlobals()->exCollHeap()); |
| return SP_SUCCESS; |
| } |
| break; |
| |
| default: break; |
| } // switch |
| return SP_SUCCESS; |
| } |
| |
| |
| NABoolean ISPIterator::initializeISPCaches(SP_ROW_DATA inputData, SP_EXTRACT_FUNCPTR eFunc, SP_ERROR_STRUCT* error, |
| const NAArray<CmpContextInfo*> & ctxs, //input |
| NAString & contextName, |
| Int32 & index //output, set initial index in arrary of CmpContextInfos |
| ) |
| { |
| //extract ISP input, find QueryCache belonging to specified context |
| //and use it for fetch later |
| Lng32 maxSize = 16; |
| char receivingField[maxSize+1]; |
| if (eFunc (0, inputData, (Lng32)maxSize, receivingField, FALSE) == SP_ERROR_EXTRACT_DATA) |
| { |
| error->error = arkcmpErrorISPFieldDef; |
| return FALSE; |
| } |
| //choose context |
| // 1. Search ctxInfos_ for all context with specified name('USER', 'META', 'USTATS'), |
| // 'ALL' option will fetch all context in ctxInfos_, index is set to 0, qcache is always NULL, |
| // 2. For remote arkcmp, which has 0 context in ctxInfos_, index is always -1, |
| |
| NAString qCntxt = receivingField; |
| qCntxt.toLower(); |
| //the receivingField is of pattern xxx$trafodion.yyy, |
| //where xxx is the desired input string. |
| Int32 dollarIdx = qCntxt.index("$"); |
| CMPASSERT(dollarIdx > 0); |
| //find the specified context |
| if(ctxs.entries() == 0){ |
| //for remote compiler |
| if( (dollarIdx==3 && strncmp(qCntxt.data(), "all", dollarIdx)==0) |
| ||(dollarIdx==4 && strncmp(qCntxt.data(), "user", dollarIdx)==0) ) |
| index = -1; |
| } |
| else |
| { |
| if(dollarIdx==3 && strncmp(qCntxt.data(), "all", dollarIdx)==0) |
| { |
| contextName = "ALL"; |
| index = 0; |
| } |
| else if(dollarIdx==4 && strncmp(qCntxt.data(), "user", dollarIdx)==0) |
| { |
| contextName = "NONE"; |
| index = 0; |
| } |
| else if(dollarIdx==4 && strncmp(qCntxt.data(), "meta", dollarIdx)==0) |
| { |
| contextName = "META"; |
| index = 0; |
| } |
| else if(dollarIdx==6 && strncmp(qCntxt.data(), "ustats", dollarIdx)==0) |
| { |
| contextName = "USTATS"; |
| index = 0; |
| } |
| } |
| return TRUE; |
| } |
| |
