| /* -*-C++-*- |
| // @@@ 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 @@@ |
| ***************************************************************************** |
| * |
| * File: NADefaults.cpp |
| * Description: Implementation for the defaults table class, NADefaults. |
| * |
| * Created: 7/11/96 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #define SQLPARSERGLOBALS_FLAGS // must precede all #include's |
| #define SQLPARSERGLOBALS_NADEFAULTS |
| |
| #include "Platform.h" |
| #include "NADefaults.h" |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| |
| #ifdef NA_HAS_SEARCH_H |
| #include <search.h> // use the bsearch binary search routine of the C RTL |
| #else |
| #include <unistd.h> // on OSS, bsearch comes from unistd.h |
| #endif |
| |
| #include "nsk/nskport.h" |
| |
| #if !defined(NDEBUG) |
| #endif |
| |
| |
| #include "CliDefs.h" |
| #include "CmpContext.h" |
| #include "CmpErrors.h" |
| #include "ComObjectName.h" |
| #include "ComRtUtils.h" |
| #include "ComSchemaName.h" |
| #include "ex_error.h" |
| #include "DefaultConstants.h" |
| #include "DefaultValidator.h" |
| #include "NAClusterInfo.h" |
| #include "parser.h" |
| #include "sql_id.h" |
| #include "SQLCLIdev.h" |
| #include "Sqlcomp.h" |
| #include "StmtCompilationMode.h" |
| #include "OptimizerSimulator.h" |
| #include "CmpSeabaseDDL.h" |
| #include "Globals.h" |
| #include "QCache.h" |
| |
| #include "SqlParserGlobals.h" // MUST be last #include! |
| |
| #include "seabed/ms.h" |
| #include "seabed/fs.h" |
| |
| |
| #define NADHEAP CTXTHEAP |
| #define ERRWARN(msg) ToErrorOrWarning(msg, errOrWarn) |
| #define ERRWARNLOOP(msg) ToErrorOrWarning(msg, errOrWarnLOOP) |
| |
| #define ENUM_RANGE_CHECK(e) (e >= 0 && (size_t)e < numDefaultAttributes()) |
| #define ATTR_RANGE_CHECK ENUM_RANGE_CHECK(attrEnum) |
| #ifndef NDEBUG |
| #define ATTR_RANGE_ASSERT CMPASSERT(ATTR_RANGE_CHECK) |
| #else |
| #define ATTR_RANGE_ASSERT |
| #endif |
| |
| // ------------------------------------------------------------------------- |
| // This table contains defaults used in SQLARK. |
| // To add a default, put it in sqlcomp/DefaultConstants.h and in this table. |
| // |
| // The #define declares the domain (allowed range of values) of the attr-value; |
| // typically it is Int1 or UI1 (signed or unsigned integral, >=1) |
| // to prevent division-by-zero errors in the calling code. |
| // |
| // The first column is the internal enum value from sqlcomp/DefaultConstants.h. |
| // The second column is the default value as a string. |
| // |
| // The DDxxxx macro identifies the domain of the attribute |
| // (the range and properties of the possible values). |
| // |
| // XDDxxxx does the same *and* externalizes the attribute |
| // (makes it visible to SHOWCONTROL; *you* need to tell Pubs to document it). |
| // |
| // SDDxxxx does the same and externalizes the attribute to HP support personnel |
| // (makes it visible to HPDM when support is logged on; *you* need to tell Pubs |
| // to document it in the support manual. You can set the |
| // SHOWCONTROL_SUPPORT_ATTRS CQD to ON to see all the externalized and |
| // support-level CQDs). |
| // |
| // For instance, DDflt0 allows any nonnegative floating-point number, while |
| // DDflte allows any positive float (the e stands for epsilon, that tiniest |
| // scintilla >0 in classical calculus, and something like +1E-38 on a Pentium). |
| // DDui allows only nonnegative integral values (ui=unsigned int), |
| // DDui1 allows only ints > 0, DDui2 only nonzero multiples of 2, etc. |
| // |
| // DDkwd validates keywords. Each attribute that is DDkwd has its own subset |
| // of acceptable tokens -- the default behavior is that the attr is bivalent |
| // (ON/OFF or TRUE/FALSE or ENABLE/DISABLE). If you want different keywords, |
| // see enum DefaultToken in DefaultConstants.h, and NADefaults::token() below. |
| // |
| // Other DD's validate percentages, and Ansi names. Certainly more could be |
| // defined, for more restrictive ranges or other criteria. |
| |
| // ************************************************************************* |
| // NOTE: You must keep the entire list in alphabetical order, |
| // or else the lookup will not work!!!!!!! Use only CAPITAL LETTERS!!!!!!!!! |
| // ************************************************************************* |
| // NOTE 2: If you choose to "hide" the default default value by setting it to |
| // "ENABLE" or "SYSTEM" or "", your code must handle this possibility. |
| // |
| // See OptPhysRelExpr.cpp's handling of PARALLEL_NUM_ESPS, |
| // an unsigned positive int which also accepts the keyword setting of "SYSTEM". |
| // See ImplRule.cpp's use of INSERT_VSBB, a keyword attr which allows "SYSTEM". |
| // |
| // A simple way to handle ON/OFF keywords that you want to hide the default for: |
| // Take OPTIMIZER_PRUNING as an example. Right now, it appears below with |
| // default "OFF", and opt.cpp does |
| // DisablePruning = (NADEFAULT(OPTIMIZER_PRUNING) == DF_OFF); |
| // To hide the default default, |
| // you would enter it below as "SYSTEM", and opt.cpp would do |
| // DisablePruning = (NADEFAULT(OPTIMIZER_PRUNING) != DF_ON); |
| // (i.e., DF_OFF and DF_SYSTEM would be treated identically, as desired). |
| // ************************************************************************* |
| // NOTE 3: The user is always allowed to say |
| // CONTROL QUERY DEFAULT attrname 'SYSTEM'; -- or 'ENABLE' or '' |
| // What this means is that the current setting for that attribute |
| // reverts to its default-default value. This default-default value |
| // may or may not be "SYSTEM"; this is completely orthogonal/irrelevant |
| // to the CQD usage. |
| // |
| // One gotcha: 'ENABLE' is a synonym for 'SYSTEM', *EXCEPT* when the |
| // SYSTEM default (the default-default) is "DISABLE". |
| // In this case, 'ENABLE' is a synonym for 'ON' |
| // (the opposite of the synonyms DISABLE/OFF). |
| // ************************************************************************* |
| // NOTE 4: After modifying this static table in any way, INCLUDING A CODE MERGE, |
| // for a quick sanity check, run w:/toolbin/checkNAD. |
| // For a complete consistency check, compile this file, link arkcmp, and |
| // runregr TEST050. |
| // ************************************************************************* |
| |
| struct DefaultDefault |
| { |
| enum DefaultConstants attrEnum; |
| const char *attrName; |
| const char *value; |
| const DefaultValidator *validator; |
| UInt32 flags; |
| }; |
| |
| #define DD(name,value,validator) { name, "" # name "", value, validator } |
| #define FDD(name,value,validator,flags) { name, "" # name "", value, validator, flags } |
| #define XDD(name,value,validator) FDD(name,value,validator,DEFAULT_IS_EXTERNALIZED) |
| #define SDD(name,value,validator) FDD(name,value,validator,DEFAULT_IS_FOR_SUPPORT) |
| |
| #define DDS(name,value,validator) FDD(name,value,validator,DEFAULT_IS_SSD) |
| #define XDDS(name,value,validator) FDD(name,value,validator,DEFAULT_IS_SSD | DEFAULT_IS_EXTERNALIZED) |
| #define SDDS(name,value,validator) FDD(name,value,validator,DEFAULT_IS_SSD | DEFAULT_IS_FOR_SUPPORT) |
| |
| #define DD_____(name,value) DD(name,value,&validateUnknown) |
| #define XDD_____(name,value) XDD(name,value,&validateUnknown) |
| #define SDD_____(name,value) SDD(name,value,&validateUnknown) |
| #define DDS_____(name,value) DDS(name,value,&validateUnknown) |
| #define XDDS_____(name,value) XDDS(name,value,&validateUnknown) |
| #define DDansi_(name,value) DD(name,value,&validateAnsiName) |
| #define XDDansi_(name,value) XDD(name,value,&validateAnsiName) |
| |
| #define DDcoll_(name,value) DD(name,value,&validateCollList) |
| |
| #define DDint__(name,value) DD(name,value,&validateInt) |
| #define SDDint__(name,value) SDD(name,value,&validateInt) |
| #define XDDint__(name,value) XDD(name,value,&validateInt) |
| #define DDSint__(name,value) DDS(name,value,&validateInt) |
| #define XDDSint__(name,value) XDDS(name,value,&validateInt) |
| #define XDDintN2(name,value) XDD(name,value,&validateIntNeg2) |
| #define DDintN1__(name,value) DD(name,value,&validateIntNeg1) |
| #define DDpct__(name,value) DD(name,value,&validatePct) |
| #define XDDpct__(name,value) XDD(name,value,&validatePct) |
| #define SDDpct__(name,value) SDD(name,value,&validatePct) |
| #define DDpct1_50(name,value) DD(name,value,&validatePct1_t50) |
| #define DD0_10485760(name,value) DD(name,value,&validate0_10485760) |
| #define DD0_255(name,value) DD(name,value,&validate0_255) |
| #define DD0_200000(name,value) DD(name,value,&validate0_200000) |
| #define XDD0_200000(name,value) XDD(name,value,&validate0_200000) |
| #define DD1_200000(name,value) DD(name,value,&validate1_200000) |
| #define XDDui30_32000(name,value) XDD(name,value,&validate30_32000) |
| #define DDui30_246(name,value) DD(name,value,&validate30_246) |
| #define DDui50_4194303(name,value) DD(name,value,&validate50_4194303) |
| #define DD1_24(name,value) DD(name,value,&validate1_24) |
| #define XDD1_1024(name,value) XDD(name,value,&validate1_1024) |
| #define DD1_1024(name,value) DD(name,value,&validate1_1024) |
| #define DD18_128(name,value) DD(name,value,&validate18_128) |
| #define DD1_128(name,value) DD(name,value,&validate1_128) |
| #define DDui___(name,value) DD(name,value,&validateUI) |
| #define XDDui___(name,value) XDD(name,value,&validateUI) |
| #define SDDui___(name,value) SDD(name,value,&validateUI) |
| #define DDui1__(name,value) DD(name,value,&validateUI1) |
| #define XDDui1__(name,value) XDD(name,value,&validateUI1) |
| #define SDDui1__(name,value) SDD(name,value,&validateUI1) |
| #define DDui2__(name,value) DD(name,value,&validateUI2) |
| #define XDDui2__(name,value) XDD(name,value,&validateUI2) |
| #define DDui8__(name,value) DD(name,value,&validateUI8) |
| #define DDui512(name,value) DD(name,value,&validateUI512) |
| #define DDui0_5(name,value) DD(name,value,&validateUIntFrom0To5) |
| #define XDDui0_5(name,value) XDD(name,value,&validateUIntFrom0To5) |
| #define DDui1_6(name,value) DD(name,value,&validateUIntFrom1To6) |
| #define DDui1_8(name,value) DD(name,value,&validateUIntFrom1To8) |
| #define DDui1_10(name,value) DD(name,value,&validateUIntFrom1To10) |
| #define DDui2_10(name,value) DD(name,value,&validateUIntFrom2To10) |
| #define DDui1500_4000(name,value) DD(name,value,&validateUIntFrom1500To4000) |
| #define DDipcBu(name,value) DD(name,value,&validateIPCBuf) |
| #define XDDipcBu(name,value) XDD(name,value,&validateIPCBuf) |
| #define DDflt__(name,value) DD(name,value,&validateFlt) |
| #define XDDflt__(name,value) XDD(name,value,&validateFlt) |
| #define SDDflt__(name,value) SDD(name,value,&validateFlt) |
| #define DDflt0_(name,value) DD(name,value,&validateFlt0) |
| #define XDDflt0_(name,value) XDD(name,value,&validateFlt0) |
| #define SDDflt0_(name,value) SDD(name,value,&validateFlt0) |
| #define DDflte_(name,value) DD(name,value,&validateFltE) |
| #define XDDflte_(name,value) XDD(name,value,&validateFltE) |
| #define SDDflte_(name,value) SDD(name,value,&validateFltE) |
| #define DDflt1_(name,value) DD(name,value,&validateFlt1) |
| #define XDDflt1_(name,value) XDD(name,value,&validateFlt1) |
| #define DDflt_0_1(name,value) DD(name,value,&validateFlt_0_1) |
| #define XDDflt_0_1(name,value) XDD(name,value,&validateFlt_0_1) |
| #define DDkwd__(name,value) DD(name,value,&validateKwd) |
| #define XDDkwd__(name,value) XDD(name,value,&validateKwd) |
| #define SDDkwd__(name,value) SDD(name,value,&validateKwd) |
| #define DDSkwd__(name,value) DDS(name,value,&validateKwd) |
| #define SDDSkwd__(name,value) SDDS(name,value,&validateKwd) |
| #define DD1_4096(name,value) DD(name,value,&validate1_4096) |
| #define DD0_18(name,value) DD(name,value,&validate0_18) |
| #define DD0_64(name,value) DD(name,value,&validate0_64) |
| #define DD16_64(name,value) DD(name,value,&validate16_64) |
| #define DDalis_(name,value) DD(name,value,&validateAnsiList) |
| #define XDDalis_(name,value) XDD(name,value,&validateAnsiList) |
| #define XDDpos__(name,value) XDD(name,value,&validatePOSTableSizes) |
| #define SDDpos__(name,value) SDD(name,value,&validatePOSTableSizes) |
| #define DDpos__(name,value) DD(name,value,&validatePOSTableSizes) |
| #define DDtp___(name,value) DD(name,value,&validateTraceStr) |
| #define DDosch_(name,value) DD(name,value,&validateOverrideSchema) |
| #define SDDosch_(name,value) SDD(name,value,&validateOverrideSchema) |
| #define DDpsch_(name,value) DD(name,value,&validatePublicSchema) |
| #define SDDpsch_(name,value) SDD(name,value,&validatePublicSchema) |
| #define DDrlis_(name,value) DD(name,value,&validateRoleNameList) |
| #define XDDrlis_(name,value) XDD(name,value,&validateRoleNameList) |
| #define DDrver_(name,value) DD(name,value,&validateReplIoVersion) |
| #define XDDMVA__(name,value) XDD(name,value,&validateMVAge) |
| #define DDusht_(name,value) DD(name,value,&validate_uint16) |
| |
| |
| const DefaultValidator validateUnknown; |
| const DefaultValidator validateAnsiName(CASE_SENSITIVE_ANSI); // e.g. 'c.s.tbl' |
| |
| ValidateCollationList validateCollList(TRUE/*mp-format*/); // list collations |
| const ValidateInt validateInt; // allows neg, zero, pos ints |
| const ValidateIntNeg1 validateIntNeg1;// allows -1 to +infinity ints |
| const ValidateIntNeg1 validateIntNeg2;// allows -1 to +infinity ints |
| const ValidatePercent validatePct; // allows zero to 100 (integral %age) |
| const ValidateNumericRange validatePct1_t50(VALID_UINT, 1, (float)50);// allows 1 to 50 (integral %age) |
| const Validate_0_10485760 validate0_10485760; // allows zero to 10Meg (integer) |
| const Validate_0_255 validate0_255; // allows zero to 255 (integer) |
| const Validate_0_200000 validate0_200000; // allows zero to 200000 (integer) |
| const Validate_1_200000 validate1_200000; // allows 1 to 200000 (integer) |
| const Validate_30_32000 validate30_32000; // allows 30 to 32000 |
| const Validate_30_246 validate30_246; // allows 30 to 246 |
| const Validate_50_4194303 validate50_4194303; // allows 50 to 4194303 (integer) |
| const Validate_1_24 validate1_24; // allows 1 to 24 (integer) |
| const ValidateUInt validateUI; // allows zero and pos |
| const ValidateUInt1 validateUI1; // allows pos only (>= 1) |
| const ValidateUInt2 validateUI2(2); // allows pos multiples of 2 only |
| const ValidateUInt2 validateUI8(8); // pos multiples of 8 only |
| const ValidateUInt2 validateUI512(512); // pos multiples of 512 only |
| const ValidateUIntFrom0To5 validateUIntFrom0To5; // integer from 0 to 5 |
| const ValidateUIntFrom1500To4000 validateUIntFrom1500To4000; // integer from 1 to 6 |
| const ValidateUIntFrom1To6 validateUIntFrom1To6; // integer from 1 to 6 |
| const ValidateUIntFrom1To8 validateUIntFrom1To8; // integer from 1 to 8 |
| const ValidateUIntFrom1To10 validateUIntFrom1To10; // integer from 1 to 10 |
| const ValidateUIntFrom2To10 validateUIntFrom2To10; // integer from 2 to 10 |
| const ValidateIPCBuf validateIPCBuf; // for IPC message buffers (DP2 msgs) |
| const ValidateFlt validateFlt; // allows neg, zero, pos (all nums) |
| const ValidateFltMin0 validateFlt0; // allows zero and pos |
| const ValidateFltMinEpsilon validateFltE; // allows pos only (>= epsilon > 0) |
| const ValidateFltMin1 validateFlt1; // allows pos only (>= 1) |
| const ValidateSelectivity ValidateSelectivity; // allows 0 to 1 (float) |
| const ValidateFlt_0_1 validateFlt_0_1; // allows 0 to 1 (float) |
| const ValidateKeyword validateKwd; // allows relevant keywords only |
| const Validate_1_4096 validate1_4096; // allows 1 to 4096 (integer) which is max character size supported. |
| const Validate_0_18 validate0_18; // allows 0 to 18 (integer) because 18 is max precision supported. |
| const Validate_1_1024 validate1_1024; // allows 1 to 1024 (integer). |
| const Validate_0_64 validate0_64; // allows 0 to 64 (integer) |
| const Validate_16_64 validate16_64; // allows 16 to 64 (integer) |
| const Validate_18_128 validate18_128; // allows 18 to 128 (integer). |
| const Validate_1_128 validate1_128; // allows 1 to 128 (integer). |
| // allows ':' separated list of three part ANSI names |
| const ValidateAnsiList validateAnsiList; |
| // allows ',' separated list of role names |
| const ValidateRoleNameList validateRoleNameList; |
| const ValidatePOSTableSizes validatePOSTableSizes; |
| const ValidateTraceStr validateTraceStr; |
| const ValidateOverrideSchema validateOverrideSchema; // check OverrideSchema format |
| const ValidatePublicSchema validatePublicSchema; |
| // This high value should be same as default value of REPLICATE_IO_VERSION |
| const ValidateReplIoVersion validateReplIoVersion(11,17); |
| const ValidateMVAge validateMVAge; |
| const Validate_uint16 validate_uint16; |
| |
| // See the NOTEs above for how to maintain this list! |
| THREAD_P DefaultDefault defaultDefaults[] = { |
| DDflt0_(ACCEPTABLE_INPUTESTLOGPROP_ERROR, "0.5"), |
| |
| SDDint__(AFFINITY_VALUE, "-2"), |
| |
| // controls the ESP allocation per core. |
| DDkwd__(AGGRESSIVE_ESP_ALLOCATION_PER_CORE, "OFF"), |
| |
| |
| // this should be used for testing only. DML should not be executed on |
| // non-audited tables |
| DDkwd__(ALLOW_DML_ON_NONAUDITED_TABLE, "OFF"), |
| |
| // DP2_EXECUTOR_POSITION_SAMPLE method in DP2. |
| // Valid values are ON, OFF and SYSTEM |
| // ON => choose DP2_ROW_SAMPLING over row sampling in EID, if sampling % is less than 50. |
| // OFF => choose EID row sampling over DP2 row sampling regardless of sampling % |
| // SYSTEM => update stats will choose DP row sampling if sampling % is less than 5. |
| |
| SDDkwd__(ALLOW_DP2_ROW_SAMPLING, "SYSTEM"), |
| |
| DDkwd__(ALLOW_FIRSTN_IN_SUBQUERIES, "TRUE"), |
| |
| // ON/OFF flag to invoke ghost objects from non-licensed process (non-super.super user) who can not use parserflags |
| DDkwd__(ALLOW_GHOST_OBJECTS, "OFF"), |
| |
| // This default, if set to ON, will allow Translate nodes (to/from UCS2) |
| // to be automatically inserted by the Binder if some children of an |
| // ItemExpr are declared as UCS2 and some are declared as ISO88591. |
| DDkwd__(ALLOW_IMPLICIT_CHAR_CASTING, "ON"), |
| |
| // this default, if set to ON, will allow certain incompatible |
| // assignment, like string to int. The assignment will be done by |
| // implicitely CASTing one operand to another as long as CAST between |
| // the two is supported. See binder for details. |
| DDkwd__(ALLOW_INCOMPATIBLE_ASSIGNMENT, "ON"), |
| |
| // this default, if set to ON, will allow certain incompatible |
| // comparisons, like string to int. The comparison will be done by |
| // implicitely CASTing one operand to another as long as CAST between |
| // the two is supported. See binder for details. |
| DDkwd__(ALLOW_INCOMPATIBLE_COMPARISON, "ON"), |
| |
| // this default, if set to ON, will allow certain incompatible |
| // comparisons. This includes incompatible comparisons, assignments, |
| // conversions, UNION, arith, string and case stmts. |
| // See binder(BindItemExpr.cpp, SynthType.cpp) for details. |
| DDkwd__(ALLOW_INCOMPATIBLE_OPERATIONS, "ON"), |
| |
| // if set to 2, the replicateNonKeyVEGPred() mdamkey method |
| // will try to use inputs to filter out VEG elements that are not |
| // local to the associated table to minimize predicate replication. |
| // It is defaulted to 0 (off), as there is some concern that this algoritm |
| // might produce to few replications, which could lead to incorrect results. |
| // Setting the Value to 1 will try a simpler optimization |
| DDui___(ALLOW_INPUT_PRED_REPLICATION_REDUCTION,"0"), |
| |
| // if set to ON, then isolation level (read committed, etc) could be |
| // specified in a regular CREATE VIEW (not a create MV) statement. |
| DDkwd__(ALLOW_ISOLATION_LEVEL_IN_CREATE_VIEW, "ON"), |
| |
| // if set to ON, then we allow subqueries of degree > 1 in the |
| // select list. |
| DDkwd__(ALLOW_MULTIDEGREE_SUBQ_IN_SELECTLIST, "SYSTEM"), |
| |
| |
| // by default, a primary key or unique constraint must be non-nullable. |
| // This default, if set, allows them to be nullable. |
| // The default value is OFF. |
| DDkwd__(ALLOW_NULLABLE_UNIQUE_KEY_CONSTRAINT, "OFF"), |
| |
| // if set to ON, then ORDER BY could be |
| // specified in a regular CREATE VIEW (not a create MV) statement. |
| DDkwd__(ALLOW_ORDER_BY_IN_CREATE_VIEW, "ON"), |
| |
| DDkwd__(ALLOW_ORDER_BY_IN_SUBQUERIES, "ON"), |
| |
| // rand() function in sql is disabled unless this CQD is turned on |
| DDkwd__(ALLOW_RAND_FUNCTION, "ON"), |
| |
| DDkwd__(ALLOW_RANGE_PARTITIONING, "TRUE"), |
| |
| DDkwd__(ALLOW_RENAME_OF_MVF_OR_SUBQ, "OFF"), |
| |
| DDkwd__(ALLOW_RISKY_UPDATE_WITH_NO_ROLLBACK, "OFF"), |
| |
| DDkwd__(ALLOW_SUBQ_IN_SET, "SYSTEM"), |
| |
| DDkwd__(ALLOW_UNEXTERNALIZED_MAINTAIN_OPTIONS, "OFF"), |
| |
| // Allow users to grant privileges to role using the with grant option |
| DDkwd__(ALLOW_WGO_FOR_ROLES, "ON"), |
| |
| DDSkwd__(ALTPRI_ESP, ""), |
| DDSkwd__(ALTPRI_MASTER, ""), |
| |
| DDS_____(AQR_ENTRIES, ""), |
| DDkwd__(AQR_WNR, "ON"), |
| DDkwd__(AQR_WNR_DELETE_NO_ROWCOUNT, "OFF"), |
| DDkwd__(AQR_WNR_EXPLAIN_INSERT, "OFF"), |
| DDkwd__(AQR_WNR_INSERT_CLEANUP, "OFF"), |
| DDkwd__(AQR_WNR_LOCK_INSERT_TARGET, "OFF"), |
| |
| DDkwd__(ARKCMP_FAKE_HW, "OFF"), |
| DDkwd__(ASG_FEATURE, "ON"), |
| // Set ASM cache |
| DDkwd__(ASM_ALLOWED, "ON"), |
| // Precompute statistics in ASM |
| DDkwd__(ASM_PRECOMPUTE, "OFF"), |
| DDkwd__(ASYMMETRIC_JOIN_TRANSFORMATION, "MAXIMUM"), |
| DDkwd__(ATTEMPT_ASYNCHRONOUS_ACCESS, "ON"), |
| DDkwd__(ATTEMPT_ESP_PARALLELISM, "ON"), |
| DDkwd__(ATTEMPT_REVERSE_SYNCHRONOUS_ORDER, "ON"), |
| |
| DDkwd__(AUTOMATIC_RECOMPILATION, "OFF"), |
| |
| DDkwd__(AUTO_QUERY_RETRY, "SYSTEM"), |
| XDDkwd__(AUTO_QUERY_RETRY_WARNINGS, "OFF"), |
| |
| DDkwd__(BASE_NUM_PAS_ON_ACTIVE_PARTS, "OFF"), |
| |
| // see comments in DefaultConstants.h |
| DDkwd__(BIGNUM_IO, "SYSTEM"), |
| |
| DDint__(BLOCK_ENCRYPTION_MODE, "0"), |
| XDDkwd__(BLOCK_TO_PREVENT_HALLOWEEN, "ON"), |
| |
| DDflte_(BMO_CITIZENSHIP_FACTOR, "1."), |
| |
| DDflte_(BMO_MEMORY_EQUAL_QUOTA_SHARE_RATIO, "0.5"), |
| DDui___(BMO_MEMORY_ESTIMATE_OUTLIER_FACTOR, "10"), |
| DDflte_(BMO_MEMORY_ESTIMATE_RATIO_CAP, "0.7"), |
| DDui___(BMO_MEMORY_LIMIT_LOWER_BOUND_HASHGROUPBY , "25"), |
| DDui___(BMO_MEMORY_LIMIT_LOWER_BOUND_HASHJOIN, "25"), |
| DDui___(BMO_MEMORY_LIMIT_LOWER_BOUND_SORT , "200"), |
| XDDui___(BMO_MEMORY_LIMIT_PER_NODE_IN_MB, "10240"), |
| DDui___(BMO_MEMORY_LIMIT_UPPER_BOUND, "1200"), |
| |
| DDui1__(BMO_MEMORY_SIZE, "204800"), |
| // percentage of physical main memory availabe for BMO. |
| // This value is only used by HJ and HGB to come up with |
| // an initial estimate for the number of clusters to allocate. |
| // It does NOT by any means determine the amount of memory |
| // used by a BMO. The memory usage depends on the amount of |
| // memory available during execution and the amount of input |
| // data. |
| DDflte_(BMO_MEMORY_USAGE_PERCENT, "5."), |
| |
| // When on, then try to bulk move nullable and variable length column values. |
| DDkwd__(BULK_MOVE_NULL_VARCHAR, "ON"), |
| |
| //Temporary fix to bypass volatile schema name checking for non-table objects - ALM Case#4764 |
| DDkwd__(BYPASS_CHECK_FOR_VOLATILE_SCHEMA_NAME, "OFF"), |
| |
| DDkwd__(CACHE_HISTOGRAMS, "ON"), |
| DDkwd__(CACHE_HISTOGRAMS_CHECK_FOR_LEAKS, "OFF"), |
| DD0_200000(CACHE_HISTOGRAMS_IN_KB, "32768"), |
| DDkwd__(CACHE_HISTOGRAMS_MONITOR_HIST_DETAIL, "OFF"), |
| DDkwd__(CACHE_HISTOGRAMS_MONITOR_MEM_DETAIL, "OFF"), |
| DD_____(CACHE_HISTOGRAMS_MONITOR_OUTPUT_FILE, ""), |
| |
| DD_____(CACHE_HISTOGRAMS_TRACE_OUTPUT_FILE, ""), |
| DDkwd__(CALL_EMBEDDED_ARKCMP, "OFF"), |
| DDui___(CANCEL_MINIMUM_BLOCKING_INTERVAL, "60"), |
| |
| DDkwd__(CASCADED_GROUPBY_TRANSFORMATION, "ON"), |
| |
| XDDansi_(CATALOG, TRAFODION_SYSCAT_LIT), |
| |
| DDkwd__(CAT_ALLOW_NEW_FEATUREX, "OFF"), |
| |
| |
| |
| DDkwd__(CAT_DEFAULT_COMPRESSION, "NONE"), |
| // Metadata table distribution schemes |
| // OFF - Place all metadata tables on one single disk |
| // LOCAL_NODE - Distribute metadata tables across disks on local segment |
| // where first schema in the catalog is created |
| // ON - Distribute metadata tables across disks in local segment |
| // and visible remote segments |
| SDDkwd__(CAT_DISTRIBUTE_METADATA, "ON"), |
| //SDDkwd__(CAT_DISTRIBUTE_METADATA, "ON"), |
| |
| // This disables Query Invalidation processing in catman when set to "OFF" |
| SDDkwd__(CAT_ENABLE_QUERY_INVALIDATION, "ON"), |
| |
| |
| |
| |
| // This enables the DB Limits functionality. If set to OFF, then blocksize |
| // is restricted to 4096 and clustering key size is limited to 255 bytes. |
| // DB Limits checking is turned off on NT since NT's DP2 does not support |
| // large blocks or keys. |
| DDkwd__(CAT_LARGE_BLOCKS_LARGE_KEYS, "ON"), |
| |
| // Controls how pathnames for routines/procedures/SPJs are interpreted |
| DDkwd__(CAT_LIBRARY_PATH_RELATIVE, "OFF"), |
| |
| |
| |
| |
| |
| |
| // CMP_ERR_LOG_FILE indicates where to save a log for certain errors. |
| DD_____(CMP_ERR_LOG_FILE, "tdm_arkcmp_errors.log"), |
| |
| |
| DDint__(COMPILER_IDLE_TIMEOUT, "1800"), // To match with set session defaults value |
| |
| // tracking compilers specific defaults |
| DDint__(COMPILER_TRACKING_INTERVAL, "0"), |
| DD_____(COMPILER_TRACKING_LOGFILE, "NONE"), |
| DDkwd__(COMPILER_TRACKING_LOGTABLE, "OFF"), |
| |
| DDkwd__(COMPILE_TIME_MONITOR, "OFF"), |
| DD_____(COMPILE_TIME_MONITOR_LOG_ALLTIME_ONLY, "OFF"), |
| DD_____(COMPILE_TIME_MONITOR_OUTPUT_FILE, "NONE"), |
| |
| |
| // Switch between new aligned internal format and exploded format |
| DDkwd__(COMPRESSED_INTERNAL_FORMAT, "SYSTEM"), |
| DDkwd__(COMPRESSED_INTERNAL_FORMAT_BMO, "SYSTEM"), |
| DDkwd__(COMPRESSED_INTERNAL_FORMAT_BMO_AFFINITY, "ON"), |
| DDkwd__(COMPRESSED_INTERNAL_FORMAT_BULK_MOVE, "ON"), |
| DDflt0_(COMPRESSED_INTERNAL_FORMAT_DEFRAG_RATIO, "0.30"), |
| DDkwd__(COMPRESSED_INTERNAL_FORMAT_EXPLAIN, "OFF"), |
| DDui1__(COMPRESSED_INTERNAL_FORMAT_MIN_ROW_SIZE, "32"), |
| DDkwd__(COMPRESSED_INTERNAL_FORMAT_ROOT_DOES_CONVERSION, "OFF"), |
| DDflt0_(COMPRESSED_INTERNAL_FORMAT_ROW_SIZE_ADJ, "0.90"), |
| |
| |
| XDDkwd__(COMPRESSION_TYPE, "NONE"), |
| |
| |
| // These are switches and variables to use for compiler debugging |
| DDkwd__(COMP_BOOL_1, "OFF"), |
| DDkwd__(COMP_BOOL_100, "OFF"), |
| DDkwd__(COMP_BOOL_101, "OFF"), |
| DDkwd__(COMP_BOOL_102, "OFF"), |
| DDkwd__(COMP_BOOL_103, "OFF"), |
| DDkwd__(COMP_BOOL_104, "OFF"), |
| DDkwd__(COMP_BOOL_106, "OFF"), |
| DDkwd__(COMP_BOOL_107, "ON"), // Being used for testing default predicate synthesis in cardinality estimation |
| DDkwd__(COMP_BOOL_108, "ON"), // Being used for testing default predicate synthesis in cardinality estimation |
| |
| DDkwd__(COMP_BOOL_11, "OFF"), |
| DDkwd__(COMP_BOOL_110, "OFF"), |
| DDkwd__(COMP_BOOL_111, "OFF"), |
| DDkwd__(COMP_BOOL_112, "OFF"), |
| DDkwd__(COMP_BOOL_113, "OFF"), |
| DDkwd__(COMP_BOOL_115, "OFF"), |
| DDkwd__(COMP_BOOL_116, "OFF"), |
| DDkwd__(COMP_BOOL_117, "OFF"), |
| DDkwd__(COMP_BOOL_118, "OFF"), // soln 10-100508-0135 - allow undo of fix. |
| DDkwd__(COMP_BOOL_119, "OFF"), |
| |
| DDkwd__(COMP_BOOL_12, "OFF"), |
| DDkwd__(COMP_BOOL_120, "OFF"), |
| DDkwd__(COMP_BOOL_122, "ON"), // Solution 10-081203-7708 fix |
| DDkwd__(COMP_BOOL_123, "OFF"), |
| DDkwd__(COMP_BOOL_124, "OFF"), |
| DDkwd__(COMP_BOOL_125, "ON"), |
| DDkwd__(COMP_BOOL_126, "OFF"), |
| DDkwd__(COMP_BOOL_127, "ON"), |
| DDkwd__(COMP_BOOL_128, "ON"), |
| DDkwd__(COMP_BOOL_129, "ON"), |
| |
| DDkwd__(COMP_BOOL_13, "OFF"), |
| DDkwd__(COMP_BOOL_130, "ON"), |
| DDkwd__(COMP_BOOL_131, "OFF"), |
| DDkwd__(COMP_BOOL_132, "OFF"), |
| DDkwd__(COMP_BOOL_133, "OFF"), |
| DDkwd__(COMP_BOOL_134, "ON"), |
| DDkwd__(COMP_BOOL_135, "ON"), |
| DDkwd__(COMP_BOOL_136, "OFF"), |
| DDkwd__(COMP_BOOL_137, "OFF"), // ON enables logging of RewriteJoinPred |
| DDkwd__(COMP_BOOL_138, "OFF"), // ON disables tryToRewriteJoinPredicate |
| DDkwd__(COMP_BOOL_139, "OFF"), |
| |
| DDkwd__(COMP_BOOL_14, "ON"), |
| DDkwd__(COMP_BOOL_140, "ON"), |
| DDkwd__(COMP_BOOL_141, "ON"), // Used for testing MC UEC adjustment for uplifting join cardinality |
| DDkwd__(COMP_BOOL_144, "OFF"), // only Key columns usage as a part of materialization of disjuncts is controlled by the CQD |
| DDkwd__(COMP_BOOL_145, "ON"), // Used for selectivity adjustment for MC Joins |
| DDkwd__(COMP_BOOL_147, "OFF"), |
| DDkwd__(COMP_BOOL_148, "ON"), // Used for GroupBy Cardinality Enhancement for complex expressions |
| DDkwd__(COMP_BOOL_149, "ON"), // Used for testing multi-col uniqueness cardinality enhancement |
| |
| DDkwd__(COMP_BOOL_150, "OFF"), |
| DDkwd__(COMP_BOOL_151, "OFF"), |
| DDkwd__(COMP_BOOL_152, "OFF"), |
| DDkwd__(COMP_BOOL_153, "ON"), // skew buster: ON == use round robin, else Co-located. |
| DDkwd__(COMP_BOOL_154, "OFF"), |
| DDkwd__(COMP_BOOL_155, "OFF"), |
| DDkwd__(COMP_BOOL_156, "ON"), // Used by RTS to turn on RTS Stats collection for ROOT operators |
| DDkwd__(COMP_BOOL_158, "ON"), // ON --> allows equijoins on VARCHAR/VARCHAR and CHAR/VARCHAR to be rewritten as VEGPreds |
| DDkwd__(COMP_BOOL_159, "OFF"), |
| |
| DDkwd__(COMP_BOOL_160, "OFF"), |
| DDkwd__(COMP_BOOL_161, "OFF"), |
| DDkwd__(COMP_BOOL_162, "ON"), // transform NOT EXISTS subquery using anti_semijoin instead of Join-Agg |
| DDkwd__(COMP_BOOL_163, "OFF"), |
| DDkwd__(COMP_BOOL_164, "OFF"), |
| DDkwd__(COMP_BOOL_165, "ON"), // set to 'ON' in M5 for SQ |
| DDkwd__(COMP_BOOL_166, "OFF"), // ON --> turn off fix for 10-100310-8659. |
| DDkwd__(COMP_BOOL_167, "OFF"), |
| DDkwd__(COMP_BOOL_168, "ON"), |
| DDkwd__(COMP_BOOL_169, "OFF"), |
| |
| DDkwd__(COMP_BOOL_171, "OFF"), |
| DDkwd__(COMP_BOOL_172, "OFF"), |
| DDkwd__(COMP_BOOL_173, "OFF"), // fix: make odbc params nullable |
| DDkwd__(COMP_BOOL_174, "ON"), // internal usage: merge stmt |
| DDkwd__(COMP_BOOL_175, "OFF"), // internal usage: merge stmt |
| DDkwd__(COMP_BOOL_176, "OFF"), |
| DDkwd__(COMP_BOOL_177, "OFF"), |
| DDkwd__(COMP_BOOL_178, "OFF"), |
| |
| DDkwd__(COMP_BOOL_18, "OFF"), |
| DDkwd__(COMP_BOOL_183, "OFF"), |
| DDkwd__(COMP_BOOL_184, "ON"), // ON => use min probe size for mdam. Using min probe size of 1 or 2 currently has a bug so this is not the default. OFF => use default probe size of 100 |
| DDkwd__(COMP_BOOL_185, "ON"), //Fix, allows extract(year from current_date) to be treated as a userinput |
| DDkwd__(COMP_BOOL_186, "OFF"), |
| DDkwd__(COMP_BOOL_187, "OFF"), // reserved for internal usage |
| DDkwd__(COMP_BOOL_188, "OFF"), |
| DDkwd__(COMP_BOOL_189, "OFF"), // reserved for internal usage |
| |
| DDkwd__(COMP_BOOL_19, "OFF"), |
| DDkwd__(COMP_BOOL_190, "OFF"), |
| DDkwd__(COMP_BOOL_191, "OFF"), // Temp for UDF metadata switch |
| DDkwd__(COMP_BOOL_192, "OFF"), |
| DDkwd__(COMP_BOOL_193, "OFF"), |
| DDkwd__(COMP_BOOL_196, "OFF"), |
| DDkwd__(COMP_BOOL_197, "OFF"), |
| DDkwd__(COMP_BOOL_198, "OFF"), |
| DDkwd__(COMP_BOOL_199, "ON"), |
| |
| DDkwd__(COMP_BOOL_2, "OFF"), |
| DDkwd__(COMP_BOOL_20, "OFF"), // ON -> disable ability of stmt to be canceled. |
| DDkwd__(COMP_BOOL_200, "OFF"), |
| DDkwd__(COMP_BOOL_201, "OFF"), |
| DDkwd__(COMP_BOOL_202, "ON"),// For SQ: |
| // ON: excluding fixup cost |
| // for EXCHANGE for |
| // anti-surf logic; |
| // OFF: do include. |
| // Change to ON in M5 |
| DDkwd__(COMP_BOOL_203, "OFF"), |
| DDkwd__(COMP_BOOL_206, "OFF"), // Internal Usage |
| DDkwd__(COMP_BOOL_207, "OFF"), // Internal Usage |
| DDkwd__(COMP_BOOL_21, "OFF"), |
| DDkwd__(COMP_BOOL_210, "ON"), |
| DDkwd__(COMP_BOOL_211, "ON"), // controls removing constants from group expression |
| DDkwd__(COMP_BOOL_217, "OFF"), |
| DDkwd__(COMP_BOOL_219, "OFF"), // for InMem obj defn |
| DDkwd__(COMP_BOOL_22, "ON"), |
| DDkwd__(COMP_BOOL_221, "OFF"), // unnests a subquery even when there is no explicit correlation |
| // bulk replicate features |
| // bulk replicate features |
| DDkwd__(COMP_BOOL_226, "OFF"), // ON enables UNLOAD feature |
| // for disk label stats. |
| DDkwd__(COMP_BOOL_23, "ON"), |
| DDkwd__(COMP_BOOL_24, "OFF"), // AS enhancement to adjust maxDoP |
| DDkwd__(COMP_BOOL_25, "OFF"), // Being used in Cardinality Estimation |
| DDkwd__(COMP_BOOL_27, "OFF"), |
| DDkwd__(COMP_BOOL_28, "OFF"), |
| DDkwd__(COMP_BOOL_29, "OFF"), |
| |
| DDkwd__(COMP_BOOL_3, "OFF"), |
| DDkwd__(COMP_BOOL_30, "ON"), |
| DDkwd__(COMP_BOOL_31, "OFF"), |
| DDkwd__(COMP_BOOL_32, "OFF"), |
| DDkwd__(COMP_BOOL_33, "OFF"), |
| DDkwd__(COMP_BOOL_34, "OFF"), |
| DDkwd__(COMP_BOOL_35, "OFF"), |
| DDkwd__(COMP_BOOL_36, "OFF"), |
| DDkwd__(COMP_BOOL_37, "OFF"), |
| DDkwd__(COMP_BOOL_38, "OFF"), |
| DDkwd__(COMP_BOOL_39, "OFF"), |
| |
| DDkwd__(COMP_BOOL_4, "OFF"), |
| DDkwd__(COMP_BOOL_40, "ON"), |
| DDkwd__(COMP_BOOL_41, "OFF"), |
| DDkwd__(COMP_BOOL_42, "ON"), |
| DDkwd__(COMP_BOOL_44, "OFF"), |
| DDkwd__(COMP_BOOL_45, "ON"), |
| DDkwd__(COMP_BOOL_46, "OFF"), |
| DDkwd__(COMP_BOOL_47, "ON"), |
| DDkwd__(COMP_BOOL_48, "ON"), // Turned "Off" because of Regression failure |
| DDkwd__(COMP_BOOL_49, "OFF"), |
| |
| DDkwd__(COMP_BOOL_5, "ON"), |
| DDkwd__(COMP_BOOL_51, "OFF"), |
| DDkwd__(COMP_BOOL_52, "OFF"), |
| DDkwd__(COMP_BOOL_53, "ON"), //Turned "ON" for OCB Cost |
| DDkwd__(COMP_BOOL_54, "OFF"), |
| DDkwd__(COMP_BOOL_55, "OFF"), |
| DDkwd__(COMP_BOOL_56, "OFF"), |
| DDkwd__(COMP_BOOL_57, "ON"), |
| DDkwd__(COMP_BOOL_59, "OFF"), |
| |
| // comp_bool_60 is used in costing of an exchange operator. This is |
| // used in deciding to use Nodemap decoupling and other exchange |
| // costing logic. |
| DDkwd__(COMP_BOOL_60, "ON"), |
| DDkwd__(COMP_BOOL_61, "OFF"), |
| DDkwd__(COMP_BOOL_62, "OFF"), |
| DDkwd__(COMP_BOOL_63, "OFF"), |
| DDkwd__(COMP_BOOL_64, "OFF"), |
| DDkwd__(COMP_BOOL_65, "OFF"), |
| DDkwd__(COMP_BOOL_66, "OFF"), |
| DDkwd__(COMP_BOOL_67, "ON"), // Being used in Cardinality Estimation |
| DDkwd__(COMP_BOOL_68, "ON"), |
| DDkwd__(COMP_BOOL_69, "OFF"), |
| |
| DDkwd__(COMP_BOOL_7, "OFF"), |
| DDkwd__(COMP_BOOL_70, "ON"), |
| DDkwd__(COMP_BOOL_71, "OFF"), |
| DDkwd__(COMP_BOOL_72, "OFF"), |
| DDkwd__(COMP_BOOL_73, "OFF"), |
| DDkwd__(COMP_BOOL_74, "ON"), |
| DDkwd__(COMP_BOOL_75, "ON"), |
| DDkwd__(COMP_BOOL_76, "ON"), |
| DDkwd__(COMP_BOOL_77, "OFF"), |
| DDkwd__(COMP_BOOL_78, "OFF"), |
| DDkwd__(COMP_BOOL_79, "ON"), |
| |
| DDkwd__(COMP_BOOL_8, "OFF"), |
| DDkwd__(COMP_BOOL_80, "OFF"), |
| DDkwd__(COMP_BOOL_81, "OFF"), |
| DDkwd__(COMP_BOOL_82, "OFF"), |
| DDkwd__(COMP_BOOL_83, "ON"), |
| DDkwd__(COMP_BOOL_84, "OFF"), |
| DDkwd__(COMP_BOOL_85, "OFF"), |
| DDkwd__(COMP_BOOL_86, "OFF"), |
| DDkwd__(COMP_BOOL_87, "OFF"), |
| DDkwd__(COMP_BOOL_88, "OFF"), |
| |
| DDkwd__(COMP_BOOL_9, "OFF"), |
| DDkwd__(COMP_BOOL_90, "ON"), |
| DDkwd__(COMP_BOOL_91, "OFF"), |
| DDkwd__(COMP_BOOL_92, "OFF"), // used by generator. |
| DDkwd__(COMP_BOOL_93, "ON"), // turn on pushdown for IUDs involving MVs. Default is off |
| DDkwd__(COMP_BOOL_94, "OFF"), |
| DDkwd__(COMP_BOOL_95, "OFF"), |
| DDkwd__(COMP_BOOL_96, "OFF"), |
| DDkwd__(COMP_BOOL_97, "OFF"), |
| DDkwd__(COMP_BOOL_98, "ON"), |
| DDkwd__(COMP_BOOL_99, "OFF"), |
| |
| DDflt0_(COMP_FLOAT_0, "0.002"), |
| DDflt0_(COMP_FLOAT_1, "0.00002"), |
| DDflt0_(COMP_FLOAT_2, "0"), |
| DDflt0_(COMP_FLOAT_3, "0.01"), |
| DDflt0_(COMP_FLOAT_4, "1.1"), |
| DDflt__(COMP_FLOAT_5, "0.01"), // For Split Top cost adjustments : 0.25 |
| DDflt__(COMP_FLOAT_6, "0.67"), // used to set the fudge factor which |
| // is used to estimate cardinality of an |
| // aggregate function in an equi-join expression |
| DDflt__(COMP_FLOAT_7, "1.5"), |
| DDflt__(COMP_FLOAT_8, "0.8"), |
| // min expected #groups when HGB under right side of NLJ |
| DDflt__(COMP_FLOAT_9, "1002.0"), |
| |
| DDint__(COMP_INT_0, "5000"), |
| DDint__(COMP_INT_10, "3"), |
| DDint__(COMP_INT_11, "-1"), |
| DDint__(COMP_INT_14, "0"), |
| DDint__(COMP_INT_15, "7"), |
| DDint__(COMP_INT_16, "1000000"), |
| DDint__(COMP_INT_17, "1000000"), |
| DDint__(COMP_INT_18, "1"), |
| DDint__(COMP_INT_19, "2"), |
| DDint__(COMP_INT_2, "1"), |
| DDint__(COMP_INT_20, "4"), |
| DDint__(COMP_INT_21, "0"), |
| DDint__(COMP_INT_22, "0"), // used to control old parser based INLIST transformation |
| // 0 ==> OFF, positive value implies ON and has the effect of implicitly shutting down much of OR_PRED transformations |
| // this cqd has been retained as a fallback in case OR_PRED has bugs. |
| DDint__(COMP_INT_23, "22"), |
| DDint__(COMP_INT_24, "1000000000"), |
| DDint__(COMP_INT_26, "1"), |
| DDint__(COMP_INT_3, "5"), |
| DDint__(COMP_INT_30, "5"), |
| DDint__(COMP_INT_31, "5"), |
| DDint__(COMP_INT_32, "100"), |
| DDint__(COMP_INT_34, "10000"), // lower bound: 10000 |
| DDint__(COMP_INT_35, "500000"), // upper bound: 200000 |
| DDint__(COMP_INT_36, "128"), // Bounds for producer for OCB |
| DDint__(COMP_INT_38, "0"), // test master's abend |
| DDint__(COMP_INT_39, "0"), // test esp's abend |
| DDint__(COMP_INT_4, "400"), |
| DDint__(COMP_INT_40, "10"), // this defines the percentage of selectivity after applying equality predicates on single column histograms |
| // beyond which the optimizer should use MC stats |
| DDint__(COMP_INT_43, "3"), // this is only for testing purposes. Once HIST_USE_SAMPLE_FOR_CARDINALITY_ESTIMATION is set to ON by default, the value of this CQD should be adjusted |
| DDint__(COMP_INT_44, "1000000"), // frequency threshold above which |
| // a boundary value will be inclded |
| // in the frequentValueList (stats) |
| DDint__(COMP_INT_45, "300"), |
| DDint__(COMP_INT_46, "10"), |
| DDint__(COMP_INT_47, "0"), |
| DDint__(COMP_INT_48, "32"), // # trips thru scheduler task list before eval of CPU time limit. |
| |
| |
| DDint__(COMP_INT_5, "0"), |
| DDint__(COMP_INT_50, "0"), |
| DDint__(COMP_INT_51, "0"), |
| DDint__(COMP_INT_54, "0"), |
| // comp_int_60 is used in costing of an exchnage operator. It is |
| // used to indicate buffer size of a DP2 exchange when sending |
| // messages down. |
| DDint__(COMP_INT_60, "4"), |
| DDint__(COMP_INT_61, "0"), |
| // Exchange operator default value |
| DDint__(COMP_INT_62, "10000"), |
| DDint__(COMP_INT_63, "10000"), // SG Insert issue |
| DDint__(COMP_INT_66, "0"), // to change #buffers per flushed cluster |
| DDint__(COMP_INT_67, "8"), // to test #outer-buffers per a batch |
| DDint__(COMP_INT_7, "10000000"), |
| DDint__(COMP_INT_70, "1000000"), |
| DDint__(COMP_INT_71, "0"), |
| // if set to 1, allows keyPredicate to be inserted without passing key col. |
| DDint__(COMP_INT_73, "1"), |
| // if set to 1, disables cursor_delete plan if there are no alternate indexes. |
| DDint__(COMP_INT_74, "0"), |
| DDint__(COMP_INT_77, "0"), |
| DDint__(COMP_INT_79, "0"), |
| // this is used temporaraly as value for parallel threshold |
| // in case ATTEMPT_ESP_PARALLELISM is set to MAXIMUM |
| DDint__(COMP_INT_8, "20"), |
| DDint__(COMP_INT_80, "3"), |
| |
| |
| DDint__(COMP_INT_89, "2"), |
| DDint__(COMP_INT_9, "0"), |
| DDint__(COMP_INT_90, "0"), |
| DDint__(COMP_INT_95, "0"), |
| DDint__(COMP_INT_98, "512"), |
| DDint__(COMP_INT_99, "10"), |
| |
| DD_____(COMP_STRING_1, "NONE"), |
| DD_____(COMP_STRING_2, ""), |
| DD_____(COMP_STRING_5, ""), |
| |
| |
| DDkwd__(CONSTANT_FOLDING, "OFF"), |
| |
| DDkwd__(COSTING_SHORTCUT_GROUPBY_FIX, "ON"), |
| DDflt0_(COST_PROBE_DENSITY_THRESHOLD, ".25"), |
| |
| DDflt0_(CPUCOST_COMPARE_COMPLEX_DATA_TYPE_OVERHEAD, "10."), |
| DDflt0_(CPUCOST_COMPARE_COMPLEX_DATA_TYPE_PER_BYTE, ".1"), |
| |
| // Same as CPUCOST_PREDICATE_COMPARISON |
| // Change HH_OP_PROBE_HASH_TABLE when you change this value: |
| DDflt0_(CPUCOST_COMPARE_SIMPLE_DATA_TYPE, ".200"), |
| // no cost overhead assumed: |
| DDflt0_(CPUCOST_COPY_ROW_OVERHEAD, "0."), |
| |
| // change CPUCOST_HASH_PER_KEY when changing this value |
| DDflt0_(CPUCOST_COPY_ROW_PER_BYTE, ".0007"), |
| |
| DDflt0_(CPUCOST_COPY_SIMPLE_DATA_TYPE, ".005"), |
| // This is a per data request overhead cost paid by the cpu |
| DDflt0_(CPUCOST_DATARQST_OVHD, ".01"), |
| DDflt0_(CPUCOST_ENCODE_PER_BYTE, ".002"), |
| DDflt0_(CPUCOST_ESP_INITIALIZATION, "10"), |
| |
| // The previous observation had calculated the number of seconds to |
| // aggregate incorrectly. Now: |
| // Number of seconds to scan 100,000 rows @ 208 bytes: 4 |
| // Number of seconds to scan 100,000 rows @ 208 bytes and aggregate |
| // 15 aggregates: 17 |
| // Thus, number of seconds per aggregate = (17-4)/15 = 0.866667 |
| // CPUCOST_PER_ROW = 1.13333/(0.00005*100,000) = 0.1733 |
| // previous observation |
| // It takes 13.96 seconds to aggregate 99,999 rows using |
| // 15 expressions, thus at 0.00005 et_cpu, we have that |
| // the cost to eval an arith op is: |
| // 6.14 / (0.00005 * 99,9999 * 15) = 0.0819 |
| DDflt0_(CPUCOST_EVAL_ARITH_OP, ".0305"), |
| |
| DDflt0_(CPUCOST_EVAL_FUNC_DEFAULT, "10."), |
| DDflt0_(CPUCOST_EVAL_SIMPLE_PREDICATE, "1."), |
| DDflt0_(CPUCOST_EXCHANGE_COST_PER_BYTE, ".002"), |
| DDflt0_(CPUCOST_EXCHANGE_INTERNODE_COST_PER_BYTE, ".008"), |
| // was 0.1, but now 0.011 |
| // XDDflt0_(CPUCOST_EXCHANGE_REMOTENODE_COST_PER_BYTE, ".011"), |
| |
| // Set the additional cost of copying a byte to message buffer for |
| // remote node to be the same as for inter node, 0.01 |
| // Also change it to be internalized |
| DDflt0_(CPUCOST_EXCHANGE_REMOTENODE_COST_PER_BYTE, ".01"), |
| // Assume |
| // CPUCOST_HASH_PER_KEY = 4 * CPUCOST_HASH_PER_BYTE |
| // History: |
| // Before 01/06/98: 0.005 |
| DDflt0_(CPUCOST_HASH_PER_BYTE, ".057325"), |
| |
| // Assume |
| // CPUCOST_HASH_PER_KEY = 4 * CPUCOST_HASH_PER_BYTE |
| // From observation: |
| // For a case when all the hash table fits into memory: |
| // 01/05/98: 42,105 rows inserted per second @ 0.00005 seconds |
| // per thousand of instructions, give: |
| // seconds to insert one row = 1/42105 = 0.00002375 |
| // thd. of instructions per row inserted = 1/42105/0.00005 = 0.4750 |
| // The cost is distributed as follows: |
| // CPUCOST_HASH_PER_KEY + CPUCOST_HASH_PER_BYTE*4 + |
| // HH_OP_INSERT_ROW_TO_CHAIN + CPUCOST_COPY_ROW_PER_BYTE * 4 |
| // = 0.4750 |
| // Thus we have: |
| // 2* CPUCOST_HASH_PER_KEY + 0.01 + 0.0016*4 = 0.4750 |
| // -> CPUCOST_HASH_PER_KEY = 0.4586/2 = 0.2293 |
| // History: |
| // Before 01/06/98: 0.02 |
| // Change |
| // CPUCOST_HASH_PER_BYTE |
| // when changing this value |
| DDflt0_(CPUCOST_HASH_PER_KEY, "1.29"), |
| DDflt0_(CPUCOST_LIKE_COMPARE_OVERHEAD, "10."), |
| DDflt0_(CPUCOST_LIKE_COMPARE_PER_BYTE, ".1"), |
| DDflt0_(CPUCOST_LOCK_ROW, ".01"), |
| DDflt0_(CPUCOST_NJ_TUPLST_FF, "10."), |
| |
| // Observation (A971125_1): |
| // CPU time to scan 100,000 rows with no exe pred: 10 |
| // CPU time to scan 100,000 rows with an exe pred like |
| // nonkeycol < K: 11 |
| // CPU time spend in every row: 1/100,000 = .00001 |
| // Thus, at 0.00005 th. inst. per sec we have: 0.00001/0.00005 = |
| // 0.2 thousand inst. to evaluate every row: |
| // |
| // Predicate comparison is very expensive right now (10/08/97) |
| // (cost it that it takes like 1000 instruction for one comparison) |
| // 10/08/97: 1. |
| // Change |
| // CPUCOST_COMPARE_SIMPLE_DATA_TYPE |
| // when you change this value: |
| // History |
| // Before 04/30/98: .2 |
| DDflt0_(CPUCOST_PREDICATE_COMPARISON, ".08"), |
| |
| // Cost of copying the data from disk to the DP2 Cache: |
| DDflt0_(CPUCOST_SCAN_DSK_TO_DP2_PER_KB, "2.5"), |
| DDflt0_(CPUCOST_SCAN_DSK_TO_DP2_PER_SEEK, "0.0"), |
| |
| // The communication between DP2 and ExeInDp2 requires to encode |
| // and decode the key. |
| DDflt0_(CPUCOST_SCAN_KEY_LENGTH, "0."), |
| |
| // The communication between DP2 and ExeInDp2 is complex and |
| // ever changing. The following factor is introduced to |
| // make the costing of scan fit observed CPU time for the scan: |
| DDflt0_(CPUCOST_SCAN_OVH_PER_KB, "0.984215"), |
| DDflt0_(CPUCOST_SCAN_OVH_PER_ROW, "0.0"), |
| |
| // It takes about 1/3 of a second to open a table, thus with a |
| // 0.00005 ff for cpu elapsed time we get: |
| // 1/3/0.00005 = 7000 thousands instructions |
| // CPUCOST_SUBSET_OPEN lumps together all the overhead needed |
| // to set-up the access to each partition. Thus it is a blocking |
| // cost, nothing can overlap with it. |
| DDflt0_(CPUCOST_SUBSET_OPEN, "7000"), |
| DDflt0_(CPUCOST_SUBSET_OPEN_AFTER_FIRST, "1250"), |
| |
| |
| |
| DDkwd__(CREATE_OBJECTS_IN_METADATA_ONLY, "OFF"), |
| |
| DDkwd__(CROSS_PRODUCT_CONTROL, "ON"), |
| |
| // CQDs for Common Subexpressions (CSEs) |
| // cache queries containing temp tables for common subexpressions |
| DDkwd__(CSE_CACHE_TEMP_QUERIES, "OFF"), |
| // "cleanup obsolete volatile tables" command cleans up Hive temp tables |
| DDkwd__(CSE_CLEANUP_HIVE_TABLES, "OFF"), |
| // don't temp if all consumers have preds on n key columns |
| DDui___(CSE_COMMON_KEY_PRED_CONTROL, "1"), |
| // emit warnings that help diagnose why CSEs are not shared |
| DDkwd__(CSE_DEBUG_WARNINGS, "OFF"), |
| // create a CommonSubExpr node for CTEs defined in WITH clauses (OFF/ON) |
| DDkwd__(CSE_FOR_WITH, "OFF"), |
| // use Hive tables as temp tables |
| DDkwd__(CSE_HIVE_TEMP_TABLE, "ON"), |
| // don't temp if avg consumer has preds on more than n percent of key cols |
| DDflt0_(CSE_PCT_KEY_COL_PRED_CONTROL, "49.9"), |
| // print debugging info on stdout |
| DDkwd__(CSE_PRINT_DEBUG_INFO, "OFF"), |
| // limit temp table size (based on max. card and regular card) |
| DDflt0_(CSE_TEMP_TABLE_MAX_MAX_SIZE, "1E12"), |
| DDflt0_(CSE_TEMP_TABLE_MAX_SIZE, "1E9"), |
| // implement CommonSubExpr as a temp table (OFF/SYSTEM/ON) |
| DDkwd__(CSE_USE_TEMP, "SYSTEM"), |
| |
| SDDui___(CYCLIC_ESP_PLACEMENT, "1"), |
| |
| // if this one is "ON" it overwrites optimizer heuristics 4 & 5 as "ON" |
| // if it's "OFF" then the defaults of the two heuristics will be used |
| DDkwd__(DATA_FLOW_OPTIMIZATION, "ON"), |
| |
| |
| DDkwd__(DDL_EXPLAIN, "OFF"), |
| DDkwd__(DDL_TRANSACTIONS, "ON"), |
| |
| |
| SDDkwd__(DEFAULT_CHARSET, (char *)SQLCHARSETSTRING_ISO88591), |
| XDDui1__(DEFAULT_DEGREE_OF_PARALLELISM, "2"), |
| |
| SDDkwd__(DEFAULT_SCHEMA_ACCESS_ONLY, "OFF"), |
| SDDkwd__(DEFAULT_SCHEMA_NAMETYPE, "SYSTEM"), |
| |
| // These DEF_xxx values of "" get filled in by updateSystemParameters(). |
| #define def_DEF_CHUNK_SIZE 5000000.0 |
| #define str_DEF_CHUNK_SIZE "5000000.0" |
| // |
| DDui2__(DEF_CHUNK_SIZE, str_DEF_CHUNK_SIZE), |
| DD_____(DEF_CPU_ARCHITECTURE, ""), |
| DDui1__(DEF_DISCS_ON_CLUSTER, ""), |
| DDui1__(DEF_INSTRUCTIONS_SECOND, ""), |
| DDui___(DEF_LOCAL_CLUSTER_NUMBER, ""), |
| DDui___(DEF_LOCAL_SMP_NODE_NUMBER, ""), |
| //DEF_MAX_HISTORY_ROWS made external RV 06/21/01 CR 10-010425-2440 |
| XDDui1__(DEF_MAX_HISTORY_ROWS, "1024"), |
| DDui___(DEF_NUM_BM_CHUNKS, ""), |
| DDui1__(DEF_NUM_NODES_IN_ACTIVE_CLUSTERS, ""), |
| DDui1__(DEF_NUM_SMP_CPUS, ""), |
| DDui2__(DEF_PAGE_SIZE, ""), |
| DDui1__(DEF_PHYSICAL_MEMORY_AVAILABLE, ""), |
| DDui1__(DEF_TOTAL_MEMORY_AVAILABLE, ""), |
| DDui1__(DEF_VIRTUAL_MEMORY_AVAILABLE, ""), |
| |
| DDkwd__(DESTROY_ORDER_AFTER_REPARTITIONING, "OFF"), |
| |
| // detailed executor statistics |
| DDkwd__(DETAILED_STATISTICS, "OPERATOR"), |
| |
| DDkwd__(DIMENSIONAL_QUERY_OPTIMIZATION, "OFF"), |
| DDkwd__(DISABLE_BUFFERED_INSERTS, "OFF"), |
| DDkwd__(DISABLE_READ_ONLY, "OFF"), |
| |
| DD_____(DISPLAY_DATA_FLOW_GRAPH, "OFF"), |
| XDDkwd__(DISPLAY_DIVISION_BY_COLUMNS, "OFF"), |
| |
| |
| // temp. disable dop reduction logic |
| DDflt0_(DOP_REDUCTION_ROWCOUNT_THRESHOLD, "0.0"), |
| |
| |
| |
| |
| |
| // DP2 Cache defaults as of 06/08/98. |
| DDui1__(DP2_CACHE_1024_BLOCKS, "152"), |
| DDui1__(DP2_CACHE_16K_BLOCKS, "1024"), |
| DDui1__(DP2_CACHE_2048_BLOCKS, "150"), |
| DDui1__(DP2_CACHE_32K_BLOCKS, "512"), |
| DDui1__(DP2_CACHE_4096_BLOCKS, "4096"), |
| DDui1__(DP2_CACHE_512_BLOCKS, "152"), |
| DDui1__(DP2_CACHE_8K_BLOCKS, "2048"), |
| // Exchange Costing |
| // 6/12/98. |
| // End of buffer header is 32 bytes or .0313 KB. |
| // Each Exchange->DP2 request is 48 bytes or .0469 KB. |
| DDflte_(DP2_END_OF_BUFFER_HEADER_SIZE, ".0313"), |
| DDflte_(DP2_EXCHANGE_REQUEST_SIZE, ".0469"), |
| DDui2__(DP2_MAX_READ_PER_ACCESS_IN_KB, "256"), |
| // The buffer size, as of 10/07/97 is 32K |
| DDui2__(DP2_MESSAGE_BUFFER_SIZE, "56"), |
| // Exchange Costing |
| // 6/12/98. |
| // Message header for Exchange->DP2 is 18 bytes or .0176 KB |
| DDflte_(DP2_MESSAGE_HEADER_SIZE, ".0176"), |
| DDui2__(DP2_MESSAGE_HEADER_SIZE_BYTES, "18"), |
| DDui1__(DP2_MINIMUM_FILE_SIZE_FOR_SEEK_IN_BLOCKS, "256"), |
| |
| |
| DDui1__(DP2_SEQ_READS_WITHOUT_SEEKS, "100"), |
| DDkwd__(DYNAMIC_HISTOGRAM_COMPRESSION, "ON"), |
| DDui2__(DYN_PA_QUEUE_RESIZE_INIT_DOWN, "1024"), |
| DDui2__(DYN_PA_QUEUE_RESIZE_INIT_UP, "1024"), |
| DDui2__(DYN_QUEUE_RESIZE_FACTOR, "4"), |
| DDui2__(DYN_QUEUE_RESIZE_INIT_DOWN, "4"), |
| DDui2__(DYN_QUEUE_RESIZE_INIT_UP, "4"), |
| DDui1__(DYN_QUEUE_RESIZE_LIMIT, "9"), |
| DDkwd__(DYN_QUEUE_RESIZE_OVERRIDE, "OFF"), |
| |
| DDkwd__(EID_SPACE_USAGE_OPT, "OFF"), |
| |
| DDkwd__(ELIMINATE_REDUNDANT_JOINS, "ON"), |
| |
| |
| DDSint__(ESP_ASSIGN_DEPTH, "0"), |
| |
| DDSint__(ESP_FIXUP_PRIORITY_DELTA, "0"), |
| DDint__(ESP_IDLE_TIMEOUT, "1800"), // To match with set session defaults value |
| DDkwd__(ESP_MULTI_FRAGMENTS, "ON"), |
| DDui1500_4000(ESP_MULTI_FRAGMENT_QUOTA_VM, "4000"), |
| DDui1_8(ESP_NUM_FRAGMENTS, "3"), |
| |
| DDSint__(ESP_PRIORITY, "0"), |
| DDSint__(ESP_PRIORITY_DELTA, "0"), |
| |
| // Disable hints - if SYSTEM, enable on SSD, and disable only on HDD |
| DDkwd__(EXE_BMO_DISABLE_CMP_HINTS_OVERFLOW_HASH, "SYSTEM"), |
| DDkwd__(EXE_BMO_DISABLE_CMP_HINTS_OVERFLOW_SORT, "SYSTEM"), |
| DDkwd__(EXE_BMO_DISABLE_OVERFLOW, "OFF"), |
| DDui___(EXE_BMO_MIN_SIZE_BEFORE_PRESSURE_CHECK_IN_MB, "50"), |
| DDkwd__(EXE_BMO_SET_BUFFERED_WRITES, "OFF"), |
| |
| SDDkwd__(EXE_DIAGNOSTIC_EVENTS, "OFF"), |
| DDui1__(EXE_HGB_INITIAL_HT_SIZE, "262144"), // == hash buffer |
| |
| DDflt__(EXE_HJ_MIN_NUM_CLUSTERS, "4"), |
| |
| DDkwd__(EXE_LOG_RETRY_IPC, "OFF"), |
| |
| // Total size of memory (in MB) available to BMOs (e.g., 1200 MB) |
| SDDui___(EXE_MEMORY_AVAILABLE_IN_MB, "1200"), |
| |
| SDDui___(EXE_MEMORY_FOR_PARTIALHGB_IN_MB, "100"), |
| |
| SDDui___(EXE_MEMORY_FOR_PROBE_CACHE_IN_MB, "100"), |
| |
| SDDui___(EXE_MEMORY_FOR_UNPACK_ROWS_IN_MB, "1024"), |
| |
| // lower-bound memory limit for BMOs/nbmos (in MB) |
| DDui___(EXE_MEMORY_LIMIT_LOWER_BOUND_EXCHANGE, "10"), |
| DDui___(EXE_MEMORY_LIMIT_LOWER_BOUND_MERGEJOIN, "10"), |
| DDui___(EXE_MEMORY_LIMIT_LOWER_BOUND_SEQUENCE , "10"), |
| |
| // Override the memory quota system; set limit per each and every BMO |
| SDDflt__(EXE_MEM_LIMIT_PER_BMO_IN_MB, "0"), |
| |
| DDui1__(EXE_NUM_CONCURRENT_SCRATCH_IOS, "4"), // |
| |
| DDkwd__(EXE_PARALLEL_DDL, "ON"), |
| |
| |
| DDkwd__(EXE_SINGLE_BMO_QUOTA, "ON"), |
| |
| // The following 3 are only for testing overflow; zero value means: ignore |
| DDui___(EXE_TEST_FORCE_CLUSTER_SPLIT_AFTER_MB, "0"), |
| DDui___(EXE_TEST_FORCE_HASH_LOOP_AFTER_NUM_BUFFERS, "0"), |
| DDui___(EXE_TEST_HASH_FORCE_OVERFLOW_EVERY, "0"), |
| |
| DDkwd__(EXE_UTIL_RWRS, "OFF"), |
| |
| DDkwd__(EXPAND_DP2_SHORT_ROWS, "ON"), |
| |
| XDDint__(EXPLAIN_DESCRIPTION_COLUMN_SIZE, "-1"), |
| |
| DDkwd__(EXPLAIN_DETAIL_COST_FOR_CALIBRATION, "FALSE"), |
| |
| DDkwd__(EXPLAIN_DISPLAY_FORMAT, "EXTERNAL"), |
| |
| DDkwd__(EXPLAIN_IN_RMS, "OFF"), |
| |
| DDkwd__(EXPLAIN_OPTION_C, "OFF"), |
| |
| DDui___(EXPLAIN_OUTPUT_ROW_SIZE, "80"), |
| |
| DDui1__(EXPLAIN_ROOT_INPUT_VARS_MAX, "2000"), // maximum number of inputs that we can tolerate to |
| // explain information for inputVars expression |
| // this is needed to avoid stack overflow |
| |
| DDkwd__(EXPLAIN_SPACE_OPT, "ON"), |
| |
| DDkwd__(EXPLAIN_STRATEGIZER_PARAMETERS, "OFF"), |
| |
| |
| // Calibration |
| // 01/23/98: 50. |
| // Original: .1 |
| DDflte_(EX_OP_ALLOCATE_BUFFER, "50."), |
| DDflte_(EX_OP_ALLOCATE_BUFFER_POOL, ".1"), |
| DDflte_(EX_OP_ALLOCATE_TUPLE, ".05"), |
| |
| // copy_atp affects the costing of NJ |
| // History: |
| // 08/21/98: 0.02, The previous change affected more than one operrator |
| // 08/13/98: 1.0 |
| // 01/08/98: 0.02 |
| DDflte_(EX_OP_COPY_ATP, "1.1335"), |
| |
| DDkwd__(FAKE_VOLUME_ASSIGNMENTS, "OFF"), |
| DDui1__(FAKE_VOLUME_NUM_VOLUMES, "24"), |
| |
| // upper and lower limit (2,10) must be in sync with error values in |
| //ExFastTransport.cpp |
| DDkwd__(FAST_EXTRACT_DIAGS, "OFF"), |
| DDui2_10(FAST_EXTRACT_IO_BUFFERS, "6"), |
| DDui___(FAST_EXTRACT_IO_TIMEOUT_SEC, "60"), |
| DDkwd__(FIND_COMMON_SUBEXPRS_IN_OR, "ON"), |
| |
| DDui___(FLOAT_ESP_RANDOM_NUM_SEED, "0"), |
| |
| DDkwd__(FORCE_BUSHY_CQS, "ON"), |
| |
| DDkwd__(FORCE_PARALLEL_INSERT_SELECT, "OFF"), |
| DDkwd__(FORCE_PASS_ONE, "OFF"), |
| DDkwd__(FORCE_PASS_TWO, "ON"), |
| |
| // Control if plan fragments need to be compressed |
| // |
| DDui___(FRAG_COMPRESSION_THRESHOLD, "16"), |
| |
| // Controls FSO Tests for debug |
| // |
| DDui___(FSO_RUN_TESTS, "0"), |
| |
| // Controls use of Simple File Scan Optimizer |
| // IF 0 - Use original "Complex" File Scan Optimizer. |
| // (in case simple causes problems) |
| // IF 1 - Use logic to determine FSO to use. (default) |
| // IF 2 - Use logic to determine FSO to use, but also use new |
| // executor predicate costing. |
| // IF >2 - Always use new "Simple" File Scan Optimizer. |
| // (not recommended) |
| // |
| DDui___(FSO_TO_USE, "1"), |
| |
| // Disallow/Allow full outer joins in MultiJoin framework |
| DDkwd__(FULL_OUTER_JOINS_SPOIL_JBB, "OFF"), |
| |
| DDkwd__(GA_PROP_INDEXES_ARITY_1, "ON"), |
| |
| // this default value is filled in |
| // NADefaults::initCurrentDefaultsWithDefaultDefaults. The default value |
| // is ON for static compiles and OFF for dynamic queries. |
| DDkwd__(GENERATE_EXPLAIN, "ON"), |
| DDui___(GEN_CS_BUFFER_SIZE, "0"), |
| DDui___(GEN_CS_NUM_BUFFERS, "0"), |
| DDui___(GEN_CS_SIZE_DOWN, "4"), |
| DDui___(GEN_CS_SIZE_UP, "4"), |
| DDkwd__(GEN_DBLIMITS_LARGER_BUFSIZE, "ON"), |
| DDui1__(GEN_DDL_BUFFER_SIZE, "30000"), |
| DDui1__(GEN_DDL_NUM_BUFFERS, "4"), |
| DDui1__(GEN_DDL_SIZE_DOWN, "2"), |
| DDui1__(GEN_DDL_SIZE_UP, "32"), |
| DDui1__(GEN_DESC_BUFFER_SIZE, "10240"), |
| DDui1__(GEN_DESC_NUM_BUFFERS, "4"), |
| DDui1__(GEN_DESC_SIZE_DOWN, "2"), |
| DDui1__(GEN_DESC_SIZE_UP, "16"), |
| DDui1__(GEN_DP2I_BUFFER_SIZE, "10000"), |
| DDui1__(GEN_DP2I_NUM_BUFFERS, "2"), |
| DDui1__(GEN_DP2I_SIZE_DOWN, "32"), |
| DDui1__(GEN_DP2I_SIZE_UP, "64"), |
| DDui1__(GEN_DPSO_BUFFER_SIZE, "10240"), |
| DDui1__(GEN_DPSO_SIZE_DOWN, "2048"), |
| DDui1__(GEN_DPSO_SIZE_UP, "2048"), |
| DDui1__(GEN_DPUO_NUM_BUFFERS, "4"), |
| DDint__(GEN_EXCHANGE_MAX_MEM_IN_KB, "4000"), |
| DDint__(GEN_EXCHANGE_MSG_COUNT, "80"), |
| |
| // Fast extract settings are for UDR method invocations |
| DDui1__(GEN_FE_BUFFER_SIZE, "31000"), |
| DDui1__(GEN_FE_NUM_BUFFERS, "2"), |
| DDui1__(GEN_FE_SIZE_DOWN, "4"), |
| DDui1__(GEN_FE_SIZE_UP, "4"), |
| |
| |
| |
| // Do not alter the buffer size; it must be 56K for SCRATCH_MGMT_OPTION == 5 |
| DDui1__(GEN_HGBY_BUFFER_SIZE, "262144"), |
| DDui1__(GEN_HGBY_NUM_BUFFERS , "5"), |
| DDui1__(GEN_HGBY_PARTIAL_GROUP_FLUSH_THRESHOLD, "100"), |
| DDui___(GEN_HGBY_PARTIAL_GROUP_ROWS_PER_CLUSTER, "0"), |
| DDui1__(GEN_HGBY_SIZE_DOWN, "2048"), |
| DDui1__(GEN_HGBY_SIZE_UP, "2048"), |
| // Do not alter the buffer size; it must be 56K for SCRATCH_MGMT_OPTION == 5 |
| DDui1__(GEN_HSHJ_BUFFER_SIZE, "262144"), |
| |
| // Controls use of the hash join min/max optimization. |
| DDkwd__(GEN_HSHJ_MIN_MAX_OPT, "OFF"), |
| DDui1__(GEN_HSHJ_NUM_BUFFERS, "1"), |
| DDui1__(GEN_HSHJ_SIZE_DOWN, "2048"), |
| DDui1__(GEN_HSHJ_SIZE_UP, "2048"), |
| |
| // Controls LeanEr Expression generation |
| DDkwd__(GEN_LEANER_EXPRESSIONS, "ON"), |
| |
| DDui1__(GEN_MEM_PRESSURE_THRESHOLD, "10000"), |
| DDui1__(GEN_MJ_BUFFER_SIZE, "32768"), |
| DDui1__(GEN_MJ_NUM_BUFFERS, "1"), |
| DDui1__(GEN_MJ_SIZE_DOWN, "2"), |
| DDui1__(GEN_MJ_SIZE_UP, "2048"), |
| DDui1__(GEN_ONLJ_BUFFER_SIZE, "5120"), |
| DDui1__(GEN_ONLJ_LEFT_CHILD_QUEUE_DOWN, "4"), |
| DDui1__(GEN_ONLJ_LEFT_CHILD_QUEUE_UP, "2048"), |
| DDui1__(GEN_ONLJ_NUM_BUFFERS, "5"), |
| DDui1__(GEN_ONLJ_RIGHT_SIDE_QUEUE_DOWN, "2048"), |
| DDui1__(GEN_ONLJ_RIGHT_SIDE_QUEUE_UP, "2048"), |
| DDkwd__(GEN_ONLJ_SET_QUEUE_LEFT, "ON"), |
| DDkwd__(GEN_ONLJ_SET_QUEUE_RIGHT, "ON"), |
| DDui1__(GEN_ONLJ_SIZE_DOWN, "8"), |
| DDui1__(GEN_ONLJ_SIZE_UP, "2048"), |
| DDipcBu(GEN_PA_BUFFER_SIZE, "31000"), |
| DDui1__(GEN_PA_NUM_BUFFERS, "5"), |
| DDui1__(GEN_PROBE_CACHE_NUM_ENTRIES, "16384"),// number of entries |
| DDui___(GEN_PROBE_CACHE_NUM_INNER, "0"), //0 means compiler decides |
| DDui1__(GEN_PROBE_CACHE_SIZE_DOWN, "2048"), |
| DDui1__(GEN_PROBE_CACHE_SIZE_UP, "2048"), |
| DDui1__(GEN_SAMPLE_SIZE_DOWN, "16"), |
| DDui1__(GEN_SAMPLE_SIZE_UP, "16"), |
| DDui1__(GEN_SEQFUNC_BUFFER_SIZE, "10240"), |
| DDui1__(GEN_SEQFUNC_NUM_BUFFERS, "10"), |
| DDui1__(GEN_SEQFUNC_SIZE_DOWN, "512"), |
| DDui1__(GEN_SEQFUNC_SIZE_UP, "2048"), |
| DDui1__(GEN_SGBY_BUFFER_SIZE, "5120"), |
| DDui1__(GEN_SGBY_NUM_BUFFERS, "5"), |
| DDui1__(GEN_SGBY_SIZE_DOWN, "2048"), |
| DDui1__(GEN_SGBY_SIZE_UP, "2048"), |
| DDui1__(GEN_SID_BUFFER_SIZE, "1024"), |
| DDui1__(GEN_SID_NUM_BUFFERS, "4"), |
| DDui1__(GEN_SNDB_NUM_BUFFERS, "4"), |
| DDui1__(GEN_SNDB_SIZE_DOWN, "4"), |
| DDui1__(GEN_SNDB_SIZE_UP, "128"), |
| DDui___(GEN_SNDT_BUFFER_SIZE_DOWN, "0"), |
| DDui___(GEN_SNDT_BUFFER_SIZE_UP, "0"), |
| DDui1__(GEN_SNDT_NUM_BUFFERS, "2"), |
| DDkwd__(GEN_SNDT_RESTRICT_SEND_BUFFERS, "ON"), |
| DDui1__(GEN_SNDT_SIZE_DOWN, "4"), |
| DDui1__(GEN_SNDT_SIZE_UP, "128"), |
| DDui1__(GEN_SORT_MAX_BUFFER_SIZE, "5242880"), |
| DDui1__(GEN_SORT_MAX_NUM_BUFFERS, "160"), |
| DDui1__(GEN_SORT_NUM_BUFFERS, "2"), |
| DDui1__(GEN_SORT_SIZE_DOWN, "8"), |
| DDui1__(GEN_SORT_SIZE_UP, "1024"), |
| DDkwd__(GEN_SORT_TOPN, "ON"), |
| DDui1__(GEN_SORT_TOPN_THRESHOLD, "10000"), |
| DDui1__(GEN_SPLT_SIZE_UP, "2048"), |
| DDui1__(GEN_TFLO_BUFFER_SIZE, "5120"), |
| DDui1__(GEN_TFLO_NUM_BUFFERS, "2"), |
| DDui1__(GEN_TFLO_SIZE_DOWN, "8"), |
| DDui1__(GEN_TFLO_SIZE_UP, "16"), |
| |
| DDui512(GEN_TIMEOUT_BUFFER_SIZE, "4096"), |
| DDui1__(GEN_TIMEOUT_NUM_BUFFERS, "1"), |
| DDui2__(GEN_TIMEOUT_SIZE_DOWN, "2"), |
| DDui2__(GEN_TIMEOUT_SIZE_UP, "4"), |
| |
| DDui1__(GEN_TRAN_BUFFER_SIZE, "4096"), |
| DDui1__(GEN_TRAN_NUM_BUFFERS, "1"), |
| DDui1__(GEN_TRAN_SIZE_DOWN, "2"), |
| DDui1__(GEN_TRAN_SIZE_UP, "4"), |
| DDui1__(GEN_TRSP_BUFFER_SIZE, "10240"), |
| DDui1__(GEN_TRSP_NUM_BUFFERS, "5"), |
| DDui1__(GEN_TRSP_SIZE_DOWN, "2048"), |
| DDui1__(GEN_TRSP_SIZE_UP, "2048"), |
| DDui1__(GEN_TUPL_BUFFER_SIZE, "1024"), |
| DDui1__(GEN_TUPL_NUM_BUFFERS, "4"), |
| DDui1__(GEN_TUPL_SIZE_DOWN, "2048"), |
| DDui1__(GEN_TUPL_SIZE_UP, "2048"), |
| |
| // GEN_UDRRS_ settings are for stored procedure result |
| // set proxy plans |
| DDui1__(GEN_UDRRS_BUFFER_SIZE, "31000"), |
| DDui1__(GEN_UDRRS_NUM_BUFFERS, "2"), |
| DDui1__(GEN_UDRRS_SIZE_DOWN, "4"), |
| DDui1__(GEN_UDRRS_SIZE_UP, "128"), |
| |
| // GEN_UDR_ settings are for UDR method invocations |
| DDui1__(GEN_UDR_BUFFER_SIZE, "31000"), |
| DDui1__(GEN_UDR_NUM_BUFFERS, "2"), |
| DDui1__(GEN_UDR_SIZE_DOWN, "4"), |
| DDui1__(GEN_UDR_SIZE_UP, "4"), |
| |
| DDui1__(GEN_UN_BUFFER_SIZE, "10240"), |
| DDui1__(GEN_UN_NUM_BUFFERS, "5"), |
| DDui1__(GEN_UN_SIZE_DOWN, "2048"), |
| DDui1__(GEN_UN_SIZE_UP, "2048"), |
| |
| |
| // When less or equal to this CQD (5000 rows by default), a partial root |
| // will be running in the Master. Set to 0 to disable the feature. |
| DDint__(GROUP_BY_PARTIAL_ROOT_THRESHOLD, "5000"), |
| DDkwd__(GROUP_BY_PUSH_TO_BOTH_SIDES_OF_JOIN, "ON"), |
| |
| DDkwd__(GROUP_OR_ORDER_BY_EXPR, "ON"), |
| |
| // HASH_JOINS ON means do HASH_JOINS |
| XDDkwd__(HASH_JOINS, "ON"), |
| |
| // HBase defaults |
| // Some of the more important ones: |
| |
| // HBASE_CATALOG: Catalog of "_ROW_" and "_CELL_" schemas |
| // HBASE_COPROCESSORS: Enable use of co-processors for aggregates. |
| // need to set the coprocessor in HBase config file |
| // HBASE_ESTIMATE_ROW_COUNT_VIA_COPROCESSOR: If ON, use a coprocessor when |
| // estimating row counts; if OFF, use client side |
| // code (the latter doesn't work if HBase encryption |
| // is being used) |
| // HBASE_INTERFACE: JNI or JNI_TRX (transactional interface) |
| // HBASE_MAX_COLUMN_xxx_LENGTH: Max length of some |
| // string columns in the "_ROW_" and "_CELL_" schemas |
| // HBASE_SQL_IUD_SEMANTICS: Off: Don't check for existing rows for insert/update |
| |
| DDkwd__(HBASE_ASYNC_DROP_TABLE, "OFF"), |
| DDkwd__(HBASE_ASYNC_OPERATIONS, "ON"), |
| // HBASE_CACHE_BLOCKS, ON => cache every scan, OFF => cache no scan |
| // SYSTEM => cache scans which take less than 1 RS block cache mem. |
| DDui___(HBASE_BLOCK_SIZE, "65536"), |
| DDkwd__(HBASE_CACHE_BLOCKS, "SYSTEM"), |
| DD_____(HBASE_CATALOG, "HBASE"), |
| DDkwd__(HBASE_CHECK_AND_UPDEL_OPT, "ON"), |
| |
| DDkwd__(HBASE_COMPRESSION_OPTION, ""), |
| |
| DDkwd__(HBASE_COPROCESSORS, "ON"), |
| |
| |
| DDkwd__(HBASE_DATA_BLOCK_ENCODING_OPTION, ""), |
| |
| // If set to 'OFF' we get a stub cost of 1 for delete operations. |
| // We can remove this once the delete costing code has broader |
| // exposure. |
| DDkwd__(HBASE_DELETE_COSTING, "ON"), |
| DDflt0_(HBASE_DOP_PARALLEL_SCANNER, "0."), |
| DDkwd__(HBASE_ESTIMATE_ROW_COUNT_VIA_COPROCESSOR, "OFF"), |
| DDkwd__(HBASE_FILTER_PREDS, "OFF"), |
| DDkwd__(HBASE_HASH2_PARTITIONING, "ON"), |
| DDui___(HBASE_INDEX_LEVEL, "0"), |
| DDui___(HBASE_MAX_COLUMN_INFO_LENGTH, "10000"), |
| DDui___(HBASE_MAX_COLUMN_NAME_LENGTH, "100"), |
| DDui___(HBASE_MAX_COLUMN_VAL_LENGTH, "1000"), |
| DDui___(HBASE_MAX_ESPS, "9999"), |
| DDui___(HBASE_MAX_NUM_SEARCH_KEYS, "512"), |
| DDkwd__(HBASE_MEMSTORE_FLUSH_SIZE_OPTION, ""), |
| DDui1__(HBASE_MIN_BYTES_PER_ESP_PARTITION, "67108864"), |
| |
| DDkwd__(HBASE_NATIVE_IUD, "ON"), |
| DDui1__(HBASE_NUM_CACHE_ROWS_MAX, "1024"), |
| DDui1__(HBASE_NUM_CACHE_ROWS_MIN, "100"), |
| |
| DDkwd__(HBASE_RANGE_PARTITIONING, "ON"), |
| DDkwd__(HBASE_RANGE_PARTITIONING_MC_SPLIT, "ON"), |
| DDkwd__(HBASE_RANGE_PARTITIONING_PARTIAL_COLS,"ON"), |
| DDui___(HBASE_REGION_SERVER_MAX_HEAP_SIZE, "1024"), // in units of MB |
| |
| DDkwd__(HBASE_ROWSET_VSBB_OPT, "ON"), |
| DDusht_(HBASE_ROWSET_VSBB_SIZE, "1024"), |
| DDflt0_(HBASE_SALTED_TABLE_MAX_FILE_SIZE, "0"), |
| DDkwd__(HBASE_SALTED_TABLE_SET_SPLIT_POLICY, "ON"), |
| DDkwd__(HBASE_SERIALIZATION, "ON"), |
| |
| DD_____(HBASE_SERVER, ""), |
| DDkwd__(HBASE_SMALL_SCANNER, "OFF"), |
| DDkwd__(HBASE_SQL_IUD_SEMANTICS, "ON"), |
| DDkwd__(HBASE_STATS_PARTITIONING, "ON"), |
| |
| // If set to 'OFF' we get a stub cost of 0 for update operations. |
| DDkwd__(HBASE_UPDATE_COSTING, "ON"), |
| |
| DDkwd__(HBASE_UPDEL_CURSOR_OPT, "ON"), |
| DDui___(HBASE_USE_FAKED_REGIONS, "0"), |
| DD_____(HBASE_ZOOKEEPER_PORT, ""), |
| |
| DDui1__(HDFS_IO_BUFFERSIZE, "65536"), |
| DDui___(HDFS_IO_BUFFERSIZE_BYTES, "0"), |
| DDui___(HDFS_IO_INTERIM_BYTEARRAY_SIZE_IN_KB, "1024"), |
| // The value 0 denotes RangeTail = max record length of table. |
| DDui___(HDFS_IO_RANGE_TAIL, "0"), |
| DDkwd__(HDFS_PREFETCH, "ON"), |
| DDkwd__(HDFS_READ_CONTINUE_ON_ERROR, "OFF"), |
| DDui1__(HDFS_REPLICATION, "1"), |
| DDkwd__(HDFS_USE_CURSOR_MULTI, "OFF"), |
| |
| DDkwd__(HGB_BITMUX, "OFF"), |
| DDflt0_(HGB_CPUCOST_INITIALIZE, "1."), |
| DDflt0_(HGB_DP2_MEMORY_LIMIT, "10000."), |
| DDflte_(HGB_GROUPING_FACTOR_FOR_SPILLED_CLUSTERS, ".5"), |
| DDflte_(HGB_MAX_TABLE_SIZE_FOR_CLUSTERS, "4E5"), |
| DDflte_(HGB_MEMORY_AVAILABLE_FOR_CLUSTERS, "10"), |
| DDflte_(HH_OP_ALLOCATE_HASH_TABLE, ".05"), |
| DDflt1_(HH_OP_HASHED_ROW_OVERHEAD, "8."), |
| |
| // From observation: |
| // 03/11/98: probing the hash table is very inexpensive, |
| // thus reduce this to almost zero. |
| // change |
| // CPUCOST_HASH_PER_KEY |
| // when changing this value |
| // It takes around 2 seconds to insert 100,000 rows into the chain: |
| // @ 0.00005 secs per k instr: |
| // k instr= 2/0.00005/100000 = 0.4 |
| // History: |
| // Before 03/11/98: 0.4 |
| // Initially: 0.01 |
| DDflte_(HH_OP_INSERT_ROW_TO_CHAIN, "0.51"), |
| |
| // From observation: |
| // 03/11/98: probing the hash table is very inexpensive, |
| // thus reduce this to almost zero. |
| // 01/05/98: 15,433 rows probed per second @ 0.00005 seconds |
| // per thousand of instructions, give: |
| // seconds to probe one row = 1/15,433 = 0.000064796 |
| // This time includes: time to position and to compare. Thus |
| // subtract the time to compare to arrive to the proper number: |
| // thd. of instructions per row inserted = |
| // 1/15,433/0.00005 - CPUCOST_COMPARE_SIMPLE_DATA_TYPE = |
| // 1.2959 - 0.2 = 1.0959 |
| // History: |
| // Before 03/11/98: 1.0959 |
| // Before 01/05/98: 0.01 |
| DDflt0_(HH_OP_PROBE_HASH_TABLE, "0.011"), |
| |
| // Added 10/16/02 |
| DDkwd__(HIDE_INDEXES, "NONE"), |
| |
| DDansi_(HISTOGRAMS_SCHEMA, ""), |
| |
| // ------------------------------------------------------------------------- |
| // Histogram fudge factors |
| // ------------------------------------------------------------------------- |
| //HIST_BASE_REDUCTION and HIST_PREFETCH externalized 08/21/01 CR 10-010713-3895 |
| |
| DDkwd__(HIST_ASSUME_INDEPENDENT_REDUCTION, "ON"), |
| DDflt0_(HIST_BASE_REDUCTION_FUDGE_FACTOR, "0.1"), |
| DDflt0_(HIST_CONSTANT_ALPHA, "0.5"), |
| DDflt_0_1(HIST_DEFAULT_BASE_SEL_FOR_LIKE_WILDCARD, "0.50"), |
| DDui1__(HIST_DEFAULT_NUMBER_OF_INTERVALS, "50"), |
| DDui1__(HIST_DEFAULT_SAMPLE_MAX, "1000000"), |
| DDui1__(HIST_DEFAULT_SAMPLE_MIN, "10000"), |
| DDflt_0_1(HIST_DEFAULT_SAMPLE_RATIO, "0.01"), |
| DDflte_(HIST_DEFAULT_SEL_FOR_BOOLEAN, "0.3333"), |
| DDflt_0_1(HIST_DEFAULT_SEL_FOR_IS_NULL, "0.01"), |
| DDflt_0_1(HIST_DEFAULT_SEL_FOR_JOIN_EQUAL, "0.3333"), |
| DDflt_0_1(HIST_DEFAULT_SEL_FOR_JOIN_RANGE, "0.3333"), |
| DDflt_0_1(HIST_DEFAULT_SEL_FOR_LIKE_NO_WILDCARD,"1.0"), |
| DDflt_0_1(HIST_DEFAULT_SEL_FOR_LIKE_WILDCARD, "0.10"), |
| DDflt_0_1(HIST_DEFAULT_SEL_FOR_PRED_EQUAL, "0.01"), |
| DDflt_0_1(HIST_DEFAULT_SEL_FOR_PRED_RANGE, "0.3333"), |
| |
| // control the amount of data in each partition of the persistent sample tble. |
| DDflt1_(HIST_FETCHCOUNT_SCRATCH_VOL_THRESHOLD, "10240000"), |
| |
| DDkwd__(HIST_FREQ_VALS_NULL_FIX, "ON"), |
| DDkwd__(HIST_INCLUDE_SKEW_FOR_NON_INNER_JOIN, "ON"), |
| DDkwd__(HIST_INTERMEDIATE_REDUCTION, "OFF"), |
| DDflt0_(HIST_INTERMEDIATE_REDUCTION_FUDGE_FACTOR, "0.25"), |
| DDflt_0_1(HIST_JOIN_CARD_LOWBOUND, "1.0"), |
| DDui1__(HIST_LOW_UEC_THRESHOLD, "55"), |
| DDui1__(HIST_MAX_NUMBER_OF_INTERVALS, "10000"), |
| |
| DDkwd__(HIST_MC_STATS_NEEDED, "ON"), |
| DDkwd__(HIST_MERGE_FREQ_VALS_FIX, "ON"), |
| |
| // Histogram min/max optimization: when the predicate is of form |
| // T.A = MIN/MAX(S.B), replace the histogram(T.A) with |
| // single_int_histogram(MIN/MAX(S.B)). Do this only when |
| // there is no local predicate on S and there exists a frequent |
| // value that is equals to MIN/MAX(S.B). |
| DDkwd__(HIST_MIN_MAX_OPTIMIZATION, "ON"), |
| |
| // This CQD is used to control the number of missing stats warnings |
| // that should be generated. |
| // 0 ? Display no warnings. |
| // 1 ? Display only missing single column stats warnings. These include 6008 and 6011 |
| // 2 ? Display all single column missing stats warnings and |
| // multi-column missing stats warnings for Scans only. |
| // 3 ? Display all missing single column stats warnings and missing |
| // multi-column stats warnings for Scans and Join operators only.. |
| // 4 ? Display all missing single column stats and missing multi-column |
| // stats warnings for all operators including Scans, Joins and GroupBys. |
| // The CQD also does not have an impact on the auto update stats behavior. The stats will |
| // still be automatically generated even if the warnings have been suppressed. |
| // USTAT_AUTO_MISSING_STATS_LEVEL. |
| // Default behavior is to generate all warnings |
| XDDui___(HIST_MISSING_STATS_WARNING_LEVEL, "4"), |
| |
| DDflt1_(HIST_NO_STATS_ROWCOUNT, "100"), |
| DDflt1_(HIST_NO_STATS_UEC, "2"), |
| DDflt1_(HIST_NO_STATS_UEC_CHAR1, "10"), |
| DDui1__(HIST_NUM_ADDITIONAL_DAYS_TO_EXTRAPOLATE, "4"), |
| DDintN1__(HIST_ON_DEMAND_STATS_SIZE, "0"), |
| DDui___(HIST_OPTIMISTIC_CARD_OPTIMIZATION, "1"), |
| XDDkwd__(HIST_PREFETCH, "ON"), |
| XDDkwd__(HIST_REMOVE_TRAILING_BLANKS, "ON"), // should remove after verifying code is solid |
| DDansi_(HIST_ROOT_NODE, ""), |
| XDDflt1_(HIST_ROWCOUNT_REQUIRING_STATS, "500"), |
| DD_____(HIST_SCRATCH_VOL, ""), |
| // control the amount of data in each partition of the sample tble. |
| DDflt1_(HIST_SCRATCH_VOL_THRESHOLD, "10240000"), |
| DDflt_0_1(HIST_SKEW_COST_ADJUSTMENT, "0.2"), |
| DDkwd__(HIST_SKIP_MC_FOR_NONKEY_JOIN_COLUMNS, "OFF"), |
| DDui___(HIST_TUPLE_FREQVAL_LIST_THRESHOLD, "40"), |
| DDkwd__(HIST_USE_HIGH_FREQUENCY_INFO, "ON"), |
| XDDkwd__(HIST_USE_SAMPLE_FOR_CARDINALITY_ESTIMATION , "ON"), |
| |
| // CQDs for Trafodion on Hive |
| // Main ones to use: |
| // HIVE_MAX_STRING_LENGTH_IN_BYTES: Hive "string" data type gets converted |
| // into a VARCHAR with this length |
| // HIVE_MIN_BYTES_PER_ESP_PARTITION: Make one ESP for this many bytes |
| // HIVE_NUM_ESPS_PER_DATANODE: Equivalent of MAX_ESPS_PER_CPU_PER_OP |
| // Note that this is really per SeaQuest node |
| |
| DD_____(HIVE_CATALOG, ""), |
| |
| DDkwd__(HIVE_CTAS_IN_NATIVE_MODE, "OFF"), |
| |
| DDkwd__(HIVE_DATA_MOD_CHECK, "ON"), |
| |
| DDkwd__(HIVE_DEFAULT_CHARSET, (char *)SQLCHARSETSTRING_UTF8), |
| DD_____(HIVE_DEFAULT_SCHEMA, "HIVE"), |
| DD_____(HIVE_FILE_CHARSET, ""), |
| DD_____(HIVE_HDFS_STATS_LOG_FILE, ""), |
| DDui___(HIVE_INSERT_ERROR_MODE, "1"), |
| DDint__(HIVE_LIB_HDFS_PORT_OVERRIDE, "-1"), |
| DDint__(HIVE_LOCALITY_BALANCE_LEVEL, "0"), |
| DDui___(HIVE_MAX_ESPS, "9999"), |
| DDui___(HIVE_MAX_STRING_LENGTH_IN_BYTES, "32000"), |
| DDint__(HIVE_METADATA_REFRESH_INTERVAL, "0"), |
| DDflt0_(HIVE_MIN_BYTES_PER_ESP_PARTITION, "67108864"), |
| DDkwd__(HIVE_NO_REGISTER_OBJECTS, "OFF"), |
| DDui___(HIVE_NUM_ESPS_PER_DATANODE, "2"), |
| DDpct__(HIVE_NUM_ESPS_ROUND_DEVIATION, "34"), |
| DDint__(HIVE_SCAN_SPECIAL_MODE, "0"), |
| DDkwd__(HIVE_SORT_HDFS_HOSTS, "ON"), |
| DDkwd__(HIVE_USE_EXT_TABLE_ATTRS, "ON"), |
| DD_____(HIVE_USE_FAKE_SQ_NODE_NAMES, "" ), |
| DDkwd__(HIVE_USE_FAKE_TABLE_DESC, "OFF"), |
| DDkwd__(HIVE_USE_HASH2_AS_PARTFUNCION, "ON"), |
| DDkwd__(HIVE_VIEWS, "ON"), |
| |
| // ------------------------------------------------------------------------- |
| |
| DDflt0_(HJ_CPUCOST_INITIALIZE, "1."), |
| DDui1__(HJ_INITIAL_BUCKETS_PER_CLUSTER, "4."), |
| DDkwd__(HJ_NEW_MCSB_PLAN, "OFF"), |
| DDint__(HJ_SCAN_TO_NJ_PROBE_SPEED_RATIO, "2000"), |
| DDkwd__(HJ_TYPE, "HYBRID"), |
| DDkwd__(HQC_CONVDOIT_DISABLE_NUMERIC_CHECK, "OFF"), |
| DDkwd__(HQC_LOG, "OFF"), |
| DD_____(HQC_LOG_FILE, ""), |
| DDui1_10(HQC_MAX_VALUES_PER_KEY, "5"), |
| DDkwd__(HYBRID_QUERY_CACHE, "ON"), |
| DDkwd__(IF_LOCKED, "WAIT"), |
| |
| |
| |
| DDkwd__(IMPLICIT_DATETIME_INTERVAL_HOSTVAR_CONVERSION, "FALSE"), |
| DDkwd__(IMPLICIT_HOSTVAR_CONVERSION, "FALSE"), |
| |
| // threshold for the number of rows inserted into a volatile/temp |
| // table which will cause an automatic update stats. |
| // -1 indicates do not upd stats. 0 indicates always upd stats. |
| DDint__(IMPLICIT_UPD_STATS_THRESHOLD, "-1"), //"10000"), |
| |
| DDkwd__(INCORPORATE_SKEW_IN_COSTING, "ON"), |
| DDkwd__(INDEX_ELIMINATION_LEVEL, "AGGRESSIVE"), |
| DDui1__(INDEX_ELIMINATION_THRESHOLD, "50"), |
| DDkwd__(INDEX_HINT_WARNINGS, "ON"), |
| SDDkwd__(INFER_CHARSET, "OFF"), |
| |
| // UDF initial row cost CQDs |
| DDui___(INITIAL_UDF_CPU_COST, "100"), |
| DDui___(INITIAL_UDF_IO_COST, "1"), |
| DDui___(INITIAL_UDF_MSG_COST, "2"), |
| DDkwd__(INPUT_CHARSET, (char *)SQLCHARSETSTRING_ISO88591), // SQLCHARSETSTRING_UTF8 |
| XDDkwd__(INSERT_VSBB, "SYSTEM"), |
| //10-040621-7139-begin |
| //This CDQ will alllow the user to force the compiler to |
| //choose an interactive access path. ie., prefer access path with |
| //index in it. If such a path is not found which ever access path is |
| //available is chosen. |
| DDkwd__(INTERACTIVE_ACCESS, "OFF"), |
| //10-040621-7139-end |
| |
| DDkwd__(IN_MEMORY_OBJECT_DEFN, "OFF"), |
| |
| // History: |
| // 3/11/99 Changed to zero because in large tables the read-ahead |
| // seems negligible (and/or hard to simulate) |
| // Before 3/11/99: 0.58 |
| DDflt0_(IO_TRANSFER_COST_PREFETCH_MISSES_FRACTION, "0."), |
| XDDkwd__(ISOLATION_LEVEL, "READ_COMMITTED"), |
| XDDkwd__(ISOLATION_LEVEL_FOR_UPDATES, "NONE"), |
| SDDkwd__(ISO_MAPPING, (char *)SQLCHARSETSTRING_ISO88591), |
| |
| DDkwd__(IS_DB_TRANSPORTER, "OFF"), |
| |
| DDkwd__(IS_SQLCI, "FALSE"), |
| |
| DDkwd__(IUD_NONAUDITED_INDEX_MAINT, "OFF"), |
| |
| DDkwd__(JDBC_PROCESS, "FALSE"), |
| |
| // Force the join order given by the user |
| XDDkwd__(JOIN_ORDER_BY_USER, "OFF"), |
| |
| DDkwd__(KEYLESS_NESTED_JOINS, "OFF"), |
| |
| XDDkwd__(LAST0_MODE, "OFF"), |
| |
| DDansi_(LDAP_USERNAME, ""), |
| |
| // Disallow/Allow left joins in MultiJoin framework |
| DDkwd__(LEFT_JOINS_SPOIL_JBB, "OFF"), |
| |
| DDkwd__(LIMIT_HBASE_SCAN_DOP, "OFF"), |
| |
| // if this default is set to ON, then the max precision of a numeric |
| // expression(arithmetic, aggregate) is limited to MAX_NUMERIC_PRECISION |
| // (= 18). If this is set to OFF, the default value, then the max precision |
| // is computed based on the operands and the operation which could make the |
| // result a software datatype(BIGNUM). Software datatypes give better |
| // precision but degraded performance. |
| SDDkwd__(LIMIT_MAX_NUMERIC_PRECISION, "SYSTEM"), |
| |
| // Size in MB used to perform garbage collection to lob data file |
| // Recommended size is 20GB . Change to adjust disk usage. If -1 it means |
| // don't do GC during insert/update operations. |
| DDint__(LOB_GC_LIMIT_SIZE, "-1"), |
| |
| DDint__(LOB_HDFS_PORT, "0"), |
| DD_____(LOB_HDFS_SERVER, "default"), |
| // For JDBC/ODBC batch operations, LOB size limited to 4K bytes |
| DDint__(LOB_INPUT_LIMIT_FOR_BATCH, "16384"), |
| // Control the locking via RMS shared lock. This ensures the CLI and HDFS |
| // operations for any LOB UID are done under a lock so concurrent operations |
| // wont conflict and cause incosistent data. For non concurrent applications, |
| // we can turn this off as a performance enhancement. |
| DDkwd__(LOB_LOCKING, "ON"), |
| // Size of memoryin Megabytes used to perform I/O to lob data file |
| // default size is 128MB . Change to adjust memory usage. |
| DDint__(LOB_MAX_CHUNK_MEM_SIZE, "128"), |
| // default size is 5 G (5120 M) |
| DDint__(LOB_MAX_SIZE, "5120"), |
| // default size is 32000bytes. Change this to extract more data into memory. |
| DDui___(LOB_OUTPUT_SIZE, "32000"), |
| |
| DD_____(LOB_STORAGE_FILE_DIR, "/user/trafodion/lobs"), |
| |
| // storage types defined in exp/ExpLOBenum.h. |
| // Default is hdfs_file (value = 2) |
| DDint__(LOB_STORAGE_TYPE, "2"), |
| |
| //New default size for buffer size for local node |
| DDui2__(LOCAL_MESSAGE_BUFFER_SIZE, "50"), |
| |
| DDansi_(MAINTAIN_CATALOG, "NEO"), |
| |
| // Set the maintain control table timeout to 5 minutes |
| DDint__(MAINTAIN_CONTROL_TABLE_TIMEOUT, "30000"), |
| |
| |
| DDkwd__(MARIAQUEST_PROCESS, "OFF"), |
| |
| DDSint__(MASTER_PRIORITY, "0"), |
| DDSint__(MASTER_PRIORITY_DELTA, "0"), |
| |
| DDint__(MATCH_CONSTANTS_OF_EQUALITY_PREDICATES, "2"), |
| |
| DDui1__(MAX_ACCESS_NODES_PER_ESP, "1024"), |
| |
| |
| DDint__(MAX_DEPTH_TO_CHECK_FOR_CYCLIC_PLAN, "1"), |
| |
| // default value of maximum dp2 groups for a hash-groupby |
| DDui1__(MAX_DP2_HASHBY_GROUPS, "1000"), |
| |
| // |
| // The max number of ESPs per cpu for a given operator. |
| // i.e. this number times the number of available CPUs is "max pipelines". |
| // |
| // On Linux, "CPU" means cores. |
| // |
| DDflt__(MAX_ESPS_PER_CPU_PER_OP, "0.5"), |
| |
| DDui1__(MAX_EXPRS_USED_FOR_CONST_FOLDING, "1000"), |
| |
| // used in hash groupby costing in esp/master |
| DDui1__(MAX_HEADER_ENTREIS_PER_HASH_TABLE, "250000"), |
| |
| DDui1__(MAX_LONG_VARCHAR_DEFAULT_SIZE, "2000"), |
| DDui1__(MAX_LONG_WVARCHAR_DEFAULT_SIZE, "2000"), |
| |
| DD18_128(MAX_NUMERIC_PRECISION_ALLOWED, "128"), |
| |
| |
| |
| // The max number of skewed values detected - skew buster |
| DDui1__(MAX_SKEW_VALUES_DETECTED, "10000"), |
| |
| // multi-column skew inner table broadcast threashold in bytes (=1 MB) |
| DDui___(MC_SKEW_INNER_BROADCAST_THRESHOLD, "1000000"), |
| |
| // multi-column skew sensitivity threshold |
| // |
| // For new MCSB (that is, we utilize MC skews directly), |
| // apply the MC skew buster when |
| // frequency of MC skews > MC_SKEW_SENSITIVITY_THRESHOLD / count_of_cpus |
| // |
| // For old MCSB (that is, we guess MC skews from SC skews), |
| // apply the MC skew buster when |
| // SFa,b... * countOfPipeline > MC_SKEW_SENSITIVITY_THRESHOLD |
| // SFa,b ... is the skew factor for multi column a,b,... |
| // |
| XDDflt__(MC_SKEW_SENSITIVITY_THRESHOLD, "0.1"), |
| |
| // Applies additional heuristics to turn off MDAM. This code was added |
| // at a time when cumulative probe cost was not considered in the MDAM |
| // cost model (a MAJOR error). The meaning of the values: |
| // 0 - do nothing (no additional heuristics) |
| // 1 - require that more key columns have predicates than key columns |
| // without predicates |
| // 2 - require that the UECs of key columns lacking predicates is below |
| // a given threshold |
| // 3 - AND of 1 and 2 |
| // These heuristics made sense when the cost model was broken and we |
| // traversed more deeply into the key than we should have. The cost model |
| // now takes cumulative probe cost into account so these should no longer |
| // be necessary (and indeed these heuristics can cause us to miss some |
| // very good plans, because they prevent us from considering MDAM plans |
| // that probe prefix columns before a column with high UEC, for example). |
| DDui___(MDAM_APPLY_RESTRICTION_CHECK, "0"), |
| |
| // MDAM_COSTING_REWRITE: If ON, then the simple cost model costing |
| // for MDAM will use the rewritten code. If OFF, it will use the |
| // older code (which was current in September 2017, at the time |
| // the rewrite commenced). This only has an effect if SIMPLE_COST_MODEL |
| // is ON (which is the current default). |
| XDDkwd__(MDAM_COSTING_REWRITE, "OFF"), |
| |
| |
| DDflt0_(MDAM_CPUCOST_NET_OVH, "2000."), |
| |
| |
| // The cost that takes to build the mdam network per predicate: |
| // (we assume that the cost to build the mdam network is a linear function |
| // of the key predicates) |
| DDflt0_(MDAM_CPUCOST_NET_PER_PRED, ".5"), |
| |
| // Added by JIRA TRAFODION-2765: Allows consideration of MDAM |
| // in more general circumstances. |
| XDDkwd__(MDAM_FSO_SIMPLE_RULE, "ON"), |
| |
| // controls the max. number of seek positions under which MDAM will be |
| // allowed. Set it to 0 turns off the feature. |
| XDDui___(MDAM_NO_STATS_POSITIONS_THRESHOLD, "10"), |
| |
| // a multiplier of probe cost used for MDAM |
| DDflt0_(MDAM_PROBE_TAX, "3"), |
| |
| // MDAM_SCAN_METHOD ON means MDAM is enabled, |
| // OFF means MDAM is disabled. MDAM is enabled by default |
| // externalized 06/21/01 RV |
| // mdam off on open source at this point |
| XDDkwd__(MDAM_SCAN_METHOD, "ON"), |
| |
| DDflt0_(MDAM_SELECTION_DEFAULT, "8.0"), |
| |
| // Overhead charge for a subset in the rewritten MDAM costing code |
| DDflt0_(MDAM_SUBSET_FACTOR, "8.0"), |
| |
| DDflt0_(MDAM_TOTAL_UEC_CHECK_MIN_RC_THRESHOLD, "10000"), |
| DDflt0_(MDAM_TOTAL_UEC_CHECK_UEC_THRESHOLD, "0.2"), |
| |
| DDkwd__(MDAM_TRACING, "OFF"), |
| |
| // controls the max. number of probes at which MDAM under NJ plan will be |
| // generated. Set it to 0 turns off the feature. |
| XDDui___(MDAM_UNDER_NJ_PROBES_THRESHOLD, "0"), |
| |
| // controls the amount of penalty for CPU resource required that is |
| // beyond the value specified by MDOP_CPUS_SOFT_LIMIT. The number of extra CPUs |
| // actually allocated is computed as the origial value divided by the CQD. |
| // If the CQD is set to 1 (default), then there is no penalty. |
| DDflt1_(MDOP_CPUS_PENALTY, "70"), |
| |
| // specify the limit beyond which the number of CPUs will be limited. |
| DDui1__(MDOP_CPUS_SOFT_LIMIT, "64"), |
| |
| // controls the amount of penalty for CPU resource per memory unit |
| // required that is beyond the value specified by MDOP_CPUS_SOFT_LIMIT. |
| // The number of extra CPUs actually allocated is computed as the |
| // origial value divided by the CQD. |
| DDflt1_(MDOP_MEMORY_PENALTY, "70"), |
| |
| // CQD to test/enforce heap memory upper limits |
| // values are in KB |
| DDui___(MEMORY_LIMIT_CMPCTXT_UPPER_KB, "0"), |
| DDui___(MEMORY_LIMIT_CMPSTMT_UPPER_KB, "0"), |
| DDui___(MEMORY_LIMIT_HISTCACHE_UPPER_KB, "0"), |
| DDui___(MEMORY_LIMIT_NATABLECACHE_UPPER_KB, "0"), |
| DDui___(MEMORY_LIMIT_QCACHE_UPPER_KB, "0"), |
| // Checked at compile time. Set to -1 to disable check. |
| // Value should be >= EXE_MEMORY_FOR_UNPACK_ROWS_IN_MB |
| DDint__(MEMORY_LIMIT_ROWSET_IN_MB, "1024"), |
| |
| // SQL/MX Compiler/Optimzer Memory Monitor. |
| DDkwd__(MEMORY_MONITOR, "OFF"), |
| DDui1__(MEMORY_MONITOR_AFTER_TASKS, "30000"), |
| DDkwd__(MEMORY_MONITOR_IN_DETAIL, "OFF"), |
| DD_____(MEMORY_MONITOR_LOGFILE, "NONE"), |
| DDkwd__(MEMORY_MONITOR_LOG_INSTANTLY, "OFF"), |
| DDui1__(MEMORY_MONITOR_TASK_INTERVAL, "5000"), |
| |
| // Hash join currently uses 20 Mb before it overflows, use this |
| // as the limit |
| DDui1__(MEMORY_UNITS_SIZE, "20480"), |
| |
| // amount of memory available per CPU for any query |
| SDDflte_(MEMORY_UNIT_ESP, "300"), |
| |
| DDflt1_(MEMORY_USAGE_NICE_CONTEXT_FACTOR, "1"), |
| DDflt1_(MEMORY_USAGE_OPT_PASS_FACTOR, "1.5"), |
| DDui1__(MEMORY_USAGE_SAFETY_NET, "500"), |
| |
| // MERGE_JOINS ON means do MERGE_JOINS |
| XDDkwd__(MERGE_JOINS, "ON"), |
| DDkwd__(MERGE_JOIN_ACCEPT_MULTIPLE_NJ_PROBES, "ON"), |
| DDkwd__(MERGE_JOIN_CONTROL, "OFF"), |
| DDkwd__(MERGE_JOIN_WITH_POSSIBLE_DEADLOCK, "OFF"), |
| |
| // controls if merge/upsert is supported on table with a unique index |
| DDkwd__(MERGE_WITH_UNIQUE_INDEX, "ON"), |
| |
| SDDui___(METADATA_CACHE_SIZE, "20"), |
| //------------------------------------------------------------------- |
| // Minimum ESP parallelism. If the user does not specify this value |
| // (default value 0 does not change) then the number of segments |
| // (totalNumCPUs/16, where totalNumCPUs=gpClusterInfo->numOfSMPs()) |
| // will be used as the value of minimum ESP parallelism. If user sets |
| // this value it should be integer between 1 and totalNumCPUs. In |
| // this case actual value of minimum ESP parallelism will be |
| // min(CDQ value, MDOP), where MDOP (maximum degree of parallelism) |
| // is defined by adaptive segmentation |
| //------------------------------------------------------------------- |
| DDui___(MINIMUM_ESP_PARALLELISM, "0"), |
| DDui1__(MIN_LONG_VARCHAR_DEFAULT_SIZE, "1"), |
| DDui1__(MIN_LONG_WVARCHAR_DEFAULT_SIZE, "1"), |
| DDkwd__(MIN_MAX_OPTIMIZATION, "ON"), |
| DDpct__(MJ_BMO_QUOTA_PERCENT, "0"), |
| DDflt0_(MJ_CPUCOST_CLEAR_LIST, ".01"), |
| DDflt0_(MJ_CPUCOST_GET_NEXT_ROW_FROM_LIST, ".01"), |
| // calibrated 01/16/98: |
| // 01/13/98 40000., this did not work with small tables |
| // Before 01/13/98: 0.5 |
| DDflt0_(MJ_CPUCOST_INITIALIZE, "1."), |
| // Before 03/12/98: 0.4 |
| // Before 01/13/98: 0.01 |
| DDflt0_(MJ_CPUCOST_INSERT_ROW_TO_LIST, ".0001"), |
| DDflt0_(MJ_CPUCOST_REWIND_LIST, ".01"), |
| DDflte_(MJ_LIST_NODE_SIZE, ".01"), |
| DDkwd__(MJ_OVERFLOW, "ON"), |
| |
| DDkwd__(MODE_SEABASE, "ON"), |
| DDkwd__(MODE_SEAHIVE, "ON"), |
| |
| SDDkwd__(MODE_SPECIAL_1, "OFF"), |
| |
| DDkwd__(MODE_SPECIAL_4, "OFF"), |
| |
| |
| // Tests suggest that RELEASE is about 2.5 times faster than DEBUG |
| // RELEASE is always faster than DEBUG code so this default must be |
| // at least one. |
| DDflt1_(MSCF_DEBUG_TO_RELEASE_MULTIPLIER, "2.5"), |
| |
| // MSCF_ET_CPU units are seconds/thousand of CPU instructions |
| // History: |
| // Before 02/01/99, the speed was calibrated for debug, now its is for |
| // release: 0.00005 |
| DDflte_(MSCF_ET_CPU, "0.000014"), |
| // was 0.00002 12/2k |
| |
| // MSCF_ET_IO_TRANSFER units are seconds/Kb |
| // History |
| // Changed to '0.000455' to reflect new calibration data |
| // Before 03/11/99 "0.000283" |
| DDflte_(MSCF_ET_IO_TRANSFER, "0.00002"), |
| // Assume time to transfer a KB of local message is 5 times |
| // faster than the time to transfer a KB from disk |
| // Units of MSCF_ET_LOCAL_MSG_TRANSFER are seconds/Kb |
| |
| DDflte_(MSCF_ET_LOCAL_MSG_TRANSFER, "0.000046"), |
| // : for calibration on 04/08/2004 |
| // Seek time will be derived from disk type. |
| |
| // MSCF_ET_NUM_IO_SEEKS units are seconds |
| DDflte_(MSCF_ET_NUM_IO_SEEKS, "0.0038"), |
| |
| // Assume sending a local message takes 1000 cpu instructions |
| DDflte_(MSCF_ET_NUM_LOCAL_MSGS, "0.000125"), |
| // Assume sending a remote message takes 10000 cpu instructions |
| // DDflte_(MSCF_ET_NUM_REMOTE_MSGS, "0.00125"), |
| |
| // Change the number of instructions to encode a remote message to be |
| // the same as the local message |
| DDflte_(MSCF_ET_NUM_REMOTE_MSGS, "0.000125"), |
| // Assume 1MB/second transfer rate for transferring remote message bytes |
| // (Based on 10 Megabit/second Ethernet transfer rate) |
| // MSCF_ET_REMOTE_MSG_TRANSFER units are kb/Sec |
| // DDflte_(MSCF_ET_REMOTE_MSG_TRANSFER, "0.001"), |
| |
| // the remote msg are 10% more costly than the local transfer |
| // but also may depend on the physical link, so externalize it |
| DDflte_(MSCF_ET_REMOTE_MSG_TRANSFER, "0.00005"), |
| |
| // ------------------------------------------------------------------------- |
| // Factors used for estimating overlappability of I/O and messaging used |
| // in the calculation for overlapped addition |
| // Assume 50% overlap for now. |
| // ------------------------------------------------------------------------- |
| DDflte_(MSCF_OV_IO, "0.5"), |
| DDflte_(MSCF_OV_MSG, "0.5"), |
| |
| |
| |
| DDkwd__(MTD_GENERATE_CC_PREDS, "ON"), |
| DDint__(MTD_MDAM_NJ_UEC_THRESHOLD, "100"), |
| |
| // Allow for the setting of the row count in a long running operation |
| XDDui1__(MULTI_COMMIT_SIZE, "10000"), |
| |
| // try the join order specified in the queries, this will cause the |
| // enumeration of the initial join order specified by the user |
| // among the join orders enumerated |
| // ** This is currently OFF by default ** |
| DDkwd__(MULTI_JOIN_CONSIDER_INITIAL_JOIN_ORDER, "OFF"), |
| |
| // used in JBBSubsetAnalysis::isAStarPattern for finding lowest cost |
| // outer subtree for NJ into fact table. |
| DDflt0_(MULTI_JOIN_PROBE_HASH_TABLE, "0.000001"), |
| |
| |
| SDDint__(MULTI_JOIN_THRESHOLD, "3"), |
| |
| DDint__(MULTI_PASS_JOIN_ELIM_LIMIT, "5"), |
| |
| DDflt0_(MU_CPUCOST_INITIALIZE, ".05"), |
| DDui___(MU_INITIAL_BUFFER_COUNT, "5."), |
| DDflte_(MU_INITIAL_BUFFER_SIZE, "1033.7891"), |
| |
| //-------------------------------------------------------------------------- |
| //++ MV |
| XDDkwd__(MVGROUP_AUTOMATIC_CREATION, "ON"), |
| |
| DDkwd__(MVQR_ALL_JBBS_IN_QD, "OFF"), |
| #ifdef NDEBUG |
| DDkwd__(MVQR_ENABLE_LOGGING, "OFF"), // No logging by default for release |
| #else |
| DDkwd__(MVQR_ENABLE_LOGGING, "ON"), |
| #endif |
| DDkwd__(MVQR_LOG_QUERY_DESCRIPTORS, "OFF"), |
| DDint__(MVQR_MAX_EXPR_DEPTH, "20"), |
| DDint__(MVQR_MAX_EXPR_SIZE, "100"), |
| DDkwd__(MVQR_PARAMETERIZE_EQ_PRED, "ON"), |
| DDkwd__(MVQR_PRIVATE_QMS_INIT, "SMD"), |
| DDkwd__(MVQR_PUBLISH_TO, "BOTH"), |
| DDansi_(MVQR_REWRITE_CANDIDATES, ""), |
| XDDkwd__(MVQR_REWRITE_ENABLED_OPTION, "OFF"), // @ZX -- change to ON later |
| XDDui0_5(MVQR_REWRITE_LEVEL, "0"), |
| XDDkwd__(MVQR_REWRITE_SINGLE_TABLE_QUERIES, "ON"), |
| DDkwd__(MVQR_USE_EXTRA_HUB_TABLES, "ON"), |
| DDkwd__(MVQR_USE_RI_FOR_EXTRA_HUB_TABLES, "OFF"), |
| DD_____(MVQR_WORKLOAD_ANALYSIS_MV_NAME, ""), |
| |
| XDDMVA__(MV_AGE, "0 MINUTES"), |
| XDDkwd__(MV_ALLOW_SELECT_SYSTEM_ADDED_COLUMNS, "OFF"), |
| DDkwd__(MV_AS_ROW_TRIGGER, "OFF"), |
| DDkwd__(MV_DUMP_DEBUG_INFO, "OFF"), |
| DDkwd__(MV_ENABLE_INTERNAL_REFRESH_SHOWPLAN, "OFF"), |
| |
| |
| DDui___(MV_LOG_CLEANUP_SAFETY_FACTOR, "200"), |
| DDui___(MV_LOG_CLEANUP_USE_MULTI_COMMIT, "1"), |
| |
| SDDkwd__(MV_LOG_PUSH_DOWN_DP2_DELETE, "OFF"), // push down mv logging tp dp2 for delete |
| SDDkwd__(MV_LOG_PUSH_DOWN_DP2_INSERT, "OFF"), // push down mv logging tp dp2 for insert |
| SDDkwd__(MV_LOG_PUSH_DOWN_DP2_UPDATE, "ON"), // push down mv logging tp dp2 for update |
| |
| SDDui___(MV_REFRESH_MAX_PARALLELISM, "0"), |
| DDui___(MV_REFRESH_MAX_PIPELINING, "0"), |
| |
| DDint__(MV_REFRESH_MDELTA_MAX_DELTAS_THRESHOLD, "31"), |
| DDint__(MV_REFRESH_MDELTA_MAX_JOIN_SIZE_FOR_SINGLE_PHASE, "3"), |
| DDint__(MV_REFRESH_MDELTA_MIN_JOIN_SIZE_FOR_SINGLE_PRODUCT_PHASE, "8"), |
| DDint__(MV_REFRESH_MDELTA_PHASE_SIZE_FOR_MID_RANGE, "6"), |
| |
| DDkwd__(MV_TRACE_INCONSISTENCY, "OFF"), |
| |
| DDSint__(MXCMP_PRIORITY, "0"), |
| DDSint__(MXCMP_PRIORITY_DELTA, "0"), |
| |
| DDkwd__(NAMETYPE, "ANSI"), |
| |
| DDkwd__(NAR_DEPOBJ_ENABLE, "ON"), |
| DDkwd__(NAR_DEPOBJ_ENABLE2, "ON"), |
| // NATIONAL_CHARSET reuses the "kwd" logic here, w/o having to add any |
| // DF_ token constants (this can be considered either clever or kludgy coding). |
| DDkwd__(NATIONAL_CHARSET, (char *)SQLCHARSETSTRING_UNICODE), |
| |
| |
| // These CQDs are reserved for NCM. These are mostly used for |
| // internal testing, turning on/off features for debugging, and for tuning. |
| // In normal situations, these will not be externalized in keeping |
| // with the very few CQDs philosophy of NCM. |
| // These are applicable only in conjunction with SIMPLE_COST_MODEL 'on'. |
| DDflt__(NCM_CACHE_SIZE_IN_BLOCKS, "52"), |
| DDflt__(NCM_COSTLIMIT_FACTOR, "0.05"), //change to 0.05 |
| DDint__(NCM_ESP_FIXUP_WEIGHT, "300"), |
| DDkwd__(NCM_ESP_STARTUP_FIX, "ON"), |
| DDflt__(NCM_EXCH_MERGE_FACTOR, "0.10"), // change to 0.10 |
| DDkwd__(NCM_EXCH_NDCS_FIX, "ON"), // change to ON |
| DDkwd__(NCM_HBASE_COSTING, "ON"), // change to ON |
| DDkwd__(NCM_HGB_OVERFLOW_COSTING, "ON"), |
| DDkwd__(NCM_HJ_OVERFLOW_COSTING, "ON"), |
| DDflt__(NCM_IND_JOIN_COST_ADJ_FACTOR, "1.0"), |
| DDflt__(NCM_IND_JOIN_SELECTIVITY, "1.0"), |
| DDflt__(NCM_IND_SCAN_COST_ADJ_FACTOR, "1.0"), |
| DDflt__(NCM_IND_SCAN_SELECTIVITY, "1.0"), |
| DDflt__(NCM_MAP_CPU_FACTOR, "4.0"), |
| DDflt__(NCM_MAP_MSG_FACTOR, "4.0"), |
| DDflt__(NCM_MAP_RANDIO_FACTOR, "4.0"), |
| DDflt__(NCM_MAP_SEQIO_FACTOR, "4.0"), |
| DDflt__(NCM_MDAM_COST_ADJ_FACTOR, "1.0"), |
| DDflt__(NCM_MJ_TO_HJ_FACTOR, "0.6"), |
| DDflt__(NCM_NJ_PC_THRESHOLD, "1.0"), |
| DDflt0_(NCM_NJ_PROBES_MAXCARD_FACTOR, "10000"), |
| DDkwd__(NCM_NJ_SEQIO_FIX, "ON"), // change to ON |
| DDint__(NCM_NUM_SORT_RUNS, "4"), |
| DDflt__(NCM_PAR_ADJ_FACTOR, "0.10"), |
| DDkwd__(NCM_PAR_GRPBY_ADJ, "ON"), |
| DDkwd__(NCM_PRINT_ROWSIZE, "OFF"), |
| DDflt__(NCM_RAND_IO_ROWSIZE_FACTOR, "0"), |
| DDflt__(NCM_RAND_IO_WEIGHT, "3258"), |
| DDflt__(NCM_SEQ_IO_ROWSIZE_FACTOR, "0"), |
| DDflt__(NCM_SEQ_IO_WEIGHT, "543"), |
| DDflt__(NCM_SERIAL_NJ_FACTOR, "2"), |
| DDflt__(NCM_SGB_TO_HGB_FACTOR, "0.8"), |
| DDkwd__(NCM_SKEW_COST_ADJ_FOR_PROBES, "OFF"), |
| DDkwd__(NCM_SORT_OVERFLOW_COSTING, "ON"), |
| DDflt__(NCM_TUPLES_ROWSIZE_FACTOR, "0.5"), |
| DDflt__(NCM_UDR_NANOSEC_FACTOR, "0.01"), |
| |
| // NESTED_JOINS ON means do NESTED_JOINS |
| XDDkwd__(NESTED_JOINS, "ON"), |
| |
| // max. number of ESPs that will deal with skews for OCR |
| // 0 means to turn off the feature |
| DDintN1__(NESTED_JOINS_ANTISKEW_ESPS , "16"), |
| |
| DDkwd__(NESTED_JOINS_CHECK_LEADING_KEY_SKEW, "OFF"), |
| DDkwd__(NESTED_JOINS_FULL_INNER_KEY, "OFF"), |
| DDkwd__(NESTED_JOINS_KEYLESS_INNERJOINS, "ON"), |
| DDui1__(NESTED_JOINS_LEADING_KEY_SKEW_THRESHOLD, "15"), |
| DDkwd__(NESTED_JOINS_NO_NSQUARE_OPENS, "ON"), |
| |
| DDkwd__(NESTED_JOINS_OCR_GROUPING, "OFF"), |
| |
| // 128X32 being the default threshold for OCR. |
| // 128 partitions per table and 32 ESPs per NJ operator |
| SDDint__(NESTED_JOINS_OCR_MAXOPEN_THRESHOLD, "4096"), |
| |
| |
| // PLAN0 is solely controlled by OCR. If this CQD is off, then |
| // PLAN0 is off unconditionally. This CQD is used by OCR unit test. |
| DDkwd__(NESTED_JOINS_PLAN0, "ON"), |
| |
| // try the explicit sort plan when plan2 produces a non-sort plan |
| DDkwd__(NESTED_JOINS_PLAN3_TRY_SORT, "ON"), |
| |
| // Enable caching for eligible nested joins - see NestedJoin::preCodeGen. |
| DDkwd__(NESTED_JOIN_CACHE, "ON"), |
| // Enable pulling up of predicates into probe cache |
| DDkwd__(NESTED_JOIN_CACHE_PREDS, "ON"), |
| // Nested Join Heuristic |
| DDkwd__(NESTED_JOIN_CONTROL, "ON"), |
| |
| |
| // Allow nested join for cross products |
| DDkwd__(NESTED_JOIN_FOR_CROSS_PRODUCTS, "ON"), |
| DDkwd__(NEW_MDAM, "ON"), |
| DDkwd__(NEW_OPT_DRIVER, "ON"), |
| |
| |
| |
| DDflt0_(NJ_CPUCOST_INITIALIZE, ".1"), |
| |
| DDflt0_(NJ_CPUCOST_PASS_ROW, ".02"), |
| |
| DDflte_(NJ_INC_AFTERLIMIT, "0.0055"), |
| DDflte_(NJ_INC_MOVEROWS, "0.0015"), |
| DDflte_(NJ_INC_UPTOLIMIT, "0.0225"), |
| |
| DDui___(NJ_INITIAL_BUFFER_COUNT, "5"), |
| DDui1__(NJ_INITIAL_BUFFER_SIZE, "5"), |
| |
| DDui1__(NJ_MAX_SEEK_DISTANCE, "5000"), |
| |
| // UDF costing CQDs for processing a steady state row |
| DDui___(NORMAL_UDF_CPU_COST, "100"), |
| DDui___(NORMAL_UDF_IO_COST, "0"), |
| DDui___(NORMAL_UDF_MSG_COST, "2"), |
| |
| XDDui30_32000(NOT_ATOMIC_FAILURE_LIMIT, "32000"), |
| |
| //NOT IN ANSI NULL semantics rule |
| DDkwd__(NOT_IN_ANSI_NULL_SEMANTICS, "ON"), |
| //NOT IN optimization |
| DDkwd__(NOT_IN_OPTIMIZATION, "ON"), |
| //NOT IN outer column optimization |
| DDkwd__(NOT_IN_OUTER_OPTIMIZATION, "ON"), |
| // NOT IN skew buster optimization |
| DDkwd__(NOT_IN_SKEW_BUSTER_OPTIMIZATION, "ON"), |
| |
| DDkwd__(NOT_NULL_CONSTRAINT_DROPPABLE_OPTION, "OFF"), |
| |
| |
| // NSK DEBUG defaults |
| DDansi_(NSK_DBG, "OFF"), |
| DDansi_(NSK_DBG_COMPILE_INSTANCE, "USER"), |
| DDkwd__(NSK_DBG_GENERIC, "OFF"), |
| DDansi_(NSK_DBG_LOG_FILE, ""), |
| DDkwd__(NSK_DBG_MJRULES_TRACKING, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_CHAR_INPUT, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_CHAR_OUTPUT, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_CONSTRAINT, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_CONTEXT, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_CONTEXT_POINTER, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_COST, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_INDEX_ELIMINATION, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_ITEM_EXPR, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_LOG_PROP, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_PHYS_PROP, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_TASK, "OFF"), |
| DDkwd__(NSK_DBG_PRINT_TASK_STACK, "OFF"), |
| DDkwd__(NSK_DBG_QUERY_LOGGING_ONLY, "OFF"), |
| DDansi_(NSK_DBG_QUERY_PREFIX, ""), |
| DDkwd__(NSK_DBG_SHOW_PASS1_PLAN, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_PASS2_PLAN, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_PLAN_LOG, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_TREE_AFTER_ANALYSIS, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_TREE_AFTER_BINDING, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_TREE_AFTER_CODEGEN, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_TREE_AFTER_NORMALIZATION, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_TREE_AFTER_PARSING, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_TREE_AFTER_PRE_CODEGEN, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_TREE_AFTER_SEMANTIC_QUERY_OPTIMIZATION, "OFF"), |
| DDkwd__(NSK_DBG_SHOW_TREE_AFTER_TRANSFORMATION, "OFF"), |
| |
| DDflt0_(NUMBER_OF_PARTITIONS_DEVIATION, "0.25"), |
| DDui1__(NUMBER_OF_ROWS_PARALLEL_THRESHOLD, "5000"), |
| DDui1__(NUMBER_OF_USERS, "1"), |
| DDui1__(NUM_OF_BLOCKS_PER_ACCESS, "SYSTEM"), |
| DDflt0_(NUM_OF_PARTS_DEVIATION_TYPE2_JOINS, "SYSTEM"), |
| |
| DDkwd__(NVCI_PROCESS, "FALSE"), |
| DDflt0_(OCB_COST_ADJSTFCTR, "0.996"), |
| DDui___(OCR_FOR_SIDETREE_INSERT, "1"), |
| |
| DDkwd__(ODBC_PROCESS, "FALSE"), |
| |
| DDflte_(OHJ_BMO_REUSE_SORTED_BMOFACTOR_LIMIT, "3.0"), |
| DDflte_(OHJ_BMO_REUSE_SORTED_UECRATIO_UPPERLIMIT, "0.7"), |
| DDflte_(OHJ_BMO_REUSE_UNSORTED_UECRATIO_UPPERLIMIT, "0.01"), |
| DDflte_(OHJ_VBMOLIMIT, "5.0"), |
| |
| DDui1__(OLAP_BUFFER_SIZE, "262144"), // Do not alter (goes to DP2) |
| DDkwd__(OLAP_CAN_INVERSE_ORDER, "ON"), |
| DDui1__(OLAP_MAX_FIXED_WINDOW_EXTRA_BUFFERS, "2"), |
| DDui1__(OLAP_MAX_FIXED_WINDOW_FRAME, "50000"), |
| DDui1__(OLAP_MAX_NUMBER_OF_BUFFERS, "100000"), |
| DDui___(OLAP_MAX_ROWS_IN_OLAP_BUFFER, "0"), |
| |
| //aplies for fixed window-- number of additional oplap buffers |
| //to allocate on top of the minumum numbers |
| |
| DDkwd__(OLD_HASH2_GROUPING, "FALSE"), |
| |
| DDkwd__(OLT_QUERY_OPT, "ON"), |
| DDkwd__(OLT_QUERY_OPT_LEAN, "OFF"), |
| |
| // ----------------------------------------------------------------------- |
| // Optimizer pruning heuristics. |
| // ----------------------------------------------------------------------- |
| DDkwd__(OPH_EXITHJCRCONTCHILOOP, "ON"), |
| DDkwd__(OPH_EXITMJCRCONTCHILOOP, "ON"), |
| DDkwd__(OPH_EXITNJCRCONTCHILOOP, "OFF"), |
| DDkwd__(OPH_PRUNE_WHEN_COST_LIMIT_EXCEEDED, "OFF"), |
| DDflt__(OPH_PRUNING_COMPLEXITY_THRESHOLD, "10.0"), |
| DDflt__(OPH_PRUNING_PASS2_COST_LIMIT, "-1.0"), |
| DDkwd__(OPH_REDUCE_COST_LIMIT_FROM_CANDIDATES, "OFF"), |
| DDkwd__(OPH_REDUCE_COST_LIMIT_FROM_PASS1_SOLUTION, "ON"), |
| DDkwd__(OPH_REUSE_FAILED_PLAN, "ON"), |
| DDkwd__(OPH_REUSE_OPERATOR_COST, "OFF"), |
| DDkwd__(OPH_SKIP_OGT_FOR_SHARED_GC_FAILED_CL, "OFF"), |
| DDkwd__(OPH_USE_CACHED_ELAPSED_TIME, "ON"), |
| DDkwd__(OPH_USE_CANDIDATE_PLANS, "OFF"), |
| DDkwd__(OPH_USE_COMPARE_COST_THRESHOLD, "ON"), |
| DDkwd__(OPH_USE_CONSERVATIVE_COST_LIMIT, "OFF"), |
| DDkwd__(OPH_USE_ENFORCER_PLAN_PROMOTION, "OFF"), |
| DDkwd__(OPH_USE_FAILED_PLAN_COST, "ON"), |
| DDkwd__(OPH_USE_NICE_CONTEXT, "OFF"), |
| DDkwd__(OPH_USE_ORDERED_MJ_PRED, "OFF"), |
| DDkwd__(OPH_USE_PWS_FLAG_FOR_CONTEXT, "OFF"), |
| |
| |
| DDkwd__(OPTIMIZATION_GOAL, "LASTROW"), |
| XDDkwd__(OPTIMIZATION_LEVEL, "3"), |
| DDpct__(OPTIMIZATION_LEVEL_1_CONSTANT_1, "50"), |
| DDpct__(OPTIMIZATION_LEVEL_1_CONSTANT_2, "0"), |
| DDui1__(OPTIMIZATION_LEVEL_1_IMMUNITY_LIMIT, "5000"), |
| DDui1__(OPTIMIZATION_LEVEL_1_MJENUM_LIMIT, "20"), |
| DDui1__(OPTIMIZATION_LEVEL_1_SAFETY_NET, "30000"), |
| DDflt__(OPTIMIZATION_LEVEL_1_SAFETY_NET_MULTIPLE, "3.0"), |
| DDui1__(OPTIMIZATION_LEVEL_1_THRESHOLD, "1000"), |
| DDui1__(OPTIMIZATION_TASKS_LIMIT, "2000000000"), |
| // Optimizer Graceful Termination: |
| // 1=> randomProbabilistic pruning |
| // > 1 pruning based on potential |
| DDui1__(OPTIMIZER_GRACEFUL_TERMINATION, "2"), |
| DDkwd__(OPTIMIZER_HEURISTIC_1, "OFF"), |
| DDkwd__(OPTIMIZER_HEURISTIC_2, "OFF"), |
| DDkwd__(OPTIMIZER_HEURISTIC_3, "OFF"), |
| DDkwd__(OPTIMIZER_HEURISTIC_4, "OFF"), |
| DDkwd__(OPTIMIZER_HEURISTIC_5, "OFF"), |
| |
| // Tells the compiler to print costing information |
| DDkwd__(OPTIMIZER_PRINT_COST, "OFF"), |
| |
| // Tells the compiler to issue a warning with its internal counters |
| DDkwd__(OPTIMIZER_PRINT_INTERNAL_COUNTERS, "OFF"), |
| |
| // Pruning is OFF because of bugs, turn to ON when bugs are fixed |
| // (03/03/98) |
| SDDkwd__(OPTIMIZER_PRUNING, "ON"), |
| DDkwd__(OPTIMIZER_PRUNING_FIX_1, "ON"), //change to ON |
| |
| DDkwd__(OPTIMIZER_SYNTH_FUNC_DEPENDENCIES, "ON"), |
| |
| //OPTS_PUSH_DOWN_DAM made external RV 06/21/01 CR 10-010425-2440 |
| DDui___(OPTS_PUSH_DOWN_DAM, "0"), |
| |
| DDkwd__(ORDERED_HASH_JOIN_CONTROL, "ON"), |
| SDDkwd__(OR_OPTIMIZATION, "ON"), |
| DDkwd__(OR_PRED_ADD_BLOCK_TO_IN_LIST, "ON"), |
| DDkwd__(OR_PRED_KEEP_CAST_VC_UCS2, "ON"), |
| // controls the jump table method of evaluating an or pred. in a scan node |
| // 0 => feature is OFF, positive integer denotes max OR pred that will be |
| // processed through a jump table. |
| DDint__(OR_PRED_TO_JUMPTABLE, "2000"), |
| // controls semijoin method of evaluating an or pred. |
| // 0 => feature is OFF, positive number means if pred do not cover key cols |
| // and jump table is not available, then the transformation is done if |
| // inlist is larger than this value. |
| DDint__(OR_PRED_TO_SEMIJOIN, "100"), |
| // Ratio of tablesize (without application of any preds)to probes below |
| // which semijoin trans. is favoured. |
| DDflt0_(OR_PRED_TO_SEMIJOIN_PROBES_MAX_RATIO, "0.001"), |
| // Minimum table size beyond which semijoin trans. is considered |
| DDint__(OR_PRED_TO_SEMIJOIN_TABLE_MIN_SIZE, "10000"), |
| |
| |
| |
| DDui2__(OS_MESSAGE_BUFFER_SIZE, "32"), |
| // if set to "ansi", datetime output is in ansi format. Currently only |
| // used in special_1 mode if the caller needs datetime value in |
| // ansi format (like, during upd stats). |
| DDansi_(OUTPUT_DATE_FORMAT, ""), |
| |
| // Overflow mode for scratch files |
| DDkwd__(OVERFLOW_MODE, "DISK"), |
| |
| // Sequence generator override identity values |
| DDkwd__(OVERRIDE_GENERATED_IDENTITY_VALUES, "OFF"), |
| |
| // allow users to specify a source schema to be |
| // replaced by a target schema |
| SDDosch_(OVERRIDE_SCHEMA, ""), |
| |
| // Allows users to specify their own SYSKEY value. In other words |
| // the system does not generate one for them. |
| |
| // Prior to this CQD, pm_regenerate_syskey_for_insert was being used |
| // to preserve the syskey. Carrying over these comments from |
| // pm_regenerate_syskey_for_insert |
| // For audited target partition, PM does the copy in multiple transactions |
| // In each transaction PM does a insert/select from the source to the target |
| // partition. The clustering key values from the last row of a transaction |
| // is used as begin key value for the next transaction. If the table |
| // has a syskey then it gets regenerated and last row contains the new |
| // value for the syskey. This obviously causes us to start at a different |
| // place then we intended to start from. The following default when set |
| // to off forces the engine to not regenerate syskey. |
| |
| DDkwd__(OVERRIDE_SYSKEY, "OFF"), |
| |
| DDui___(PARALLEL_ESP_NODEMASK, "0"), |
| |
| // by default all parallelism heuristics are switched ON. |
| DDkwd__(PARALLEL_HEURISTIC_1, "ON"), |
| DDkwd__(PARALLEL_HEURISTIC_2, "ON"), |
| DDkwd__(PARALLEL_HEURISTIC_3, "ON"), |
| DDkwd__(PARALLEL_HEURISTIC_4, "ON"), |
| |
| // If PARALLEL_NUM_ESPS is "SYSTEM", |
| // optimizer will compute the number of ESPs. |
| XDDui1__(PARALLEL_NUM_ESPS, "SYSTEM"), |
| |
| |
| // is partial sort applicable; if so adjust sort cost accordingly |
| DDflt0_(PARTIAL_SORT_ADJST_FCTR, "1"), |
| |
| DDint__(PARTITIONING_SCHEME_SHARING, "1"), |
| |
| // The optimal number of partition access nodes for a process. |
| // NOTE: Setting this to anything other than 1 will cause problems |
| // with Cascades plan stealing! Don't do it unless you have to! |
| DDui1__(PARTITION_ACCESS_NODES_PER_ESP, "1"), |
| |
| DD_____(PCODE_DEBUG_LOGDIR, "" ), // Pathname of log directory for PCode work |
| DDint__(PCODE_EXPR_CACHE_CMP_ONLY, "0" ), // PCode Expr Cache compare-only mode |
| DDint__(PCODE_EXPR_CACHE_DEBUG, "0" ), // PCode Expr Cache debug (set to 1 to enable dbg logging) |
| DDint__(PCODE_EXPR_CACHE_ENABLED, "0" ), // PCode Expr Cache Enabled (set to 0 to disable the cache) |
| DD0_10485760(PCODE_EXPR_CACHE_SIZE,"2000000"), // PCode Expr Cache Max Size |
| |
| // Maximum number of PCODE Branch Instructions in an Expr |
| // for which we will attempt PCODE optimizations. |
| // NOTE: Default value reduced to 12000 for Trafodion to avoid stack |
| // overflow in PCODE optimization where recursion is used. |
| DDint__(PCODE_MAX_OPT_BRANCH_CNT, "12000"), |
| |
| // Maximum number of PCODE Instructions in an Expr |
| // for which we will attempt PCODE optimizations. |
| DDint__(PCODE_MAX_OPT_INST_CNT, "50000"), |
| |
| DDint__(PCODE_NE_DBG_LEVEL, "-1"), // Native Expression Debug Level |
| DDint__(PCODE_NE_ENABLED, "1" ), // Native Expressions Enabled |
| DDkwd__(PCODE_NE_IN_SHOWPLAN, "ON"), // Native Expression in Showplan output |
| |
| |
| DDint__(PCODE_OPT_FLAGS, "60"), |
| |
| DDkwd__(PCODE_OPT_LEVEL, "MAXIMUM"), |
| |
| DDint__(PHY_MEM_CONTINGENCY_MB, "3072"), |
| |
| DDkwd__(PLAN_STEALING, "ON"), |
| |
| // Partition OVerlay Support (POS) options |
| SDDkwd__(POS, "DISK_POOL"), |
| DD_____(POS_DISKS_IN_SEGMENT, ""), |
| DD_____(POS_DISK_POOL, "0"), |
| SDDui___(POS_NUM_DISK_POOLS, "0"), |
| DDui___(POS_NUM_OF_PARTNS, "SYSTEM"), |
| SDDint__(POS_NUM_OF_TEMP_TABLE_PARTNS, "SYSTEM"), |
| SDDpos__(POS_TEMP_TABLE_SIZE, ""), |
| DDui___(POS_TEST_NUM_NODES, "0"), |
| |
| // Use info from right child to require order on left child of NJ |
| //PREFERRED_PROBING_ORDER_FOR_NESTED_JOIN made external RV 06/21/01 CR 10-010425-2440 |
| |
| DDkwd__(PREFERRED_PROBING_ORDER_FOR_NESTED_JOIN, "OFF"), |
| |
| DD0_18(PRESERVE_MIN_SCALE, "0"), |
| |
| DDkwd__(PRIMARY_KEY_CONSTRAINT_DROPPABLE_OPTION, "OFF"), |
| DDkwd__(PSHOLD_CLOSE_ON_ROLLBACK, "OFF"), |
| DDkwd__(PSHOLD_UPDATE_BEFORE_FETCH, "OFF"), |
| SDDpsch_(PUBLIC_SCHEMA_NAME, ""), |
| |
| |
| // Query Invalidation - Debug/Regression test CQDs -- DO NOT externalize these |
| DD_____(QI_PATH, "" ), // Specifies cat.sch.object path for object to have cache entries removed |
| DD0_255(QI_PRIV, "0"), // Note: 0 disables the Debug Mechanism. Set non-zero to kick out cache entries. |
| // Then set back to 0 *before* setting to a non-zero value again. |
| |
| // Do the query analysis phase |
| DDkwd__(QUERY_ANALYSIS, "ON"), |
| |
| // query_cache max should be 200 MB. Set it 0 to turn off query cache |
| //XDD0_200000(QUERY_CACHE, "0"), |
| XDD0_200000(QUERY_CACHE, "16384"), |
| |
| // the initial average plan size (in kbytes) to use for configuring the |
| // number of hash buckets to use for mxcmp's hash table of cached plans |
| DD1_200000(QUERY_CACHE_AVERAGE_PLAN_SIZE, "30"), |
| |
| // literals longer than this are not parameterized |
| DDui___(QUERY_CACHE_MAX_CHAR_LEN, "32000"), |
| |
| // a query with more than QUERY_CACHE_MAX_EXPRS ExprNodes is not cacheable |
| DDint__(QUERY_CACHE_MAX_EXPRS, "1000"), |
| |
| // the largest number of cache entries that an unusually large cache |
| // entry is allowed to displace from mxcmp's cache of query plans |
| DD0_200000(QUERY_CACHE_MAX_VICTIMS, "10"), |
| DD0_255(QUERY_CACHE_REQUIRED_PREFIX_KEYS, "255"), |
| DDkwd__(QUERY_CACHE_RUNTIME, "ON"), |
| SDDflt0_(QUERY_CACHE_SELECTIVITY_TOLERANCE, "0"), |
| |
| // query cache statement pinning is off by default |
| DDkwd__(QUERY_CACHE_STATEMENT_PINNING, "OFF"), |
| DDkwd__(QUERY_CACHE_STATISTICS, "OFF"), |
| DD_____(QUERY_CACHE_STATISTICS_FILE, "qcachsts"), |
| DDkwd__(QUERY_CACHE_TABLENAME, "OFF"), |
| DDkwd__(QUERY_CACHE_USE_CONVDOIT_FOR_BACKPATCH, "ON"), |
| |
| // Limit CPU time a query can use in master or any ESP. Unit is seconds. |
| XDDint__(QUERY_LIMIT_SQL_PROCESS_CPU, "0"), |
| // Extra debugging info for QUERY_LIMIT feature. |
| DDkwd__(QUERY_LIMIT_SQL_PROCESS_CPU_DEBUG, "OFF"), |
| // For X-prod HJ: (# of rows joined * LIMIT) before preempt. |
| DDint__(QUERY_LIMIT_SQL_PROCESS_CPU_XPROD, "10000"), |
| // controls various expr optimizations based on bit flags. |
| // see enum QueryOptimizationOptions in DefaultConstants.h |
| DDint__(QUERY_OPTIMIZATION_OPTIONS, "3"), |
| DDkwd__(QUERY_STRATEGIZER, "ON"), |
| DDkwd__(QUERY_TEMPLATE_CACHE, "ON"), |
| DDkwd__(QUERY_TEXT_CACHE, "SYSTEM"), |
| |
| DDkwd__(R2_HALLOWEEN_SUPPORT, "OFF"), |
| |
| DDkwd__(RANGESPEC_TRANSFORMATION, "ON"), // RangeSpec Transformation CQD. |
| // To be ANSI compliant you would have to set this default to 'FALSE' |
| DDkwd__(READONLY_CURSOR, "TRUE"), |
| |
| DDflt0_(READ_AHEAD_MAX_BLOCKS, "16.0"), |
| // OFF means Ansi/NIST setting, ON is more similar to the SQL/MP behavior |
| DDkwd__(RECOMPILATION_WARNINGS, "OFF"), |
| // CLI caller to redrive CTAS(create table as) for child query monitoring |
| DDkwd__(REDRIVE_CTAS, "OFF"), |
| // The group by reduction for pushing a partial group by past the |
| // right side of the TSJ must be at least this much. If 0.0, then |
| // pushing it will always be tried. |
| DDflt0_(REDUCTION_TO_PUSH_GB_PAST_TSJ, "0.0000000001"), |
| // This is the code base for the calibration machine. It must be either |
| // "DEBUG" or "RELEASE" |
| // History: |
| // Before 02/01/99: DEBUG |
| |
| DDkwd__(REFERENCE_CODE, "RELEASE"), |
| |
| // This is the frequency of the representative CPU of the base calibration |
| // cluster. |
| // REFERENCE_CPU_FREQUENCY units are MhZ |
| DDflte_(REFERENCE_CPU_FREQUENCY, "199."), |
| |
| // This is the seek time of the representative disk of the base |
| // calibration cluster. |
| // REFERENCE_IO_SEEK_TIME units are seconds |
| DDflte_(REFERENCE_IO_SEEK_TIME, "0.0038"), |
| |
| // This is the sequential transfer rate for the representative |
| // disk of the base calibration cluster. |
| // REFERENCE_IO_SEQ_READ_RATE units are Mb/Sec |
| DDflte_(REFERENCE_IO_SEQ_READ_RATE, "50.0"), |
| |
| // This is the transfer rate for the fast speed connection of |
| // nodes in the base calibration cluster. |
| // REFERENCE_MSG_LOCAL_RATE units are Mb/Sec |
| DDflte_(REFERENCE_MSG_LOCAL_RATE, "10."), |
| |
| // This is the timeper local msg for the fast speed connection of |
| // nodes in the base calibration cluster. |
| // REFERENCE_MSG_LOCAL_TIME units are seconds |
| DDflte_(REFERENCE_MSG_LOCAL_TIME, "0.000125"), |
| |
| // This is the transfer rate for the connection among clusters |
| // in the base calibration cluster (this only applies to NSK) |
| // REFERENCE_MSG_REMOTE_RATE units are Mb/Sec |
| DDflte_(REFERENCE_MSG_REMOTE_RATE, "1."), |
| |
| // This is the time per remote msg for the fast speed connection of |
| // nodes in the base calibration cluster. |
| // REFERENCE_MSG_REMOTE_TIME units are seconds |
| DDflte_(REFERENCE_MSG_REMOTE_TIME, "0.00125"), |
| DDkwd__(REF_CONSTRAINT_NO_ACTION_LIKE_RESTRICT, "SYSTEM"), |
| |
| |
| |
| DDrlis_(REPLICATE_ALLOW_ROLES, ""), |
| // Determines the compression type to be used with DDL when replicating |
| DDkwd__(REPLICATE_COMPRESSION_TYPE, "SYSTEM"), |
| // Determines if DISK POOL setting should be passed with DDL when replicating |
| DDkwd__(REPLICATE_DISK_POOL, "ON"), |
| // VERSION of the message from the source system to maintain compatibility |
| // This version should be same as REPL_IO_VERSION_CURR in executor/ExeReplInterface.h |
| // Make changes accordingly in validataorReplIoVersion validator |
| DDrver_(REPLICATE_IO_VERSION, "17"), |
| |
| |
| |
| |
| DDkwd__(REUSE_BASIC_COST, "ON"), |
| |
| // if set, tables are not closed at the end of a query. This allows |
| // the same open to be reused for the next query which accesses that |
| // table. |
| // If the table is shared opened by multiple openers from the same |
| // process, then the share count is decremented until it reaches 1. |
| // At that time, the last open is preserved so it could be reused. |
| // Tables are closed if user id changes. |
| DDkwd__(REUSE_OPENS, "ON"), |
| |
| // multiplicative factor used to inflate cost of risky operators. |
| // = 1.0 means do not demand an insurance premium from risky operators. |
| // = 1.2 means demand a 20% insurance premium that cost of risky operators |
| // must overcome before they will be chosen over less-risky operators. |
| DDflt0_(RISK_PREMIUM_MJ, "1.15"), |
| XDDflt0_(RISK_PREMIUM_NJ, "1.0"), |
| XDDflt0_(RISK_PREMIUM_SERIAL, "1.0"), |
| XDDui___(RISK_PREMIUM_SERIAL_SCALEBACK_MAXCARD_THRESHOLD, "10000"), |
| |
| DDflt0_(ROBUST_HJ_TO_NJ_FUDGE_FACTOR, "0.0"), |
| DDflt0_(ROBUST_PAR_GRPBY_EXCHANGE_FCTR, "0.25"), |
| DDflt0_(ROBUST_PAR_GRPBY_LEAF_FCTR, "0.25"), |
| |
| |
| // external master CQD that sets following internal CQDs |
| // robust_query_optimization |
| // MINIMUM SYSTEM HIGH MAXIMUM |
| // risk_premium_NJ 1.0 system 2.5 5.0 |
| // risk_premium_SERIAL 1.0 system 1.5 2.0 |
| // partitioning_scheme_sharing 0 system 2 2 |
| // robust_hj_to_nj_fudge_factor 0.0 system 3.0 1.0 |
| // robust_sortgroupby 0 system 2 2 |
| // risk_premium_MJ 1.0 system 1.5 2.0 |
| // see optimizer/ControlDB.cpp ControlDB::doRobustQueryOptimizationCQDs |
| // for the actual cqds that set these values |
| XDDkwd__(ROBUST_QUERY_OPTIMIZATION, "SYSTEM"), |
| |
| // 0: allow sort group by in all |
| // 1: disallow sort group by from partial grpByRoot if no order requirement |
| // 2: disallow sort group by from partial grpByRoot |
| // 3: disallow sort group by in ESP |
| DDint__(ROBUST_SORTGROUPBY, "1"), |
| |
| SDDui___(ROUNDING_MODE, "0"), |
| |
| DDui___(ROUTINE_CACHE_SIZE, "20"), |
| |
| // UDF default Uec |
| DDui___(ROUTINE_DEFAULT_UEC, "1"), |
| |
| DDkwd__(ROUTINE_JOINS_SPOIL_JBB, "OFF"), |
| DDkwd__(ROWSET_ROW_COUNT, "OFF"), |
| DDint__(SAP_KEY_NJ_TABLE_SIZE_THRESHOLD, "10000000"), |
| DDkwd__(SAP_PREFER_KEY_NESTED_JOIN, "OFF"), |
| DDint__(SAP_TUPLELIST_SIZE_THRESHOLD, "5000"), |
| XDDansi_(SCHEMA, "SEABASE"), |
| //specify a : separated list of full path names where scratch files |
| //should reside. Ensure each specified directoy exisst on each node and |
| //Trafodion user has permissions to access them. |
| DD_____(SCRATCH_DIRS, ""), |
| DDkwd__(SCRATCH_DISK_LOGGING, "OFF"), |
| SDDpct__(SCRATCH_FREESPACE_THRESHOLD_PERCENT, "1"), |
| DDui___(SCRATCH_IO_BLOCKSIZE_SORT_MAX, "5242880"), |
| //On LINUX, writev and readv calls are used to perform |
| //scratch file IO. This CQD sets the vector size to use |
| //in writev and readv calls. Overall IO size is affected |
| //by this cqd. Also, related cqds that are related to |
| //IO size are: COMP_INT_67, GEN_HGBY_BUFFER_SIZE. |
| //GEN_HSHJ_BUFFER_SIZE, OLAP_BUFFER_SIZE, |
| //EXE_HGB_INITIAL_HT_SIZE. Vector size is no-op on other |
| //platforms. |
| DDui___(SCRATCH_IO_VECTOR_SIZE_HASH, "8"), |
| DDui___(SCRATCH_IO_VECTOR_SIZE_SORT, "1"), |
| DDui___(SCRATCH_MAX_OPENS_HASH, "1"), |
| DDui___(SCRATCH_MAX_OPENS_SORT, "1"), |
| DDui___(SCRATCH_MGMT_OPTION, "11"), |
| DDkwd__(SCRATCH_PREALLOCATE_EXTENTS, "OFF"), |
| |
| DD_____(SEABASE_CATALOG, TRAFODION_SYSCAT_LIT), |
| |
| DDkwd__(SEABASE_VOLATILE_TABLES, "ON"), |
| |
| // SeaMonster messaging -- the default can be ON, OFF, or SYSTEM. |
| // When the default is SYSTEM we take the setting from env var |
| // SQ_SEAMONSTER which will have a value of 0 or 1. |
| DDkwd__(SEAMONSTER, "SYSTEM"), |
| |
| // If the inner table of a semi-join has fewer rows than this, |
| // we'll allow it to be transformed to a join. |
| DDflt1_(SEMIJOIN_TO_INNERJOIN_INNER_ALLOWANCE, "100.0"), |
| // Ratio of right child cardinality to uec above which semijoin |
| // trans. is favored. |
| DDflt1_(SEMIJOIN_TO_INNERJOIN_REDUCTION_RATIO, "5.0"), |
| SDDkwd__(SEMIJOIN_TO_INNERJOIN_TRANSFORMATION, "SYSTEM"), |
| // Disallow/Allow semi and anti-semi joins in MultiJoin framework |
| DDkwd__(SEMI_JOINS_SPOIL_JBB, "OFF"), |
| |
| |
| DDansi_(SESSION_ID, ""), |
| |
| DDkwd__(SESSION_IN_USE, "OFF"), |
| |
| DDansi_(SESSION_USERNAME, ""), |
| |
| DDflt0_(SGB_CPUCOST_INITIALIZE, ".05"), |
| DDui___(SGB_INITIAL_BUFFER_COUNT, "5."), |
| DDui1__(SGB_INITIAL_BUFFER_SIZE, "5."), |
| DDkwd__(SHARE_TEMPLATE_CACHED_PLANS, "ON"), |
| DDui___(SHORT_OPTIMIZATION_PASS_THRESHOLD, "12"), |
| |
| SDDkwd__(SHOWCONTROL_SHOW_ALL, "OFF"), |
| SDDkwd__(SHOWCONTROL_SHOW_SUPPORT, "OFF"), |
| DDkwd__(SHOWDDL_DISPLAY_FORMAT, "EXTERNAL"), |
| DDkwd__(SHOWDDL_DISPLAY_PRIVILEGE_GRANTS, "SYSTEM"), |
| DDint__(SHOWDDL_FOR_REPLICATE, "0"), |
| DDkwd__(SHOWWARN_OPT, "ON"), |
| |
| DDkwd__(SIMPLE_COST_MODEL, "ON"), |
| |
| XDDkwd__(SKEW_EXPLAIN, "ON"), |
| XDDflt__(SKEW_ROWCOUNT_THRESHOLD, "1000000"), // Column row count |
| // threshold below |
| // which skew |
| // buster is disabled. |
| XDDflt__(SKEW_SENSITIVITY_THRESHOLD, "0.1"), |
| |
| DDkwd__(SKIP_UNAVAILABLE_PARTITION, "OFF"), |
| |
| |
| DDui0_5(SOFT_REQ_HASH_TYPE, "2"), |
| DDkwd__(SORT_ALGO, "QS"), |
| // Calibration |
| // 01/23/98: 10000 |
| // Original: 10. |
| DDflt0_(SORT_CPUCOST_INITIALIZE, "10000."), |
| |
| DDui1__(SORT_EX_BUFFER_SIZE, "5."), |
| DDkwd__(SORT_INTERMEDIATE_SCRATCH_CLEANUP, "ON"), |
| DDui1__(SORT_IO_BUFFER_SIZE, "128."), |
| |
| DD1_200000(SORT_MAX_HEAP_SIZE_MB, "800"), |
| DDkwd__(SORT_MEMORY_QUOTA_SYSTEM, "ON"), |
| DD1_128(SORT_MERGE_BUFFER_UNIT_56KB, "1"), |
| |
| // Calibration |
| // 04/06/2005: 1.5 |
| DDflte_(SORT_QS_FACTOR, "1.5"), |
| |
| //Maximum records after which sort would switch over to |
| //iterative heap sort. Most often in partial sort, we may want |
| //do a quick sort or similar to avoid larger in-memory sort |
| //setup. |
| DDint__(SORT_REC_THRESHOLD, "1000"), |
| |
| // Calibration |
| DDflte_(SORT_RS_FACTOR, "3.55"), |
| // Calibration |
| // 04/06/2005: 2.1 |
| DDflte_(SORT_RW_FACTOR, "2.1"), |
| |
| DDflte_(SORT_TREE_NODE_SIZE, ".012"), |
| |
| DDkwd__(SQLMX_REGRESS, "OFF"), |
| SDDui___(SSD_BMO_MAX_MEM_THRESHOLD_IN_MB, "1200"), |
| |
| // BertBert VV |
| // Timeout for a streaming cursor to return to the fetch(), even if no |
| // rows to return. The cursor is NOT closed, it just gives control to |
| // the user again. |
| // "0" means no timeout, just check instead. |
| // "negative" means never timeout. |
| // "positive" means the number of centiseconds to wait before timing out. |
| XDDint__(STREAM_TIMEOUT, "-1"), |
| |
| XDDkwd__(SUBQUERY_UNNESTING, "ON"), |
| DDkwd__(SUBQUERY_UNNESTING_P2, "ON"), |
| DDkwd__(SUBSTRING_TRANSFORMATION, "OFF"), |
| |
| DDkwd__(SUPPRESS_CHAR_LIMIT_CHECK, "OFF"), |
| XDDkwd__(TABLELOCK, "SYSTEM"), |
| |
| // This is the code base for the end user calibration cluster. |
| // It must be either "DEBUG" or "RELEASE" |
| #ifdef NDEBUG |
| DDkwd__(TARGET_CODE, "RELEASE"), |
| #else |
| DDkwd__(TARGET_CODE, "DEBUG"), |
| #endif |
| // This is the frequency of the representative CPU of the end user |
| // cluster. |
| // TARGET_CPU_FREQUENCY units are MhZ. |
| DDflte_(TARGET_CPU_FREQUENCY, "199."), |
| |
| // This is the seek time of the representative disk of the end user |
| // cluster. |
| // TARGET_IO_SEEK_TIME units are seconds |
| DDflte_(TARGET_IO_SEEK_TIME, "0.0038"), |
| |
| // This is the sequential transfer rate for the representative |
| // disk of the end user cluster. |
| // TARGET_IO_SEQ_READ_RATE units are Mb/Sec |
| DDflte_(TARGET_IO_SEQ_READ_RATE, "50.0"), |
| |
| // This is the transfer rate for the fast speed connection of |
| // nodes in the end user cluster. |
| // TARGET_MSG_LOCAL_RATE units are Mb/Sec |
| DDflte_(TARGET_MSG_LOCAL_RATE, "10."), |
| |
| // This is the per msg time for the fast speed connection of |
| // nodes in the end user cluster. |
| // TARGET_MSG_LOCAL_TIME are seconds |
| DDflte_(TARGET_MSG_LOCAL_TIME, "0.000125"), |
| |
| // This is the transfer rate for the connection among clusters |
| // in the end user cluster (this only applies to NSK) |
| // TARGET_MSG_REMOTE_RATE units are Mb/Sec |
| DDflte_(TARGET_MSG_REMOTE_RATE, "1."), |
| |
| // This is the per msg time for the the connection among clusters |
| // nodes in the end user cluster. |
| // TARGET_MSG_REMOTE_TIME are seconds |
| DDflte_(TARGET_MSG_REMOTE_TIME, "0.00125"), |
| |
| DDkwd__(TERMINAL_CHARSET, (char *)SQLCHARSETSTRING_ISO88591), |
| |
| DDint__(TEST_PASS_ONE_ASSERT_TASK_NUMBER, "-1"), |
| DDint__(TEST_PASS_TWO_ASSERT_TASK_NUMBER, "-1"), |
| |
| XDDintN2(TIMEOUT, "6000"), |
| |
| DDflt0_(TMUDF_CARDINALITY_FACTOR, "1"), |
| DDflt0_(TMUDF_LEAF_CARDINALITY, "1"), |
| |
| DDkwd__(TOTAL_RESOURCE_COSTING, "ON"), |
| |
| DDkwd__(TRAF_ALIGNED_ROW_FORMAT, "ON"), |
| |
| DDkwd__(TRAF_ALLOW_ESP_COLOCATION, "OFF"), |
| |
| DDkwd__(TRAF_ALLOW_RESERVED_COLNAMES, "OFF"), |
| |
| DDkwd__(TRAF_ALLOW_SELF_REF_CONSTR, "ON"), |
| |
| DDkwd__(TRAF_ALTER_ADD_PKEY_AS_UNIQUE_CONSTRAINT, "OFF"), |
| |
| DDkwd__(TRAF_ALTER_COL_ATTRS, "ON"), |
| |
| DDkwd__(TRAF_AUTO_CREATE_SCHEMA, "OFF"), |
| |
| DDkwd__(TRAF_BLOB_AS_VARCHAR, "ON"), //set to OFF to enable Lobs support |
| |
| DDkwd__(TRAF_BOOLEAN_IO, "OFF"), |
| |
| DDkwd__(TRAF_BOOTSTRAP_MD_MODE, "OFF"), |
| |
| DDkwd__(TRAF_CLOB_AS_VARCHAR, "ON"), //set to OFF to enable Lobs support |
| |
| DDkwd__(TRAF_COL_LENGTH_IS_CHAR, "ON"), |
| |
| DDkwd__(TRAF_CREATE_SIGNED_NUMERIC_LITERAL, "ON"), |
| |
| DDansi_(TRAF_CREATE_TABLE_WITH_UID, ""), |
| |
| DDkwd__(TRAF_CREATE_TINYINT_LITERAL, "ON"), |
| |
| DDkwd__(TRAF_DDL_ON_HIVE_OBJECTS, "ON"), |
| |
| DDkwd__(TRAF_DEFAULT_COL_CHARSET, (char *)SQLCHARSETSTRING_ISO88591), |
| |
| DDkwd__(TRAF_ENABLE_ORC_FORMAT, "OFF"), |
| |
| DDkwd__(TRAF_HBASE_MAPPED_TABLES, "ON"), |
| DDkwd__(TRAF_HBASE_MAPPED_TABLES_IUD, "OFF"), |
| |
| DDkwd__(TRAF_INDEX_ALIGNED_ROW_FORMAT, "ON"), |
| DDkwd__(TRAF_INDEX_CREATE_OPT, "OFF"), |
| |
| DDkwd__(TRAF_LARGEINT_UNSIGNED_IO, "OFF"), |
| |
| DDkwd__(TRAF_LOAD_ALLOW_RISKY_INDEX_MAINTENANCE, "OFF"), |
| DDkwd__(TRAF_LOAD_CONTINUE_ON_ERROR, "OFF"), |
| DD_____(TRAF_LOAD_ERROR_COUNT_ID, "" ), |
| DD_____(TRAF_LOAD_ERROR_COUNT_TABLE, "ERRORCOUNTER" ), |
| DD_____(TRAF_LOAD_ERROR_LOGGING_LOCATION, "/user/trafodion/bulkload/logs" ), |
| DDint__(TRAF_LOAD_FLUSH_SIZE_IN_KB, "1024"), |
| DDkwd__(TRAF_LOAD_FORCE_CIF, "ON"), |
| DDkwd__(TRAF_LOAD_LOG_ERROR_ROWS, "OFF"), |
| DDint__(TRAF_LOAD_MAX_ERROR_ROWS, "0"), |
| DDint__(TRAF_LOAD_MAX_HFILE_SIZE, "10240"), // in MB -->10GB by default |
| |
| DDkwd__(TRAF_LOAD_PREP_ADJUST_PART_FUNC, "ON"), |
| DDkwd__(TRAF_LOAD_PREP_CLEANUP, "ON"), |
| DDkwd__(TRAF_LOAD_PREP_KEEP_HFILES, "OFF"), |
| DDkwd__(TRAF_LOAD_PREP_SKIP_DUPLICATES , "OFF"), |
| |
| //need add code to check if folder exists or not. if not issue an error and ask |
| //user to create it |
| DD_____(TRAF_LOAD_PREP_TMP_LOCATION, "/user/trafodion/bulkload/" ), |
| DDkwd__(TRAF_LOAD_TAKE_SNAPSHOT , "OFF"), |
| DDkwd__(TRAF_LOAD_USE_FOR_INDEXES, "ON"), |
| DDkwd__(TRAF_LOAD_USE_FOR_STATS, "OFF"), |
| |
| DDkwd__(TRAF_MAKE_PKEY_COLUMNS_NOT_NULL, "ON"), |
| |
| // max size in bytes of a char or varchar column. Set to 16M |
| DDui___(TRAF_MAX_CHARACTER_COL_LENGTH, MAX_CHAR_COL_LENGTH_IN_BYTES_STR), |
| DDkwd__(TRAF_MAX_CHARACTER_COL_LENGTH_OVERRIDE, "OFF"), |
| // max size in MB of a row that canbe accomodated in scanner cache when |
| // using th the default scanner cache size. |
| DDint__(TRAF_MAX_ROWSIZE_IN_CACHE, "10"), |
| |
| DDkwd__(TRAF_MULTI_COL_FAM, "ON"), |
| |
| DDkwd__(TRAF_NO_CONSTR_VALIDATION, "OFF"), |
| |
| DDkwd__(TRAF_NO_DTM_XN, "OFF"), |
| |
| DDkwd__(TRAF_NO_HBASE_DROP_CREATE, "OFF"), |
| |
| DDint__(TRAF_NUM_HBASE_VERSIONS, "0"), |
| |
| DDint__(TRAF_NUM_OF_SALT_PARTNS, "-1"), |
| |
| DDkwd__(TRAF_READ_OBJECT_DESC, "OFF"), |
| |
| DDkwd__(TRAF_RELOAD_NATABLE_CACHE, "OFF"), |
| DD_____(TRAF_SAMPLE_TABLE_LOCATION, "/user/trafodion/sample/"), |
| DDint__(TRAF_SEQUENCE_CACHE_SIZE, "-1"), |
| |
| DDint__(TRAF_SEQUENCE_RETRY_TIMES, "100"), |
| |
| DDkwd__(TRAF_SIMILARITY_CHECK, "ROOT"), |
| |
| DDkwd__(TRAF_STORE_OBJECT_DESC, "OFF"), |
| |
| DDkwd__(TRAF_STRING_AUTO_TRUNCATE, "OFF"), |
| DDkwd__(TRAF_STRING_AUTO_TRUNCATE_WARNING, "OFF"), |
| |
| //TRAF_TABLE_SNAPSHOT_SCAN CQD can be set to : |
| //NONE--> Snapshot scan is disabled and regular scan is used , |
| //SUFFIX --> Snapshot scan enabled for the bulk unload (bulk unload |
| // behavior id not changed) |
| //LATEST --> enabled for the scan independently from bulk unload |
| // the latest snapshot is used if it exists |
| DDkwd__(TRAF_TABLE_SNAPSHOT_SCAN, "NONE"), |
| DD_____(TRAF_TABLE_SNAPSHOT_SCAN_SNAP_SUFFIX, "SNAP"), |
| //when the estimated table size is below the threshold (in MBs) |
| //defined by TRAF_TABLE_SNAPSHOT_SCAN_TABLE_SIZE_THRESHOLD |
| //regular scan instead of snapshot scan |
| //does not apply to bulk unload which maintains the old behavior |
| DDint__(TRAF_TABLE_SNAPSHOT_SCAN_TABLE_SIZE_THRESHOLD, "1000"), |
| //timeout before we give up when trying to create the snapshot scanner |
| DDint__(TRAF_TABLE_SNAPSHOT_SCAN_TIMEOUT, "6000"), |
| //location for temporary links and files produced by snapshot scan |
| DD_____(TRAF_TABLE_SNAPSHOT_SCAN_TMP_LOCATION, "/user/trafodion/bulkload/"), |
| |
| DDkwd__(TRAF_TINYINT_INPUT_PARAMS, "OFF"), |
| DDkwd__(TRAF_TINYINT_RETURN_VALUES, "OFF"), |
| DDkwd__(TRAF_TINYINT_SPJ_SUPPORT, "OFF"), |
| DDkwd__(TRAF_TINYINT_SUPPORT, "ON"), |
| |
| // DTM Transaction Type: MVCC, SSCC |
| XDDkwd__(TRAF_TRANS_TYPE, "MVCC"), |
| |
| DD_____(TRAF_UNLOAD_DEF_DELIMITER, "|" ), |
| DD_____(TRAF_UNLOAD_DEF_RECORD_SEPARATOR, "\n" ), |
| DDint__(TRAF_UNLOAD_HDFS_COMPRESS, "0"), |
| DDkwd__(TRAF_UPSERT_ADJUST_PARAMS, "OFF"), |
| DDkwd__(TRAF_UPSERT_MODE, "MERGE"), |
| DDkwd__(TRAF_UPSERT_TO_EFF_TREE, "ON"), |
| DDint__(TRAF_UPSERT_WB_SIZE, "2097152"), |
| DDkwd__(TRAF_UPSERT_WRITE_TO_WAL, "OFF"), |
| |
| DDkwd__(TRAF_USE_REGION_XN, "OFF"), |
| |
| DDkwd__(TRAF_USE_RWRS_FOR_MD_INSERT, "ON"), |
| DDkwd__(TRANSLATE_ERROR, "ON"), |
| DDkwd__(TRANSLATE_ERROR_UNICODE_TO_UNICODE, "ON"), |
| |
| DDkwd__(TRY_DP2_REPARTITION_ALWAYS, "OFF"), |
| |
| SDDkwd__(TRY_PASS_ONE_IF_PASS_TWO_FAILS, "OFF"), |
| |
| // Disallow/Allow TSJs in MultiJoin framework |
| DDkwd__(TSJS_SPOIL_JBB, "OFF"), |
| |
| // type a CASE expression or ValueIdUnion as varchar if its leaves |
| // are of type CHAR of unequal length |
| DDkwd__(TYPE_UNIONED_CHAR_AS_VARCHAR, "ON"), |
| |
| // UDF scalar indicating maximum number of rows out for each row in. |
| DDui___(UDF_FANOUT, "1"), |
| // Must be in form <cat>.<sch>. Delimited catalog names not allowed. |
| DD_____(UDF_METADATA_SCHEMA, "TRAFODION.\"_UDF_\""), |
| |
| DDkwd__(UDF_SUBQ_IN_AGGS_AND_GBYS, "SYSTEM"), |
| |
| XDDui___(UDR_DEBUG_FLAGS, "0"), // see sqludr/sqludr.h for values |
| SDD_____(UDR_JAVA_OPTIONS, "OFF"), |
| DD_____(UDR_JAVA_OPTION_DELIMITERS, " "), |
| XDDui___(UDR_JVM_DEBUG_PORT, "0"), |
| XDDui___(UDR_JVM_DEBUG_TIMEOUT, "0"), |
| |
| DDkwd__(UNAVAILABLE_PARTITION, "STOP"), // "?" used? |
| DDkwd__(UNC_PROCESS, "OFF"), |
| SDDkwd__(UNIQUE_HASH_JOINS, "SYSTEM"), |
| SDDui___(UNIQUE_HASH_JOIN_MAX_INNER_SIZE, "1000"), |
| SDDui___(UNIQUE_HASH_JOIN_MAX_INNER_SIZE_PER_INSTANCE, "100"), |
| SDDui___(UNIQUE_HASH_JOIN_MAX_INNER_TABLES, "2"), |
| DDui___(UNOPTIMIZED_ESP_BUFFER_SIZE_DOWN, "31000"), |
| DDui___(UNOPTIMIZED_ESP_BUFFER_SIZE_UP, "31000"), |
| DDui1__(UPDATED_BYTES_PER_ESP, "400000"), |
| DDkwd__(UPDATE_CLUSTERING_OR_UNIQUE_INDEX_KEY,"ON"), |
| |
| DDkwd__(UPD_ABORT_ON_ERROR, "OFF"), |
| |
| XDDkwd__(UPD_ORDERED, "ON"), |
| |
| DDkwd__(UPD_PARTIAL_ON_ERROR, "OFF"), |
| DDkwd__(UPD_SAVEPOINT_ON_ERROR, "ON"), |
| |
| DDkwd__(USER_EXPERIENCE_LEVEL, "BEGINNER"), |
| |
| // ------------------------------------------------------------------------ |
| // This default will use a new type of an ASSERT, CCMPASSERT as a CMPASSERT |
| // when ON, else use that as a DCMPASSERT. Changed this default to OFF |
| // just before the final build for R2 07/23/2004 RV |
| // ------------------------------------------------------------------------- |
| DDkwd__(USE_CCMPASSERT_AS_CMPASSERT, "OFF"), |
| |
| |
| // Use Hive tables as source for traf ustat and popindex |
| DDkwd__(USE_HIVE_SOURCE, ""), |
| // Use large queues on RHS of Flow/Nested Join when appropriate |
| DDkwd__(USE_LARGE_QUEUES, "ON"), |
| |
| XDDkwd__(USE_LIBHDFS, "OFF"), |
| |
| DDkwd__(USE_MAINTAIN_CONTROL_TABLE, "OFF"), |
| |
| DDkwd__(USE_OLD_DT_CONSTRUCTOR, "OFF"), |
| |
| // Adaptive segmentation, use operator max to determine degree of parallelism |
| DDui___(USE_OPERATOR_MAX_FOR_DOP, "1"), |
| |
| // Specify the number of partitions before invoking parallel label operations |
| DDui1__(USE_PARALLEL_FOR_NUM_PARTITIONS, "32"), |
| |
| DDkwd__(USTAT_ADD_SALTED_KEY_PREFIXES_FOR_MC, "ON"), // When ON, generate MCs for primary key prefixes as well as full key |
| // of salted table when ON EVERY KEY or ON EVERY COLUMN is specified. |
| DDkwd__(USTAT_ATTEMPT_ESP_PARALLELISM, "ON"), // for reading column values |
| DDkwd__(USTAT_AUTOMATIC_LOGGING, "ON"), // OFF gives same semantics as |
| // UPDATE STATISTICS LOG OFF, while |
| // ON gives same semantics as |
| // UPDATE STATISTICS LOG SYSTEM |
| DDui___(USTAT_AUTOMATION_INTERVAL, "0"), |
| DDkwd__(USTAT_AUTO_EMPTYHIST_TWO_TRANS, "OFF"), // When ON empty hist insert will be 2 trans. |
| DDkwd__(USTAT_AUTO_FOR_VOLATILE_TABLES, "OFF"), // Toggle for vol tbl histogram usage |
| DDui1__(USTAT_AUTO_MC_MAX_WIDTH, "10"), // The max columns in an MC histogram for automation. |
| DDui___(USTAT_AUTO_MISSING_STATS_LEVEL, "4"), // Similar to HIST_MISSING_STATS_WARNING_LEVEL, but controls |
| // if automation inserts missing stats to HISTOGRAMS table. |
| // 0 - insert no stats, |
| // 1 - insert single col hists, |
| // 2 - insert all single col hists and MC hists for scans, |
| // 3 - insert all single col hists and MC stats for scans and joins. |
| // 4 - insert all single col hists and MC stats for scans, joins, and groupbys. |
| DDui1__(USTAT_AUTO_READTIME_UPDATE_INTERVAL, "86400"), // Seconds between updates of READ_COUNT. |
| // Should be > CACHE_HISTOGRAMS_REFRESH_INTERVAL. |
| |
| DDkwd__(USTAT_COLLECT_FILE_STATS, "ON"), // do we collect file stats |
| |
| DDkwd__(USTAT_COLLECT_MC_SKEW_VALUES, "OFF"), |
| |
| DDkwd__(USTAT_COMPACT_VARCHARS, "OFF"), // If on, internal sort does not pad out varchars |
| DD_____(USTAT_CQDS_ALLOWED_FOR_SPAWNED_COMPILERS, ""), // list of CQDs that can be pushed to seconday compilers |
| // CQDs are delimited by "," |
| |
| DD_____(USTAT_DEBUG_TEST, ""), |
| DDkwd__(USTAT_DELETE_NO_ROLLBACK, "ON"), // If ON, use DELETE WITH NO ROLLBACK in IUS when updating sample table |
| DDflte_(USTAT_DSHMAX, "50.0"), |
| DDkwd__(USTAT_ESTIMATE_HBASE_ROW_COUNT, "ON"), |
| DDkwd__(USTAT_FETCHCOUNT_ACTIVE, "OFF"), |
| DDkwd__(USTAT_FORCE_MOM_ESTIMATOR, "OFF"), |
| DDkwd__(USTAT_FORCE_TEMP, "OFF"), |
| DDflt0_(USTAT_FREQ_SIZE_PERCENT, "0.5"), // >100 effectively disables |
| DDflt0_(USTAT_GAP_PERCENT, "10.0"), |
| DDflt0_(USTAT_GAP_SIZE_MULTIPLIER, "1.5"), |
| DDui___(USTAT_HBASE_SAMPLE_RETURN_INTERVAL, "10000000"), // Avoid scanner timeout by including on average at |
| // least one row per this many when sampling within HBase. |
| DDflt0_(USTAT_INCREMENTAL_FALSE_PROBABILITY, "0.01"), |
| DDkwd__(USTAT_INCREMENTAL_UPDATE_STATISTICS, "SAMPLE"), // "SAMPLE" ==> don't use Counting Bloom Filters |
| |
| DDkwd__(USTAT_INTERNAL_SORT, "HYBRID"), |
| |
| DDkwd__(USTAT_IS_IGNORE_UEC_FOR_MC, "OFF"), // if MCIS is ON, use IS to compute SC stats |
| DDflt_0_1(USTAT_IS_MEMORY_FRACTION, "0.6"), |
| DDflt0_(USTAT_IUS_INTERVAL_ROWCOUNT_CHANGE_THRESHOLD, "0.05"), |
| DDflt0_(USTAT_IUS_INTERVAL_UEC_CHANGE_THRESHOLD, "0.05"), |
| |
| DDui1_6(USTAT_IUS_MAX_NUM_HASH_FUNCS, "5"), |
| |
| // the max disk space IUS CBFs can use is |
| // MINOF(USTAT_IUS_MAX_PERSISTENT_DATA_IN_MB, |
| // TtotalSpace * USTAT_IUS_MAX_PERSISTENT_DATA_IN_PERCENTAGE) |
| DDui___(USTAT_IUS_MAX_PERSISTENT_DATA_IN_MB, "50000"), // 50GB |
| DDflt0_(USTAT_IUS_MAX_PERSISTENT_DATA_IN_PERCENTAGE, "0.20"), // 20% of the total |
| |
| DDui1_6(USTAT_IUS_MAX_TRANSACTION_DURATION, "5"), // in minutes |
| DDkwd__(USTAT_IUS_NO_BLOCK, "OFF"), |
| DDansi_(USTAT_IUS_PERSISTENT_CBF_PATH, "SYSTEM"), |
| |
| DDflt0_(USTAT_IUS_TOTAL_ROWCOUNT_CHANGE_THRESHOLD, "0.05"), |
| DDflt0_(USTAT_IUS_TOTAL_UEC_CHANGE_THRESHOLD, "0.05"), |
| DDkwd__(USTAT_IUS_USE_PERIODIC_SAMPLING, "OFF"), |
| |
| |
| DDkwd__(USTAT_JIT_LOGGING, "OFF"), |
| DD_____(USTAT_LOG, ""), // if non-empty, gives second qualifier to ustat log file name |
| DDui30_246(USTAT_MAX_CHAR_BOUNDARY_LEN, "30"), // Values can be 30-246. |
| DDui___(USTAT_MAX_CHAR_COL_LENGTH_IN_BYTES, "256"), // When computing UECs, char cols are limited to this many bytes |
| DDflt0_ (USTAT_MAX_CHAR_DATASIZE_FOR_IS, "1000"), // max data size in MB for char type to use |
| XDDui___(USTAT_MAX_READ_AGE_IN_MIN, "5760"), |
| |
| // internal sort without checking UEC. |
| DDflt0_(USTAT_MIN_CHAR_UEC_FOR_IS, "0.2"), // minimum UEC for char type to use internal sort |
| DDflt0_(USTAT_MIN_DEC_BIN_UEC_FOR_IS, "0.0"), // minimum UEC for binary types to use internal sort |
| |
| DDflt0_(USTAT_MIN_ESTIMATE_FOR_ROWCOUNT, "10000000"), |
| XDDui1__(USTAT_MIN_ROWCOUNT_FOR_LOW_SAMPLE, "1000000"), |
| XDDui1__(USTAT_MIN_ROWCOUNT_FOR_SAMPLE, "10000"), |
| DDflt0_(USTAT_MODIFY_DEFAULT_UEC, "0.05"), |
| DDflt0_(USTAT_NAHEAP_ESTIMATED_MAX, "1.3"), // estimated max memory allocation (in GB) feasible with NAHEAP. |
| DDui1__(USTAT_NUM_MC_GROUPS_FOR_KEYS, "10"), |
| DDkwd__(USTAT_PROCESS_GAPS, "ON"), |
| DD0_255(USTAT_RETRY_DELAY, "100"), |
| DD0_255(USTAT_RETRY_LIMIT, "3"), |
| DD0_255(USTAT_RETRY_NEC_COLS_LIMIT, "3"), // by default, use retry for AddNecessaryColumns |
| DDpct__(USTAT_SAMPLE_PERCENT_DIFF, "10"), |
| DDansi_(USTAT_SAMPLE_TABLE_NAME, " "), |
| DDansi_(USTAT_SAMPLE_TABLE_NAME_CREATE, " "), |
| DDkwd__(USTAT_SHOW_MC_INTERVAL_INFO, "OFF"), |
| DDkwd__(USTAT_SHOW_MFV_INFO, "OFF"), |
| DDflte_(USTAT_UEC_HI_RATIO, "0.5"), |
| DDflte_(USTAT_UEC_LOW_RATIO, "0.1"), |
| DDkwd__(USTAT_USE_BACKING_SAMPLE, "OFF"), |
| DDkwd__(USTAT_USE_BULK_LOAD, "OFF"), |
| DDkwd__(USTAT_USE_GROUPING_FOR_SAMPLING, "ON"), |
| DDkwd__(USTAT_USE_INTERNAL_SORT_FOR_MC, "ON"), |
| DDkwd__(USTAT_USE_IS_WHEN_NO_STATS, "ON"), // use IS when no histograms exist for the column |
| DDkwd__(USTAT_USE_SLIDING_SAMPLE_RATIO, "ON"), // Trend sampling rate down w/increasing table size, going |
| // flat at 1%. |
| XDDflt1_(USTAT_YOULL_LIKELY_BE_SORRY, "100000000"), // guard against unintentional long-running UPDATE STATS |
| |
| DDkwd__(VALIDATE_VIEWS_AT_OPEN_TIME, "OFF"), |
| |
| //this is the default length of a param which is typed as a VARCHAR. |
| DD1_4096(VARCHAR_PARAM_DEFAULT_SIZE, "255"), |
| |
| // allows pcodes for varchars |
| DDkwd__(VARCHAR_PCODE, "ON"), |
| |
| DDansi_(VOLATILE_CATALOG, ""), |
| |
| DDkwd__(VOLATILE_SCHEMA_IN_USE, "OFF"), |
| |
| // if this is set to ON or SYSTEM, then find a suitable key among all the |
| // columns of a volatile table. |
| // If this is set to OFF, and there is no user specified primary key or |
| // store by clause, then make the first column of the volatile table |
| // to be the clustering key. |
| DDkwd__(VOLATILE_TABLE_FIND_SUITABLE_KEY, "SYSTEM"), |
| |
| |
| DDkwd__(VSBB_TEST_MODE, "OFF"), |
| XDDkwd__(WMS_CHILD_QUERY_MONITORING, "OFF"), |
| XDDkwd__(WMS_QUERY_MONITORING, "OFF"), |
| // amount of work we are willing to assign per CPU for any query |
| // not running at full system parallelism |
| SDDflte_(WORK_UNIT_ESP, "0.08"), |
| SDDflte_(WORK_UNIT_ESP_DATA_COPY_COST, "0.001"), |
| |
| // ZIG_ZAG_TREES ON means do ZIG_ZAG_TREES |
| // $$$ OFF for beta |
| DDkwd__(ZIG_ZAG_TREES, "SYSTEM"), |
| DDkwd__(ZIG_ZAG_TREES_CONTROL, "OFF") |
| |
| }; |
| |
| // |
| // NOTE: The defDefIx_ array is an array of integers that map |
| // 'enum' values to defaultDefaults[] entries. |
| // The defDefIx_ array could probably be made global static |
| // since all threads should map the same 'enum' values to the |
| // same defaultDefaults[] entries. Such as change is being |
| // left to a future round of optimizations. |
| // |
| static THREAD_P size_t defDefIx_[__NUM_DEFAULT_ATTRIBUTES]; |
| |
| inline static const char *getAttrName(Int32 attrEnum) |
| { |
| return defaultDefaults[defDefIx_[attrEnum]].attrName; |
| } |
| |
| inline static const char *getDefaultDefaultValue(Int32 attrEnum) |
| { |
| return defaultDefaults[defDefIx_[attrEnum]].value; |
| } |
| |
| inline static const DefaultValidator *validator(Int32 attrEnum) |
| { |
| return defaultDefaults[defDefIx_[attrEnum]].validator; |
| } |
| |
| inline static UInt32 getFlags(Int32 attrEnum) |
| { |
| return defaultDefaults[defDefIx_[attrEnum]].flags; |
| } |
| |
| inline static NABoolean isFlagOn(Int32 attrEnum, NADefaultFlags flagbit) |
| { |
| return defaultDefaults[defDefIx_[attrEnum]].flags & (UInt32)flagbit; |
| } |
| |
| inline static void setFlagOn(Int32 attrEnum, NADefaultFlags flagbit) |
| { |
| defaultDefaults[defDefIx_[attrEnum]].flags |= (UInt32)flagbit; |
| } |
| |
| static NABoolean isSynonymOfRESET(NAString &value) |
| { |
| return (value == "RESET"); |
| } |
| |
| static NABoolean isSynonymOfSYSTEM(Int32 attrEnum, NAString &value) |
| { |
| if (value == "") |
| return TRUE; |
| if (value == "SYSTEM") |
| return !isFlagOn(attrEnum, DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| if (value == "ENABLE"){ |
| value = "ON"; |
| return FALSE; |
| } |
| else if (value == "DISABLE"){ |
| value = "OFF"; |
| return FALSE; |
| } |
| // if (getDefaultDefaultValue(attrEnum) != NAString("DISABLE")) // cast reqd!! |
| // return TRUE; |
| // else |
| // value = "ON"; |
| return FALSE; |
| } |
| |
| // Helper class used for holding and restoring CQDs |
| class NADefaults::HeldDefaults |
| { |
| public: |
| |
| HeldDefaults(void); |
| |
| ~HeldDefaults(void); |
| |
| // CMPASSERT's on stack overflow |
| void pushDefault(const char * value); |
| |
| // returns null if nothing to pop |
| char * popDefault(void); |
| |
| private: |
| |
| enum { STACK_SIZE = 3 }; |
| |
| int stackPointer_; |
| char * stackValue_[STACK_SIZE]; |
| |
| }; |
| |
| // Methods for helper class HeldDefaults |
| NADefaults::HeldDefaults::HeldDefaults(void) : stackPointer_(0) |
| { |
| for (int i = 0; i < STACK_SIZE; i++) |
| stackValue_[i] = NULL; |
| } |
| |
| NADefaults::HeldDefaults::~HeldDefaults(void) |
| { |
| for (int i = 0; i < STACK_SIZE; i++) |
| { |
| if (stackValue_[i]) |
| { |
| NADELETEBASIC(stackValue_[i], NADHEAP); |
| } |
| } |
| } |
| |
| // CMPASSERT's on stack overflow |
| void NADefaults::HeldDefaults::pushDefault(const char * value) |
| { |
| CMPASSERT(stackPointer_ < STACK_SIZE); |
| stackValue_[stackPointer_] = new NADHEAP char[strlen(value) + 1]; |
| strcpy(stackValue_[stackPointer_],value); |
| stackPointer_++; |
| } |
| |
| // returns null if nothing to pop |
| char * NADefaults::HeldDefaults::popDefault(void) |
| { |
| char * result = 0; |
| if (stackPointer_ > 0) |
| { |
| stackPointer_--; |
| result = stackValue_[stackPointer_]; |
| stackValue_[stackPointer_] = NULL; |
| } |
| return result; |
| } |
| |
| |
| size_t NADefaults::numDefaultAttributes() |
| { |
| return (size_t)__NUM_DEFAULT_ATTRIBUTES; |
| } |
| |
| // Returns current defaults in alphabetic order (for SHOWCONTROL listing). |
| const char *NADefaults::getCurrentDefaultsAttrNameAndValue( |
| size_t ix, const char* &name, const char* &value, |
| NABoolean userDefaultsOnly) |
| { |
| if (ix < numDefaultAttributes()) { |
| NABoolean get = FALSE; |
| if (userDefaultsOnly) |
| { |
| // if this default was entered by user, return it. |
| get = userDefault(defaultDefaults[ix].attrEnum); |
| } |
| else |
| { |
| // display the control if |
| // - it is externalized or |
| // - it is for support only and a CQD is set to show those, or |
| // - a CQD is set to show all the controls |
| get = |
| (defaultDefaults[ix].flags & DEFAULT_IS_EXTERNALIZED) || // bit-AND |
| ((defaultDefaults[ix].flags & DEFAULT_IS_FOR_SUPPORT) && |
| (getToken(SHOWCONTROL_SHOW_SUPPORT) == DF_ON)) || |
| (getToken(SHOWCONTROL_SHOW_ALL) == DF_ON); |
| } |
| if (get) { |
| name = defaultDefaults[ix].attrName; |
| value = currentDefaults_[defaultDefaults[ix].attrEnum]; |
| return name; |
| } |
| } |
| return name = value = NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // convert the default defaults into a table organized by enum values |
| // ----------------------------------------------------------------------- |
| void NADefaults::initCurrentDefaultsWithDefaultDefaults() |
| { |
| deleteMe(); |
| |
| |
| const size_t numAttrs = numDefaultAttributes(); |
| if (numAttrs != sizeof(defaultDefaults) / sizeof(DefaultDefault)) |
| return; |
| |
| CMPASSERT_STRING |
| (numAttrs == sizeof(defaultDefaults) / sizeof(DefaultDefault), |
| "Check sqlcomp/DefaultConstants.h for a gap in enum DefaultConstants or sqlcomp/nadefaults.cpp for duplicate entries in array defaultDefaults[]."); |
| |
| SqlParser_NADefaults_Glob = |
| SqlParser_NADefaults_ = new NADHEAP SqlParser_NADefaults(); |
| |
| provenances_ = new NADHEAP char [numAttrs]; // enum fits in 2 bits |
| flags_ = new NADHEAP char [numAttrs]; |
| resetToDefaults_ = new NADHEAP char * [numAttrs]; |
| currentDefaults_ = new NADHEAP const char * [numAttrs]; |
| currentFloats_ = new NADHEAP float * [numAttrs]; |
| currentTokens_ = new NADHEAP DefaultToken * [numAttrs]; |
| currentState_ = INIT_DEFAULT_DEFAULTS; |
| heldDefaults_ = new NADHEAP HeldDefaults * [numAttrs]; |
| |
| // reset all entries |
| size_t i = 0; |
| for (i = 0; i < numAttrs; i++) |
| { |
| provenances_[i] = currentState_; |
| flags_[i] = 0; |
| defDefIx_[i] = 0; |
| } |
| |
| memset( resetToDefaults_, 0, sizeof(char *) * numAttrs ); |
| memset( currentDefaults_, 0, sizeof(char *) * numAttrs ); |
| memset( currentFloats_, 0, sizeof(float *) * numAttrs ); |
| memset( currentTokens_, 0, sizeof(DefaultToken *) * numAttrs ); |
| memset( heldDefaults_, 0, sizeof(HeldDefaults *) * numAttrs ); |
| |
| #ifndef NDEBUG |
| // This env-var turns on consistency checking of default-defaults and |
| // other static info. The env-var does not get passed from sqlci to arkdev |
| // until *AFTER* the initialization code runs, so you must do a static |
| // arkcmp compile to do this checking. TEST050 does this, in fact. |
| NABoolean nadval = !!getenv("NADEFAULTS_VALIDATE"); |
| #endif |
| |
| // for each entry of the (alphabetically sorted) default defaults |
| // table, enter the default default into the current default table |
| // which is sorted by enum values |
| NAString prevAttrName; |
| for (i = 0; i < numAttrs; i++) |
| { |
| // the enum must be less than the max (if this assert fails |
| // you might have made the range of constants in the enum |
| // non-contiguous by assigning hard-coded numbers to some entries) |
| CMPASSERT(ENUM_RANGE_CHECK(defaultDefaults[i].attrEnum)); |
| |
| // can't have the same enum value twice in defaultDefaults |
| CMPASSERT(currentDefaults_[defaultDefaults[i].attrEnum] == NULL); |
| |
| // set currentDefaults_[enum] to the static string, |
| // leaving the "allocated from heap" flag as FALSE |
| char * value = new NADHEAP char[strlen(defaultDefaults[i].value) + 1]; |
| strcpy(value,defaultDefaults[i].value); |
| |
| // trim trailing spaces (except UDR_JAVA_OPTION_DELIMITERS, since |
| // trailing space is allowed for it) |
| if (defaultDefaults[i].attrEnum != UDR_JAVA_OPTION_DELIMITERS) |
| { |
| Lng32 len = strlen(value); |
| while ((len > 0) && (value[len-1] == ' ')) |
| { |
| value[len-1] = 0; |
| len--; |
| } |
| } |
| |
| currentDefaults_[defaultDefaults[i].attrEnum] = value; |
| |
| |
| // set up our backlink which maps [enum] to its defaultDefaults entry |
| defDefIx_[defaultDefaults[i].attrEnum] = i; |
| |
| // attrs must be in ascending sorted order. If not, error out. |
| if (prevAttrName > defaultDefaults[i].attrName) |
| { |
| SqlParser_NADefaults_ = NULL; |
| |
| return; |
| } |
| prevAttrName = defaultDefaults[i].attrName; |
| |
| // validate initial default default values |
| CMPASSERT(defaultDefaults[i].validator); |
| if (! defaultDefaults[i].validator->validate( |
| defaultDefaults[i].value, |
| this, |
| defaultDefaults[i].attrEnum, |
| +1/*warning*/)) |
| { |
| SqlParser_NADefaults_ = NULL; |
| |
| cerr << "\nERROR: " << defaultDefaults[i].attrName |
| << " has invalid value" << defaultDefaults[i].value << endl; |
| |
| return; |
| } |
| |
| // for debugging only |
| #ifndef NDEBUG |
| if (nadval) { // additional sanity checking we want to do occasionally |
| |
| NAString v; |
| |
| // ensure the static table really is in alphabetic order |
| CMPASSERT(i == 0 || |
| strcmp(defaultDefaults[i-1].attrName, |
| defaultDefaults[i].attrName) < 0); |
| |
| // ensure these names are fit and trim and in canonical form |
| v = defaultDefaults[i].attrName; |
| TrimNAStringSpace(v); |
| v.toUpper(); |
| CMPASSERT(v == defaultDefaults[i].attrName); |
| |
| // validate initial default default values |
| CMPASSERT(defaultDefaults[i].validator); |
| defaultDefaults[i].validator->validate( |
| defaultDefaults[i].value, |
| this, |
| defaultDefaults[i].attrEnum, |
| +1/*warning*/); |
| |
| // ensure these values are fit and trim and in canonical form |
| v = defaultDefaults[i].value; |
| TrimNAStringSpace(v); |
| defaultDefaults[i].validator->applyUpper(v); |
| CMPASSERT(v == defaultDefaults[i].value); |
| |
| // alert the programmer |
| if (isSynonymOfSYSTEM(defaultDefaults[i].attrEnum, v)) |
| if (v != "" || defaultDefaults[i].validator != &validateAnsiName) |
| cerr << "\nWARNING: " << defaultDefaults[i].attrName |
| << " has SYSTEM default (" |
| << v << ");\n\t read NOTE 2 in " << __FILE__ << endl; |
| if (isSynonymOfRESET(v)) |
| if (v != "" || defaultDefaults[i].validator != &validateAnsiName) |
| cerr << "\nWARNING: " << defaultDefaults[i].attrName |
| << " has RESET default (" |
| << v << ");\n\t this makes no sense!" << endl; |
| if (defaultDefaults[i].validator == &validateUnknown) |
| cerr << "\nWARNING: " << defaultDefaults[i].attrName |
| << " has a NO-OP validator" << endl; |
| |
| // the token keyword array must have no missing strings, |
| // it must also be in alphabetic order, |
| // each entry must be canonical, and |
| // must have no embedded spaces (see token() method, space/uscore...) |
| if (i == 0) |
| for (size_t j = 0; j < DF_lastToken; j++) { |
| CMPASSERT(keywords_[j]); |
| CMPASSERT(j == 0 || strcmp(keywords_[j-1], keywords_[j]) < 0); |
| |
| NAString v(keywords_[j]); |
| TrimNAStringSpace(v); |
| v.toUpper(); // we know keywords must be caseINsens |
| CMPASSERT(v == keywords_[j]); |
| |
| CMPASSERT(v.first(' ') == NA_NPOS); |
| |
| } |
| } // if env-var |
| #endif // NDEBUG |
| |
| } // for i |
| |
| // set the default value for GENERATE_EXPLAIN depending on whether |
| // this is a static compile or a dynamic compile. |
| if (CmpCommon::context()->GetMode() == STMT_STATIC) |
| { |
| currentDefaults_[GENERATE_EXPLAIN] = "ON"; |
| } |
| else |
| { |
| currentDefaults_[GENERATE_EXPLAIN] = "OFF"; |
| currentDefaults_[DETAILED_STATISTICS] = "OPERATOR"; |
| } |
| |
| // set the default value of hive_catalog to the hive_system_catalog |
| currentDefaults_[HIVE_CATALOG] = HIVE_SYSTEM_CATALOG; |
| |
| // set the default value of hbase_catalog to the hbase_system_catalog |
| currentDefaults_[HBASE_CATALOG] = HBASE_SYSTEM_CATALOG; |
| currentDefaults_[SEABASE_CATALOG] = TRAFODION_SYSCAT_LIT; |
| |
| // Test for TM_USE_SSCC from ms.env. |
| // Only a setting of TM_USE_SSCC set to 1 will change the value to SSCC. |
| // Otherwise, the default will remain at MVCC. |
| char * ev = getenv("TM_USE_SSCC"); |
| Lng32 useValue = 0; |
| |
| if (ev) { |
| useValue = (Lng32)str_atoi(ev, str_len(ev)); |
| if (useValue == 1) |
| currentDefaults_[TRAF_TRANS_TYPE] = "SSCC"; |
| } |
| |
| // Begin: Temporary workaround for SQL build regressions to pass |
| NABoolean resetNeoDefaults = FALSE; |
| // On SQ, the way to get an envvar from inside a un-attached process |
| // is to use the msg_getenv_str() call and set the env inside |
| // the SQ_PROP_ property file. In this case the property |
| // file is $TRAF_HOME/etc/SQ_PROP_tdm_arkcmp which contains the line |
| // "SQLMX_REGRESS=1". This file was generated by tools/setuplnxenv. |
| // resetNeoDefaults = (msg_getenv_str("SQLMX_REGRESS") != NULL); |
| resetNeoDefaults = (getenv("SQLMX_REGRESS") != NULL); |
| |
| if(resetNeoDefaults) |
| { |
| |
| // turn on INTERNAL format for SHOWDDL statements |
| currentDefaults_[SHOWDDL_DISPLAY_FORMAT] = "INTERNAL"; |
| } |
| // End: Temporary workaround for SQL build regressions to pass |
| |
| // Cache all the default keywords up front, |
| // leaving other non-keyword token to be cached on demand. |
| // The "keyword" that is not cached is the kludge/clever trick that |
| // Matt puts in for NATIONAL_CHARSET. |
| NAString tmp( NADHEAP ); |
| for ( i = 0; i < numAttrs; i++ ) |
| { |
| #ifndef NDEBUG |
| const DefaultValidatorType validatorType = validator(i)->getType(); |
| #endif |
| |
| if ( validator(i)->getType() == VALID_KWD && (i != NATIONAL_CHARSET) && |
| (i != INPUT_CHARSET) && (i != ISO_MAPPING) ) |
| { |
| currentTokens_[i] = new NADHEAP DefaultToken; |
| |
| // do not call 'token' method as it will return an error if FALSE |
| // is to be inserted. Just directly assign DF_OFF to non-resetable defs. |
| if (isNonResetableAttribute(defaultDefaults[defDefIx_[i]].attrName)) |
| *currentTokens_[i] = DF_OFF; |
| else |
| *currentTokens_[i] = token( i, tmp ); |
| } |
| } |
| |
| if (getToken(MODE_SEABASE) == DF_ON) |
| { |
| currentDefaults_[CATALOG] = TRAFODION_SYSCAT_LIT; |
| |
| if (getToken(SEABASE_VOLATILE_TABLES) == DF_ON) |
| { |
| NAString sbCat = getValue(SEABASE_CATALOG); |
| CmpCommon::context()->sqlSession()->setVolatileCatalogName(sbCat, TRUE); |
| } |
| } |
| |
| SqlParser_NADefaults_->NAMETYPE_ = getToken(NAMETYPE); |
| SqlParser_NADefaults_->NATIONAL_CHARSET_ = |
| CharInfo::getCharSetEnum(currentDefaults_[NATIONAL_CHARSET]); |
| SqlParser_NADefaults_->ISO_MAPPING_ = |
| CharInfo::getCharSetEnum(currentDefaults_[ISO_MAPPING]); |
| SqlParser_NADefaults_->DEFAULT_CHARSET_ = |
| CharInfo::getCharSetEnum(currentDefaults_[DEFAULT_CHARSET]); |
| SqlParser_NADefaults_->ORIG_DEFAULT_CHARSET_ = |
| CharInfo::getCharSetEnum(currentDefaults_[DEFAULT_CHARSET]); |
| |
| // Set the NAString_isoMappingCS memory cache for use by routines |
| // ToInternalIdentifier() and ToAnsiIdentifier[2|3]() in module |
| // w:/common/NAString[2].cpp. These routines currently cannot |
| // access SqlParser_ISO_MAPPING directly due to the complex |
| // build hierarchy. |
| NAString_setIsoMapCS((SQLCHARSET_CODE) SqlParser_NADefaults_->ISO_MAPPING_); |
| |
| } |
| |
| NADefaults::NADefaults(NAMemory * h) |
| : provenances_(NULL) |
| , flags_(NULL) |
| , resetToDefaults_(NULL) |
| , currentDefaults_(NULL) |
| , currentFloats_(NULL) |
| , currentTokens_(NULL) |
| , heldDefaults_(NULL) |
| , currentState_(UNINITIALIZED) |
| , readFromSQDefaultsTable_(FALSE) |
| , SqlParser_NADefaults_(NULL) |
| , catSchSetToUserID_(0) |
| , heap_(h) |
| , resetAll_(FALSE) |
| , defFlags_(0) |
| , tablesRead_(h) |
| { |
| static THREAD_P NABoolean systemParamterUpdated = FALSE; |
| // First (but only if NSK-LITE Services exist), |
| // write system parameters (attributes DEF_*) into DefaultDefaults, |
| if (!systemParamterUpdated && !cmpCurrentContext->isStandalone()) |
| { |
| updateSystemParameters(); |
| systemParamterUpdated = TRUE; |
| } |
| |
| // then copy DefaultDefaults into CurrentDefaults. |
| initCurrentDefaultsWithDefaultDefaults(); |
| |
| // Set additional defaultDefaults flags: |
| |
| // If an attr allows ON/OFF/SYSTEM and the default-default is not SYSTEM, |
| // then you must set this flag. Otherwise, CQD attr 'system' will revert |
| // the value back to the default-default, which is not SYSTEM. |
| // setFlagOn(...attr..., DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| // |
| // (See attESPPara in OptPhysRelExpr.cpp.) |
| setFlagOn(ATTEMPT_ESP_PARALLELISM, DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| setFlagOn(HJ_TYPE, DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| setFlagOn(ZIG_ZAG_TREES, DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| setFlagOn(COMPRESSED_INTERNAL_FORMAT, DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| setFlagOn(COMPRESSED_INTERNAL_FORMAT_BMO, DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| setFlagOn(HBASE_SMALL_SCANNER, DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| } |
| |
| NADefaults::~NADefaults() |
| { |
| deleteMe(); |
| } |
| |
| void NADefaults::deleteMe() |
| { |
| if (resetToDefaults_) { |
| for (size_t i = numDefaultAttributes(); i--; ) |
| NADELETEBASIC(resetToDefaults_[i], NADHEAP); |
| NADELETEBASIC(resetToDefaults_, NADHEAP); |
| } |
| |
| if (currentDefaults_) { |
| for (size_t i = numDefaultAttributes(); i--; ) |
| if (provenances_[i] > INIT_DEFAULT_DEFAULTS) |
| NADELETEBASIC(currentDefaults_[i], NADHEAP); |
| NADELETEBASIC(currentDefaults_, NADHEAP); |
| } |
| |
| if (currentFloats_) { |
| for (size_t i = numDefaultAttributes(); i--; ) |
| NADELETEBASIC(currentFloats_[i], NADHEAP); |
| NADELETEBASIC(currentFloats_, NADHEAP); |
| } |
| |
| if (currentTokens_) { |
| for (size_t i = numDefaultAttributes(); i--; ) |
| NADELETEBASIC(currentTokens_[i], NADHEAP); |
| NADELETEBASIC(currentTokens_, NADHEAP); |
| } |
| |
| if (heldDefaults_) { |
| for (size_t i = numDefaultAttributes(); i--; ) |
| NADELETE(heldDefaults_[i], HeldDefaults, NADHEAP); |
| NADELETEBASIC(heldDefaults_, NADHEAP); |
| } |
| |
| for (CollIndex i = tablesRead_.entries(); i--; ) |
| tablesRead_.removeAt(i); |
| |
| NADELETEBASIC(provenances_, NADHEAP); |
| NADELETEBASIC(flags_, NADHEAP); |
| NADELETE(SqlParser_NADefaults_, SqlParser_NADefaults, NADHEAP); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Find the attribute name from its enum value in the defaults table. |
| // ----------------------------------------------------------------------- |
| const char *NADefaults::lookupAttrName(Int32 attrEnum, |
| Int32 errOrWarn) |
| { |
| if (ATTR_RANGE_CHECK) return getAttrName(attrEnum); |
| |
| static THREAD_P char noSuchAttr[20]; |
| sprintf(noSuchAttr, "**%d**", attrEnum); |
| if (errOrWarn) // $0~string0 is not the name of any DEFAULTS table attribute. |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(2050)) << DgString0(noSuchAttr); |
| return noSuchAttr; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Find the enum value from its string representation in the defaults table. |
| // ----------------------------------------------------------------------- |
| enum DefaultConstants NADefaults::lookupAttrName(const char *name, |
| Int32 errOrWarn, |
| Int32 *position) |
| { |
| NAString attrName(name); |
| TrimNAStringSpace(attrName, FALSE, TRUE); // trim trailing blanks only |
| attrName.toUpper(); |
| |
| // start with the full range of defaultDefaults |
| size_t lo = 0; |
| size_t hi = numDefaultAttributes(); |
| size_t split; |
| Int32 cresult; |
| |
| // perform a binary search in the ordered table defaultDefaults |
| do |
| { |
| // compare the token with the middle entry in the range |
| split = (lo + hi) / 2; |
| cresult = attrName.compareTo(defaultDefaults[split].attrName); |
| |
| if (cresult < 0) |
| { |
| // token < split value, search first half of range |
| hi = split; |
| } |
| else if (cresult > 0) |
| { |
| if (lo == split) // been there, done that |
| { |
| CMPASSERT(lo == hi-1); |
| break; |
| } |
| // token > split value, search second half of range |
| lo = split; |
| } |
| } |
| while (cresult != 0 && lo < hi); |
| |
| if (position != 0) |
| *position = split; |
| |
| // if the last comparison result was equal, return value at "split" |
| if (cresult == 0) |
| return defaultDefaults[split].attrEnum; |
| |
| // otherwise the string has no corresponding enum value |
| if (errOrWarn) // $0~string0 is not the name of any DEFAULTS table attribute. |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(2050)) << DgString0(attrName); |
| return __INVALID_DEFAULT_ATTRIBUTE; // negative |
| } |
| |
| #define WIDEST_CPUARCH_VALUE 30 // also wider than any utoa_() result |
| |
| static void utoa_(UInt32 val, char *buf) { sprintf(buf, "%u", val); } |
| |
| static void itoa_(Int32 val, char *buf) { sprintf(buf, "%d", val); } |
| |
| static void ftoa_(float val, char *buf) |
| { |
| snprintf(buf, WIDEST_CPUARCH_VALUE, "%0.2f", val); |
| } |
| |
| |
| // Updates the system parameters in the defaultDefaults table. |
| void NADefaults::updateSystemParameters(NABoolean reInit) |
| { |
| |
| static const char *arrayOfSystemParameters[] = { |
| "DEF_CPU_ARCHITECTURE", |
| "DEF_DISCS_ON_CLUSTER", |
| "DEF_INSTRUCTIONS_SECOND", |
| "DEF_PAGE_SIZE", |
| "DEF_LOCAL_CLUSTER_NUMBER", |
| "DEF_LOCAL_SMP_NODE_NUMBER", |
| "DEF_NUM_SMP_CPUS", |
| "MAX_ESPS_PER_CPU_PER_OP", |
| "DEFAULT_DEGREE_OF_PARALLELISM", |
| "DEF_NUM_NODES_IN_ACTIVE_CLUSTERS", |
| // this is deliberately not in the list: "DEF_CHUNK_SIZE", |
| "DEF_NUM_BM_CHUNKS", |
| "DEF_PHYSICAL_MEMORY_AVAILABLE", //returned in KB not bytes |
| "DEF_TOTAL_MEMORY_AVAILABLE", //returned in KB not bytes |
| "DEF_VIRTUAL_MEMORY_AVAILABLE" |
| , "USTAT_IUS_PERSISTENT_CBF_PATH" |
| }; //returned in KB not bytes |
| |
| char valuestr[WIDEST_CPUARCH_VALUE]; |
| |
| // Set up global cluster information. |
| setUpClusterInfo(CmpCommon::contextHeap()); |
| |
| // Extract SMP node number and cluster number where this arkcmp is running. |
| short nodeNum = 0; |
| Int32 clusterNum = 0; |
| OSIM_getNodeAndClusterNumbers(nodeNum, clusterNum); |
| |
| // First (but only if NSK-LITE Services exist), |
| // write system parameters (attributes DEF_*) into DefaultDefaults, |
| // then copy DefaultDefaults into CurrentDefaults. |
| if (!cmpCurrentContext->isStandalone()) { |
| |
| size_t numElements = sizeof(arrayOfSystemParameters) / sizeof(char *); |
| for (size_t i = 0; i < numElements; i++) { |
| |
| Int32 j; |
| // perform a lookup for the string, using a binary search |
| lookupAttrName(arrayOfSystemParameters[i], -1, &j); |
| |
| CMPASSERT(j >= 0); |
| |
| if(reInit) |
| NADELETEBASIC(defaultDefaults[j].value,NADHEAP); |
| char *newValue = new (GetCliGlobals()->exCollHeap()) char[WIDEST_CPUARCH_VALUE]; |
| newValue[0] = '\0'; |
| defaultDefaults[j].value = newValue; |
| |
| switch(defaultDefaults[j].attrEnum) { |
| |
| case DEF_CPU_ARCHITECTURE: |
| |
| switch(gpClusterInfo->cpuArchitecture()) { |
| // 123456789!1234567890@123456789 |
| case CPU_ARCH_INTEL_80386: |
| strcpy(newValue, "INTEL_80386"); |
| break; |
| |
| case CPU_ARCH_INTEL_80486: |
| strcpy(newValue, "INTEL_80486"); |
| break; |
| |
| case CPU_ARCH_PENTIUM: |
| strcpy(newValue, "PENTIUM"); |
| break; |
| |
| case CPU_ARCH_PENTIUM_PRO: |
| strcpy(newValue, "PENTIUM_PRO"); |
| break; |
| |
| case CPU_ARCH_MIPS: |
| strcpy(newValue, "MIPS"); |
| break; |
| |
| case CPU_ARCH_ALPHA: |
| strcpy(newValue, "ALPHA"); |
| break; |
| |
| case CPU_ARCH_PPC: |
| strcpy(newValue, "PPC"); |
| break; |
| |
| default: |
| strcpy(newValue, "UNKNOWN"); |
| break; |
| } |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j], FALSE); |
| break; |
| |
| |
| case DEF_DISCS_ON_CLUSTER: |
| strcpy(newValue, "8"); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEF_PAGE_SIZE: |
| utoa_(gpClusterInfo->pageSize(), valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEF_LOCAL_CLUSTER_NUMBER: |
| utoa_(clusterNum, valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEF_LOCAL_SMP_NODE_NUMBER: |
| utoa_(nodeNum, valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEF_NUM_SMP_CPUS: |
| utoa_(gpClusterInfo->numberOfCpusPerSMP(), valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEFAULT_DEGREE_OF_PARALLELISM: |
| { |
| Lng32 x = 2; |
| |
| utoa_(x, valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| } |
| break; |
| |
| case MAX_ESPS_PER_CPU_PER_OP: |
| { |
| float espsPerCore = computeNumESPsPerCore(FALSE); |
| ftoa_(espsPerCore, valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| } |
| break; |
| |
| case DEF_NUM_NODES_IN_ACTIVE_CLUSTERS: |
| |
| utoa_(gpClusterInfo->numOfPhysicalSMPs(), valuestr); |
| strcpy(newValue, valuestr); |
| |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEF_PHYSICAL_MEMORY_AVAILABLE: |
| utoa_(gpClusterInfo->physicalMemoryAvailable(), valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEF_TOTAL_MEMORY_AVAILABLE: |
| utoa_(gpClusterInfo->totalMemoryAvailable(), valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEF_VIRTUAL_MEMORY_AVAILABLE: |
| utoa_(gpClusterInfo->virtualMemoryAvailable(), valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| break; |
| |
| case DEF_NUM_BM_CHUNKS: |
| { |
| UInt32 numChunks = (UInt32) |
| (gpClusterInfo->physicalMemoryAvailable() / def_DEF_CHUNK_SIZE / 4); |
| utoa_(numChunks, valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| } |
| break; |
| |
| case DEF_INSTRUCTIONS_SECOND: |
| { |
| Int32 frequency, speed; |
| frequency = gpClusterInfo->processorFrequency(); |
| |
| switch (gpClusterInfo->cpuArchitecture()) { |
| case CPU_ARCH_PENTIUM_PRO: speed = (Int32) (frequency * 0.5); break; |
| case CPU_ARCH_PENTIUM: speed = (Int32) (frequency * 0.4); break; |
| default: speed = (Int32) (frequency * 0.3); break; |
| } |
| |
| itoa_(speed, valuestr); |
| strcpy(newValue, valuestr); |
| if(reInit) |
| ActiveSchemaDB()-> |
| getDefaults(). |
| updateCurrentDefaultsForOSIM(&defaultDefaults[j]); |
| } |
| break; |
| |
| case USTAT_IUS_PERSISTENT_CBF_PATH: |
| |
| { |
| // set the CQD it to $HOME/cbfs |
| const char* home = getenv("HOME"); |
| |
| if ( home ) { |
| str_cat(home, "/cbfs", newValue); |
| } |
| |
| } |
| break; |
| |
| default: |
| #ifndef NDEBUG |
| cerr << "updateSystemParameters: no case for " |
| << defaultDefaults[j].attrName << endl; |
| #endif |
| break; |
| |
| } // switch (arrayOfSystemParameters) |
| } // for |
| } // isStandalone |
| |
| } // updateSystemParameters() |
| |
| //============================================================================== |
| // Get SMP node number and cluster number on which this arkcmp.exe is running. |
| //============================================================================== |
| void |
| NADefaults::getNodeAndClusterNumbers(short& nodeNum, Int32& clusterNum) |
| { |
| |
| SB_Phandle_Type pHandle; |
| Int32 error = XPROCESSHANDLE_GETMINE_(&pHandle); |
| |
| Int32 nodeNumInt; // XPROCESSHANDLE_DECOMPOSE_ takes an integer. |
| Int32 pin; |
| error = XPROCESSHANDLE_DECOMPOSE_(&pHandle, &nodeNumInt, &pin, &clusterNum); |
| nodeNum = nodeNumInt; // Store 4-byte integer back to short integer |
| |
| |
| CMPASSERT(error == 0); |
| |
| } |
| |
| inline static NABoolean initializeSQLdone() |
| { |
| return FALSE; |
| } |
| |
| // Setup for readFromSQLTable(): |
| // |
| #include "SQLCLIdev.h" |
| |
| const SQLMODULE_ID __SQL_mod_866668761818000 = { |
| /* version */ SQLCLI_CURRENT_VERSION, |
| /* module name */ "HP_SYSTEM_CATALOG.SYSTEM_SCHEMA.READDEF_N29_000", |
| /* time stamp */ 866668761818000LL, |
| /* char set */ "ISO88591", |
| /* name length */ 47 |
| }; |
| |
| static const Int32 MAX_VALUE_LEN = 1000; |
| |
| // Read the SQL defaults table, to layer on further defaults. |
| // |
| // [1] This is designed such that it can be called multiple times |
| // (a site-wide defaults table, then a user-specific one, e.g.) |
| // and by default it will supersede values read/computed from earlier tables. |
| // |
| // [2] It can also be called *after* CQD's have been issued |
| // (e.g. from the getCatalogAndSchema() method) |
| // and by default it will supersede values from earlier tables |
| // but *not* explicitly CQD-ed settings. |
| // |
| // This default behavior is governed by the overwrite* arguments in |
| // various methods (see the .h file). Naturally you can override such behavior, |
| // e.g., if you wanted to reset to an earlier state, erasing all user CQD's. |
| // |
| void NADefaults::readFromSQLTable(const char *tname, |
| Provenance overwriteIfNotYet, |
| Int32 errOrWarn) |
| { |
| char value[MAX_VALUE_LEN + 1]; |
| // CMPASSERT(MAX_VALUE_LEN >= ComMAX_2_PART_EXTERNAL_UCS2_NAME_LEN_IN_NAWCHARS); |
| |
| // First (but only if NSK-LITE Services exist), |
| // write system parameters (attributes DEF_*) into DefaultDefaults, |
| // then copy DefaultDefaults into CurrentDefaults. |
| if (!cmpCurrentContext->isStandalone()) { |
| |
| Lng32 initialErrCnt = CmpCommon::diags()->getNumber(); |
| |
| |
| // Set this *before* doing any insert()'s ... |
| currentState_ = READ_FROM_SQL_TABLE; |
| |
| Int32 loop_here=0; |
| while (loop_here > 10) |
| { |
| loop_here++; |
| if (loop_here > 1000) |
| loop_here=100; |
| } |
| |
| if (tname) { |
| |
| NABoolean isSQLTable = TRUE; |
| if (*tname == ' ') { // called from NADefaults::readFromFlatFile() |
| isSQLTable = FALSE; // -- see kludge in .h file! |
| tname++; |
| } |
| |
| char attrName[101]; // column ATTRIBUTE VARCHAR(100) UPSHIFT |
| Int32 sqlcode; |
| static THREAD_P struct SQLCLI_OBJ_ID __SQL_id0; |
| FILE *flatfile = NULL; |
| |
| if (isSQLTable) { |
| init_SQLCLI_OBJ_ID(&__SQL_id0, SQLCLI_CURRENT_VERSION, cursor_name, |
| &__SQL_mod_866668761818000, "S1", 0, |
| SQLCHARSETSTRING_ISO88591, 2); |
| |
| /* EXEC SQL OPEN S1; See file NADefaults.mdf for cursor declaration */ |
| sqlcode = SQL_EXEC_ClearDiagnostics(&__SQL_id0); |
| sqlcode = SQL_EXEC_Exec(&__SQL_id0,NULL,1,tname,NULL); |
| } |
| else { |
| flatfile = fopen(tname, "r"); |
| sqlcode = flatfile ? 0 : -ABS(arkcmpErrorFileOpenForRead); |
| } |
| |
| /* EXEC SQL FETCH S1 INTO :attrName, :value; */ |
| // Since the DEFAULTS table is PRIMARY KEY (SUBSYSTEM, ATTRIBUTE), |
| // we'll fetch (scanning the clustering index) |
| // CATALOG before SCHEMA; this is important if user has rows like |
| // ('CATALOG','c1') and ('SCHEMA','c2.sn') -- |
| // the schema setting must supersede the catalog one. |
| // We should also put an ORDER BY into the cursor decl in the .mdf, |
| // to handle user-created DEFAULTS tables w/o a PK. |
| |
| if (sqlcode >= 0) |
| if (isSQLTable) |
| { |
| sqlcode = SQL_EXEC_Fetch(&__SQL_id0,NULL,2,attrName,NULL,value,NULL); |
| if (sqlcode >= 0) |
| readFromSQDefaultsTable_ = TRUE; |
| } |
| else { |
| value[0] = 0; // NULL terminator |
| if (fscanf(flatfile, " %100[A-Za-z0-9_#] ,", attrName) < 0) |
| sqlcode = +100; |
| else |
| fgets((char *) value, sizeof(value), flatfile); |
| } |
| |
| // Ignore warnings except for end-of-data |
| while (sqlcode >= 0 && sqlcode != +100) { |
| |
| NAString v(value); |
| |
| // skip comments, indicated by a # |
| if (attrName[0] != '#') |
| validateAndInsert(attrName, v, FALSE, errOrWarn, overwriteIfNotYet); |
| |
| /* EXEC SQL FETCH S1 INTO :attrName, :value; */ |
| if (isSQLTable) |
| sqlcode = SQL_EXEC_Fetch(&__SQL_id0,NULL,2,attrName,NULL,value,NULL); |
| else { |
| value[0] = 0; // NULL terminator |
| if (fscanf(flatfile, " %100[A-Za-z0-9_#] ,", attrName) < 0) sqlcode = +100; |
| else fgets((char *) value, sizeof(value), flatfile); |
| } |
| } |
| if (sqlcode < 0 && errOrWarn && initializeSQLdone()) { |
| if (ABS(sqlcode) == ABS(CLI_MODULEFILE_OPEN_ERROR) && |
| cmpCurrentContext->isInstalling()) { |
| // Emit no warning when (re)installing, |
| // because obviously the module will not exist before we have |
| // (re)arkcmp'd it! |
| } |
| else { |
| // 2001 Error $0 reading table $1. Using $2 values. |
| CollIndex n = tablesRead_.entries(); |
| const char *errtext = n ? tablesRead_[n-1].data() : "default-default"; |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(2001)) |
| << DgInt0(sqlcode) << DgTableName(tname) << DgString0(errtext); |
| } |
| } |
| |
| if (isSQLTable) { |
| /* EXEC SQL CLOSE S1; */ |
| sqlcode = SQL_EXEC_ClearDiagnostics(&__SQL_id0); |
| sqlcode = SQL_EXEC_CloseStmt(&__SQL_id0); |
| |
| // The above statement should not start any transactions because |
| // it uses read uncommitted access. If it ever changes, then we |
| // would need to commit it at this time. |
| } |
| |
| } // tname |
| |
| if (initialErrCnt < CmpCommon::diags()->getNumber() && errOrWarn) |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(2059)) |
| << DgString0(tname ? tname : ""); |
| } // isStandalone |
| |
| } // NADefaults::readFromSQLTable() |
| |
| void NADefaults::readFromSQLTables(Provenance overwriteIfNotYet, Int32 errOrWarn) |
| { |
| NABoolean cat = FALSE; |
| NABoolean sch = FALSE; |
| |
| |
| if (getToken(MODE_SEABASE) == DF_ON && !readFromSQDefaultsTable()) |
| { |
| // Read system defaults from configuration file. |
| // keep this name in sync with file cli/SessionDefaults.cpp |
| NAString confFile(getenv("TRAF_HOME")); |
| confFile += "/etc/SQSystemDefaults.conf"; |
| readFromFlatFile(confFile, overwriteIfNotYet, errOrWarn); |
| tablesRead_.insert(confFile); |
| |
| CmpSeabaseDDL cmpSBD((NAHeap *)heap_, FALSE); |
| Lng32 hbaseErr = 0; |
| NAString hbaseErrStr; |
| Lng32 errNum = cmpSBD.validateVersions(this, NULL, NULL, NULL, |
| NULL, NULL, NULL, |
| NULL, NULL, NULL, NULL, |
| &hbaseErr, &hbaseErrStr); |
| if (errNum == 0) // seabase is initialized properly |
| { |
| // read from seabase defaults table |
| cmpSBD.readAndInitDefaultsFromSeabaseDefaultsTable |
| (overwriteIfNotYet, errOrWarn, this); |
| |
| // set authorization state |
| |
| NABoolean checkAllPrivTables = FALSE; |
| errNum = cmpSBD.isPrivMgrMetadataInitialized(this,checkAllPrivTables); |
| CmpCommon::context()->setAuthorizationState(errNum); |
| } |
| else |
| { |
| CmpCommon::context()->setIsUninitializedSeabase(TRUE); |
| CmpCommon::context()->uninitializedSeabaseErrNum() = errNum; |
| CmpCommon::context()->hbaseErrNum() = hbaseErr; |
| CmpCommon::context()->hbaseErrStr() = hbaseErrStr; |
| } |
| } |
| |
| currentState_ = SET_BY_CQD; // enter the next state... |
| |
| // Make self fully consistent, by executing deferred actions last of all |
| getSqlParser_NADefaults(); |
| } // NADefaults::readFromSQLTables() |
| |
| // This method is used by SchemaDB::initPerStatement |
| const char * NADefaults::getValueWhileInitializing(Int32 attrEnum) |
| { |
| // We can't rely on our state_ because SQLC might have called CQD::bindNode() |
| // which does a setState(SET_BY_CQD)... |
| if (!tablesRead_.entries()) |
| if (getProvenance(attrEnum) < SET_BY_CQD) |
| readFromSQLTables(SET_BY_CQD); |
| |
| return getValue(attrEnum); |
| } |
| |
| // This method is used by SchemaDB::initPerStatement *and* |
| // by CmpCommon, CmpStatement, and SQLC/SQLCO. |
| void NADefaults::getCatalogAndSchema(NAString &cat, NAString &sch) |
| { |
| cat = getValueWhileInitializing(CATALOG); |
| sch = getValueWhileInitializing(SCHEMA); |
| } |
| |
| // Should be called only privately and by DefaultValidator! |
| Int32 NADefaults::validateFloat(const char *value, float &result, |
| Int32 attrEnum, Int32 errOrWarn) const |
| { |
| Int32 n = -1; // NT's scanf("%n") is not quite correct; hence this code-around |
| sscanf(value, "%g%n", &result, &n); |
| if (n > 0 && value[n] == '\0') |
| { |
| switch (attrEnum) |
| { |
| case HIVE_INSERT_ERROR_MODE: |
| { |
| Lng32 v = str_atoi(value, str_len(value)); |
| if (v >= 0 && v <= 3) |
| return TRUE; |
| } |
| break; |
| default: |
| return TRUE; // a valid float |
| } |
| } |
| |
| NAString v(value); |
| NABoolean silentIf = (errOrWarn == SilentIfSYSTEM); |
| if (silentIf) errOrWarn = 0/*silent*/; |
| NABoolean useSYSTEM = (token(attrEnum, v, TRUE, errOrWarn) == DF_SYSTEM); |
| |
| if (useSYSTEM && silentIf) // ValidateNumeric is caller |
| return SilentIfSYSTEM; // special it-is-valid return! |
| |
| if (errOrWarn) |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(2055)) |
| << DgString0(value) |
| << DgString1(lookupAttrName(attrEnum, errOrWarn)); |
| |
| if (useSYSTEM) { // programmer error |
| CMPASSERT("Numeric attr allows SYSTEM -- you need to call token() first to see if its current value is this keyword, and compute your system default value!" == NULL); |
| } |
| |
| // ensure an out-of-range error if domainMatch or ValidateNumeric is called |
| result = -FLT_MAX; |
| return FALSE; // not valid |
| } |
| |
| NABoolean NADefaults::insert(Int32 attrEnum, const NAString &value, Int32 errOrWarn) |
| { |
| // private method; callers have all already done this: ATTR_RANGE_ASSERT; |
| assert(errOrWarn != SilentIfSYSTEM); // yeh private, but just in case |
| |
| // Update cache: |
| // (Re)validate that new value is numeric. |
| // Useful if programmer did not correctly specify the DefaultValidator for |
| // this attr in DefaultDefaults. |
| // |
| if (currentFloats_[attrEnum]) { |
| float result; |
| if (validateFloat(value, result, attrEnum, errOrWarn)) |
| *currentFloats_[attrEnum] = result; |
| else |
| return FALSE; // not a valid float |
| } |
| |
| // Update cache for DefaultToken by deallocating the cached entry. |
| if ( currentTokens_[attrEnum] ) |
| { |
| NADELETEBASIC( currentTokens_[attrEnum], NADHEAP ); |
| currentTokens_[attrEnum] = NULL; |
| } |
| |
| // If we're past the read-from-SQLTable phase, then |
| // the first CQD of a given attr must first save the from-SQLTable value, |
| // to which the user can RESET if desired. |
| // |
| if (currentState_ >= SET_BY_CQD && !resetToDefaults_[attrEnum]) { |
| NAString currValStr(currentDefaults_[attrEnum]); |
| Lng32 currValLen = str_len(currValStr) + 1; |
| char *pCurrVal = new NADHEAP char[currValLen]; |
| str_cpy_all(pCurrVal, currValStr, currValLen); |
| resetToDefaults_[attrEnum] = pCurrVal; |
| } |
| |
| char *newVal = NULL; |
| Lng32 newValLen = str_len(value) + 1; |
| if (provenances_[attrEnum] > INIT_DEFAULT_DEFAULTS) { |
| Lng32 oldValLen = str_len(currentDefaults_[attrEnum]) + 1; |
| if (oldValLen >= newValLen && oldValLen < newValLen + 100) |
| newVal = const_cast<char*>(currentDefaults_[attrEnum]); // reuse, to reduce mem frag |
| else |
| NADELETEBASIC(currentDefaults_[attrEnum], NADHEAP); |
| } |
| |
| if (!newVal) newVal = new NADHEAP char[newValLen]; |
| str_cpy_all(newVal, value, newValLen); |
| currentDefaults_[attrEnum] = newVal; |
| |
| // when the parser flag is on for a set-once CQD |
| // set its provenance as INIT_DEFAULT_DEFAULTS, |
| // so the user can set it once later |
| if ( isSetOnceAttribute(attrEnum) && |
| Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL) ) |
| { |
| provenances_[attrEnum] = INIT_DEFAULT_DEFAULTS; |
| } |
| else |
| { |
| provenances_[attrEnum] = currentState_; |
| } |
| |
| return TRUE; |
| } |
| |
| NADefaults::Provenance NADefaults::getProvenance(Int32 attrEnum) const |
| { |
| ATTR_RANGE_ASSERT; |
| return (Provenance)provenances_[attrEnum]; |
| } |
| |
| NABoolean NADefaults::getValue(Int32 attrEnum, NAString &result) const |
| { |
| ATTR_RANGE_ASSERT; |
| result = currentDefaults_[attrEnum]; |
| return TRUE; // we always have a STRING REPRESENTATION value |
| } |
| |
| NAString NADefaults::getString(Int32 attrEnum) const |
| { |
| ATTR_RANGE_ASSERT; |
| return currentDefaults_[attrEnum]; |
| } |
| |
| const char * NADefaults::getValue(Int32 attrEnum) const |
| { |
| ATTR_RANGE_ASSERT; |
| return currentDefaults_[attrEnum]; |
| } |
| |
| NABoolean NADefaults::getFloat(Int32 attrEnum, float &result) const |
| { |
| ATTR_RANGE_ASSERT; |
| if (currentFloats_[attrEnum]) { |
| result = *currentFloats_[attrEnum]; |
| } |
| else if (validateFloat(currentDefaults_[attrEnum], result, attrEnum)) { |
| currentFloats_[attrEnum] = new NADHEAP float; // cache the result |
| *currentFloats_[attrEnum] = result; |
| } |
| else { |
| return FALSE; // result is neg, from failed validateFloat() |
| } |
| |
| return TRUE; |
| } |
| |
| double NADefaults::getAsDouble(Int32 attrEnum) const |
| { |
| // No domainMatch() needed: any float or double (or int or uint) is okay; |
| // getFloat()/validateFloat() will disallow any non-numerics. |
| float flt; |
| getFloat(attrEnum, flt); |
| return double(flt); |
| } |
| |
| Lng32 NADefaults::getAsLong(Int32 attrEnum) const |
| { |
| float flt; |
| getFloat(attrEnum, flt); |
| if (!domainMatch(attrEnum, VALID_INT, &flt)) { CMPBREAK; } |
| return Lng32(flt); |
| } |
| |
| ULng32 NADefaults::getAsULong(Int32 attrEnum) const |
| { |
| float flt; |
| getFloat(attrEnum, flt); |
| if (!domainMatch(attrEnum, VALID_UINT, &flt)) { CMPBREAK; } |
| return (ULng32)(flt); |
| } |
| |
| ULng32 NADefaults::getNumOfESPsPerNode() const |
| { |
| return (ULng32)MAXOF(ceil(getNumOfESPsPerNodeInFloat()), 1); |
| } |
| |
| float NADefaults::getNumOfESPsPerNodeInFloat() const |
| { |
| double maxEspPerCpuPerOp = getAsDouble(MAX_ESPS_PER_CPU_PER_OP); |
| |
| CollIndex cores = |
| ( (CmpCommon::context() && CURRSTMT_OPTDEFAULTS->isFakeHardware()) |
| ) ? |
| getAsLong(DEF_NUM_SMP_CPUS) : |
| gpClusterInfo->numberOfCpusPerSMP(); |
| |
| return float(maxEspPerCpuPerOp * cores); |
| } |
| |
| ULng32 NADefaults::getTotalNumOfESPsInCluster(NABoolean& fakeEnv) const |
| { |
| fakeEnv = FALSE; |
| |
| if (getToken(PARALLEL_NUM_ESPS, 0) != DF_SYSTEM ) { |
| fakeEnv = TRUE; |
| return getAsLong(PARALLEL_NUM_ESPS); |
| } |
| |
| float espsPerNode = getNumOfESPsPerNodeInFloat(); |
| |
| CollIndex numOfNodes = gpClusterInfo->numOfSMPs(); |
| |
| if ( (CmpCommon::context() && CURRSTMT_OPTDEFAULTS->isFakeHardware())) { |
| fakeEnv = TRUE; |
| numOfNodes = getAsLong(DEF_NUM_NODES_IN_ACTIVE_CLUSTERS); |
| } |
| |
| return MAXOF(ceil(espsPerNode * numOfNodes), 1); |
| } |
| |
| NABoolean NADefaults::domainMatch(Int32 attrEnum, |
| Int32 expectedType/*DefaultValidatorType*/, |
| float *flt) const |
| { |
| if (validator(attrEnum)->getType() == expectedType) |
| return TRUE; // yes, domains match |
| |
| // Emit error messages only if the value is actually out-of-range. |
| // |
| // Users (optimizer code) should REALLY be using 'unsigned long' fields |
| // and calling getAsULong, instead of using 'long' fields to retrieve |
| // unsigned(DDui*) attr values via getAsLong ... |
| // |
| // if we get here the compiler will crash |
| if (flt) { |
| DefaultValidator *validator = NULL; |
| if (expectedType == VALID_INT) validator = (DefaultValidator *)&validateInt; |
| else if (expectedType == VALID_UINT) validator = (DefaultValidator *)&validateUI; |
| |
| // Explicitly check for TRUE here -- |
| // both FALSE/error and SilentIfSYSTEM are out-of-range/out-of-domain |
| // from this method's point of view. |
| if (validator) |
| if (validator->validate( |
| currentDefaults_[attrEnum], this, attrEnum, -1, flt) == TRUE) |
| return TRUE; // domain mismatch, but value *is* in the domain range |
| |
| } // fall thru to emit additional failure info |
| |
| *CmpCommon::diags() << DgSqlCode(+2058) // emit a mismatch WARNING |
| << DgString0(lookupAttrName(attrEnum)) |
| << DgString1(validator(attrEnum)->getTypeText()) |
| << DgString2(DefaultValidator::getTypeText( |
| DefaultValidatorType(expectedType))); |
| #ifndef NDEBUG |
| cerr << "Warning[2058] " << lookupAttrName(attrEnum) |
| << " " << validator(attrEnum)->getTypeText() |
| << " " << DefaultValidator::getTypeText( |
| DefaultValidatorType(expectedType)) |
| << " " << (flt ? *flt : 123.45) << endl; |
| #endif |
| |
| return FALSE; |
| } |
| |
| // CONTROL QUERY DEFAULT attr RESET; |
| // resets the single attr to the value it had right after we read all |
| // the DEFAULTS tables, |
| // or the value it had right before a CQD * RESET RESET. |
| // CONTROL QUERY DEFAULT * RESET; |
| // resets all attrs to the values they had by same criteria as above. |
| // CONTROL QUERY DEFAULT * RESET RESET; |
| // resets the "reset-to" values so that all current values become the |
| // effective "reset-to"'s -- i.e, the current values can't be lost |
| // on the next CQD * RESET; |
| // Useful for apps that dynamically send startup settings that ought |
| // to be preserved -- ODBC and SQLCI do this. |
| // |
| void NADefaults::resetAll(NAString &value, NABoolean reset, Int32 errOrWarn) |
| { |
| size_t i, numAttrs = numDefaultAttributes(); |
| |
| if (reset == 1) { // CQD * RESET; (not RESET RESET) |
| setResetAll(TRUE); |
| for (i = 0; i < numAttrs; i++) |
| { |
| const char * attributeName = defaultDefaults[i].attrName; |
| DefaultConstants attrEnum = lookupAttrName(attributeName, errOrWarn); |
| |
| if (isNonResetableAttribute(attributeName)) |
| continue; |
| |
| validateAndInsert(attributeName, value, TRUE, errOrWarn); |
| } |
| // if DEFAULT_SCHEMA_NAMETYPE=USER after CQD * RESET |
| // set SCHEMA to LDAP_USERNAME |
| // if SCHEMA has not been specified by user |
| if ( (getToken(DEFAULT_SCHEMA_NAMETYPE) == DF_USER) && |
| schSetByNametype() ) |
| { |
| setSchemaAsLdapUser(); |
| } |
| setResetAll(FALSE); |
| } |
| else if (reset == 2) { |
| for (i = 0; i < numAttrs; i++) { |
| if (resetToDefaults_[i]) { |
| // CONTROL QUERY DEFAULT * RESET RESET; -- this code cloned below |
| // Can't reset prov, because to which? |
| // provenances_[i] = READ_FROM_SQL_TABLE or COMPUTED ?? |
| NADELETEBASIC(resetToDefaults_[i], NADHEAP); |
| resetToDefaults_[i] = NULL; |
| } |
| } |
| } |
| else { |
| CMPASSERT(!reset); |
| } |
| } |
| |
| // Reset to default-defaults, as if readFromSQLTables() had not executed, |
| // but setting state and provenance so no future reads will be triggered. |
| // See StaticCompiler and Genesis 10-990204-2469 above for motivation. |
| void NADefaults::undoReadsAndResetToDefaultDefaults() |
| { |
| initCurrentDefaultsWithDefaultDefaults(); |
| } |
| |
| NABoolean NADefaults::isReadonlyAttribute(const char* attrName) const |
| { |
| if ((( stricmp(attrName, "ISO_MAPPING") == 0 ) || |
| ( stricmp(attrName, "OVERFLOW_MODE") == 0 ) || |
| ( stricmp(attrName, "SORT_ALGO") == 0 )) |
| && ( CmpCommon::getDefault(DISABLE_READ_ONLY) == DF_ON )) |
| return FALSE; // for internal development and testing purposes |
| |
| if (( stricmp(attrName, "ISO_MAPPING") == 0 )|| |
| ( stricmp(attrName, "NATIONAL_CHARSET") == 0 ) || |
| ( stricmp(attrName, "VALIDATE_VIEWS_AT_OPEN_TIME") == 0 ) || |
| ( stricmp(attrName, "USER_EXPERIENCE_LEVEL") == 0 ) || |
| ( stricmp(attrName, "POS_DISKS_IN_SEGMENT") == 0 ) || |
| ( stricmp(attrName, "BMO_MEMORY_LIMIT_LOWER_BOUND_HASHJOIN") == 0 ) || |
| ( stricmp(attrName, "EXE_MEMORY_LIMIT_LOWER_BOUND_MERGEJOIN") == 0 ) || |
| ( stricmp(attrName, "BMO_MEMORY_LIMIT_LOWER_BOUND_HASHGROUPBY") == 0 ) || |
| ( stricmp(attrName, "BMO_MEMORY_LIMIT_LOWER_BOUND_SORT") == 0 ) || |
| ( stricmp(attrName, "EXE_MEMORY_LIMIT_LOWER_BOUND_SEQUENCE") == 0 ) || |
| ( stricmp(attrName, "EXE_MEMORY_LIMIT_LOWER_BOUND_EXCHANGE") == 0 ) || |
| ( stricmp(attrName, "SORT_ALGO") == 0 ) || |
| ( stricmp(attrName, "OVERFLOW_MODE") == 0 ) |
| ) |
| return TRUE; |
| |
| if (strlen(attrName) > 0) |
| { |
| DefaultConstants v = lookupAttrName(attrName, 0, 0); |
| if ((v != __INVALID_DEFAULT_ATTRIBUTE) && |
| (getFlags(v) & DEFAULT_IS_SSD)) |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| // these defaults cannot be reset or set to FALSE through a cqd. |
| NABoolean NADefaults::isNonResetableAttribute(const char* attrName) const |
| { |
| if (( stricmp(attrName, "IS_SQLCI") == 0 ) || |
| ( stricmp(attrName, "NVCI_PROCESS") == 0 ) || |
| ( stricmp(attrName, "SESSION_ID") == 0 ) || |
| ( stricmp(attrName, "LDAP_USERNAME") == 0 ) || |
| ( stricmp(attrName, "VOLATILE_SCHEMA_IN_USE") == 0 ) || |
| ( stricmp(attrName, "SESSION_USERNAME") == 0 ) ) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| // these defaults can be set only once by user. |
| NABoolean NADefaults::isSetOnceAttribute(Int32 attrEnum) const |
| { |
| if ( attrEnum == DEFAULT_SCHEMA_ACCESS_ONLY ) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| void NADefaults::resetSessionOnlyDefaults() |
| { |
| NAString value; |
| validateAndInsert("NVCI_PROCESS", value, 3, 0); |
| } |
| |
| // Parameter <reset> must not be a reference (&); |
| // see <value = ... fall thru> below. |
| enum DefaultConstants NADefaults::validateAndInsert(const char *attrName, |
| NAString &value, |
| NABoolean reset, |
| Int32 errOrWarn, |
| Provenance overwriteIfNotYet) |
| { |
| NABoolean overwrite = FALSE; |
| NABoolean isJDBC = FALSE; |
| NABoolean isODBC = FALSE; |
| |
| if (ActiveSchemaDB()) |
| { |
| isJDBC = (CmpCommon::getDefault(JDBC_PROCESS) == DF_ON ? TRUE : FALSE); |
| isODBC = (CmpCommon::getDefault(ODBC_PROCESS) == DF_ON ? TRUE : FALSE); |
| } |
| |
| if (reset && !attrName[0]) { // CONTROL QUERY DEFAULT * RESET |
| overwrite = currentState_ < overwriteIfNotYet; |
| if (overwrite) resetAll(value, reset, errOrWarn); |
| return (DefaultConstants)0; // success |
| } |
| |
| // Perform a lookup for the string, using a binary search. |
| DefaultConstants attrEnum = lookupAttrName(attrName, errOrWarn); |
| |
| if (attrEnum >= 0) { // valid attrName |
| |
| // ignore DEFAULT_SCHEMA_ACCESS_ONLY if it is in system defaults |
| if ( attrEnum == DEFAULT_SCHEMA_ACCESS_ONLY && |
| getState() < SET_BY_CQD ) |
| return attrEnum; |
| |
| // do the following check when |
| // this is the primary mxcmp |
| // and INTERNAL_QUERY_FROM_EXEUTIL is not set |
| |
| if (!CmpCommon::context()->isSecondaryMxcmp() && |
| !Get_SqlParser_Flags(INTERNAL_QUERY_FROM_EXEUTIL)) |
| { |
| // This logic will catch if the set-once CQD |
| // is set, but the ALLOW_SET_ONCE_DEFAULTS parserflags |
| // are not set. This is absolutely necessary for security |
| // to ensure that the correct parserflags are set. |
| if ((isSetOnceAttribute(attrEnum)) && |
| (!isResetAll()) && // no error msg for cqd * reset |
| (NOT Get_SqlParser_Flags(ALLOW_SET_ONCE_DEFAULTS))) |
| { |
| *CmpCommon::diags() << DgSqlCode(-30042) << DgString0(attrName); |
| return attrEnum; |
| } |
| |
| // if DEFAULT_SCHEMA_ACCESS_ONLY is on, |
| // users cannot change the following CQDs |
| if ( getState() >= SET_BY_CQD && |
| getToken(DEFAULT_SCHEMA_ACCESS_ONLY) == DF_ON ) |
| { |
| if (attrEnum == SCHEMA || |
| attrEnum == PUBLIC_SCHEMA_NAME || |
| attrEnum == DEFAULT_SCHEMA_NAMETYPE) |
| { |
| if (!isResetAll()) // no error msg for cqd * reset |
| *CmpCommon::diags() << DgSqlCode(-30043) << DgString0(attrName); |
| return attrEnum; |
| } |
| } |
| } |
| else |
| { |
| // ignore LAST0_MODE cqd if we are in secondary mxcmp or if |
| // internal_query_from_exeutil is set. This cqd is not meant |
| // to apply in these cases |
| if ( attrEnum == LAST0_MODE ) |
| return attrEnum; |
| |
| } |
| |
| |
| overwrite = getProvenance(attrEnum) < overwriteIfNotYet; |
| |
| // Put value into canonical form (trimmed, upcased where pertinent). |
| // |
| // Possibly revert to initial default default value -- see NOTE 3 up above. |
| // Note further that ANSI names cannot revert on values of |
| // 'SYSTEM' or 'ENABLE', as those are legal cat/sch/tbl names, |
| // nor can they revert on '' (empty/blank), as ANSI requires us to |
| // emit a syntax error for this. |
| // |
| // Possibly RESET to read-from-table value (before any CQD value). |
| // |
| TrimNAStringSpace(value); |
| if (validator(attrEnum) != &validateAnsiName && !reset) { |
| validator(attrEnum)->applyUpper(value); |
| |
| if (isSynonymOfSYSTEM(attrEnum, value)) |
| value = getDefaultDefaultValue(attrEnum); |
| else if (isSynonymOfRESET(value)) // CQD attr 'RESET'; ... |
| reset = 1; |
| } |
| |
| if (reset) { // CQD attr RESET; |
| |
| if ((isNonResetableAttribute(attrName)) && |
| (reset != 3)) |
| return attrEnum; |
| |
| if (!resetToDefaults_[attrEnum]) { |
| if (overwrite) |
| value = currentDefaults_[attrEnum]; // return actual val to caller |
| |
| if (attrEnum == ISOLATION_LEVEL) |
| { |
| // reset this in the global area |
| TransMode::IsolationLevel il; |
| getIsolationLevel(il); |
| CmpCommon::transMode()->updateAccessModeFromIsolationLevel(il); |
| } |
| // Solution: 10-060418-5903. Do not update MXCMP global access mode |
| // with CQD ISOLATION_LEVEL_FOR_UPDATES as it will overwrite that |
| // set by ISOLATION_LEVE. The CQD ISOLATION_LEVEL_FOR_UPDATES is |
| // always accessed directly when necessary. |
| //else if (attrEnum == ISOLATION_LEVEL_FOR_UPDATES) |
| // { |
| // // reset this in the global area |
| // TransMode::IsolationLevel il; |
| // getIsolationLevel(il, getToken(attrEnum)); |
| // CmpCommon::transMode()->updateAccessModeFromIsolationLevel(il, |
| // FALSE); |
| // } |
| |
| return attrEnum; |
| } |
| value = resetToDefaults_[attrEnum]; // fall thru, REINSERT this val |
| } |
| |
| if (attrEnum == CATALOG) { |
| if (!setCatalog(value, errOrWarn, overwrite)) |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| else |
| { |
| if (getState() == READ_FROM_SQL_TABLE) |
| { |
| // set the volatile catalog to be same as the catalog read from |
| // defaults table. If there is no catalog or volatile_catalog |
| // specified in the defaults table, then volatile catalog name |
| // will be the default catalog in use in the session where |
| // volatile tables are created. |
| CmpCommon::context()->sqlSession()->setVolatileCatalogName(value); |
| } |
| } |
| } |
| else if (attrEnum == SCHEMA) { |
| if (!setSchema(value, errOrWarn, overwrite)) |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| else |
| { |
| if (getState() == READ_FROM_SQL_TABLE) |
| { |
| // set the volatile catalog to be same as the catalog read from |
| // defaults table. If there is no catalog or volatile_catalog |
| // specified in the defaults table, then volatile catalog name |
| // will be the default catalog in use in the session where |
| // volatile tables are created. |
| NAString cat(getValue(CATALOG)); |
| CmpCommon::context()->sqlSession()->setVolatileCatalogName(cat); |
| } |
| } |
| } |
| |
| else { |
| if ( attrEnum == MAX_LONG_VARCHAR_DEFAULT_SIZE || |
| attrEnum == MAX_LONG_WVARCHAR_DEFAULT_SIZE ) { |
| |
| ULng32 minLength; |
| switch (attrEnum) { |
| case MAX_LONG_VARCHAR_DEFAULT_SIZE: |
| minLength = (Lng32)getAsULong(MIN_LONG_VARCHAR_DEFAULT_SIZE); |
| break; |
| case MAX_LONG_WVARCHAR_DEFAULT_SIZE: |
| minLength = (Lng32)getAsULong(MIN_LONG_WVARCHAR_DEFAULT_SIZE); |
| break; |
| default: |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| } |
| |
| if ( attrEnum != __INVALID_DEFAULT_ATTRIBUTE ) { |
| UInt32 newMaxLength; |
| Int32 n = -1; |
| sscanf(value.data(), "%u%n", &newMaxLength, &n); |
| if ( n>0 && (UInt32)n == value.length() ) { // a valid unsigned number |
| if ( newMaxLength < minLength ) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2030) << DgInt0((Lng32)minLength); |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| } |
| } |
| } |
| } |
| |
| if ( attrEnum == MIN_LONG_VARCHAR_DEFAULT_SIZE || |
| attrEnum == MIN_LONG_WVARCHAR_DEFAULT_SIZE ) { |
| |
| ULng32 maxLength; |
| switch (attrEnum) { |
| case MIN_LONG_VARCHAR_DEFAULT_SIZE: |
| maxLength = getAsULong(MAX_LONG_VARCHAR_DEFAULT_SIZE); |
| break; |
| case MIN_LONG_WVARCHAR_DEFAULT_SIZE: |
| maxLength = getAsULong(MAX_LONG_WVARCHAR_DEFAULT_SIZE); |
| break; |
| default: |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| } |
| |
| if ( attrEnum != __INVALID_DEFAULT_ATTRIBUTE ) { |
| UInt32 newMinLength; |
| Int32 n = -1; |
| sscanf(value.data(), "%u%n", &newMinLength, &n); |
| if ( n>0 && (UInt32)n == value.length() ) { // a valid unsigned number |
| if ( newMinLength > maxLength ) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2029) << DgInt0((Lng32)maxLength); |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| } |
| } |
| } |
| } |
| |
| if (errOrWarn && (attrEnum == ROUNDING_MODE)) |
| { |
| if (NOT ((value.length() == 1) && |
| ((*value.data() == '0') || |
| (*value.data() == '1') || |
| (*value.data() == '2')))) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(value) |
| << DgString1(lookupAttrName(attrEnum)); |
| |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| } |
| } |
| |
| if ( attrEnum == SCRATCH_MAX_OPENS_HASH || |
| attrEnum == SCRATCH_MAX_OPENS_SORT ) |
| { |
| if (NOT ((value.length() == 1) && |
| ((*value.data() == '1') || |
| (*value.data() == '2') || |
| (*value.data() == '3') || |
| (*value.data() == '4')))) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(value) |
| << DgString1(lookupAttrName(attrEnum)); |
| |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| } |
| } |
| |
| if (attrEnum != __INVALID_DEFAULT_ATTRIBUTE) |
| { |
| |
| // We know that the MP_COLLATIONS validator emits only warnings |
| // and always returns TRUE. On the validate-but-do-not-insert step |
| // (CQD compilation), those warnings will be seen by the user. |
| // On the validate-AND-insert (CQD execution), there is no need |
| // to repeat them (besides, that causes Executor to choke on the |
| // warnings in the diags and say 'Error fetching from TCB tree'). |
| |
| Int32 isValid = TRUE; |
| if (!overwrite || currentState_ < SET_BY_CQD || |
| validator(attrEnum) != &validateCollList) |
| isValid = validator(attrEnum)->validate(value, this, attrEnum, errOrWarn); |
| |
| // if an internal reset is being done, then make it a valid attr |
| // even if the 'validate' method above returned invalid. |
| if ((!isValid) && |
| (isNonResetableAttribute(attrName)) && |
| (reset == 3)) |
| { |
| isValid = TRUE; |
| } |
| |
| if (!isValid) |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| |
| else if (overwrite) { |
| if (isValid == SilentIfSYSTEM) { // defDef value was "SYSTEM" or "" |
| // Undo any caching from getFloat() |
| NADELETEBASIC(currentFloats_[attrEnum], NADHEAP); |
| currentFloats_[attrEnum] = NULL; |
| |
| // Undo any caching from getToken() |
| NADELETEBASIC( currentTokens_[attrEnum], NADHEAP ); |
| currentTokens_[attrEnum] = NULL; |
| |
| // Now fall thru to insert the string "SYSTEM" or "" |
| } |
| |
| if (!insert(attrEnum, value, errOrWarn)) |
| attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| } // overwrite (i.e. insert) |
| } |
| } // not special val/ins for CAT, SCH, or MPLOC |
| } // valid attrName |
| |
| if (attrEnum >= 0) { |
| if (overwrite) { |
| if ((! reset) && |
| (currentState_ == SET_BY_CQD)) |
| { |
| // indicate that this attribute was set by a user CQD. |
| setUserDefault(attrEnum, TRUE); |
| } |
| |
| switch (attrEnum) { |
| |
| case CATALOG: |
| case SCHEMA: |
| break; |
| case ISOLATION_LEVEL: |
| { |
| // Ansi 14.1 SR 4. See comexe/ExControlArea::addControl(). |
| //## I now think this implementation is wrong |
| //## because this is setting GLOBAL state |
| //## for something that should be CONTEXT-dependent. |
| //## Will cause us headaches later, when we |
| //## make arkcmp be a multi-context multi-threaded server. |
| TransMode::IsolationLevel il; |
| getIsolationLevel(il); |
| CmpCommon::transMode()->updateAccessModeFromIsolationLevel(il); |
| } |
| break; |
| // Solution: 10-060418-5903. Do not update MXCMP global access mode |
| // with CQD ISOLATION_LEVEL_FOR_UPDATES as it will overwrite that |
| // set by ISOLATION_LEVEL. The CQD ISOLATION_LEVEL_FOR_UPDATES is |
| // always accessed directly when necessary. |
| //case ISOLATION_LEVEL_FOR_UPDATES: |
| //{ |
| // TransMode::IsolationLevel il; |
| // getIsolationLevel(il, getToken(attrEnum)); |
| // CmpCommon::transMode()->updateAccessModeFromIsolationLevel(il, |
| // FALSE); |
| //} |
| //break; |
| |
| case ALLOW_INCOMPATIBLE_ASSIGNMENT: |
| case ALLOW_INCOMPATIBLE_COMPARISON: |
| { |
| NAString val; |
| |
| if (value == "ON") |
| val = "ON"; |
| else |
| val = "OFF"; |
| |
| insert(ALLOW_INCOMPATIBLE_OPERATIONS, val, errOrWarn); |
| } |
| break; |
| |
| case MODE_SPECIAL_1: |
| { |
| NAString val; |
| |
| if (value == "ON") |
| val = "ON"; |
| else |
| val = "OFF"; |
| |
| insert(ALLOW_INCOMPATIBLE_OPERATIONS, val, errOrWarn); |
| |
| // find_suitable_key to be turned off in this mode, unless |
| // it has been explicitely set. |
| if (getToken(VOLATILE_TABLE_FIND_SUITABLE_KEY) == DF_SYSTEM) |
| { |
| insert(VOLATILE_TABLE_FIND_SUITABLE_KEY, "OFF", errOrWarn); |
| } |
| } |
| break; |
| |
| case MODE_SPECIAL_4: |
| { |
| NAString val; |
| |
| if (value == "ON") |
| val = "ON"; |
| else |
| val = "OFF"; |
| |
| insert(ALLOW_INCOMPATIBLE_OPERATIONS, val, errOrWarn); |
| |
| NAString csVal; |
| if (value == "ON") |
| csVal = SQLCHARSETSTRING_UTF8; |
| else |
| csVal = ""; |
| |
| validateAndInsert("TRAF_DEFAULT_COL_CHARSET", csVal, FALSE, errOrWarn); |
| |
| NAString notVal; |
| if (value == "ON") |
| notVal = "OFF"; |
| else |
| notVal = "ON"; |
| insert(TRAF_COL_LENGTH_IS_CHAR, notVal, errOrWarn); |
| |
| NAString costVal1; |
| NAString costVal2; |
| if (value == "ON") { |
| costVal1 = "8.0"; |
| costVal2 = "16.0" ; |
| } |
| else { |
| costVal1 = "1.0"; |
| costVal2 = "1.0" ; |
| } |
| validateAndInsert("NCM_IND_JOIN_COST_ADJ_FACTOR", costVal1, |
| FALSE, errOrWarn); |
| validateAndInsert("NCM_IND_SCAN_COST_ADJ_FACTOR", costVal2, |
| FALSE, errOrWarn); |
| |
| if (value == "ON") |
| Set_SqlParser_Flags(IN_MODE_SPECIAL_4); |
| else |
| Reset_SqlParser_Flags(IN_MODE_SPECIAL_4); |
| } |
| break; |
| |
| case MODE_SEABASE: |
| { |
| if (value == "ON") |
| { |
| if (NOT seabaseDefaultsTableRead()) |
| { |
| CmpSeabaseDDL cmpSBD((NAHeap *)heap_); |
| Lng32 errNum = cmpSBD.validateVersions(this); |
| if (errNum == 0) // seabase is initialized properly |
| { |
| // read from seabase defaults table |
| cmpSBD.readAndInitDefaultsFromSeabaseDefaultsTable |
| (overwriteIfNotYet, errOrWarn, this); |
| } |
| else |
| { |
| CmpCommon::context()->setIsUninitializedSeabase(TRUE); |
| CmpCommon::context()->uninitializedSeabaseErrNum() = errNum; |
| } |
| } |
| |
| NAString sbCat = getValue(SEABASE_CATALOG); |
| insert(SEABASE_VOLATILE_TABLES, "ON", errOrWarn); |
| CmpCommon::context()->sqlSession()->setVolatileCatalogName(sbCat, TRUE); |
| |
| insert(UPD_SAVEPOINT_ON_ERROR, "OFF", errOrWarn); |
| } |
| else |
| { |
| NAString defCat = getValue(CATALOG); |
| insert(SEABASE_VOLATILE_TABLES, "OFF", errOrWarn); |
| CmpCommon::context()->sqlSession()->setVolatileCatalogName(defCat); |
| |
| insert(UPD_SAVEPOINT_ON_ERROR, "ON", errOrWarn); |
| } |
| } |
| break; |
| |
| case MEMORY_LIMIT_QCACHE_UPPER_KB: |
| CURRENTQCACHE->setHeapUpperLimit((size_t) 1024 * atoi(value.data())); |
| break; |
| |
| case MEMORY_LIMIT_HISTCACHE_UPPER_KB: |
| CURRCONTEXT_HISTCACHE->setHeapUpperLimit((size_t) 1024 * atoi(value.data())); |
| break; |
| |
| case MEMORY_LIMIT_CMPSTMT_UPPER_KB: |
| STMTHEAP->setUpperLimit((size_t) 1024 * atoi(value.data())); |
| break; |
| |
| case MEMORY_LIMIT_CMPCTXT_UPPER_KB: |
| CTXTHEAP->setUpperLimit((size_t) 1024 * atoi(value.data())); |
| break; |
| |
| case MEMORY_LIMIT_NATABLECACHE_UPPER_KB: |
| ActiveSchemaDB()->getNATableDB()->setHeapUpperLimit((size_t) 1024 * atoi(value.data())); |
| break; |
| |
| case NAMETYPE: |
| SqlParser_NADefaults_->NAMETYPE_ = token(NAMETYPE, value, TRUE); |
| break; |
| case NATIONAL_CHARSET: |
| SqlParser_NADefaults_->NATIONAL_CHARSET_ = CharInfo::getCharSetEnum(value); |
| break; |
| case SESSION_ID: |
| { |
| CmpCommon::context()->sqlSession()->setSessionId(value); |
| } |
| break; |
| case SESSION_USERNAME: |
| { |
| CmpCommon::context()->sqlSession()->setSessionUsername(value); |
| } |
| break; |
| case SESSION_IN_USE: |
| { |
| CmpCommon::context()->sqlSession()->setSessionInUse |
| ((getToken(attrEnum) == DF_ON)); |
| } |
| break; |
| |
| case SQLMX_REGRESS: |
| { |
| if (value == "ON") |
| { |
| insert(SHOWDDL_DISPLAY_FORMAT, "INTERNAL", errOrWarn); |
| insert(MODE_SPECIAL_1, "OFF", errOrWarn); |
| if (getToken(VOLATILE_TABLE_FIND_SUITABLE_KEY) == DF_SYSTEM) |
| { |
| insert(VOLATILE_TABLE_FIND_SUITABLE_KEY, "OFF", errOrWarn); |
| } |
| |
| char * env = getenv("SQLMX_REGRESS"); |
| if (env) |
| CmpCommon::context()->setSqlmxRegress(atoi(env)); |
| else |
| CmpCommon::context()->setSqlmxRegress(1); |
| } |
| else |
| { |
| insert(SHOWDDL_DISPLAY_FORMAT, "EXTERNAL", errOrWarn); |
| |
| CmpCommon::context()->setSqlmxRegress(0); |
| } |
| } |
| break; |
| |
| case VOLATILE_CATALOG: |
| { |
| CmpCommon::context()->sqlSession()->setVolatileCatalogName(value); |
| } |
| break; |
| case VOLATILE_SCHEMA_IN_USE: |
| { |
| CmpCommon::context()->sqlSession()->setVolatileSchemaInUse |
| ((getToken(attrEnum) == DF_ON)); |
| } |
| break; |
| |
| case ISO_MAPPING: |
| { |
| SqlParser_NADefaults_->ISO_MAPPING_ = CharInfo::getCharSetEnum(value); |
| // Set the NAString_isoMappingCS memory cache for use by routines |
| // ToInternalIdentifier() and ToAnsiIdentifier[2|3]() in module |
| // w:/common/NAString[2].cpp. These routines currently cannot |
| // access SqlParser_ISO_MAPPING directly due to the complex |
| // build hierarchy. |
| NAString_setIsoMapCS((SQLCHARSET_CODE) SqlParser_NADefaults_->ISO_MAPPING_); |
| } |
| break; |
| |
| case DEFAULT_CHARSET: |
| { |
| SqlParser_NADefaults_->DEFAULT_CHARSET_ = CharInfo::getCharSetEnum(value); |
| SqlParser_NADefaults_->ORIG_DEFAULT_CHARSET_ = CharInfo::getCharSetEnum(value); |
| } |
| break; |
| |
| case QUERY_TEXT_CACHE: |
| { |
| // If public schema is in use, query text cache has to be off |
| NAString pSchema = getValue(PUBLIC_SCHEMA_NAME); |
| if (pSchema != "") |
| value = "OFF"; |
| } |
| break; |
| |
| case PUBLIC_SCHEMA_NAME: |
| { |
| // when PUBLIC_SCHEMA is used, turn off Query Text Cache |
| if ( (value != "") && !(getToken(QUERY_TEXT_CACHE) == DF_OFF) ) |
| insert(QUERY_TEXT_CACHE, "OFF"); |
| // when PUBLIC_SCHEMA is not used, reset to the default value |
| if ( value == "" ) |
| { |
| NAString v(""); |
| validateAndInsert("QUERY_TEXT_CACHE", v, TRUE); |
| } |
| } |
| break; |
| |
| case LDAP_USERNAME: |
| { |
| // when the LDAP_USERNAME is set (first time by CLI) |
| // if DEFAULT_SCHEMA_NAMETYPE is USER, set schema to LDAP_USERNAME |
| if ( !value.isNull() && |
| (getToken(DEFAULT_SCHEMA_NAMETYPE) == DF_USER) && |
| !userDefault(SCHEMA) && // do not change user setting |
| ( schSetToUserID() || // only when schema was initialized to guardian id |
| schSetByNametype() ) ) // or changed by same CQD |
| { |
| setSchemaAsLdapUser(value); |
| setSchByNametype(TRUE); |
| } |
| } |
| break; |
| |
| case DEFAULT_SCHEMA_ACCESS_ONLY: |
| { |
| if ( value == "ON" ) |
| { |
| NAString schemaNameType = getValue(DEFAULT_SCHEMA_NAMETYPE); |
| if ( schemaNameType == "USER" ) |
| { |
| setSchemaAsLdapUser(); |
| } |
| } |
| } |
| break; |
| |
| case DEFAULT_SCHEMA_NAMETYPE: |
| { |
| if ( userDefault(SCHEMA) ) // if SCHEMA has been changed by user, do nothing |
| break; |
| |
| if ( value == "SYSTEM" ) |
| // reset to default schema |
| { |
| if ( schSetByNametype() ) // only when schema was changed by this CQD |
| { |
| // do not change catSchSetToUserID_ flag |
| Int32 preVal = catSchSetToUserID_; |
| NAString v(""); |
| validateAndInsert("SCHEMA", v, TRUE); |
| catSchSetToUserID_ = preVal; |
| } |
| } |
| if ( value == "USER" ) |
| // set default schema to ldpa username |
| { |
| if ( schSetToUserID() || // only when schema was initialized to guardian id |
| schSetByNametype() ) // or was changed by this CQD |
| { |
| setSchemaAsLdapUser(); |
| setSchByNametype(TRUE); |
| } |
| } |
| } |
| break; |
| |
| case USTAT_IUS_PERSISTENT_CBF_PATH: |
| { |
| // if the CBF path is SYSTEM, set it to $HOME/cbfs |
| if ( value == "SYSTEM" ) { |
| const char* home = getenv("HOME"); |
| |
| if ( home ) { |
| value = home; |
| value += "/cbfs"; |
| validateAndInsert("USTAT_IUS_PERSISTENT_CBF_PATH", value, FALSE); |
| } |
| } |
| } |
| break; |
| |
| case TRAF_LOAD_ERROR_LOGGING_LOCATION: |
| { |
| if (value.length() > 512) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(value) |
| << DgString1(lookupAttrName(attrEnum)); |
| } |
| } |
| break; |
| |
| case AGGRESSIVE_ESP_ALLOCATION_PER_CORE: |
| { |
| NABoolean useAgg = (getToken(attrEnum) == DF_ON); |
| float numESPsPerCore = computeNumESPsPerCore(useAgg); |
| char valuestr[WIDEST_CPUARCH_VALUE]; |
| ftoa_(numESPsPerCore, valuestr); |
| NAString val(valuestr); |
| insert(MAX_ESPS_PER_CPU_PER_OP, val, errOrWarn); |
| } |
| break; |
| |
| // max char col length is defined in common/ComSmallDefs.h. |
| // In special cases, it could be overridden. Internal use only or |
| // use only under trafodion supervision. |
| case TRAF_MAX_CHARACTER_COL_LENGTH: |
| { |
| NABoolean override = (getToken(TRAF_MAX_CHARACTER_COL_LENGTH_OVERRIDE) == DF_ON); |
| double d = atof(value.data()); |
| if ((NOT override) && |
| (NOT (d >= 0 && d <= MAX_CHAR_COL_LENGTH_IN_BYTES))) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(value) |
| << DgString1(lookupAttrName(attrEnum)); |
| } |
| } |
| break; |
| |
| case TRAF_MAX_CHARACTER_COL_LENGTH_OVERRIDE: |
| { |
| // if override is being turned off, reset max_char_len to default value. |
| if (value == "OFF") |
| { |
| NAString val; |
| validateAndInsert("TRAF_MAX_CHARACTER_COL_LENGTH", val, TRUE); |
| } |
| } |
| break; |
| case LOB_GC_LIMIT_SIZE: |
| if ((atoi(value.data()) < -1) || (((atoi(value.data()) >0) && (atoi(value.data())) <= 512))) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(value) |
| << DgString1(lookupAttrName(attrEnum)); |
| } |
| break; |
| |
| case LOB_MAX_CHUNK_MEM_SIZE: |
| if (atoi(value.data()) < 0 || atoi(value.data()) > 5120) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(value) |
| << DgString1(lookupAttrName(attrEnum)); |
| } |
| break; |
| |
| case LOB_INPUT_LIMIT_FOR_BATCH: |
| if (atoi(value.data()) <0 && (atoi(value.data())*1024) > INT_MAX ) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(value) |
| << DgString1(lookupAttrName(attrEnum)); |
| } |
| break; |
| default: |
| break; |
| } |
| } // code to valid overwrite (insert) |
| |
| if (reset && overwrite) { |
| // CONTROL QUERY DEFAULT attr RESET; -- this code cloned above |
| // Can't reset prov, because to which? |
| // provenances_[attrEnum] = READ_FROM_SQL_TABLE or COMPUTED ?? |
| NADELETEBASIC(resetToDefaults_[attrEnum], NADHEAP); |
| resetToDefaults_[attrEnum] = NULL; |
| } |
| else if (!overwrite && errOrWarn && getProvenance(attrEnum) >= IMMUTABLE) { |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(2200)) |
| << DgString0(lookupAttrName(attrEnum, errOrWarn)); |
| } |
| } // valid attrName |
| |
| return attrEnum; |
| |
| } // NADefaults::validateAndInsert() |
| |
| float NADefaults::computeNumESPsPerCore(NABoolean aggressive) |
| { |
| #define DEFAULT_ESPS_PER_NODE 2 // for conservation allocation |
| #define DEFAULT_ESPS_PER_CORE 0.5 // for aggressive allocation |
| |
| // Make sure the gpClusterInfo points at an NAClusterLinux object. |
| // In osim simulation mode, the pointer can point at a NAClusterNSK |
| // object, for which the method numTSEsForPOS() is not defined. |
| NAClusterInfoLinux* gpLinux = dynamic_cast<NAClusterInfoLinux*>(gpClusterInfo); |
| assert(gpLinux); |
| |
| // cores per node |
| Lng32 coresPerNode = gpClusterInfo->numberOfCpusPerSMP(); |
| |
| if ( aggressive ) { |
| float totalMemory = gpLinux->totalMemoryAvailable(); // per Node, in KB |
| totalMemory /= (1024*1024); // per Node, in GB |
| totalMemory /= coresPerNode ; // per core, in GB |
| totalMemory /= 2; // per core, 2GB per ESP |
| return MINOF(DEFAULT_ESPS_PER_CORE, totalMemory); |
| } else { |
| Lng32 numESPsPerNode = DEFAULT_ESPS_PER_NODE; |
| return (float)(numESPsPerNode)/(float)(coresPerNode); |
| } |
| |
| // The following lines of code are comment out but retained for possible |
| // future references. |
| // |
| // // number of POS TSE |
| // Lng32 numTSEsPerCluster = gpLinux->numTSEsForPOS(); |
| // |
| // // cluster nodes |
| // Lng32 nodesdPerCluster = gpClusterInfo->getTotalNumberOfCPUs(); |
| // |
| // // TSEs per node |
| // Lng32 TSEsPerNode = numTSEsPerCluster/nodesdPerCluster; |
| // |
| // |
| // |
| // // For Linux/nt, we conservatively allocate ESPs per node as follows |
| // // - 1 ESP per 2 cpu cores if cores are equal or less than TSEs |
| // // - 1 ESP per TSE if number of cores is more than double the TSEs |
| // // - 1 ESP per 2 TSEs if cores are more than TSEs but less than double the TSEs |
| // // - 1 ESP per node. Only possible on NT or workstations |
| // // - number of cores less than TSEs and there are 1 or 2 cpur cores per node |
| // // - number of TSEs is less than cpu cores and there 1 or 2 TSEs per node. |
| // // This case is probable if virtual nodes are used |
| // |
| // // TSEsPerNode is 0 for arkcmps started by the seapilot universal comsumers |
| // // in this case we only consider cpu cores |
| // if ( coresPerNode <= TSEsPerNode || TSEsPerNode == 0 ) |
| // { |
| // if (coresPerNode > 1) |
| // numESPsPerNode = DEFAULT_ESPS_PER_NODE; |
| // } |
| // else if (coresPerNode > (TSEsPerNode*2)) |
| // { |
| // numESPsPerNode = TSEsPerNode; |
| // } |
| // else if (TSEsPerNode > 1) |
| // { |
| // numESPsPerNode = TSEsPerNode/2; |
| // } |
| // else // not really needed since numESPsPerNode is set to 1 from above |
| // { |
| // numESPsPerNode = DEFAULT_ESPS_PER_NODE; |
| // } |
| // |
| // return (float)(numESPsPerNode)/(float)(coresPerNode); |
| } |
| |
| enum DefaultConstants NADefaults::holdOrRestore (const char *attrName, |
| Lng32 holdOrRestoreCQD) |
| { |
| DefaultConstants attrEnum = __INVALID_DEFAULT_ATTRIBUTE; |
| if (holdOrRestoreCQD == 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2050) |
| << DgString0(attrName); |
| |
| return attrEnum; |
| } |
| |
| // Perform a lookup for the string, using a binary search. |
| attrEnum = lookupAttrName(attrName, -1); |
| |
| if (attrEnum < 0) |
| { |
| *CmpCommon::diags() << DgSqlCode(-2050) |
| << DgString0(attrName); |
| |
| return attrEnum; |
| } |
| |
| char * value = NULL; |
| if (holdOrRestoreCQD == 1) // hold cqd |
| { |
| if (currentDefaults_[attrEnum]) |
| { |
| value = new NADHEAP char[strlen(currentDefaults_[attrEnum]) + 1]; |
| strcpy(value, currentDefaults_[attrEnum]); |
| } |
| else |
| { |
| value = new NADHEAP char[strlen(defaultDefaults[defDefIx_[attrEnum]].value) + 1]; |
| strcpy(value, defaultDefaults[defDefIx_[attrEnum]].value); |
| } |
| |
| if (! heldDefaults_[attrEnum]) |
| heldDefaults_[attrEnum] = new NADHEAP HeldDefaults(); |
| |
| heldDefaults_[attrEnum]->pushDefault(value); |
| } |
| else |
| { |
| // restore cqd from heldDefaults_ array, if it was held. |
| if (! heldDefaults_[attrEnum]) |
| return attrEnum; |
| |
| value = heldDefaults_[attrEnum]->popDefault(); |
| if (! value) |
| return attrEnum; |
| |
| // there is an odd semantic that if currentDefaults_[attrEnum] |
| // is null, we leave it as null, but pop a held value anyway; |
| // this semantic was preserved when heldDefaults_ was converted |
| // to a stack. |
| |
| if (currentDefaults_[attrEnum]) |
| { |
| // do a validateAndInsert so the caches (such as currentToken_) |
| // get updated and so appropriate semantic actions are taken. |
| // Note that validateAndInsert will take care of deleting the |
| // storage currently held by currentDefaults_[attrEnum]. |
| NAString valueS(value); |
| validateAndInsert(lookupAttrName(attrEnum), // sad that we have to do a lookup again |
| valueS, |
| FALSE); |
| } |
| NADELETEBASIC(value, NADHEAP); |
| } |
| |
| return attrEnum; |
| } |
| |
| |
| const SqlParser_NADefaults *NADefaults::getSqlParser_NADefaults() |
| { |
| return SqlParser_NADefaults_; |
| } |
| |
| static void setCatSchErr(NAString &value, |
| Lng32 sqlCode, |
| Int32 errOrWarn, |
| NABoolean catErr = FALSE) |
| { |
| if (!sqlCode || !errOrWarn) return; |
| |
| TrimNAStringSpace(value); // prettify further (neater errmsg) |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(sqlCode)) |
| << DgCatalogName(value) << DgSchemaName(value) |
| << DgString0(value) << DgString1(value); |
| |
| if (value.first('"') == NA_NPOS) { // delimited names too complicated ! |
| NAString namepart = value; |
| size_t dot = value.first('.'); |
| if (dot != NA_NPOS) { |
| namepart.remove(dot); |
| if (!IsSqlReservedWord(namepart)) { |
| namepart = value; |
| namepart.remove(0, dot+1); |
| } |
| } |
| if (IsSqlReservedWord(namepart)) { |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(3128)) |
| << DgString0(namepart) << DgString1(namepart); |
| return; |
| } |
| } |
| |
| // must determine if the defaults have been set up before parseDML is called |
| if (IdentifyMyself::GetMyName() == I_AM_UNKNOWN){ |
| return; // diagnostic already put into diags above. |
| } |
| // Produce additional (more informative) syntax error messages, |
| // trying delimited-value first and then possibly regular-value-itself. |
| Parser parser(CmpCommon::context()); |
| Lng32 errs = CmpCommon::diags()->getNumber(DgSqlCode::ERROR_); |
| NAString pfx(catErr ? "SET CATALOG " : "SET SCHEMA "); |
| NAString stmt; |
| char c = *value.data(); |
| if (c && c != '\"') { |
| stmt = pfx; |
| stmt += "\""; |
| stmt += value; |
| stmt += "\""; |
| stmt += ";"; |
| parser.parseDML(stmt, stmt.length(), |
| OBJECTNAMECHARSET |
| ); |
| } |
| if (errs == CmpCommon::diags()->getNumber(DgSqlCode::ERROR_)) { |
| stmt = pfx; |
| stmt += value; |
| stmt += ";"; |
| parser.parseDML(stmt, stmt.length(), |
| OBJECTNAMECHARSET |
| ); |
| } |
| |
| // Change errors to warnings if errOrWarn is +1 (i.e. warning). |
| if (errOrWarn > 0) NegateAllErrors(CmpCommon::diags()); |
| } |
| |
| NABoolean NADefaults::setCatalog(NAString &value, |
| Int32 errOrWarn, |
| NABoolean overwrite, |
| NABoolean alreadyCanonical) |
| { |
| setCatUserID(currentState_ == COMPUTED); |
| |
| // The input value is in external (Ansi) format. |
| // If we are in the COMPUTED currentState_, |
| // make the value strictly canonical, |
| // and try non-delimited first, then delimited. |
| // Prettify removes lead/trailing blanks, |
| // and upcases where unquoted (for nicer errmsgs); |
| // ComSchemaName parses/validates. |
| // |
| if (alreadyCanonical) |
| ; // leave it alone, for performance's sake |
| else if (currentState_ == COMPUTED) { // ' SQL.FOO' |
| TrimNAStringSpace(value); // 'SQL.FOO' |
| NAString tmp(value); |
| value = ToAnsiIdentifier(value); // nondelim ok? |
| if (value.isNull()) value = NAString("\"") + tmp + "\""; // '"SQL.FOO"' |
| } |
| else |
| PrettifySqlText(value); |
| |
| ComSchemaName nam(value); |
| if (nam.getSchemaNamePart().isEmpty() || // 0 name parts, if *any* error |
| !nam.getCatalogNamePart().isEmpty()) { // 2 parts (cat.sch) is an error |
| setCatSchErr(value, EXE_INVALID_CAT_NAME, errOrWarn, TRUE); |
| return FALSE; // invalid value |
| } |
| else { |
| // Get the 1 name part (the "schema" part as far as ComSchema knows...) |
| if (overwrite) insert(CATALOG, nam.getSchemaNamePartAsAnsiString()); |
| return TRUE; |
| } |
| } |
| |
| |
| |
| NABoolean NADefaults::setSchema(NAString &value, |
| Int32 errOrWarn, |
| NABoolean overwrite, |
| NABoolean alreadyCanonical) |
| { |
| // if this is part of CQD *RESET and it was initialized with role name |
| // do not change the following flags |
| // to allow DEFAULT_SCHEMA_NAMETYPE to set its value |
| if (!( schSetToUserID() && isResetAll() )) |
| { |
| setSchUserID(currentState_ == COMPUTED); |
| setSchByNametype(FALSE); |
| } |
| |
| if (alreadyCanonical) |
| ; // leave it alone, for performance's sake |
| else if (currentState_ == COMPUTED) { // ' SQL.FOO' |
| TrimNAStringSpace(value); // 'SQL.FOO' |
| NAString tmp(value); |
| value = ToAnsiIdentifier(value); // nondelim ok? |
| if (value.isNull()) value = NAString("\"") + tmp + "\""; // '"SQL.FOO"' |
| } |
| else |
| PrettifySqlText(value); |
| |
| ComSchemaName nam(value); |
| if (nam.getSchemaNamePart().isEmpty()) { // 0 name parts, if *any* error |
| setCatSchErr(value, EXE_INVALID_SCH_NAME, errOrWarn); |
| return FALSE; // invalid value |
| } |
| else { |
| if (overwrite) |
| insert(SCHEMA, |
| nam.getSchemaNamePartAsAnsiString()); |
| |
| // If 2 parts, overwrite any prior catalog default |
| if (!nam.getCatalogNamePart().isEmpty()) { |
| if (overwrite) |
| { |
| insert(CATALOG, |
| nam.getCatalogNamePartAsAnsiString()); |
| |
| if (currentState_ == SET_BY_CQD) |
| { |
| // indicate that this attribute was set by a user CQD. |
| setUserDefault(CATALOG, TRUE); |
| } |
| } |
| } |
| return TRUE; |
| } |
| } |
| |
| NAString NADefaults::keyword(DefaultToken tok) |
| { |
| CMPASSERT(tok >= 0 && tok < DF_lastToken); |
| return keywords_[tok]; |
| } |
| |
| // Defaults Tokens |
| // There is a set of keywords which can appear as values of Defaults entries |
| // in the Defaults Table. We declare, for each such token, a string (the |
| // keyword), and an enumeration value. The string values belong in an |
| // array, DFkeywords, in sorted order. The idea is we can use binary |
| // search in order to obtain the index of a string to the matching |
| // entry in this sorted array. |
| // |
| // If we define the enumerations carefully (pay attention here!), then |
| // that index we just found (see previous paragraph) is the enum value |
| // of the token. |
| |
| // In simple words: this has to be in identical order with enum DefaultToken |
| // in DefaultConstants.h |
| |
| const char *NADefaults::keywords_[DF_lastToken] = { |
| "ACCUMULATED", |
| "ADVANCED", |
| "AGGRESSIVE", |
| "ALL", |
| "ANSI", |
| "BEGINNER", |
| "BOTH", |
| "CLEAR", |
| "DEBUG", |
| "DISK", |
| "DISK_POOL", |
| "DUMP", |
| "DUMP_MV", |
| "EXTERNAL", |
| "EXTERNAL_DETAILED", |
| "FIRSTROW", |
| "HARDWARE", |
| "HEAP", |
| "HIGH", |
| "HYBRID", |
| "IEEE", |
| "INDEXES", |
| "INTERNAL", |
| "IQS", |
| "JNI", |
| "JNI_TRX", |
| "KEYINDEXES", |
| "LASTROW", |
| "LATEST", |
| "LEAF", |
| "LOADNODUP", |
| "LOCAL", |
| "LOCAL_NODE", |
| "LOG", |
| "MAXIMUM", |
| "MEDIUM", |
| "MEDIUM_LOW", |
| "MERGE", |
| "MINIMUM", |
| "MMAP", |
| "MULTI_NODE", |
| "MVCC", |
| "NONE", |
| "OFF", |
| "ON", |
| "OPENS_FOR_WRITE", |
| "OPERATOR", |
| "OPTIMAL", |
| "ORDERED", |
| "PERTABLE", |
| "PRINT", |
| "PRIVATE", |
| "PUBLIC", |
| "QS", |
| "READ_COMMITTED", |
| "READ_UNCOMMITTED", |
| "RELEASE", |
| "REMOTE", |
| "REPEATABLE_READ", |
| "REPLACE", |
| "REPSEL", |
| "RESOURCES", |
| "RETURN", |
| "ROOT", |
| "SAMPLE", |
| "SERIALIZABLE", |
| "SHORTANSI", |
| "SIMPLE", |
| "SKIP", |
| "SMD", |
| "SOFTWARE", |
| "SOURCE", |
| "SQLMP", |
| "SSCC", |
| "SSD", |
| "STOP", |
| "SUFFIX", |
| "SYSTEM", |
| "TANDEM", |
| "THRIFT", |
| "USER", |
| "VERTICAL", |
| "WAIT", |
| "WARN", |
| "XML" |
| }; |
| |
| // To call bsearch we must satisfy each of its arguments. Either |
| // NULL comes back, or, comes back a pointer to the element which is |
| // a true match for our key. bsearch.key is upperKey.data(). |
| // bsearch.base is keywords_. nel is DF_lastToken. |
| // The next argument is sizeof char*. Finally, the comparison |
| // function can simply be the strcmp function. |
| // |
| // Note that this function makes heavy reliance on the idea that |
| // the DefaultToken enumerations go up in sequence 0, 1, 2, 3... . |
| // |
| // We do the cast on strcmp because its signature from the header |
| // file is: int (*)(const char *, const char *). In general, we're |
| // doing a lot of type casting in here. |
| |
| static Int32 stringCompare(const void* s1, const void* s2) |
| { return strcmp( * (char**) s1, * (char**) s2); } |
| |
| DefaultToken NADefaults::token(Int32 attrEnum, |
| NAString &value, |
| NABoolean valueAlreadyGotten, |
| Int32 errOrWarn) const |
| { |
| ATTR_RANGE_ASSERT; |
| |
| if (!valueAlreadyGotten) { |
| value = getValue(attrEnum); // already trim & upper (by validateAndInsert) |
| TrimNAStringSpace(value); // can't trust that the stored value is canonical |
| } |
| else { |
| TrimNAStringSpace(value); // can't trust that input value is canonical, |
| value.toUpper(); // so here do what validateAndInsert does |
| } |
| |
| DefaultToken tok = DF_noSuchToken; |
| |
| if (value.isNull()) |
| tok = DF_SYSTEM; |
| else { |
| if ((attrEnum == TERMINAL_CHARSET) || |
| (attrEnum == USE_HIVE_SOURCE) || |
| (attrEnum == HIVE_FILE_CHARSET) || |
| (attrEnum == HBASE_DATA_BLOCK_ENCODING_OPTION) || |
| (attrEnum == HBASE_MEMSTORE_FLUSH_SIZE_OPTION) || |
| (attrEnum == HBASE_COMPRESSION_OPTION)) |
| return DF_USER; |
| |
| if ( attrEnum == NATIONAL_CHARSET || |
| attrEnum == DEFAULT_CHARSET || |
| attrEnum == HIVE_DEFAULT_CHARSET || |
| attrEnum == ISO_MAPPING || |
| attrEnum == INPUT_CHARSET || |
| attrEnum == TRAF_DEFAULT_COL_CHARSET ) |
| { |
| CharInfo::CharSet cs = CharInfo::getCharSetEnum(value); |
| Int32 err_found = 0; |
| |
| if ( !CharInfo::isCharSetSupported(cs) ) |
| { |
| err_found = 1; |
| } else { |
| switch( attrEnum ) { |
| case NATIONAL_CHARSET: |
| if (cs == CharInfo::KANJI_MP) break; //Allow (for regression test) |
| if ((cs != CharInfo::UNICODE) && (cs != CharInfo::ISO88591)) |
| err_found = 1; |
| break; |
| case DEFAULT_CHARSET: |
| if (cs != CharInfo::ISO88591 |
| && cs != CharInfo::UTF8 |
| // && cs != CharInfo::SJIS |
| ) |
| err_found = 1; |
| break; |
| case HIVE_DEFAULT_CHARSET: |
| case TRAF_DEFAULT_COL_CHARSET: |
| if ((cs != CharInfo::UTF8) && (cs != CharInfo::ISO88591)) |
| err_found = 1; |
| break; |
| case ISO_MAPPING: |
| if (cs != CharInfo::ISO88591) |
| err_found = 1; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| if ( (err_found != 0) && errOrWarn ) |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(3010)) << DgString0(value); |
| else |
| return DF_USER; // kludge, return any valid token |
| } //else |
| //else fall thru to see if value is SYSTEM |
| |
| // OPTIMIZATION_LEVEL |
| if ((attrEnum == OPTIMIZATION_LEVEL) && |
| value.length() == 1) |
| switch (*value.data()) { |
| case '0': return DF_MINIMUM; |
| case '1': return DF_MINIMUM; |
| case '2': return DF_MEDIUM_LOW; |
| case '3': return DF_MEDIUM; |
| case '4': return DF_MEDIUM; |
| case '5': return DF_MAXIMUM; |
| } |
| |
| // PCODE_OPT_LEVEL |
| if ((attrEnum == PCODE_OPT_LEVEL) && |
| value.length() == 1) |
| switch (*value.data()) { |
| case '0': return DF_MINIMUM; |
| case '1': return DF_MEDIUM; |
| case '2': return DF_HIGH; |
| case '3': return DF_MAXIMUM; |
| } |
| // HBASE_FILTER_PREDS |
| if ((attrEnum == HBASE_FILTER_PREDS) && value.length()==1) |
| switch (*value.data()){ |
| case '0': return DF_OFF; |
| case '1': return DF_MINIMUM; |
| case '2': return DF_MEDIUM; |
| // in the future add DF_HIGH and DF_MAXIMUM when we implement more |
| // pushdown capabilities |
| } |
| |
| if (attrEnum == MVQR_REWRITE_CANDIDATES || |
| attrEnum == MVQR_WORKLOAD_ANALYSIS_MV_NAME || |
| attrEnum == HIST_SCRATCH_VOL) |
| return DF_SYSTEM; |
| |
| const char *k = value.data(); |
| char *match = (char*) bsearch( |
| &k, keywords_, DF_lastToken, sizeof(char*), stringCompare); |
| if (match) |
| tok = (DefaultToken) (((const char**) match) - keywords_); |
| |
| else { // Check for synonyms |
| |
| const char *c = value; |
| for (; *c == '0'; c++) ; // all ascii '0' ? |
| if (*c == '\0') // terminating nul '\0' |
| tok = DF_OFF; |
| |
| else if (value.length() <= 2) { |
| if (value == "1" || value == "+1" || value == "-1") |
| tok = DF_ON; |
| } |
| |
| else { |
| if ((value == "STOP_AT") || (value == "STOP AT")) |
| tok = DF_STOP; |
| else if (value == "READ COMMITTED") |
| tok = DF_READ_COMMITTED; |
| else if (value == "READ UNCOMMITTED") |
| tok = DF_READ_UNCOMMITTED; |
| else if (value == "REPEATABLE READ") |
| tok = DF_REPEATABLE_READ; |
| else if (value == "BEGINNER") |
| tok = DF_BEGINNER; |
| else if (value == "ADVANCED") |
| tok = DF_ADVANCED; |
| |
| |
| #define CONVERT_SYNONYM(from,to) \ |
| else if (value == "" # from "") { \ |
| CMPASSERT(DF_ ## from == DF_ ## to); \ |
| tok = DF_ ## to; \ |
| } |
| CONVERT_SYNONYM(COMPAQ, TANDEM) |
| CONVERT_SYNONYM(DISABLE, OFF) |
| CONVERT_SYNONYM(ENABLE, SYSTEM) |
| CONVERT_SYNONYM(FALSE, OFF) |
| CONVERT_SYNONYM(FULL, MAXIMUM) |
| CONVERT_SYNONYM(TRUE, ON) |
| } |
| } |
| } |
| |
| NABoolean isValid = FALSE; |
| |
| if (tok != DF_noSuchToken) |
| switch (attrEnum) { |
| |
| case DEFAULT_SCHEMA_ACCESS_ONLY: |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case DEFAULT_SCHEMA_NAMETYPE: |
| if (tok == DF_SYSTEM || tok == DF_USER) |
| isValid = TRUE; |
| break; |
| |
| case DETAILED_STATISTICS: |
| if (tok == DF_ALL || |
| tok == DF_ACCUMULATED || tok == DF_OPERATOR || |
| tok == DF_PERTABLE || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case HIDE_INDEXES: |
| if (tok == DF_NONE || tok == DF_ALL || |
| tok == DF_VERTICAL || tok == DF_INDEXES || tok == DF_KEYINDEXES) |
| isValid = TRUE; |
| break; |
| |
| case HIVE_USE_EXT_TABLE_ATTRS: |
| if (tok == DF_ALL || tok == DF_OFF || tok == DF_ON ) |
| isValid = TRUE; |
| break; |
| |
| case INDEX_ELIMINATION_LEVEL: |
| if (tok == DF_MINIMUM || tok == DF_MEDIUM || |
| tok == DF_MAXIMUM || tok == DF_AGGRESSIVE ) |
| isValid = TRUE; |
| break; |
| case IF_LOCKED: |
| if (tok == DF_RETURN || tok == DF_WAIT) |
| isValid = TRUE; |
| break; |
| |
| case INSERT_VSBB: |
| if (tok == DF_OFF || tok == DF_LOADNODUP || |
| tok == DF_SYSTEM || tok == DF_USER) |
| isValid = TRUE; |
| break; |
| case OVERFLOW_MODE: |
| if (tok == DF_DISK || tok == DF_SSD || |
| tok == DF_MMAP) |
| isValid = TRUE; |
| break; |
| case SORT_ALGO: |
| if(tok == DF_HEAP || tok == DF_IQS || |
| tok == DF_REPSEL || tok == DF_QS) |
| isValid = TRUE; |
| break; |
| |
| case QUERY_TEMPLATE_CACHE: |
| case SHARE_TEMPLATE_CACHED_PLANS: |
| case VSBB_TEST_MODE: |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case QUERY_TEXT_CACHE: |
| if (tok == DF_ON || tok == DF_OFF || tok == DF_SYSTEM || tok == DF_SKIP) |
| isValid = TRUE; |
| break; |
| |
| case DISABLE_BUFFERED_INSERTS: |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case ISOLATION_LEVEL: |
| { |
| TransMode::IsolationLevel iltmp; |
| isValid = getIsolationLevel(iltmp, tok); |
| } |
| break; |
| |
| case ISOLATION_LEVEL_FOR_UPDATES: |
| { |
| TransMode::IsolationLevel iltmp; |
| isValid = getIsolationLevel(iltmp, tok); |
| } |
| break; |
| |
| case MVGROUP_AUTOMATIC_CREATION: |
| case MV_TRACE_INCONSISTENCY: //++ MV |
| case MV_AS_ROW_TRIGGER: //++ MV |
| { |
| if(DF_ON == tok || DF_OFF == tok) |
| { |
| isValid = TRUE; |
| |
| } |
| } |
| break; |
| |
| case IUD_NONAUDITED_INDEX_MAINT: |
| if (tok == DF_OFF || tok == DF_SYSTEM || |
| tok == DF_WARN || tok == DF_ON) |
| isValid = TRUE; |
| break; |
| |
| case HIVE_SCAN_SPECIAL_MODE: |
| isValid = TRUE; |
| break; |
| |
| case IS_SQLCI: |
| // for primary mxcmp that is invoked for user queries, the only valid |
| // value for mxci_process cqd is TRUE. This cqd is set once by mxci |
| // at startup time and cannot be changed by user. That way we know that |
| // a request has come in from mxci(trusted) process. |
| // For secondary mxcmp's invoked for internal queries where cqd's are |
| // sent using sendAllControls method, all values are valid. This will |
| // ensure that if this default is not set and is sent over to secondary |
| // mxcmp using an internal CQD statement, it doesn't return an error. |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case NVCI_PROCESS: |
| // for primary mxcmp that is invoked for user queries, the only valid |
| // value for nvci_process cqd is TRUE. This cqd is set once by nvci |
| // at startup time and cannot be changed by user. That way we know that |
| // a request has come in from nvci(trusted) process. |
| // For secondary mxcmp's invoked for internal queries where cqd's are |
| // sent using sendAllControls method, all values are valid. This will |
| // ensure that if this default is not set and is sent over to secondary |
| // mxcmp using an internal CQD statement, it doesn't return an error. |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case NAMETYPE: |
| if (tok == DF_ANSI || tok == DF_SHORTANSI) |
| isValid = TRUE; |
| break; |
| |
| case OPTIMIZATION_GOAL: |
| if (tok == DF_FIRSTROW || tok == DF_LASTROW || |
| tok == DF_RESOURCES) |
| isValid = TRUE; |
| break; |
| |
| case USER_EXPERIENCE_LEVEL: |
| if (tok == DF_ADVANCED || tok == DF_BEGINNER) |
| isValid = TRUE; |
| break; |
| |
| |
| case PCODE_OPT_LEVEL: |
| if (tok == DF_OFF) |
| { |
| isValid = TRUE; |
| break; |
| } |
| // else fall through to the next case, all those keywords are allowed |
| // as well |
| |
| case ATTEMPT_ESP_PARALLELISM: |
| if (tok == DF_SYSTEM || tok == DF_ON || |
| tok == DF_OFF || tok == DF_MAXIMUM) |
| isValid = TRUE; |
| break; |
| |
| case OPTIMIZATION_LEVEL: |
| if (tok == DF_MINIMUM || tok == DF_MEDIUM_LOW || |
| tok == DF_MEDIUM || tok == DF_MAXIMUM) |
| isValid = TRUE; |
| break; |
| |
| case HBASE_FILTER_PREDS: |
| if(tok == DF_OFF || tok == DF_ON) |
| { |
| if (tok == DF_ON) |
| tok = DF_MINIMUM; // to keep backward compatibility |
| isValid= TRUE; |
| } |
| break; |
| |
| case ROBUST_QUERY_OPTIMIZATION: |
| if (tok == DF_MINIMUM || tok == DF_SYSTEM || tok == DF_MAXIMUM || |
| tok == DF_HIGH) |
| isValid = TRUE; |
| break; |
| |
| case REFERENCE_CODE: |
| case TARGET_CODE: |
| if (tok == DF_RELEASE || tok == DF_DEBUG) |
| isValid = TRUE; |
| break; |
| |
| /* case ROLLBACK_ON_ERROR: |
| if (tok == DF_OFF || tok == DF_ON || |
| tok == DF_SYSTEM) |
| isValid = TRUE; |
| break; |
| */ |
| |
| case AUTO_QUERY_RETRY: |
| if (tok == DF_ON || |
| tok == DF_OFF || |
| tok == DF_SYSTEM) |
| isValid = TRUE; |
| break; |
| |
| case AUTO_QUERY_RETRY_WARNINGS: |
| case USE_LIBHDFS: |
| if (tok == DF_ON || |
| tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case EXE_PARALLEL_DDL: |
| if (tok == DF_OFF || |
| tok == DF_ON || |
| tok == DF_EXTERNAL || |
| tok == DF_INTERNAL) |
| isValid = TRUE; |
| break; |
| |
| case UNAVAILABLE_PARTITION: |
| if (tok == DF_SKIP || tok == DF_STOP) |
| isValid = TRUE; |
| break; |
| |
| case QUERY_CACHE_STATISTICS: |
| // on, off are no-ops |
| if (tok == DF_PRINT || tok == DF_ON || tok == DF_OFF) isValid = TRUE; |
| break; |
| |
| case QUERY_CACHE_STATEMENT_PINNING: |
| if (tok == DF_CLEAR || tok == DF_ON || tok == DF_OFF) isValid = TRUE; |
| break; |
| |
| case HJ_TYPE: |
| if (tok == DF_ORDERED || tok == DF_HYBRID || tok == DF_SYSTEM) |
| isValid = TRUE; |
| break; |
| |
| case REF_CONSTRAINT_NO_ACTION_LIKE_RESTRICT: |
| if (tok == DF_OFF || tok == DF_ON || |
| tok == DF_SYSTEM) |
| isValid = TRUE; |
| break; |
| |
| case POS: |
| if (tok == DF_LOCAL_NODE || tok == DF_OFF || |
| tok == DF_MULTI_NODE || tok == DF_DISK_POOL) |
| isValid = TRUE; |
| break; |
| |
| case USTAT_INTERNAL_SORT: |
| if (tok == DF_ON || tok == DF_OFF || tok == DF_HYBRID) |
| isValid = TRUE; |
| break; |
| |
| case USTAT_AUTO_FOR_VOLATILE_TABLES: |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case SUBQUERY_UNNESTING: |
| if (tok == DF_OFF || tok == DF_ON || tok == DF_DEBUG) |
| isValid = TRUE; |
| break; |
| |
| case SUBQUERY_UNNESTING_P2: |
| if (tok == DF_OFF || tok == DF_ON || tok == DF_INTERNAL) |
| isValid = TRUE; |
| break; |
| |
| case SORT_INTERMEDIATE_SCRATCH_CLEANUP: |
| if(tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case SORT_MEMORY_QUOTA_SYSTEM: |
| if(tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| /* |
| If MDAM_SCAN_METHOD's value is "MAXIMUM" only, Right side of Nested Join will |
| use the MDAM path |
| Allowable values for MDAM_SCAN_METHOD are 'ON' | 'OFF' | 'MAXIMUM' |
| */ |
| case MDAM_SCAN_METHOD: |
| if (tok == DF_ON || tok == DF_OFF || tok == DF_MAXIMUM) |
| isValid = TRUE; |
| break; |
| |
| case SHOWDDL_DISPLAY_FORMAT: |
| if (tok == DF_INTERNAL || tok == DF_EXTERNAL || tok == DF_LOG) |
| isValid = TRUE; |
| break; |
| |
| case SHOWDDL_DISPLAY_PRIVILEGE_GRANTS: |
| if (tok == DF_SYSTEM || tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case EXPLAIN_DISPLAY_FORMAT: |
| if (tok == DF_INTERNAL || tok == DF_EXTERNAL || tok == DF_EXTERNAL_DETAILED) |
| isValid = TRUE; |
| break; |
| |
| case UPDATE_CLUSTERING_OR_UNIQUE_INDEX_KEY: |
| if (tok == DF_ON || tok == DF_OFF || tok == DF_AGGRESSIVE) |
| isValid = TRUE; |
| break; |
| |
| case MVQR_ALL_JBBS_IN_QD: |
| case MVQR_REWRITE_ENABLED_OPTION: |
| case MVQR_REWRITE_SINGLE_TABLE_QUERIES: |
| case MVQR_USE_EXTRA_HUB_TABLES: |
| case MVQR_ENABLE_LOGGING: |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case MVQR_LOG_QUERY_DESCRIPTORS: |
| if (tok == DF_OFF || tok == DF_DUMP || tok == DF_DUMP_MV || tok == DF_LOG) |
| isValid = TRUE; |
| break; |
| |
| case MVQR_PRIVATE_QMS_INIT: |
| if (tok == DF_SMD || tok == DF_XML || tok == DF_NONE) |
| isValid = TRUE; |
| break; |
| |
| case MVQR_PUBLISH_TO: |
| if (tok == DF_PUBLIC || tok == DF_PRIVATE || tok == DF_BOTH || tok == DF_NONE) |
| isValid = TRUE; |
| break; |
| |
| case MVQR_WORKLOAD_ANALYSIS_MV_NAME: |
| isValid = TRUE; |
| break; |
| |
| case ELIMINATE_REDUNDANT_JOINS: |
| if (tok == DF_OFF || tok == DF_ON || tok == DF_DEBUG || tok == DF_MINIMUM) |
| isValid = TRUE; |
| break; |
| |
| case VOLATILE_TABLE_FIND_SUITABLE_KEY: |
| if (tok == DF_SYSTEM || tok == DF_ON || |
| tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case CAT_DISTRIBUTE_METADATA: |
| if (tok == DF_OFF || tok == DF_LOCAL_NODE || tok == DF_ON) |
| isValid = TRUE; |
| break; |
| |
| case MV_DUMP_DEBUG_INFO: |
| if (tok == DF_OFF || tok == DF_ON) |
| isValid = TRUE; |
| break; |
| |
| case RANGESPEC_TRANSFORMATION: |
| if (tok == DF_OFF || tok == DF_ON || tok == DF_MINIMUM) |
| isValid = TRUE; |
| break; |
| |
| case ASYMMETRIC_JOIN_TRANSFORMATION: |
| if (tok == DF_MINIMUM || tok == DF_MAXIMUM) |
| isValid = TRUE; |
| break; |
| |
| case CAT_DEFAULT_COMPRESSION: |
| if (tok == DF_NONE || tok == DF_HARDWARE || tok == DF_SOFTWARE) |
| isValid = TRUE; |
| break; |
| |
| case REPLICATE_DISK_POOL: |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case COMPRESSION_TYPE: |
| if (tok == DF_NONE || tok == DF_HARDWARE || tok == DF_SOFTWARE) |
| isValid = TRUE; |
| break; |
| |
| // The DF_SAMPLE setting indicates that the persistent sample will be |
| // updated incrementally, but not the histograms; they will be created |
| // anew from the incrementally updated sample. |
| case USTAT_INCREMENTAL_UPDATE_STATISTICS: |
| if (tok == DF_OFF || tok == DF_SAMPLE || tok == DF_ON) |
| isValid = TRUE; |
| break; |
| |
| case REPLICATE_COMPRESSION_TYPE: |
| if (tok == DF_NONE || tok == DF_HARDWARE || tok == DF_SOFTWARE |
| || tok == DF_SOURCE || tok == DF_SYSTEM) |
| isValid = TRUE; |
| break; |
| |
| case REUSE_OPENS: |
| if (tok==DF_ON || tok == DF_OFF || tok == DF_OPENS_FOR_WRITE) |
| isValid = TRUE; |
| break; |
| |
| case USE_HIVE_SOURCE: |
| isValid = TRUE; |
| break; |
| |
| case TRAF_SIMILARITY_CHECK: |
| if (tok == DF_ROOT || tok == DF_LEAF || tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| |
| case TRAF_TABLE_SNAPSHOT_SCAN: |
| if (tok == DF_NONE || tok == DF_SUFFIX || tok == DF_LATEST) |
| isValid = TRUE; |
| break; |
| |
| case TRAF_TRANS_TYPE: |
| if (tok == DF_MVCC || tok == DF_SSCC) |
| isValid = TRUE; |
| break; |
| |
| case HBASE_RANGE_PARTITIONING_PARTIAL_COLS: |
| if (tok == DF_OFF || tok == DF_MINIMUM || |
| tok == DF_MEDIUM || tok == DF_MAXIMUM || tok == DF_ON) |
| isValid = TRUE; |
| break; |
| case TRAF_UPSERT_MODE: |
| if (tok == DF_MERGE || tok == DF_REPLACE || tok == DF_OPTIMAL) |
| isValid = TRUE; |
| break; |
| |
| // Nothing needs to be added here for ON/OFF/SYSTEM keywords -- |
| // instead, add to DEFAULT_ALLOWS_SEPARATE_SYSTEM code in the ctor. |
| |
| default: |
| if (tok == DF_ON || tok == DF_OFF) |
| isValid = TRUE; |
| break; |
| } |
| |
| // See "NOTE 2" way up top. |
| if (!isValid) { |
| if (tok == DF_SYSTEM) { |
| isValid = isFlagOn(attrEnum, DEFAULT_ALLOWS_SEPARATE_SYSTEM); |
| if (!isValid) { |
| NAString tmp(getDefaultDefaultValue(attrEnum)); |
| isValid = isSynonymOfSYSTEM(attrEnum, tmp); |
| } |
| } |
| } |
| |
| if (!isValid) { |
| tok = DF_noSuchToken; |
| if (errOrWarn) |
| *CmpCommon::diags() << DgSqlCode(ERRWARN(2055)) |
| << DgString0(value) << DgString1(lookupAttrName(attrEnum)); |
| } |
| |
| return tok; |
| } |
| |
| DefaultToken NADefaults::getToken( const Int32 attrEnum, |
| const Int32 errOrWarn ) const |
| { |
| // Check the cache first. |
| if ( currentTokens_[attrEnum] != NULL ) |
| { |
| return *currentTokens_[attrEnum]; |
| } |
| |
| // Get the token and allocate memory to store the token value. |
| NAString tmp( NADHEAP ); |
| currentTokens_[attrEnum] = new NADHEAP DefaultToken; |
| *currentTokens_[attrEnum] = token( attrEnum, tmp, FALSE, errOrWarn ); |
| |
| return *currentTokens_[attrEnum]; |
| } |
| |
| NABoolean NADefaults::getIsolationLevel(TransMode::IsolationLevel &arg, |
| DefaultToken tok) const |
| { |
| NABoolean specifiedOK = TRUE; |
| |
| if (tok == DF_noSuchToken) |
| tok = getToken(ISOLATION_LEVEL); |
| |
| switch (tok) { |
| case DF_READ_COMMITTED: arg = TransMode::READ_COMMITTED_; break; |
| case DF_READ_UNCOMMITTED: arg = TransMode::READ_UNCOMMITTED_; break; |
| case DF_REPEATABLE_READ: arg = TransMode::REPEATABLE_READ_; break; |
| |
| case DF_SERIALIZABLE: |
| case DF_SYSTEM: arg = TransMode::SERIALIZABLE_; break; |
| case DF_NONE: arg = TransMode::IL_NOT_SPECIFIED_; break; |
| |
| default: arg = TransMode::SERIALIZABLE_; |
| specifiedOK = FALSE; |
| NAString value(NADHEAP); |
| if (tok != DF_noSuchToken) value = keyword(tok); |
| *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(value) |
| << DgString1("ISOLATION_LEVEL"); |
| } |
| |
| return specifiedOK; |
| } |
| |
| // find the packed length for all the default values stored |
| // in currentDefaults_ array. |
| // currentDefaults_ is a fixed sized array of "char *" where each |
| // entry is pointing to the default value for that default. |
| // After pack, the default values are put in the buffer in |
| // sequential order with a null terminator. |
| Lng32 NADefaults::packedLengthDefaults() |
| { |
| Lng32 size = 0; |
| |
| const size_t numAttrs = numDefaultAttributes(); |
| |
| for (size_t i = 0; i < numAttrs; i++) |
| { |
| size += strlen(currentDefaults_[i]) + 1; |
| } |
| |
| return size; |
| } |
| |
| Lng32 NADefaults::packDefaultsToBuffer(char * buffer) |
| { |
| const size_t numAttrs = numDefaultAttributes(); |
| |
| Lng32 totalSize = 0; |
| Lng32 size = 0; |
| |
| for (UInt32 i = 0; i < numAttrs; i++) |
| { |
| size = (Lng32)strlen(currentDefaults_[i]) + 1; |
| |
| strcpy(buffer, currentDefaults_[i]); |
| |
| buffer += size; |
| |
| totalSize += size; |
| } |
| |
| |
| return totalSize; |
| } |
| |
| Lng32 NADefaults::unpackDefaultsFromBuffer(Lng32 numEntriesInBuffer, |
| char * buffer) |
| { |
| return 0; |
| } |
| |
| NABoolean NADefaults::isSameCQD(Lng32 numEntriesInBuffer, |
| char * buffer, Lng32 bufLen) |
| { |
| const Lng32 numCurrentDefaultAttrs = (Lng32)numDefaultAttributes(); |
| |
| // check to see if the default values in 'buffer' are the same |
| // as those in the currentDefaults_ array. |
| // Return TRUE if they are all the same. |
| if (numCurrentDefaultAttrs != numEntriesInBuffer) |
| return FALSE; |
| |
| if (bufLen == 0) |
| return FALSE; |
| |
| Int32 curPos = 0; |
| for (Int32 i = 0; i < numEntriesInBuffer; i++) |
| { |
| if (strcmp(currentDefaults_[i], &buffer[curPos]) != 0) |
| return FALSE; |
| curPos += strlen(&buffer[curPos]) + 1; |
| } |
| |
| // everything matches. |
| return TRUE; |
| } |
| |
| Lng32 NADefaults::createNewDefaults(Lng32 numEntriesInBuffer, |
| char * buffer) |
| { |
| const Lng32 numCurrentDefaultAttrs = (Lng32)numDefaultAttributes(); |
| |
| // save the current defaults |
| savedCurrentDefaults_ = currentDefaults_; |
| savedCurrentFloats_ = currentFloats_; |
| savedCurrentTokens_ = currentTokens_; |
| |
| // VO, Plan Versioning Support. |
| // |
| // This code may execute in a downrev compiler, which knows about fewer |
| // defaults than the compiler originally used to compile the statement. |
| // Only copy those defaults we know about, and skip the rest. |
| Lng32 numEntriesToCopy = _min (numEntriesInBuffer, numCurrentDefaultAttrs); |
| |
| // allocate a new currentDefaults_ array and make it point to |
| // the default values in the input 'buffer'. |
| // If the current number of default attributes are greater than the |
| // ones in the input buffer, then populate the remaining default |
| // entries in the currentDefaults_ array with the values from the |
| // the savedCurrentDefaults_. |
| currentDefaults_ = new NADHEAP const char * [numCurrentDefaultAttrs]; |
| |
| Int32 curPos = 0; |
| Int32 i = 0; |
| for (i = 0; i < numEntriesToCopy; i++) |
| { |
| currentDefaults_[i] = &buffer[curPos]; |
| curPos += strlen(&buffer[curPos]) + 1; |
| } |
| |
| for (i = numEntriesToCopy; i < numCurrentDefaultAttrs; i++) |
| { |
| currentDefaults_[i] = savedCurrentDefaults_[i]; |
| } |
| |
| // allocate two empty arrays for floats and tokens. |
| currentFloats_ = new NADHEAP float * [numCurrentDefaultAttrs]; |
| currentTokens_ = new NADHEAP DefaultToken * [numCurrentDefaultAttrs]; |
| memset( currentFloats_, 0, sizeof(float *) * numCurrentDefaultAttrs ); |
| memset( currentTokens_, 0, sizeof(DefaultToken *) * numCurrentDefaultAttrs ); |
| |
| return 0; |
| } |
| |
| Lng32 NADefaults::restoreDefaults(Lng32 numEntriesInBuffer, |
| char * buffer) |
| { |
| // Deallocate the currentDefaults_ array. |
| // The array entries are not to be deleted as they point to |
| // entries in 'buffer' or the 'savedCurrentDefaults_'. |
| // See NADefaults::createNewDefaults() method. |
| if (currentDefaults_) |
| { |
| NADELETEBASIC(currentDefaults_, NADHEAP); |
| } |
| |
| if (currentFloats_) |
| { |
| for (size_t i = numDefaultAttributes(); i--; ) |
| NADELETEBASIC(currentFloats_[i], NADHEAP); |
| NADELETEBASIC(currentFloats_, NADHEAP); |
| } |
| |
| if (currentTokens_) |
| { |
| for (size_t i = numDefaultAttributes(); i--; ) |
| NADELETEBASIC(currentTokens_[i], NADHEAP); |
| NADELETEBASIC(currentTokens_, NADHEAP); |
| } |
| |
| // restore the saved defaults |
| currentDefaults_ = savedCurrentDefaults_; |
| currentFloats_ = savedCurrentFloats_; |
| currentTokens_ = savedCurrentTokens_; |
| |
| return 0; |
| } |
| |
| void NADefaults::updateCurrentDefaultsForOSIM(DefaultDefault * defaultDefault, |
| NABoolean validateFloatVal) |
| { |
| Int32 attrEnum = defaultDefault->attrEnum; |
| const char * defaultVal = defaultDefault->value; |
| const char * valueStr = currentDefaults_[attrEnum]; |
| |
| if(valueStr) |
| { |
| NADELETEBASIC(valueStr,NADHEAP); |
| } |
| |
| char * value = new NADHEAP char[strlen(defaultVal) + 1]; |
| strcpy(value, defaultVal); |
| currentDefaults_[attrEnum] = value; |
| |
| if ( validateFloatVal ) |
| { |
| float floatVal = 0; |
| if (validateFloat(currentDefaults_[attrEnum], floatVal, attrEnum)) { |
| if (currentFloats_[attrEnum]) { |
| NADELETEBASIC(currentFloats_[attrEnum], NADHEAP); |
| } |
| currentFloats_[attrEnum] = new NADHEAP float; |
| *currentFloats_[attrEnum] = floatVal; |
| } |
| } |
| |
| if ( currentTokens_[attrEnum] ) |
| { |
| NADELETEBASIC( currentTokens_[attrEnum], NADHEAP ); |
| currentTokens_[attrEnum] = NULL; |
| } |
| } |
| |
| void NADefaults::setSchemaAsLdapUser(const NAString val) |
| { |
| NAString ldapUsername = val; |
| if ( ldapUsername.isNull() ) |
| ldapUsername = getValue(LDAP_USERNAME); |
| if ( ldapUsername.isNull() ) |
| return; |
| |
| ldapUsername.toUpper(); |
| NAString schName = '"'; |
| schName += ldapUsername; |
| schName += '"'; |
| // check schema name before insert |
| // may get special characters from ldap |
| ComSchemaName cSchName(schName); |
| if ( !cSchName.getSchemaNamePart().isEmpty() && |
| cSchName.getCatalogNamePart().isEmpty()) // should have no catalog |
| { |
| insert(SCHEMA, schName); |
| } |
| else |
| { *CmpCommon::diags() << DgSqlCode(-2055) |
| << DgString0(schName) |
| << DgString1("SCHEMA"); |
| } |
| } |