| /********************************************************************** |
| // @@@ 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: SessionDefaults.cpp |
| * Description: Default settings for cli. |
| * |
| * Created: 9/8/2005 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #include "Platform.h" |
| #include "cli_stdh.h" |
| #include "ex_stdh.h" |
| #include "ex_tcb.h" |
| #include "ExExeUtil.h" |
| #include "SessionDefaults.h" |
| #include "exp_clause_derived.h" |
| #include "sql_id.h" |
| #include "SQLCLIdev.h" |
| #include "charinfo.h" |
| #include "ComRtUtils.h" |
| #include "ComTdbExeUtil.h" |
| #include "NLSConversion.h" |
| |
| #define SDEntry(sesDef, sesDefStr, datatype, isCQD, defTab, isSSD, ext) {sesDef, "" # sesDefStr "", datatype, isCQD, defTab, isSSD, ext} |
| |
| static const SessionDefaults::SessionDefaultMap sessionDefaultMap[] = |
| { |
| // Attribute Attr String Attr Datatype IsCQD InDef IsSSD Ext |
| // Table |
| // ============================================================================================================================================== |
| SDEntry(SessionDefaults::AQR_ENTRIES, AQR_ENTRIES, SessionDefaults::SDT_ASCII, FALSE, TRUE, TRUE, FALSE), |
| SDEntry(SessionDefaults::AUTO_QUERY_RETRY_WARNINGS,AUTO_QUERY_RETRY_WARNINGS, SessionDefaults::SDT_BOOLEAN, TRUE, TRUE, FALSE, FALSE), |
| SDEntry(SessionDefaults::CALL_EMBEDDED_ARKCMP, CALL_EMBEDDED_ARKCMP, SessionDefaults::SDT_BOOLEAN, TRUE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::CANCEL_ESCALATION_INTERVAL,CANCEL_ESCALATION_INTERVAL,SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::CANCEL_ESCALATION_MXOSRVR_INTERVAL, |
| CANCEL_ESCALATION_MXOSRVR_INTERVAL, |
| SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::CANCEL_ESCALATION_SAVEABEND, |
| CANCEL_ESCALATION_SAVEABEND, |
| SessionDefaults::SDT_BOOLEAN, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::CANCEL_LOGGING, CANCEL_LOGGING, SessionDefaults::SDT_BOOLEAN, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::CANCEL_QUERY_ALLOWED, CANCEL_QUERY_ALLOWED, SessionDefaults::SDT_BOOLEAN, TRUE, TRUE, TRUE, FALSE), |
| SDEntry(SessionDefaults::CANCEL_UNIQUE_QUERY, CANCEL_UNIQUE_QUERY, SessionDefaults::SDT_BOOLEAN, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::CATALOG, CATALOG, SessionDefaults::SDT_ASCII, TRUE, TRUE, FALSE, FALSE), |
| SDEntry(SessionDefaults::COMPILER_IDLE_TIMEOUT, COMPILER_IDLE_TIMEOUT, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::DBTR_PROCESS, DBTR_PROCESS, SessionDefaults::SDT_BOOLEAN, TRUE, FALSE, FALSE, FALSE), |
| SDEntry(SessionDefaults::ESP_ASSIGN_DEPTH, ESP_ASSIGN_DEPTH, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::ESP_ASSIGN_TIME_WINDOW, ESP_ASSIGN_TIME_WINDOW, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::ESP_CLOSE_ERROR_LOGGING, ESP_CLOSE_ERROR_LOGGING, SessionDefaults::SDT_BOOLEAN, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::ESP_FREEMEM_TIMEOUT, ESP_FREEMEM_TIMEOUT, SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, TRUE, TRUE), |
| SDEntry(SessionDefaults::ESP_IDLE_TIMEOUT, ESP_IDLE_TIMEOUT, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::ESP_INACTIVE_TIMEOUT, ESP_INACTIVE_TIMEOUT, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::ESP_STOP_IDLE_TIMEOUT, ESP_STOP_IDLE_TIMEOUT, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::ESP_RELEASE_WORK_TIMEOUT, ESP_RELEASE_WORK_TIMEOUT, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::INTERNAL_FORMAT_IO, INTERNAL_FORMAT_IO, SessionDefaults::SDT_BOOLEAN, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::ISO_MAPPING, ISO_MAPPING, SessionDefaults::SDT_ASCII, FALSE, TRUE, TRUE, FALSE), |
| SDEntry(SessionDefaults::MAX_POLLING_INTERVAL, MAX_POLLING_INTERVAL, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::PARENT_QID, PARENT_QID, SessionDefaults::SDT_ASCII, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::PARENT_QID_SYSTEM, PARENT_QID_SYSTEM, SessionDefaults::SDT_ASCII, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::PARSER_FLAGS, PARSER_FLAGS, SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::PERSISTENT_OPENS, PERSISTENT_OPENS, SessionDefaults::SDT_BINARY_SIGNED, FALSE, TRUE, TRUE, TRUE), |
| SDEntry(SessionDefaults::RECLAIM_FREE_MEMORY_RATIO, RECLAIM_FREE_MEMORY_RATIO, SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, TRUE, TRUE), |
| SDEntry(SessionDefaults::RECLAIM_FREE_PFS_RATIO, RECLAIM_FREE_PFS_RATIO, SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, TRUE, TRUE), |
| SDEntry(SessionDefaults::RECLAIM_MEMORY_AFTER, RECLAIM_MEMORY_AFTER, SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, TRUE, TRUE), |
| SDEntry(SessionDefaults::ROWSET_ATOMICITY, ROWSET_ATOMICITY, SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, FALSE, FALSE), |
| SDEntry(SessionDefaults::RTS_TIMEOUT, RTS_TIMEOUT, SessionDefaults::SDT_BINARY_SIGNED, FALSE, FALSE, TRUE, TRUE), |
| SDEntry(SessionDefaults::SCHEMA, SCHEMA, SessionDefaults::SDT_ASCII, TRUE, TRUE, FALSE, FALSE), |
| SDEntry(SessionDefaults::STATISTICS_VIEW_TYPE, STATISTICS_VIEW_TYPE, SessionDefaults::SDT_ASCII, FALSE, FALSE, TRUE, TRUE), |
| SDEntry(SessionDefaults::SUSPEND_LOGGING, SUSPEND_LOGGING, SessionDefaults::SDT_BOOLEAN, FALSE, FALSE, TRUE, FALSE), |
| SDEntry(SessionDefaults::USE_LIBHDFS, USE_LIBHDFS, SessionDefaults::SDT_BOOLEAN, TRUE, TRUE, FALSE, FALSE), |
| SDEntry(SessionDefaults::USER_EXPERIENCE_LEVEL, USER_EXPERIENCE_LEVEL, SessionDefaults::SDT_ASCII, TRUE, TRUE, FALSE, FALSE), |
| SDEntry(SessionDefaults::WMS_PROCESS, WMS_PROCESS, SessionDefaults::SDT_BOOLEAN, FALSE, FALSE, TRUE, FALSE) |
| }; |
| |
| SessionDefaults::SessionDefaults(CollHeap * heap) |
| : heap_(heap), |
| dbtrProcess_(FALSE), |
| nvciProcess_(FALSE), |
| mariaQuestProcess_(FALSE), |
| internalCli_(FALSE), |
| espCloseErrorLogging_(FALSE), // Don't log EMS event for outstanding request at close time |
| cliBulkMove_(TRUE), |
| aqrEmsEvent_(FALSE), |
| aqrType_(1), // SYSTEM |
| catalog_(NULL), |
| schema_(NULL), |
| uel_(NULL), |
| internalFormatIO_(FALSE), |
| isoMappingName_(NULL), |
| isoMappingEnum_(0), |
| parserFlags_(0), |
| rowsetAtomicity_(-1), |
| parentQid_(NULL), |
| wmsProcess_(FALSE), |
| cancelEscalationInterval_(60), |
| cancelEscalationMxosrvrInterval_(120), |
| cancelEscalationSaveabend_(FALSE), |
| cancelQueryAllowed_(TRUE), |
| cancelUniqueQuery_(FALSE), |
| cancelLogging_(TRUE), |
| suspendLogging_(TRUE), |
| aqrWarn_(0), |
| redriveCTAS_(FALSE), |
| callEmbeddedArkcmp_(FALSE), |
| exsmTraceLevel_(0), |
| exsmTraceFilePrefix_(NULL) |
| { |
| parentQidSystem_[0] = '\0'; |
| Lng32 len = sizeof(sessionDefaultMap) / sizeof(SessionDefaultMap); |
| ex_assert(len == LAST_SESSION_DEFAULT_ATTRIBUTE, "Mismatch between sessionDefaultMap and SessionDefaultAttribute"); |
| |
| defaultsValueString_ = new(heap) char * [len]; |
| for (Int32 i = 0; i < len; i++) |
| { |
| defaultsValueString_[i] = NULL; |
| } |
| |
| savedDefaultsValueString_ = new(heap) char * [len]; |
| for (Int32 i = 0; i < len; i++) |
| { |
| savedDefaultsValueString_[i] = NULL; |
| } |
| |
| setJdbcProcess(FALSE); |
| setOdbcProcess(FALSE); |
| setMxciProcess(FALSE); |
| char *enableValue; |
| enableValue = getenv("ENABLE_EMBEDDED_ARKCMP"); |
| if (enableValue != NULL && enableValue[0] == '0') |
| setCallEmbeddedArkcmp(FALSE); |
| else |
| setCallEmbeddedArkcmp(TRUE); |
| char *espAssignDepthEnvvar = getenv("ESP_ASSIGN_DEPTH"); |
| if (espAssignDepthEnvvar != NULL) |
| setEspAssignDepth(atoi(espAssignDepthEnvvar)); |
| else |
| setEspAssignDepth(-1); |
| // Default is 60 (master won't use this esp if it has this or less seconds |
| // left to be idle timed out. |
| // This value can not be less 30, see ex_control.cpp how it is handled |
| // when processing this set session default command |
| setEspAssignTimeWindow(60); |
| // Default is 60 (master kills ESPs that were idling for 1 minute or more) |
| setEspStopIdleTimeout(60); |
| // Default is 1800 (idle ESPs time out in 30 minutes) |
| setEspIdleTimeout(30*60); |
| // Default is 1800 (Compiler Idle time out in 30 minutes) |
| setCompilerIdleTimeout(30*60); |
| // Default is 0 (inactive ESPs never time out) |
| setEspInactiveTimeout(0); |
| // how long master waits for release work reply from esps (default is 15 |
| // minutes) |
| setEspReleaseWorkTimeout(15*60); |
| setMaxPollingInterval(300); |
| char *perOpenssEnvvar = getenv("ESP_PERSISTENT_OPENS"); |
| if (perOpenssEnvvar != NULL) |
| setPersistentOpens(atoi(perOpenssEnvvar)); |
| else |
| setPersistentOpens(0); |
| // Default idle esp freemem timeout is 10 seconds |
| setEspFreeMemTimeout(10); |
| setRtsTimeout(0); |
| |
| |
| setEspFreeMemTimeout(espFreeMemTimeout_); |
| setEspCloseErrorLogging(espCloseErrorLogging_); |
| |
| // set the default to ISO88591 |
| setIsoMappingName(SQLCHARSETSTRING_ISO88591, strlen(SQLCHARSETSTRING_ISO88591)); |
| |
| sessionEnvvars_ = new(heap) NAList<SessionEnvvar>(heap); |
| |
| setParentQid(NULL, 0); |
| setParentQidSystem(NULL, 0); |
| setWmsProcess(FALSE); |
| aqrInfo_ = new(heap) AQRInfo(heap); |
| setRtsTimeout(rtsTimeout_); |
| setStatisticsViewType(SQLCLI_PERTABLE_STATS); |
| setReclaimTotalMemorySize(DEFAULT_RECLAIM_MEMORY_AFTER); |
| setReclaimFreeMemoryRatio(DEFAULT_RECLAIM_FREE_MEMORY_RATIO); |
| setReclaimFreePFSRatio(DEFAULT_RECLAIM_FREE_PFS_RATIO); |
| setCancelEscalationInterval(60); |
| setCancelEscalationMxosrvrInterval(120); |
| setCancelEscalationSaveabend(FALSE); |
| setUseLibHdfs(FALSE); |
| } |
| |
| SessionDefaults::~SessionDefaults() |
| { |
| delete sessionEnvvars_; |
| } |
| |
| SessionDefaults::SessionDefaultMap SessionDefaults::getSessionDefaultMap |
| (char * attribute, Lng32 attrLen) |
| { |
| Lng32 len = sizeof(sessionDefaultMap) / sizeof(SessionDefaultMap); |
| for (Int32 i = 0; i < len; i++) |
| { |
| if ((sessionDefaultMap[i].fromDefaultsTable) && |
| (strcmp(sessionDefaultMap[i].attributeString, attribute) |
| == 0)) |
| { |
| return sessionDefaultMap[i]; |
| } |
| } |
| |
| SessionDefaultMap sdm; |
| sdm.attribute = INVALID_SESSION_DEFAULT; |
| sdm.attributeString = NULL; |
| sdm.attributeType = SessionDefaults::SDT_BOOLEAN; |
| sdm.fromDefaultsTable = sdm.isCQD = sdm.isSSD = sdm.externalized = FALSE; |
| |
| return sdm; |
| } |
| |
| void SessionDefaults::setIsoMappingName(const char * attrValue, Lng32 attrValueLen) |
| { |
| if (isoMappingName_) |
| { |
| NADELETEBASIC(isoMappingName_, heap_); |
| } |
| |
| isoMappingName_ = new(heap_) char[attrValueLen + 1]; |
| strncpy(isoMappingName_, attrValue, attrValueLen); |
| isoMappingName_[attrValueLen] = '\0'; |
| |
| // upcase isoMappingName_ |
| str_cpy_convert(isoMappingName_, isoMappingName_, attrValueLen, 1); |
| |
| setIsoMappingEnum(); |
| } |
| |
| void SessionDefaults::setIsoMappingEnum() |
| { |
| isoMappingEnum_ = (Lng32)CharInfo::getCharSetEnum(isoMappingName_); |
| |
| } |
| |
| void SessionDefaults::setSessionDefaultAttributeValue |
| (SessionDefaultMap sda, char * attrValue, Lng32 attrValueLen) |
| { |
| Lng32 defaultValueAsLong = -1; |
| NABoolean defaultValueAsBoolean = FALSE; |
| |
| if (attrValue) |
| { |
| if (sda.attributeType == SessionDefaults::SDT_BINARY_SIGNED) |
| { |
| ex_expr::exp_return_type rc = |
| convDoIt(attrValue, attrValueLen, REC_BYTE_F_ASCII, |
| 0, 0, |
| (char*)&defaultValueAsLong, sizeof(Lng32), |
| REC_BIN32_SIGNED, |
| 0, 0, |
| NULL, 0); |
| if (rc != ex_expr::EXPR_OK) |
| { |
| return; // error |
| } |
| } |
| else if (sda.attributeType == SessionDefaults::SDT_BOOLEAN) |
| { |
| if ((strcmp(attrValue, "ON") == 0) || |
| (strcmp(attrValue, "TRUE") == 0)) |
| defaultValueAsBoolean = TRUE; |
| } |
| } |
| |
| switch (sda.attribute) |
| { |
| case AQR_ENTRIES: |
| { |
| aqrInfo()->setAQREntriesFromInputStr(attrValue, attrValueLen); |
| } |
| break; |
| |
| case AUTO_QUERY_RETRY_WARNINGS: |
| { |
| if (defaultValueAsBoolean) |
| setAQRWarnings(1); |
| else |
| setAQRWarnings(0); |
| } |
| break; |
| |
| case DBTR_PROCESS: |
| { |
| setDbtrProcess(defaultValueAsBoolean); |
| } |
| break; |
| |
| case ESP_ASSIGN_DEPTH: |
| { |
| setEspAssignDepth(defaultValueAsLong); |
| } |
| break; |
| |
| case ESP_ASSIGN_TIME_WINDOW: |
| { |
| setEspAssignTimeWindow(defaultValueAsLong); |
| } |
| break; |
| |
| case ESP_STOP_IDLE_TIMEOUT: |
| { |
| setEspStopIdleTimeout(defaultValueAsLong); |
| } |
| break; |
| |
| case ESP_IDLE_TIMEOUT: |
| { |
| setEspIdleTimeout(defaultValueAsLong); |
| } |
| break; |
| |
| case COMPILER_IDLE_TIMEOUT: |
| { |
| setCompilerIdleTimeout(defaultValueAsLong); |
| } |
| break; |
| |
| case ESP_INACTIVE_TIMEOUT: |
| { |
| setEspInactiveTimeout(defaultValueAsLong); |
| } |
| break; |
| |
| case ESP_RELEASE_WORK_TIMEOUT: |
| { |
| setEspReleaseWorkTimeout(defaultValueAsLong); |
| } |
| break; |
| |
| case MAX_POLLING_INTERVAL: |
| { |
| setMaxPollingInterval(defaultValueAsLong); |
| } |
| break; |
| case PERSISTENT_OPENS: |
| { |
| setPersistentOpens(defaultValueAsLong); |
| } |
| break; |
| |
| case ESP_CLOSE_ERROR_LOGGING: |
| { |
| setEspCloseErrorLogging(defaultValueAsBoolean); |
| } |
| break; |
| |
| case CATALOG: |
| { |
| setCatalog(attrValue, attrValueLen); |
| }; |
| break; |
| |
| case SCHEMA: |
| { |
| setSchema(attrValue, attrValueLen); |
| }; |
| break; |
| |
| case USE_LIBHDFS: |
| { |
| setUseLibHdfs(defaultValueAsBoolean); |
| |
| } |
| break; |
| case USER_EXPERIENCE_LEVEL: |
| { |
| setUEL(attrValue, attrValueLen); |
| }; |
| break; |
| |
| case RTS_TIMEOUT: |
| { |
| setRtsTimeout(defaultValueAsLong); |
| } |
| break; |
| |
| case INTERNAL_FORMAT_IO: |
| { |
| setInternalFormatIO(defaultValueAsBoolean); |
| } |
| break; |
| case ISO_MAPPING: |
| { |
| if (attrValueLen != strlen(SQLCHARSETSTRING_ISO88591) || |
| strcmp(attrValue, SQLCHARSETSTRING_ISO88591) != 0) |
| { |
| // Ignore the specified ISO_MAPPING setting |
| } |
| setIsoMappingName(SQLCHARSETSTRING_ISO88591, strlen(SQLCHARSETSTRING_ISO88591)); |
| } |
| break; |
| case PARENT_QID: |
| setParentQid(attrValue, attrValueLen); |
| break; |
| case PARENT_QID_SYSTEM: |
| setParentQidSystem(attrValue, attrValueLen); |
| break; |
| case WMS_PROCESS: |
| setWmsProcess(defaultValueAsBoolean); |
| break; |
| case ESP_FREEMEM_TIMEOUT: |
| { |
| setEspFreeMemTimeout(defaultValueAsLong); |
| } |
| break; |
| case STATISTICS_VIEW_TYPE: |
| setStatisticsViewType(defaultValueAsLong); |
| break; |
| case RECLAIM_MEMORY_AFTER: |
| setReclaimTotalMemorySize(defaultValueAsLong); |
| break; |
| case RECLAIM_FREE_MEMORY_RATIO: |
| setReclaimFreeMemoryRatio(defaultValueAsLong); |
| break; |
| case RECLAIM_FREE_PFS_RATIO: |
| setReclaimFreePFSRatio(defaultValueAsLong); |
| break; |
| case CANCEL_ESCALATION_INTERVAL: |
| { |
| setCancelEscalationInterval(defaultValueAsLong); |
| } |
| break; |
| case CANCEL_ESCALATION_MXOSRVR_INTERVAL: |
| { |
| setCancelEscalationMxosrvrInterval(defaultValueAsLong); |
| } |
| break; |
| case CANCEL_ESCALATION_SAVEABEND: |
| { |
| setCancelEscalationSaveabend(defaultValueAsBoolean); |
| } |
| break; |
| case CANCEL_LOGGING: |
| { |
| setCancelLogging(defaultValueAsBoolean); |
| } |
| break; |
| case CANCEL_QUERY_ALLOWED: |
| { |
| setCancelQueryAllowed(defaultValueAsBoolean); |
| } |
| break; |
| case CANCEL_UNIQUE_QUERY: |
| { |
| setCancelUniqueQuery(defaultValueAsBoolean); |
| } |
| break; |
| case SUSPEND_LOGGING: |
| { |
| setSuspendLogging(defaultValueAsBoolean); |
| } |
| break; |
| case CALL_EMBEDDED_ARKCMP: |
| { |
| setCallEmbeddedArkcmp(defaultValueAsBoolean); |
| } |
| break; |
| default: |
| { |
| } |
| break; |
| }; |
| } |
| |
| void SessionDefaults::initializeSessionDefault |
| (char * attribute, Lng32 attrLen, |
| char * attrValue, Lng32 attrValueLen) |
| { |
| SessionDefaultMap sda = |
| getSessionDefaultMap(attribute, attrLen); |
| |
| if (sda.attribute == INVALID_SESSION_DEFAULT) |
| return; |
| |
| setSessionDefaultAttributeValue(sda, attrValue, attrValueLen); |
| } |
| |
| void SessionDefaults::updateDefaultsValueString(SessionDefaultAttribute sda, |
| const Int16 DisAmbiguate, |
| NABoolean value) |
| { |
| if (defaultsValueString_[sda]) |
| NADELETEBASIC(defaultsValueString_[sda], heap_); |
| |
| defaultsValueString_[sda] = new(heap_) char[6]; |
| |
| if (value == TRUE) |
| strcpy(defaultsValueString_[sda], "TRUE"); |
| else |
| strcpy(defaultsValueString_[sda], "FALSE"); |
| } |
| |
| void SessionDefaults::updateDefaultsValueString(SessionDefaultAttribute sda, |
| Lng32 value) |
| { |
| if (defaultsValueString_[sda]) |
| NADELETEBASIC(defaultsValueString_[sda], heap_); |
| |
| defaultsValueString_[sda] = new(heap_) char[12]; |
| |
| if (value < 0) |
| { |
| defaultsValueString_[sda][0] = '-'; |
| |
| str_itoa((ULng32)(-value), &defaultsValueString_[sda][1]); |
| } |
| else |
| str_itoa((ULng32)(value), defaultsValueString_[sda]); |
| } |
| |
| void SessionDefaults::updateDefaultsValueString(SessionDefaultAttribute sda, |
| char * value) |
| { |
| if (defaultsValueString_[sda]) |
| NADELETEBASIC(defaultsValueString_[sda], heap_); |
| |
| if (value) |
| { |
| defaultsValueString_[sda] = new(heap_) char[strlen(value) + 1]; |
| strcpy(defaultsValueString_[sda], value); |
| } |
| else |
| defaultsValueString_[sda] = NULL; |
| } |
| |
| Lng32 SessionDefaults::setIsoMappingDefine() |
| { |
| |
| return 0; |
| } |
| |
| void SessionDefaults::saveSessionDefaults() |
| { |
| Lng32 len = sizeof(sessionDefaultMap) / sizeof(SessionDefaultMap); |
| |
| for (Int32 i = 0; i < len; i++) |
| { |
| NADELETEBASIC(savedDefaultsValueString_[i], heap_); |
| |
| if (defaultsValueString_[i]) |
| { |
| savedDefaultsValueString_[i] = |
| new(heap_) char[strlen(defaultsValueString_[i]) + 1]; |
| strcpy(savedDefaultsValueString_[i], defaultsValueString_[i]); |
| } |
| else |
| { |
| savedDefaultsValueString_[i] = NULL; |
| } |
| } |
| |
| } |
| |
| void SessionDefaults::restoreSessionDefaults() |
| { |
| Lng32 len = sizeof(sessionDefaultMap) / sizeof(SessionDefaultMap); |
| |
| for (Int32 i = 0; i < len; i++) |
| { |
| if (savedDefaultsValueString_[i]) |
| { |
| setSessionDefaultAttributeValue( |
| sessionDefaultMap[i], |
| savedDefaultsValueString_[i], |
| strlen(savedDefaultsValueString_[i])); |
| } |
| } |
| |
| } |
| |
| Lng32 SessionDefaults::readFromDefaultsTable(CliGlobals * cliGlobals) |
| { |
| // Read system defaults from configuration file |
| // keep this name in sync with file sqlcomp/nadefaults.cpp |
| NAString confFile(getenv("TRAF_CONF")); |
| confFile += "/SQSystemDefaults.conf"; |
| |
| FILE *f = fopen(confFile, "r"); |
| |
| if (f) |
| { |
| char attrName[101]; |
| char attrValue[4000]; |
| int rc = 0; |
| |
| while (rc = fscanf(f, " %100[A-Za-z0-9_#] ,", attrName) == 0) |
| { |
| fgets(attrValue, sizeof(attrValue), f); |
| NAString attrNameUp(attrName); |
| |
| attrNameUp.toUpper(); |
| if (attrNameUp[0] != '#') |
| initializeSessionDefault((char *) attrNameUp.data(), |
| attrNameUp.length(), |
| attrValue, |
| str_len(attrValue)); |
| } |
| } |
| |
| return 0; |
| } |
| |
| void SessionDefaults::position() |
| { |
| currDef_ = 0; |
| } |
| |
| short SessionDefaults::getNextSessionDefault(char* &attributeString, |
| char* &attributeValue, |
| Lng32 &isCQD, |
| Lng32 &fromDefaultsTable, |
| Lng32 &isSSD, |
| Lng32 &isExternalized) |
| { |
| Lng32 len = sizeof(sessionDefaultMap) / sizeof(SessionDefaultMap); |
| if (currDef_ == len) |
| return -1; |
| |
| attributeString = (char*)sessionDefaultMap[currDef_].attributeString; |
| |
| attributeValue = |
| defaultsValueString_[sessionDefaultMap[currDef_].attribute]; |
| |
| isCQD = sessionDefaultMap[currDef_].isCQD; |
| fromDefaultsTable = sessionDefaultMap[currDef_].fromDefaultsTable; |
| isSSD = sessionDefaultMap[currDef_].isSSD; |
| isExternalized = sessionDefaultMap[currDef_].externalized; |
| currDef_++; |
| |
| return 0; |
| } |
| |
| ////////////////////////////////////////////////////////////////////// |
| // class AQRInfo |
| ////////////////////////////////////////////////////////////////////// |
| static const QueryString cqdInfo[] = |
| { |
| {"unique_hash_joins"}, {"OFF"} |
| , {"transform_to_sidetree_insert"}, {"OFF"} |
| , {"METADATA_CACHE_SIZE"}, {"0"} |
| , {"QUERY_CACHE"}, {"0"} |
| , {"TRAF_RELOAD_NATABLE_CACHE"}, {"ON"} |
| }; |
| |
| static const AQRInfo::AQRErrorMap aqrErrorMap[] = |
| { |
| // SQLCODE NSKCODE RETRIES DELAY TYPE NUM CQD CMP INTERNAL |
| // CQDS STR INFO |
| // ===================================================================== |
| |
| // object does not exist in Trafodion |
| AQREntry( 1009, 0, 1, 0, 1, 1, "03", 0, 0), |
| AQREntry( 1254, 0, 1, 0, 1, 1, "03", 0, 0), |
| AQREntry( 1389, 0, 1, 0, 1, 1, "03", 0, 0), |
| AQREntry( 1584, 0, 1, 0, 1, 1, "03", 0, 0), |
| |
| // process could not be created (40) |
| AQREntry( 2012, 0, 3, 60, 0, 0, "", 0, 0), |
| |
| // comm failure with esp (201, 246, 249) |
| AQREntry( 2034, 0, 1, 0, 2, 0, "", 0, 0), |
| AQREntry( 2235, 0, 1, 0, 1, 1, "03", 0, 0), |
| AQREntry( 4001, 0, 1, 0, 1, 1, "03", 0, 0), |
| AQREntry( 4023, 0, 1, 0, 1, 1, "03", 0, 0), |
| AQREntry( 4039, 0, 1, 0, 1, 1, "03", 0, 0), |
| |
| // parallel purgedata failed |
| AQREntry( 8022, 0, 3, 60, 0, 0, "", 0, 1), |
| |
| // hive data modification timestamp mismatch. |
| // query will be AQR'd and hive metadata will be reloaded. |
| AQREntry( 8436, 0, 1, 0, 0, 2, "04:05", 0, 0), |
| |
| // FS memory errors |
| AQREntry( 8550, 30, 1, 60, 0, 0, "", 0, 0), |
| AQREntry( 8550, 31, 1, 60, 0, 0, "", 0, 0), |
| AQREntry( 8550, 33, 1, 60, 0, 0, "", 0, 0), |
| AQREntry( 8550, 35, 1, 60, 0, 0, "", 0, 0), |
| |
| // locked row timeout |
| AQREntry( 8550, 73, 2, 0, 0, 0, "", 0, 0), |
| AQREntry( 8550, 78, 1, 60, 0, 0, "", 0, 0), |
| AQREntry( 8551, 12, 1, 60, 0, 0, "", 0, 0), |
| |
| // DP2/FS memory errors |
| AQREntry( 8551, 30, 1, 60, 0, 0, "", 0, 0), |
| AQREntry( 8551, 31, 1, 60, 0, 0, "", 0, 0), |
| AQREntry( 8551, 33, 1, 60, 0, 0, "", 0, 0), |
| AQREntry( 8551, 35, 1, 60, 0, 0, "", 0, 0), |
| |
| // operation timeout against dp2 |
| AQREntry( 8551, 40, 1, 60, 0, 0, "", 0, 0), |
| |
| // locked row timeout |
| AQREntry( 8551, 73, 2, 0, 0, 0, "", 0, 0), |
| AQREntry( 8551, 78, 1, 60, 0, 0, "", 0, 0), |
| AQREntry( 8551, 200, 1, 30, 0, 0, "", 0, 0), |
| |
| AQREntry( 8551, 1054, 1, 60, 0, 0, "", 0, 0), |
| |
| // out of sqlmxbufferspace in dp2 |
| AQREntry( 8551, 1187, 1, 60, 0, 0, "", 0, 0), |
| |
| // out of server storage |
| AQREntry( 8551, 3502, 1, 60, 0, 0, "", 0, 0), |
| |
| // locked row timeout |
| AQREntry( 8558, 0 , 2, 10, 0, 0, "", 0, 0), |
| |
| // lost open |
| AQREntry( 8574, 0, 1, 0, 1, 0, "", 0, 0), |
| |
| // timestamp mismatch |
| AQREntry( 8575, 0, 1, 0, 1, 0, "", 0, 0), |
| |
| // table not found |
| AQREntry( 8577, 0, 1, 0, 1, 2, "04:05", 0, 0), |
| |
| // sim check failure |
| AQREntry( 8579, 0, 1, 0, 1, 0, "", 0, 0), |
| |
| // unavailable partitions |
| AQREntry( 8580, 0, 1, 0, 0, 0, "", 0, 0), |
| |
| // in-memory join out of memory |
| AQREntry( 8581, 0, 1, 0, 1, 1, "01", 0, 0), |
| |
| // No generated plan |
| AQREntry( 8583, 0, 1, 0, 1, 0, "", 0, 1), |
| // Schema security changed |
| AQREntry( 8585, 0, 1, 0, 1, 0, "", 0, 0), |
| |
| // esp could have died during fragment assignment |
| AQREntry( 8586, 0, 1, 60, 2, 0, "", 0, 0), |
| |
| // could not transform to sidetree insert. Reprepare as regular no rollback insert. |
| AQREntry( 8587, 0, 1, 0, 1, 1, "02", 0, 0), |
| |
| // dead esp |
| AQREntry( 8596, 0, 1, 0, 2, 0, "", 0, 0), |
| |
| // view not found |
| AQREntry( 8598, 0, 1, 0, 1, 0, "", 0, 0), |
| |
| AQREntry( 8606, 73, 3, 60, 0, 0, "", 0, 0), |
| |
| AQREntry( 8606, 97, 1, 0, 5, 0, "", 0, 0), |
| // privileges may have been revoked |
| AQREntry( 8734, 0, 1, 0, 1, 0, "", 0, 0), |
| |
| // DDL change detected before query started |
| AQREntry( 8738, 0, 1, 0, 1, 0, "", 0, 0), |
| |
| // internal error, no entries in diags. |
| AQREntry( 8810, 0, 1, 60, 0, 0, "", 0, 1), |
| |
| // transaction mode mismatch |
| AQREntry( 8814, 0, 1, 0, 0, 0, "", 0, 0), |
| |
| // compiler died |
| AQREntry( 8838, 0, 1, 0, 0, 0, "", 0, 1), |
| |
| // transaction state needs to be cleaned up in compiler - kill compiler |
| // only valid after prepare errors |
| AQREntry( 8841, 0, 1, 0, 4, 0, "", 0, 0), |
| |
| // transaction state needs to be cleaned up in compiler - kill compiler |
| // only valid after prepare errors. |
| AQREntry( 8844, 0, 1, 0, 4, 0, "", 0, 0), |
| |
| // Error was returned by the SeaMonster API |
| AQREntry( 8951, 10001, 1, 30, 0, 0, "", 0, 0), |
| AQREntry( 8951, 10012, 1, 0, 2, 0, "", 0, 0), |
| |
| // transaction state needs to be cleaned up in compiler - kill compiler |
| // only valid after prepare errors. |
| AQREntry( 8613, 0, 1, 0, 4, 0, "", 0, 0), |
| // memory condition in compiler - kill compiler |
| // only valid after prepare errors. |
| AQREntry( 2008, 0, 1, 0, 4, 0, "", 0, 0), |
| // UNLOAD failed to open file |
| // all three UNLOAD errors are retried only in NO APPEND mode |
| AQREntry( 8960, 0, 1, 0, 2, 0, "", 0, 0), |
| // UNLOAD failed during write to file |
| AQREntry( 8961, 0, 1, 0, 2, 0, "", 0, 0), |
| // UNLOAD failed to allocate buffers at start of execution |
| AQREntry( 8962, 0, 1, 0, 2, 0, "", 0, 0) |
| |
| }; |
| |
| |
| AQRInfo::AQRInfo(CollHeap * heap) |
| : heap_(heap), |
| currErr_(0), |
| aqrStmtInfo_(NULL), |
| flags_(0) |
| { |
| Lng32 numEntries = sizeof(aqrErrorMap) / sizeof(AQRErrorMap); |
| |
| aqrErrorList_ = new(heap) LIST(AQRErrorMap) (heap); |
| for (Int32 i = 0; i < numEntries; i++) |
| { |
| AQRErrorMap tgt; |
| AQRErrorMap src = aqrErrorMap[i]; |
| tgt.sqlcode = src.sqlcode; |
| tgt.nskcode = src.nskcode; |
| tgt.retries = src.retries; |
| tgt.delay = src.delay; |
| tgt.type = src.type; |
| tgt.numCQDs = src.numCQDs; |
| tgt.cqdStr = NULL; |
| tgt.cmpInfo = src.cmpInfo; |
| tgt.intAQR = src.intAQR; |
| if (tgt.numCQDs > 0) |
| { |
| tgt.cqdStr = new(heap_) char[strlen(src.cqdStr) + 1]; |
| strcpy((char*)tgt.cqdStr, src.cqdStr); |
| } |
| |
| aqrErrorList_->insert(tgt); //aqrErrorMap[i]); |
| } |
| |
| origAqrErrorList_ = new(heap) LIST(AQRErrorMap) (heap); |
| origAqrErrorList_->insert(*aqrErrorList_); |
| |
| |
| } |
| |
| AQRInfo::~AQRInfo() |
| { |
| } |
| |
| short AQRInfo::setAQREntry(Lng32 task, |
| Lng32 sqlcode, Lng32 nskcode, |
| Int32 retries, Int32 delay, Int32 type, |
| Int32 numCQDs, char * cqdStr, |
| Lng32 cmpInfo, Lng32 intAQR) |
| { |
| if ((sqlcode < 0) || (nskcode < 0) || (retries < 0) || (delay < 0) || |
| (type < 0) || (numCQDs < 0) || (cmpInfo < 0) || (cmpInfo > 1)) |
| return -1; |
| |
| UInt32 entry = 0; |
| NABoolean found = FALSE; |
| while ((NOT found) && (entry < aqrErrorList_->entries())) |
| { |
| entry++; |
| |
| Int64 currSqlcode = (*aqrErrorList_)[(entry-1)].sqlcode; |
| Int64 currNskcode = (*aqrErrorList_)[(entry-1)].nskcode; |
| if ((currSqlcode == sqlcode) && |
| (currNskcode == nskcode)) |
| { |
| found = TRUE; |
| } |
| } // while |
| |
| switch (task) |
| { |
| case ComTdbExeUtilAQR::ADD_: // add |
| { |
| if (found) |
| { |
| // check if it's the same string |
| if ( ((*aqrErrorList_)[(entry-1)].delay == delay ) && |
| ((*aqrErrorList_)[(entry-1)].retries == retries )) |
| //ignore . it's the same entry |
| return 0; |
| else |
| { |
| return -1; |
| } |
| |
| |
| } |
| else |
| { |
| // insert the new entry sorted on sqlcode/nskcode. |
| AQRErrorMap r; |
| r.sqlcode = sqlcode; |
| r.nskcode = nskcode; |
| r.retries = retries; |
| r.delay = delay; |
| r.type = type; |
| r.numCQDs = numCQDs; |
| r.cqdStr = NULL; |
| if (r.numCQDs > 0) |
| { |
| r.cqdStr = new(heap_) char[strlen(cqdStr) + 1]; |
| strcpy((char*)r.cqdStr, cqdStr); |
| } |
| r.cmpInfo = cmpInfo; |
| r.intAQR = intAQR; |
| |
| NABoolean done = FALSE; |
| entry = 0; |
| while ((NOT done) && (entry < aqrErrorList_->entries())) |
| { |
| Int64 currSqlcode = (*aqrErrorList_)[entry].sqlcode; |
| Int64 currNskcode = (*aqrErrorList_)[entry].nskcode; |
| if ((sqlcode < currSqlcode) || |
| ((sqlcode == currSqlcode) && |
| (nskcode < currNskcode))) |
| { |
| done = TRUE; |
| } |
| else |
| entry++; |
| } // while |
| |
| aqrErrorList_->insertAt(entry, r); |
| } |
| } // add |
| break; |
| |
| case ComTdbExeUtilAQR::DELETE_: // delete |
| { |
| // remove errors |
| if (found) |
| { |
| NADELETEBASIC((*aqrErrorList_)[(entry-1)].cqdStr, heap_); |
| aqrErrorList_->removeAt(entry-1); |
| } |
| else |
| { |
| // not found, ignore |
| return 0; |
| } |
| } |
| break; |
| |
| case ComTdbExeUtilAQR::UPDATE_: // update |
| { |
| if (found) |
| if ( ((*aqrErrorList_)[(entry-1)].delay == delay ) && |
| ((*aqrErrorList_)[(entry-1)].retries == retries )) |
| { |
| // ignore the update - it's the same |
| return 0; |
| } |
| else |
| { |
| (*aqrErrorList_)[(entry-1)].retries = retries; |
| (*aqrErrorList_)[(entry-1)].delay = delay; |
| (*aqrErrorList_)[(entry-1)].type = type; |
| (*aqrErrorList_)[(entry-1)].cmpInfo = cmpInfo; |
| (*aqrErrorList_)[(entry-1)].intAQR = intAQR; |
| } |
| else |
| { |
| // not found, return error. |
| return -1; |
| } |
| } |
| break; |
| |
| } // switch |
| |
| return 0; |
| } |
| |
| short AQRInfo::setAQREntriesFromInputStr(char * inStr, Lng32 inStrLen) |
| { |
| if ((! inStr) || (inStrLen <= 0)) |
| return -1; |
| |
| char * newStr = new(heap_) char[inStrLen + 1 + 1]; |
| str_cpy_all(newStr, inStr, inStrLen); |
| newStr[inStrLen] = 0; |
| Lng32 n = 0; |
| |
| Int32 i = 0; |
| while (i < inStrLen) |
| { |
| if ((inStr[i] != '+') && |
| (inStr[i] != '-') && |
| (inStr[i] != '.') && |
| (inStr[i] != ' ') && |
| (inStr[i] != ',') && |
| (inStr[i] != '|') && |
| (NOT ((inStr[i] >= '0') && |
| (inStr[i] <= '9')))) |
| return -1; |
| |
| if (inStr[i] != ' ') |
| { |
| newStr[n] = inStr[i]; |
| n++; |
| } |
| |
| i++; |
| } |
| |
| if (newStr[n-1] != '|') |
| { |
| newStr[n] = '|'; |
| n++; |
| } |
| newStr[n] = 0; |
| |
| i = 0; |
| Int32 j = 0; |
| Int32 k = 1; |
| Lng32 sqlcode = -1; |
| Lng32 nskcode = 0; |
| Lng32 retries = 1; |
| Lng32 delay = 60; |
| Lng32 type = 0; |
| Lng32 numCQDs = 0; |
| char * cqdStr = NULL; |
| Lng32 cmpInfo = 0; |
| Lng32 intAQR = 0; |
| Lng32 task = ComTdbExeUtilAQR::NONE_; |
| NABoolean numberSeen = FALSE; |
| while (i < n) |
| { |
| if ((newStr[i] >= '0') && |
| (newStr[i] <= '9')) |
| numberSeen = TRUE; |
| |
| if (newStr[i] == '+') |
| { |
| if ((numberSeen) || |
| (task != ComTdbExeUtilAQR::NONE_)) |
| return -1; |
| |
| task = ComTdbExeUtilAQR::ADD_; |
| j++; |
| } |
| else if (newStr[i] == '-') |
| { |
| if ((numberSeen) || |
| (task != ComTdbExeUtilAQR::NONE_)) |
| return -1; |
| |
| task = ComTdbExeUtilAQR::DELETE_; |
| j++; |
| } |
| else if (newStr[i] == '.') |
| { |
| if ((numberSeen) || |
| (task != ComTdbExeUtilAQR::NONE_)) |
| return -1; |
| |
| task = ComTdbExeUtilAQR::UPDATE_; |
| j++; |
| } |
| |
| if ((newStr[i] == ',') || |
| (newStr[i] == '|')) |
| { |
| if (i > j) |
| { |
| Lng32 v = 0; |
| if ((k < 7) || (k == 8) || (k == 9)) |
| { |
| Int64 bigV = str_atoi(&newStr[j], i-j); |
| if (bigV == -1) |
| return -1; |
| |
| if (bigV > INT_MAX) |
| return -1; |
| |
| v = (Lng32)bigV; |
| } |
| |
| switch (k) |
| { |
| case 1: |
| sqlcode = v; |
| break; |
| |
| case 2: |
| nskcode = v; |
| break; |
| |
| case 3: |
| retries = v; |
| break; |
| |
| case 4: |
| delay = v; |
| break; |
| |
| case 5: |
| type = v; |
| break; |
| |
| case 6: |
| numCQDs = v; |
| break; |
| |
| case 7: |
| cqdStr = new(heap_) char[i-j+1]; |
| str_cpy_all(cqdStr, &newStr[j], i-j); |
| cqdStr[i-j] = 0; |
| break; |
| |
| case 8: |
| cmpInfo = v; |
| break; |
| |
| case 9: |
| intAQR = v; |
| break; |
| |
| } // switch |
| } |
| |
| k++; |
| |
| j = i + 1; |
| } |
| |
| if (newStr[i] == '|') |
| { |
| if (task == ComTdbExeUtilAQR::NONE_) |
| task = ComTdbExeUtilAQR::ADD_; |
| |
| if (setAQREntry(task, sqlcode, nskcode, retries, delay, type, |
| numCQDs, cqdStr, cmpInfo, intAQR)) |
| return -1; |
| |
| sqlcode = -1; |
| nskcode = 0; |
| retries = 1; |
| delay = 60; |
| type = 0; |
| numCQDs = 0; |
| cqdStr = NULL; |
| cmpInfo = 0; |
| intAQR = 0; |
| |
| numberSeen = FALSE; |
| task = ComTdbExeUtilAQR::NONE_; |
| |
| k = 1; |
| j = i+1; |
| } |
| |
| i++; |
| } |
| |
| return 0; |
| } |
| |
| |
| short AQRInfo::getAQREntry(Lng32 sqlcode, Lng32 nskcode, |
| Lng32 &retries, Lng32 &delay, |
| Lng32 &type, |
| Int32 &numCQDs, char* &cqdStr, |
| Lng32 &cmpInfo, Lng32 &intAQR) |
| { |
| NABoolean sqlcodeZeroFound = FALSE; |
| UInt32 sqlcodeZeroEntryNum = 0; |
| NABoolean nskcodeZeroFound = FALSE; |
| UInt32 nskcodeZeroEntryNum = 0; |
| for (UInt32 i = 0; i < aqrErrorList_->entries(); i++) |
| { |
| NABoolean found = FALSE; |
| |
| // if '0' has been set as sqlcode by user, then retry on all errors. |
| if (0 == (*aqrErrorList_)[i].sqlcode) |
| { |
| sqlcodeZeroFound = TRUE; |
| sqlcodeZeroEntryNum = i; |
| } |
| else if ((ABS(sqlcode) == (*aqrErrorList_)[i].sqlcode) && |
| ((*aqrErrorList_)[i].nskcode == 0)) |
| { |
| nskcodeZeroFound = TRUE; |
| nskcodeZeroEntryNum = i; |
| } |
| else if ((ABS(sqlcode) == (*aqrErrorList_)[i].sqlcode) && |
| (ABS(nskcode) == (*aqrErrorList_)[i].nskcode)) |
| found = TRUE; |
| |
| if (found) |
| { |
| retries = (Int32)(*aqrErrorList_)[i].retries; |
| delay = (Int32)(*aqrErrorList_)[i].delay; |
| type = (Int32)(*aqrErrorList_)[i].type; |
| numCQDs = (Int32)(*aqrErrorList_)[i].numCQDs; |
| cqdStr = (char*)(*aqrErrorList_)[i].cqdStr; |
| cmpInfo = (Int32)(*aqrErrorList_)[i].cmpInfo; |
| intAQR = (Int32)(*aqrErrorList_)[i].intAQR; |
| |
| return 0; |
| } |
| } |
| |
| if ((nskcodeZeroFound) || (sqlcodeZeroFound)) |
| { |
| UInt32 i = |
| (nskcodeZeroFound ? nskcodeZeroEntryNum : sqlcodeZeroEntryNum); |
| |
| retries = (Int32)(*aqrErrorList_)[i].retries; |
| delay = (Int32)(*aqrErrorList_)[i].delay; |
| type = (Int32)(*aqrErrorList_)[i].type; |
| numCQDs = (Int32)(*aqrErrorList_)[i].numCQDs; |
| cqdStr = (char*)(*aqrErrorList_)[i].cqdStr; |
| cmpInfo = (Int32)(*aqrErrorList_)[i].cmpInfo; |
| intAQR = (Int32)(*aqrErrorList_)[i].intAQR; |
| |
| return 0; |
| } |
| |
| return -1; |
| } |
| |
| void AQRInfo::position() |
| { |
| currErr_ = 0; |
| } |
| |
| short AQRInfo::getNextAQREntry(Lng32 &sqlcode, Lng32 &nskcode, |
| Lng32 &retries, Lng32 &delay, |
| Lng32 &type, Lng32 &intAQR) |
| { |
| if (currErr_ == aqrErrorList_->entries()) |
| return -1; |
| |
| sqlcode = (*aqrErrorList_)[currErr_].sqlcode; |
| nskcode = (*aqrErrorList_)[currErr_].nskcode; |
| retries = (*aqrErrorList_)[currErr_].retries; |
| delay = (*aqrErrorList_)[currErr_].delay; |
| type = (*aqrErrorList_)[currErr_].type; |
| intAQR = (*aqrErrorList_)[currErr_].intAQR; |
| |
| currErr_++; |
| |
| return 0; |
| } |
| |
| void AQRInfo::saveAQRErrors() |
| { |
| aqrErrorList_->clear(); |
| aqrErrorList_->insert(*origAqrErrorList_); |
| } |
| |
| NABoolean AQRInfo::restoreAQRErrors() |
| { |
| if (origAqrErrorList_) |
| { |
| if (origAqrErrorList_->isEmpty()) |
| { |
| return FALSE; |
| } |
| |
| aqrErrorList_->clear(); |
| aqrErrorList_->insert(*origAqrErrorList_); |
| } |
| return TRUE; |
| } |
| |
| |
| void AQRInfo::clearRetryInfo() |
| { |
| if (aqrStmtInfo_) |
| { |
| aqrStmtInfo_ = NULL; |
| } |
| |
| flags_ = 0; |
| } |
| |
| AQRStatementInfo::AQRStatementInfo(CollHeap * heap) |
| { |
| heap_ = heap; |
| savedStmtAttributes_ = new (heap) AQRStatementAttributes(heap); |
| clearRetryInfo(); |
| |
| } |
| |
| void AQRStatementInfo::clearRetryInfo() |
| { |
| retryStatementId_ = NULL; |
| retrySqlSource_ = NULL; |
| retryInputDesc_ = NULL; |
| retryOutputDesc_ = NULL; |
| retryTempInputDesc_ = NULL; |
| retryTempOutputDesc_ = NULL; |
| retryPrepareFlags_ = 0; |
| retryFlags_ = 0; |
| retryStatementHandle_ = 0; |
| if (savedStmtAttributes_) |
| savedStmtAttributes_->clear(); |
| |
| } |
| |
| void AQRStatementInfo::saveAttributesFromStmt(Statement *fromStmt) |
| { |
| if (savedStmtAttributes_) |
| savedStmtAttributes_->getAttributesFromStatement(fromStmt); |
| } |
| void AQRStatementInfo::copyAttributesToStmt(Statement *toStmt) |
| { |
| if (savedStmtAttributes_) |
| savedStmtAttributes_->setAttributesInStatement(toStmt); |
| } |
| AQRStatementAttributes::AQRStatementAttributes(CollHeap *heap) |
| { |
| heap_ = heap; |
| holdable_ = SQLCLIDEV_NONHOLDABLE; |
| rowsetAtomicity_ = Statement::UNSPECIFIED_; |
| inputArrayMaxsize_ = 0; |
| uniqueStmtId_ = NULL; |
| uniqueStmtIdLen_ = 0; |
| parentQID_ = NULL; |
| parentQIDSystem_[0] = '\0'; |
| exeStartTime_ = -1; |
| } |
| |
| AQRStatementAttributes::~AQRStatementAttributes() |
| { |
| if (uniqueStmtId_) |
| NADELETEBASIC(uniqueStmtId_,heap_); |
| if (parentQID_) |
| NADELETEBASIC(parentQID_,heap_); |
| } |
| void AQRStatementAttributes::clear() |
| { |
| holdable_ = SQLCLIDEV_NONHOLDABLE; |
| rowsetAtomicity_ = Statement::UNSPECIFIED_; |
| inputArrayMaxsize_ = 0; |
| uniqueStmtId_ = NULL; |
| uniqueStmtIdLen_ = 0; |
| parentQID_ = NULL; |
| parentQIDSystem_[0] = '\0'; |
| exeStartTime_ = -1; |
| } |
| void AQRStatementAttributes::setAttributesInStatement(Statement *targetStmt) |
| { |
| ComDiagsArea d; |
| if(targetStmt) |
| { |
| targetStmt->setHoldable(holdable_); |
| targetStmt->setRowsetAtomicity(d,rowsetAtomicity_); |
| targetStmt->setInputArrayMaxsize(d,inputArrayMaxsize_); |
| targetStmt->setUniqueStmtId(uniqueStmtId_); |
| targetStmt->setParentQid(parentQID_); |
| targetStmt->setParentQidSystem(parentQIDSystem_); |
| targetStmt->setExeStartTime(exeStartTime_); |
| } |
| return; |
| |
| } |
| void AQRStatementAttributes::getAttributesFromStatement(Statement *fromStmt) |
| { |
| Lng32 len; |
| if (fromStmt) |
| { |
| holdable_ = fromStmt->getHoldable(); |
| rowsetAtomicity_ = fromStmt->getRowsetAtomicity(); |
| inputArrayMaxsize_ = fromStmt->getInputArrayMaxsize(); |
| if (fromStmt->getUniqueStmtId()) |
| { |
| uniqueStmtId_ = new(heap_) char[fromStmt->getUniqueStmtIdLen() + 1]; |
| str_cpy_all(uniqueStmtId_, fromStmt->getUniqueStmtId(), fromStmt->getUniqueStmtIdLen()); |
| uniqueStmtId_[fromStmt->getUniqueStmtIdLen()] = 0; |
| } |
| uniqueStmtIdLen_ = fromStmt->getUniqueStmtIdLen(); |
| |
| if (fromStmt->getParentQid()) |
| { |
| len = str_len(fromStmt->getParentQid()); |
| parentQID_ = new(heap_) char[len+1]; |
| str_cpy_all(parentQID_, fromStmt->getParentQid(),len); |
| parentQID_[len] = 0; |
| } |
| len = str_len(fromStmt->getParentQidSystem()); |
| str_cpy_all(parentQIDSystem_, fromStmt->getParentQidSystem(), len); |
| parentQIDSystem_[len] = '\0'; |
| if (fromStmt->getStatsArea() && fromStmt->getStatsArea()->getMasterStats()) |
| exeStartTime_ = fromStmt->getStatsArea()->getMasterStats()->getExeStartTime(); |
| |
| } |
| return; |
| } |
| |
| Lng32 AQRInfo::setCQDs(Lng32 numCQDs, char * cqdStr, |
| ContextCli * context) |
| { |
| Lng32 rc = 0; |
| if (numCQDs > 0) |
| { |
| for (Lng32 i = 0; i < numCQDs; i++) |
| { |
| // for each entry in the cqdStr, extract the corresponding |
| // entry from cqdInfo array and execute that cqd. |
| // Entries in cqdStr are of the form: |
| // NN:NN:....NN |
| // For ex: numCQDs=2 and cqdStr = 01:03 |
| // would indicate that entries #1 and #3 from the cqdInfo |
| // array need to be executed and set. |
| Int64 v = str_atoi(&cqdStr[i*3], 2); |
| if (v <= 0) |
| return -1; |
| |
| rc = context->holdAndSetCQD(cqdInfo[(v-1)*2].str, |
| cqdInfo[(v-1)*2+1].str); |
| if (rc < 0) |
| return rc; |
| } |
| } |
| |
| return 0; |
| } |
| |
| Lng32 AQRInfo::resetCQDs(Lng32 numCQDs, char * cqdStr, |
| ContextCli * context) |
| { |
| Lng32 rc = 0; |
| if (numCQDs > 0) |
| { |
| for (Lng32 i = 0; i < numCQDs; i++) |
| { |
| Int64 v = str_atoi(&cqdStr[i*3], 2); |
| if (v <= 0) |
| return -1; |
| |
| rc = context->restoreCQD(cqdInfo[(v-1)*2].str); |
| if (rc < 0) |
| return rc; |
| } |
| } |
| |
| return rc; |
| } |
| |
| Lng32 AQRInfo::setCompilerInfo(char * queryId, |
| ComCondition * errCond, |
| ContextCli * context) |
| { |
| Lng32 rc = 0; |
| char * csVal = NULL; |
| |
| Lng32 len = 0; |
| len = strlen("QUERY_ID: ") + strlen(queryId) + 1; |
| |
| csVal = new(heap_) char[len]; |
| |
| str_sprintf(csVal, "QUERY_ID: %s", queryId); |
| |
| rc = context->setCS("AQR_COMPILER_INFO", |
| csVal); |
| |
| return rc; |
| } |
| |
| Lng32 AQRInfo::resetCompilerInfo(char * queryId, |
| ComCondition * errCond, |
| ContextCli * context) |
| { |
| Lng32 rc = 0; |
| |
| rc = context->resetCS("AQR_COMPILER_INFO"); |
| |
| return rc; |
| } |
| |
| void SessionDefaults::resetSessionOnlyAttributes() |
| { |
| nvciProcess_ = FALSE; |
| internalCli_ = FALSE; |
| } |
| |
| SessionEnvvar::SessionEnvvar(CollHeap * heap, |
| char * envvarName, char * envvarValue) |
| : heap_(heap), |
| envvarName_(NULL), envvarValue_(NULL) |
| { |
| if (! envvarName) |
| return; |
| |
| envvarName_ = new(heap) char[strlen(envvarName)+1]; |
| strcpy(envvarName_, envvarName); |
| |
| if (envvarValue) |
| { |
| envvarValue_ = new(heap) char[strlen(envvarValue)+1]; |
| strcpy(envvarValue_, envvarValue); |
| } |
| else |
| envvarValue_ = NULL; |
| } |
| |
| SessionEnvvar::SessionEnvvar() |
| { |
| heap_ = NULL; |
| envvarName_ = NULL; |
| envvarValue_ = NULL; |
| } |
| |
| SessionEnvvar::~SessionEnvvar() |
| { |
| if (envvarName_) |
| NADELETEBASIC(envvarName_, heap_); |
| |
| if (envvarValue_) |
| NADELETEBASIC(envvarValue_, heap_); |
| } |
| |
| NABoolean SessionEnvvar::operator ==(const SessionEnvvar &other) const |
| { |
| if ((! envvarName_) || (! other.envvarName_)) |
| return FALSE; |
| |
| if (strcmp(envvarName_, other.envvarName_) == 0) |
| return TRUE; |
| else |
| return FALSE; |
| } |
| |
| SessionEnvvar& SessionEnvvar::operator =(const SessionEnvvar &other) |
| { |
| if (envvarName_) |
| NADELETEBASIC(envvarName_, heap_); |
| |
| if (envvarValue_) |
| NADELETEBASIC(envvarValue_, heap_); |
| |
| heap_ = other.heap_; |
| |
| if (other.envvarName_) |
| { |
| envvarName_ = new(heap_) char[strlen(other.envvarName_)+1]; |
| strcpy(envvarName_, other.envvarName_); |
| } |
| else |
| envvarName_ = NULL; |
| |
| if (other.envvarValue_) |
| { |
| envvarValue_ = new(heap_) char[strlen(other.envvarValue_)+1]; |
| strcpy(envvarValue_, other.envvarValue_); |
| } |
| else |
| envvarValue_ = NULL; |
| |
| return (*this); |
| } |
| |
| SessionEnvvar::SessionEnvvar(const SessionEnvvar &other) |
| { |
| *this = other; |
| } |
| |
| void SessionDefaults::setParentQid(char *attrValue, Lng32 attrValueLen) |
| { |
| if (parentQid_) |
| { |
| NADELETEBASIC(parentQid_, heap_); |
| } |
| if (attrValue) |
| { |
| if (attrValueLen == 4 && strncmp(attrValue, "NONE", 4) == 0) |
| parentQid_ = NULL; |
| else |
| { |
| parentQid_ = new(heap_) char[attrValueLen + 1]; |
| strncpy(parentQid_, attrValue, attrValueLen); |
| parentQid_[attrValueLen] = '\0'; |
| } |
| } |
| else |
| parentQid_ = NULL; |
| updateDefaultsValueString(PARENT_QID, parentQid_); |
| } |
| |
| void SessionDefaults::setParentQidSystem(char *attrValue, Lng32 attrValueLen) |
| { |
| if (attrValue != NULL) |
| { |
| if (attrValueLen == 4 && strncmp(attrValue, "NONE", 4) == 0) |
| parentQidSystem_[0] = '\0'; |
| else |
| { |
| str_cpy_all(parentQidSystem_, attrValue, attrValueLen); |
| parentQidSystem_[attrValueLen] = '\0'; |
| } |
| } |
| else |
| parentQidSystem_[0] = '\0'; |
| updateDefaultsValueString(PARENT_QID_SYSTEM, parentQidSystem_); |
| } |
| |
| void SessionDefaults::beginSession() |
| { |
| setParentQid(NULL, 0); |
| setParentQidSystem(NULL, 0); |
| setWmsProcess(FALSE); |
| setStatisticsViewType(SQLCLI_PERTABLE_STATS); |
| setReclaimTotalMemorySize(DEFAULT_RECLAIM_MEMORY_AFTER); |
| setReclaimFreeMemoryRatio(DEFAULT_RECLAIM_FREE_MEMORY_RATIO); |
| setReclaimFreePFSRatio(DEFAULT_RECLAIM_FREE_PFS_RATIO); |
| setRedriveCTAS(FALSE); |
| setExSMTraceFilePrefix(NULL, 0); |
| } |
| |
| |
| void SessionDefaults::setExSMTraceFilePrefix(const char *attrValue, |
| Int32 attrValueLen) |
| { |
| if (exsmTraceFilePrefix_) |
| { |
| NADELETEBASICARRAY(exsmTraceFilePrefix_, heap_); |
| exsmTraceFilePrefix_ = NULL; |
| } |
| |
| if (attrValue == NULL || attrValue[0] == 0 || attrValueLen == 0) |
| return; |
| |
| exsmTraceFilePrefix_ = new(heap_) char[attrValueLen + 1]; |
| strncpy(exsmTraceFilePrefix_, attrValue, attrValueLen); |
| exsmTraceFilePrefix_[attrValueLen] = 0; |
| } |
