| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: <file> |
| * Description: |
| * |
| * |
| * Created: 7/10/95 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #include "Platform.h" |
| |
| |
| #include "exp_stdh.h" |
| #include "exp_clause_derived.h" |
| #include "exp_function.h" |
| #include "exp_interval.h" |
| #include "SQLTypeDefs.h" |
| |
| __declspec(dllimport) NABoolean ExExprComputeSpace(ex_tcb * tcb); |
| |
| static void getCaseDatatypes(short attr_type1, Lng32 attr_len1, short &type_op1, |
| short attr_type2, Lng32 attr_len2, short &type_op2, |
| Lng32 scaleDifference) |
| { |
| type_op1 = attr_type1; |
| type_op2 = attr_type2; |
| // |
| // If an operand is an interval, get its end field. |
| // |
| rec_datetime_field endField1; |
| rec_datetime_field endField2; |
| if ((type_op1 >= REC_MIN_INTERVAL) && (type_op1 <= REC_MAX_INTERVAL) && |
| (ExpInterval::getIntervalEndField(type_op1, endField1) != 0)) |
| return; |
| if ((type_op2 >= REC_MIN_INTERVAL) && (type_op2 <= REC_MAX_INTERVAL) && |
| (ExpInterval::getIntervalEndField(type_op2, endField2) != 0)) |
| return; |
| // |
| // If an operand is an interval and the other is an exact numeric or |
| // datetime, treat the interval as numeric. If both operands are intervals |
| // and they have the same end fields and the same fraction precision, |
| // treat them both as numeric. If an interval operand remains after |
| // these transformations, map it to a canonical type. |
| // |
| if ((type_op1 >= REC_MIN_INTERVAL) && (type_op1 <= REC_MAX_INTERVAL)) |
| { |
| if ( ((type_op2 >= REC_MIN_BINARY) && (type_op2 <= REC_MAX_BINARY)) || |
| ((type_op2 >= REC_MIN_DECIMAL) && (type_op2 <= REC_MAX_DECIMAL)) || |
| (type_op2 == REC_DATETIME) || |
| ((type_op2 >= REC_MIN_INTERVAL) && (type_op2 <= REC_MAX_INTERVAL) && |
| (endField1 == endField2) && (scaleDifference == 0)) ) |
| { |
| switch (attr_len1) |
| { |
| case SQL_SMALL_SIZE: |
| type_op1 = REC_BIN16_SIGNED; |
| break; |
| case SQL_INT_SIZE: |
| type_op1 = REC_BIN32_SIGNED; |
| break; |
| case SQL_LARGE_SIZE: |
| type_op1 = REC_BIN64_SIGNED; |
| break; |
| default: |
| assert(0); |
| break; |
| } |
| } |
| |
| // if type_op1 remained an interval datatype, convert it to canonical form |
| // (since internal representation only depends on end field) |
| |
| switch(type_op1) |
| { |
| case REC_INT_YEAR_MONTH: |
| type_op1 = REC_INT_MONTH; |
| break; |
| case REC_INT_DAY_HOUR: |
| type_op1 = REC_INT_HOUR; |
| break; |
| case REC_INT_DAY_MINUTE: |
| case REC_INT_HOUR_MINUTE: |
| type_op1 = REC_INT_MINUTE; |
| break; |
| case REC_INT_DAY_SECOND: |
| case REC_INT_HOUR_SECOND: |
| case REC_INT_MINUTE_SECOND: |
| type_op1 = REC_INT_SECOND; |
| break; |
| default: |
| break; // leave it unchanged |
| } |
| |
| } // end if type_op1 is an interval |
| |
| if ((type_op2 >= REC_MIN_INTERVAL) && (type_op2 <= REC_MAX_INTERVAL)) |
| { |
| if ( ((type_op1 >= REC_MIN_BINARY) && (type_op1 <= REC_MAX_BINARY)) || |
| ((type_op1 >= REC_MIN_DECIMAL) && (type_op1 <= REC_MAX_DECIMAL)) || |
| (type_op1 == REC_DATETIME) ) |
| { |
| switch (attr_len2) |
| { |
| case SQL_SMALL_SIZE: |
| type_op2 = REC_BIN16_SIGNED; |
| break; |
| case SQL_INT_SIZE: |
| type_op2 = REC_BIN32_SIGNED; |
| break; |
| case SQL_LARGE_SIZE: |
| type_op2 = REC_BIN64_SIGNED; |
| break; |
| } |
| } |
| |
| switch(type_op2) |
| { |
| case REC_INT_YEAR_MONTH: |
| type_op2 = REC_INT_MONTH; |
| break; |
| case REC_INT_DAY_HOUR: |
| type_op2 = REC_INT_HOUR; |
| break; |
| case REC_INT_DAY_MINUTE: |
| case REC_INT_HOUR_MINUTE: |
| type_op2 = REC_INT_MINUTE; |
| break; |
| case REC_INT_DAY_SECOND: |
| case REC_INT_HOUR_SECOND: |
| case REC_INT_MINUTE_SECOND: |
| type_op2 = REC_INT_SECOND; |
| break; |
| default: |
| break; // leave it unchanged |
| } |
| |
| } // end if type_op2 is an interval |
| } |
| |
| static void getConvCaseDatatypes(short attr_type1, Lng32 attr_len1, short &type_op1, |
| short attr_type2, Lng32 attr_len2, short &type_op2, |
| Lng32 scaleDifference) |
| { |
| // |
| // If an operand is ASCII and other is interval, just return |
| // some interval type (so as to not add multiple entries in |
| // the convert case array). At actual conversion time, the |
| // correct conversion is done based on the start and end fields. |
| // Lets make that 'fixed' datatype to be REC_INT_YEAR. |
| // |
| if ((attr_type1 >= REC_MIN_INTERVAL) && (attr_type1 <= REC_MAX_INTERVAL) && |
| (attr_type2 >= REC_MIN_CHARACTER) && (attr_type2 <= REC_MAX_CHARACTER)) |
| { |
| type_op1 = REC_INT_YEAR; |
| type_op2 = attr_type2; |
| } |
| else |
| if ((attr_type2 >= REC_MIN_INTERVAL) && (attr_type2 <= REC_MAX_INTERVAL) && |
| (attr_type1 >= REC_MIN_CHARACTER) && (attr_type1 <= REC_MAX_CHARACTER)) |
| { |
| type_op2 = REC_INT_YEAR; |
| type_op1 = attr_type1; |
| } |
| else |
| getCaseDatatypes(attr_type1, attr_len1, type_op1, |
| attr_type2, attr_len2, type_op2, |
| scaleDifference); |
| } |
| |
| ex_expr::exp_return_type ex_expr::fixup(Lng32 /*base*/, unsigned short mode, |
| const ex_tcb * tcb, |
| Space * space, |
| CollHeap * exHeap, |
| NABoolean computeSpaceOnly, |
| ex_globals * glob) |
| { |
| exp_return_type retcode = EXPR_OK; |
| |
| setHeap(exHeap); |
| myTcb_ = tcb; |
| |
| // The check for space is to prevent allocating off the heap in DP2. |
| if (space && tempsAreaLength_ > 0) // temps used |
| { |
| char * tempAllocArea = new(space) char[tempsAreaLength_]; |
| if (NOT computeSpaceOnly) |
| tempsArea_ = tempAllocArea; |
| } |
| |
| ex_clause *clause = clauses_; |
| while (clause) |
| { |
| retcode = clause->fixup(space, exHeap, |
| constantsArea_, tempsArea_, persistentArea_, |
| (short)getFixupConstsAndTemps(), |
| computeSpaceOnly); |
| clause->setProcessNulls(); |
| if (retcode == EXPR_ERROR) |
| return retcode; |
| |
| clause->setExeGlobals(glob); |
| clause->setTcb(tcb); |
| clause = clause->getNextClause(); |
| } |
| |
| // Set the fast evaluation pointer |
| if (!computeSpaceOnly) |
| setEvalPtr( TRUE /* isSamePrimary */ ); |
| |
| if (mode & INJECT_ERROR) |
| errorInjection_ = TRUE; |
| else |
| if (mode & INJECT_WARNING) |
| warningInjection_ = TRUE; |
| |
| return EXPR_OK; |
| }; |
| |
| ex_expr::exp_return_type ex_expr_lean::fixup(Lng32 /*base*/, |
| unsigned short mode, |
| const ex_tcb * tcb, |
| Space * space, |
| CollHeap * exHeap, |
| NABoolean computeSpaceOnly) |
| { |
| exp_return_type retcode = EXPR_OK; |
| |
| // The check for space is to prevent allocating off the heap in DP2. |
| if (space && tempsAreaLength_ > 0) // temps used |
| { |
| char * tempAllocArea = new(space) char[tempsAreaLength_]; |
| if (NOT computeSpaceOnly) |
| tempsArea_ = tempAllocArea; |
| } |
| |
| setHeap(exHeap); |
| |
| return retcode; |
| }; |
| |
| ex_expr::exp_return_type AggrExpr::fixup(Lng32 base, unsigned short mode, |
| const ex_tcb * tcb, |
| Space * space, |
| CollHeap * exHeap, |
| NABoolean computeSpaceOnly, |
| ex_globals * glob) |
| { |
| ex_expr::exp_return_type retcode; |
| |
| if (initExpr_) |
| { |
| if ((retcode = initExpr_->fixup(base, mode, tcb, space, |
| exHeap, computeSpaceOnly, glob)) != EXPR_OK) |
| return retcode; |
| } |
| |
| if (perrecExpr_) |
| { |
| if ((retcode = perrecExpr_->fixup(base, mode, tcb, space, |
| exHeap, computeSpaceOnly, glob)) != EXPR_OK) |
| return retcode; |
| } |
| |
| if (finalNullExpr_) |
| { |
| if ((retcode = finalNullExpr_->fixup(base, mode, tcb, space, |
| exHeap, computeSpaceOnly, glob)) |
| != EXPR_OK) |
| return retcode; |
| } |
| |
| if (finalExpr_) |
| { |
| if ((retcode = finalExpr_->fixup(base, mode, tcb, space, |
| exHeap, computeSpaceOnly, glob)) != EXPR_OK) |
| return retcode; |
| } |
| |
| if (groupingExpr_) |
| { |
| if ((retcode = groupingExpr_->fixup(base, mode, tcb, space, |
| exHeap, computeSpaceOnly, glob)) != EXPR_OK) |
| return retcode; |
| } |
| |
| // fixup the expression to do perrec aggregate evaluation. |
| if ((retcode = ex_expr::fixup(base, mode, tcb, space, |
| exHeap, computeSpaceOnly, glob)) != EXPR_OK) |
| return retcode; |
| |
| return EXPR_OK; |
| } |
| |
| ///////////////////////////////////////////////////////// |
| // clause fixup |
| ///////////////////////////////////////////////////////// |
| ex_expr::exp_return_type ex_clause::fixup(Space * space, |
| CollHeap * exHeap, |
| char * constantsArea, |
| char * tempsArea, |
| char * persistentArea, |
| short fixupFlag, |
| NABoolean spaceCompOnly) |
| { |
| for (Lng32 i=0; i<numOperands_;i++) |
| if (op_[i]) |
| op_[i]->fixup(space, |
| constantsArea, |
| tempsArea, |
| persistentArea, |
| fixupFlag, |
| spaceCompOnly); |
| |
| return ex_expr::EXPR_OK; |
| }; |
| |
| |
| ex_expr::exp_return_type ex_branch_clause::fixup(Space * space, |
| CollHeap * exHeap, |
| char * constantsArea, |
| char * tempsArea, |
| char * persistentArea, |
| short fixupFlag, |
| NABoolean spaceCompOnly) { |
| if (getNextClause() != saved_next_clause) |
| setNextClause(saved_next_clause); |
| return ex_clause::fixup(space, exHeap, constantsArea,tempsArea, persistentArea, fixupFlag, spaceCompOnly); |
| } |
| |
| |
| const ex_arith_clause::ArithInstrStruct ex_arith_clause::arithInstrInfo[] = |
| { |
| // op op1 datatype op2 datatype result datatype case statement index |
| {ITM_PLUS, REC_BIN16_SIGNED, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(ADD_BIN16S_BIN16S_BIN16S)}, |
| {ITM_PLUS, REC_BIN16_SIGNED, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(ADD_BIN16S_BIN16S_BIN32S)}, |
| {ITM_PLUS, REC_BIN16_SIGNED, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(ADD_BIN16S_BIN32S_BIN32S)}, |
| {ITM_PLUS, REC_BIN32_SIGNED, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(ADD_BIN32S_BIN16S_BIN32S)}, |
| {ITM_PLUS, REC_BIN32_SIGNED, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(ADD_BIN32S_BIN32S_BIN32S)}, |
| {ITM_PLUS, REC_BIN32_SIGNED, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(ADD_BIN32S_BIN64S_BIN64S)}, |
| {ITM_PLUS, REC_BIN64_SIGNED, REC_BIN32_SIGNED, REC_BIN64_SIGNED, instrAndText(ADD_BIN64S_BIN32S_BIN64S)}, |
| {ITM_PLUS, REC_BIN64_SIGNED, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(ADD_BIN64S_BIN64S_BIN64S)}, |
| |
| {ITM_PLUS, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(ADD_BIN16U_BIN16U_BIN16U)}, |
| {ITM_PLUS, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(ADD_BIN16U_BIN16U_BIN16U)}, |
| {ITM_PLUS, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(ADD_BIN16U_BIN16U_BIN16U)}, |
| {ITM_PLUS, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN16U_BIN16U_BIN32U)}, |
| {ITM_PLUS, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN16U_BIN16U_BIN32U)}, |
| {ITM_PLUS, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN16U_BIN16U_BIN32U)}, |
| {ITM_PLUS, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN16U_BIN32U_BIN32U)}, |
| {ITM_PLUS, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN32U_BIN16U_BIN32U)}, |
| {ITM_PLUS, REC_BPINT_UNSIGNED, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(ADD_BPINTU_BIN64S_BIN64S)}, |
| {ITM_PLUS, REC_BIN64_SIGNED, REC_BPINT_UNSIGNED, REC_BIN64_SIGNED, instrAndText(ADD_BIN64S_BPINTU_BIN64S)}, |
| |
| {ITM_PLUS, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(ADD_BIN16U_BIN16U_BIN16U)}, |
| {ITM_PLUS, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN16U_BIN16U_BIN32U)}, |
| {ITM_PLUS, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN16U_BIN32U_BIN32U)}, |
| {ITM_PLUS, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN32U_BIN16U_BIN32U)}, |
| {ITM_PLUS, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(ADD_BIN32U_BIN32U_BIN32U)}, |
| {ITM_PLUS, REC_BIN32_UNSIGNED, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(ADD_BIN32U_BIN64S_BIN64S)}, |
| {ITM_PLUS, REC_BIN64_SIGNED, REC_BIN32_UNSIGNED, REC_BIN64_SIGNED, instrAndText(ADD_BIN64S_BIN32U_BIN64S)}, |
| |
| {ITM_PLUS, REC_FLOAT32, REC_FLOAT32, REC_FLOAT32, instrAndText(ADD_FLOAT32_FLOAT32_FLOAT32)}, |
| {ITM_PLUS, REC_FLOAT64, REC_FLOAT64, REC_FLOAT64, instrAndText(ADD_FLOAT64_FLOAT64_FLOAT64)}, |
| {ITM_PLUS, REC_DATETIME, REC_BIN16_SIGNED, REC_DATETIME, instrAndText(ADD_DATETIME_INTERVAL_DATETIME)}, |
| {ITM_PLUS, REC_DATETIME, REC_BIN32_SIGNED, REC_DATETIME, instrAndText(ADD_DATETIME_INTERVAL_DATETIME)}, |
| {ITM_PLUS, REC_DATETIME, REC_BIN64_SIGNED, REC_DATETIME, instrAndText(ADD_DATETIME_INTERVAL_DATETIME)}, |
| {ITM_PLUS, REC_BIN16_SIGNED, REC_DATETIME, REC_DATETIME, instrAndText(ADD_INTERVAL_DATETIME_DATETIME)}, |
| {ITM_PLUS, REC_BIN32_SIGNED, REC_DATETIME, REC_DATETIME, instrAndText(ADD_INTERVAL_DATETIME_DATETIME)}, |
| {ITM_PLUS, REC_BIN64_SIGNED, REC_DATETIME, REC_DATETIME, instrAndText(ADD_INTERVAL_DATETIME_DATETIME)}, |
| |
| {ITM_PLUS, REC_UNKNOWN, REC_UNKNOWN, REC_UNKNOWN, instrAndText(ADD_COMPLEX)}, |
| |
| |
| {ITM_MINUS, REC_BIN16_SIGNED, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(SUB_BIN16S_BIN16S_BIN16S)}, |
| {ITM_MINUS, REC_BIN16_SIGNED, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(SUB_BIN16S_BIN16S_BIN32S)}, |
| {ITM_MINUS, REC_BIN16_SIGNED, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(SUB_BIN16S_BIN32S_BIN32S)}, |
| {ITM_MINUS, REC_BIN32_SIGNED, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(SUB_BIN32S_BIN16S_BIN32S)}, |
| {ITM_MINUS, REC_BIN32_SIGNED, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(SUB_BIN32S_BIN32S_BIN32S)}, |
| {ITM_MINUS, REC_BIN64_SIGNED, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(SUB_BIN64S_BIN64S_BIN64S)}, |
| {ITM_MINUS, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(SUB_BIN16U_BIN16U_BIN16U)}, |
| {ITM_MINUS, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(SUB_BIN16U_BIN16U_BIN16U)}, |
| {ITM_MINUS, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(SUB_BIN16U_BIN16U_BIN16U)}, |
| {ITM_MINUS, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN16U_BIN16U_BIN32U)}, |
| {ITM_MINUS, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN16U_BIN16U_BIN32U)}, |
| {ITM_MINUS, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN16U_BIN16U_BIN32U)}, |
| {ITM_MINUS, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN16U_BIN32U_BIN32U)}, |
| {ITM_MINUS, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN32U_BIN16U_BIN32U)}, |
| {ITM_MINUS, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(SUB_BIN16U_BIN16U_BIN16U)}, |
| {ITM_MINUS, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN16U_BIN16U_BIN32U)}, |
| {ITM_MINUS, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN16U_BIN32U_BIN32U)}, |
| {ITM_MINUS, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN32U_BIN16U_BIN32U)}, |
| {ITM_MINUS, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(SUB_BIN32U_BIN32U_BIN32U)}, |
| {ITM_MINUS, REC_FLOAT32, REC_FLOAT32, REC_FLOAT32, instrAndText(SUB_FLOAT32_FLOAT32_FLOAT32)}, |
| {ITM_MINUS, REC_FLOAT64, REC_FLOAT64, REC_FLOAT64, instrAndText(SUB_FLOAT64_FLOAT64_FLOAT64)}, |
| {ITM_MINUS, REC_DATETIME, REC_BIN16_SIGNED, REC_DATETIME, instrAndText(SUB_DATETIME_INTERVAL_DATETIME)}, |
| {ITM_MINUS, REC_DATETIME, REC_BIN32_SIGNED, REC_DATETIME, instrAndText(SUB_DATETIME_INTERVAL_DATETIME)}, |
| {ITM_MINUS, REC_DATETIME, REC_BIN64_SIGNED, REC_DATETIME, instrAndText(SUB_DATETIME_INTERVAL_DATETIME)}, |
| {ITM_MINUS, REC_DATETIME, REC_DATETIME, REC_BIN16_SIGNED, instrAndText(SUB_DATETIME_DATETIME_INTERVAL)}, |
| {ITM_MINUS, REC_DATETIME, REC_DATETIME, REC_BIN32_SIGNED, instrAndText(SUB_DATETIME_DATETIME_INTERVAL)}, |
| {ITM_MINUS, REC_DATETIME, REC_DATETIME, REC_BIN64_SIGNED, instrAndText(SUB_DATETIME_DATETIME_INTERVAL)}, |
| {ITM_MINUS, REC_UNKNOWN, REC_UNKNOWN, REC_UNKNOWN, instrAndText(SUB_COMPLEX)}, |
| |
| |
| {ITM_TIMES, REC_BIN16_SIGNED, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(MUL_BIN16S_BIN16S_BIN16S)}, |
| {ITM_TIMES, REC_BIN16_SIGNED, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(MUL_BIN16S_BIN16S_BIN32S)}, |
| {ITM_TIMES, REC_BIN16_SIGNED, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(MUL_BIN16S_BIN32S_BIN32S)}, |
| {ITM_TIMES, REC_BIN32_SIGNED, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(MUL_BIN32S_BIN16S_BIN32S)}, |
| {ITM_TIMES, REC_BIN32_SIGNED, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(MUL_BIN32S_BIN32S_BIN32S)}, |
| {ITM_TIMES, REC_BIN64_SIGNED, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(MUL_BIN64S_BIN64S_BIN64S)}, |
| {ITM_TIMES, REC_BIN16_SIGNED, REC_BIN32_SIGNED, REC_BIN64_SIGNED, instrAndText(MUL_BIN16S_BIN32S_BIN64S)}, |
| {ITM_TIMES, REC_BIN32_SIGNED, REC_BIN16_SIGNED, REC_BIN64_SIGNED, instrAndText(MUL_BIN32S_BIN16S_BIN64S)}, |
| {ITM_TIMES, REC_BIN32_SIGNED, REC_BIN32_SIGNED, REC_BIN64_SIGNED, instrAndText(MUL_BIN32S_BIN32S_BIN64S)}, |
| {ITM_TIMES, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(MUL_BIN16U_BIN16U_BIN16U)}, |
| {ITM_TIMES, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(MUL_BIN16U_BIN16U_BIN16U)}, |
| {ITM_TIMES, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(MUL_BIN16U_BIN16U_BIN16U)}, |
| {ITM_TIMES, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN16U_BIN16U_BIN32U)}, |
| {ITM_TIMES, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN16U_BIN16U_BIN32U)}, |
| {ITM_TIMES, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN16U_BIN16U_BIN32U)}, |
| {ITM_TIMES, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN16U_BIN32U_BIN32U)}, |
| {ITM_TIMES, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN32U_BIN16U_BIN32U)}, |
| {ITM_TIMES, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(MUL_BIN16U_BIN16U_BIN16U)}, |
| {ITM_TIMES, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN16U_BIN16U_BIN32U)}, |
| {ITM_TIMES, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN16U_BIN32U_BIN32U)}, |
| {ITM_TIMES, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN32U_BIN16U_BIN32U)}, |
| {ITM_TIMES, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(MUL_BIN32U_BIN32U_BIN32U)}, |
| {ITM_TIMES, REC_FLOAT32, REC_FLOAT32, REC_FLOAT32, instrAndText(MUL_FLOAT32_FLOAT32_FLOAT32)}, |
| {ITM_TIMES, REC_FLOAT64, REC_FLOAT64, REC_FLOAT64, instrAndText(MUL_FLOAT64_FLOAT64_FLOAT64)}, |
| {ITM_TIMES, REC_UNKNOWN, REC_UNKNOWN, REC_UNKNOWN, instrAndText(MUL_COMPLEX)}, |
| |
| |
| {ITM_DIVIDE, REC_BIN16_SIGNED, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(DIV_BIN16S_BIN16S_BIN16S)}, |
| {ITM_DIVIDE, REC_BIN16_SIGNED, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(DIV_BIN16S_BIN16S_BIN32S)}, |
| {ITM_DIVIDE, REC_BIN16_SIGNED, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(DIV_BIN16S_BIN32S_BIN32S)}, |
| {ITM_DIVIDE, REC_BIN32_SIGNED, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(DIV_BIN32S_BIN16S_BIN32S)}, |
| {ITM_DIVIDE, REC_BIN32_SIGNED, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(DIV_BIN32S_BIN32S_BIN32S)}, |
| {ITM_DIVIDE, REC_BIN64_SIGNED, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(DIV_BIN64S_BIN64S_BIN64S)}, |
| {ITM_DIVIDE, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(DIV_BIN16U_BIN16U_BIN16U)}, |
| {ITM_DIVIDE, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(DIV_BIN16U_BIN16U_BIN16U)}, |
| {ITM_DIVIDE, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(DIV_BIN16U_BIN16U_BIN16U)}, |
| {ITM_DIVIDE, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN16U_BIN16U_BIN32U)}, |
| {ITM_DIVIDE, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN16U_BIN16U_BIN32U)}, |
| {ITM_DIVIDE, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN16U_BIN16U_BIN32U)}, |
| {ITM_DIVIDE, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN16U_BIN32U_BIN32U)}, |
| {ITM_DIVIDE, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN32U_BIN16U_BIN32U)}, |
| {ITM_DIVIDE, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(DIV_BIN16U_BIN16U_BIN16U)}, |
| {ITM_DIVIDE, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN16U_BIN16U_BIN32U)}, |
| {ITM_DIVIDE, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN16U_BIN32U_BIN32U)}, |
| {ITM_DIVIDE, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN32U_BIN16U_BIN32U)}, |
| {ITM_DIVIDE, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(DIV_BIN32U_BIN32U_BIN32U)}, |
| {ITM_DIVIDE, REC_FLOAT64, REC_FLOAT64, REC_FLOAT64, instrAndText(DIV_FLOAT64_FLOAT64_FLOAT64)}, |
| {ITM_DIVIDE, REC_UNKNOWN, REC_UNKNOWN, REC_UNKNOWN, instrAndText(DIV_COMPLEX)}, |
| |
| {ITM_DIVIDE, REC_BIN64_SIGNED, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(DIV_BIN64S_BIN64S_BIN64S_ROUND)}, |
| |
| {ITM_NEGATE, REC_BOOLEAN, REC_BOOLEAN, REC_BOOLEAN, instrAndText(NEGATE_BOOLEAN)}, |
| |
| }; |
| |
| const ex_arith_clause::ArithInstrStruct * ex_arith_clause::getMatchingRow(OperatorTypeEnum op, |
| short datatype1, |
| short datatype2, |
| short resulttype) |
| { |
| Int32 max_array_size = sizeof(arithInstrInfo) / sizeof(ArithInstrStruct); |
| |
| Int32 i = 0; |
| Int32 found = 0; |
| while ((i < max_array_size) && (!found)) |
| if ((arithInstrInfo[i].op == op) && |
| (arithInstrInfo[i].type_op1 == datatype1) && |
| (arithInstrInfo[i].type_op2 == datatype2) && |
| (arithInstrInfo[i].type_op0 == resulttype)) |
| found = -1; |
| else |
| i++; |
| |
| if (found) |
| { |
| setInstrArrayIndex(i); |
| return &arithInstrInfo[i]; |
| } |
| else |
| return 0; |
| } |
| |
| Lng32 ex_arith_clause::findIndexIntoInstrArray(ArithInstruction ci) |
| { |
| Int32 max_array_size = sizeof(arithInstrInfo) / sizeof(ArithInstrStruct); |
| |
| Int32 i = 0; |
| while ((i < max_array_size) && |
| (arithInstrInfo[i].instruction != ci)) |
| { |
| i++; |
| } |
| |
| if (i < max_array_size) |
| return i; |
| |
| return -1; // not found |
| } |
| |
| const ArithInstruction ex_arith_clause::computeCaseIndex(OperatorTypeEnum op, |
| Attributes * attr1, |
| Attributes * attr2, |
| Attributes * result) |
| { |
| ArithInstruction instruction = ARITH_NOT_SUPPORTED; |
| |
| short type_op1 = -1; |
| short type_op2 = -1; |
| short type_result = -1; |
| getCaseDatatypes(attr1->getDatatype(), attr1->getLength(), type_op1, |
| result->getDatatype(), result->getLength(), type_result, |
| 0 /* don't need to take scale difference into account here */); |
| |
| // attr2 eill be null for unary operands. |
| // Some methods below expect 2 operands. Change oper2 to be the same as oper1 |
| // to avoid null pointer exception. |
| if (!attr2) |
| attr2 = attr1; |
| getCaseDatatypes(attr2->getDatatype(), attr2->getLength(), type_op2, |
| result->getDatatype(), result->getLength(), type_result, |
| 0 /* don't need to take scale difference into account here */); |
| |
| const ArithInstrStruct * as = getMatchingRow(op, |
| type_op1, |
| type_op2, |
| type_result); |
| |
| if (as) |
| { |
| instruction = as->instruction; |
| |
| // for binary numeric and interval datatypes, arith done only if scales |
| // are the same and operation is addition or subtraction |
| if (((op == ITM_PLUS) || (op == ITM_MINUS)) && |
| (((result->getDatatype() >= REC_MIN_BINARY) && |
| (result->getDatatype() <= REC_MAX_BINARY)) || |
| ((result->getDatatype() >= REC_MIN_INTERVAL) && |
| (result->getDatatype() <= REC_MAX_INTERVAL)))) |
| { |
| // numeric or interval types |
| if (attr1->getScale() != attr2->getScale()) |
| { |
| instruction = ARITH_NOT_SUPPORTED; |
| setInstrArrayIndex(-1); |
| } |
| |
| } // numeric or interval types |
| else if ((op == ITM_DIVIDE) && |
| (arithRoundingMode_ != 0)) |
| { |
| if (instruction == DIV_BIN64S_BIN64S_BIN64S) |
| { |
| instruction = DIV_BIN64S_BIN64S_BIN64S_ROUND; |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| else |
| { |
| instruction = ARITH_NOT_SUPPORTED; |
| setInstrArrayIndex(-1); |
| } |
| } |
| } |
| |
| if (instruction == ARITH_NOT_SUPPORTED) |
| setInstrArrayIndex(-1); |
| |
| return instruction; |
| } |
| |
| void ex_arith_clause::setInstruction() |
| { |
| ArithInstruction instruction = ARITH_NOT_SUPPORTED; |
| setInstrArrayIndex(-1); |
| |
| if (getOperand(0)->isComplexType()) |
| { |
| switch (getOperType()) |
| { |
| case ITM_PLUS: |
| instruction = ADD_COMPLEX; |
| break; |
| |
| case ITM_MINUS: |
| instruction = SUB_COMPLEX; |
| break; |
| |
| case ITM_TIMES: |
| instruction = MUL_COMPLEX; |
| break; |
| |
| case ITM_DIVIDE: |
| instruction = DIV_COMPLEX; |
| break; |
| |
| default: |
| break; |
| } |
| |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| else |
| { |
| // Simple types are handled here. |
| instruction = computeCaseIndex(getOperType(), |
| getOperand(1), |
| (getNumOperands() == 3 ? getOperand(2) : NULL), |
| getOperand(0)); |
| } |
| |
| if ((instruction == ARITH_NOT_SUPPORTED) && |
| (getInstrArrayIndex() >= 0)) |
| { |
| // this is an error, reset instr array index |
| setInstrArrayIndex(-1); |
| } |
| } |
| |
| void ex_arith_clause::setInstruction(OperatorTypeEnum op, |
| Attributes * attr1, |
| Attributes * attr2, |
| Attributes * result) |
| { |
| // Only simple types are handled here. |
| ArithInstruction instruction = computeCaseIndex(op, attr1, attr2, result); |
| |
| if ((instruction == ARITH_NOT_SUPPORTED) && |
| (getInstrArrayIndex() >= 0)) |
| { |
| // this is an error, reset instr array index |
| setInstrArrayIndex(-1); |
| } |
| } |
| |
| short ex_arith_clause::isArithSupported(OperatorTypeEnum op, |
| Attributes * attr1, |
| Attributes * attr2, |
| Attributes * result) |
| { |
| if (computeCaseIndex(op, attr1, attr2, result) |
| == ARITH_NOT_SUPPORTED) |
| return 0; |
| else |
| return -1; |
| } |
| |
| ex_expr::exp_return_type ex_arith_clause::fixup(Space * space, |
| CollHeap * exHeap, |
| char * constants_area, |
| char * temps_area, |
| char * persistentArea, |
| short fixupConstsAndTemps, |
| NABoolean spaceCompOnly) |
| { |
| setInstruction(); |
| return ex_clause::fixup(space, exHeap, constants_area, temps_area, |
| persistentArea, |
| fixupConstsAndTemps, spaceCompOnly); |
| } |
| |
| const ex_comp_clause::CompInstrStruct ex_comp_clause::compInstrInfo[] = |
| { |
| // op op1 datatype op2 datatype instruction+str |
| |
| // ITM_ANY_COMP entries are generic entries needed to get the corresponding |
| // instructions added to this array. |
| {ITM_ANY_COMP, REC_UNKNOWN, REC_UNKNOWN, instrAndText(ASCII_COMP)}, |
| {ITM_ANY_COMP, REC_UNKNOWN, REC_UNKNOWN, instrAndText(COMP_COMPLEX)}, |
| |
| {ITM_EQUAL, REC_BIN8_SIGNED, REC_BIN8_SIGNED, instrAndText(EQ_BIN8S_BIN8S)}, |
| {ITM_EQUAL, REC_BIN8_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(EQ_BIN8U_BIN8U)}, |
| |
| {ITM_EQUAL, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(EQ_BIN16S_BIN16S)}, |
| {ITM_EQUAL, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(EQ_BIN16S_BIN32S)}, |
| {ITM_EQUAL, REC_BIN16_SIGNED, REC_BPINT_UNSIGNED, instrAndText(EQ_BIN16S_BIN16U)}, |
| {ITM_EQUAL, REC_BIN16_SIGNED, REC_BIN16_UNSIGNED, instrAndText(EQ_BIN16S_BIN16U)}, |
| {ITM_EQUAL, REC_BIN16_SIGNED, REC_BIN32_UNSIGNED, instrAndText(EQ_BIN16S_BIN32U)}, |
| |
| {ITM_EQUAL, REC_BPINT_UNSIGNED, REC_BIN16_SIGNED, instrAndText(EQ_BIN16U_BIN16S)}, |
| {ITM_EQUAL, REC_BPINT_UNSIGNED, REC_BIN32_SIGNED, instrAndText(EQ_BIN16U_BIN32S)}, |
| {ITM_EQUAL, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(EQ_BIN16U_BIN16U)}, |
| {ITM_EQUAL, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(EQ_BIN16U_BIN16U)}, |
| {ITM_EQUAL, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(EQ_BIN16U_BIN32U)}, |
| |
| {ITM_EQUAL, REC_BIN16_UNSIGNED, REC_BIN16_SIGNED, instrAndText(EQ_BIN16U_BIN16S)}, |
| {ITM_EQUAL, REC_BIN16_UNSIGNED, REC_BIN32_SIGNED, instrAndText(EQ_BIN16U_BIN32S)}, |
| {ITM_EQUAL, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(EQ_BIN16U_BIN16U)}, |
| {ITM_EQUAL, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(EQ_BIN16U_BIN16U)}, |
| {ITM_EQUAL, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(EQ_BIN16U_BIN32U)}, // Was BIN32S. Error? ANS |
| |
| {ITM_EQUAL, REC_BIN32_SIGNED, REC_BIN16_SIGNED, instrAndText(EQ_BIN32S_BIN16S)}, |
| {ITM_EQUAL, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(EQ_BIN32S_BIN32S)}, |
| {ITM_EQUAL, REC_BIN32_SIGNED, REC_BPINT_UNSIGNED, instrAndText(EQ_BIN32S_BIN16U)}, |
| {ITM_EQUAL, REC_BIN32_SIGNED, REC_BIN16_UNSIGNED, instrAndText(EQ_BIN32S_BIN16U)}, |
| {ITM_EQUAL, REC_BIN32_SIGNED, REC_BIN32_UNSIGNED, instrAndText(EQ_BIN32S_BIN32U)}, // Was BIN32S. Error? ANS |
| |
| {ITM_EQUAL, REC_BIN32_UNSIGNED, REC_BIN16_SIGNED, instrAndText(EQ_BIN32U_BIN16S)}, |
| {ITM_EQUAL, REC_BIN32_UNSIGNED, REC_BIN32_SIGNED, instrAndText(EQ_BIN32U_BIN32S)}, |
| {ITM_EQUAL, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(EQ_BIN32U_BIN16U)}, |
| {ITM_EQUAL, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(EQ_BIN32U_BIN16U)}, |
| {ITM_EQUAL, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(EQ_BIN32U_BIN32U)}, // Was BIN32S. Error? ANS |
| |
| {ITM_EQUAL, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(EQ_BIN64S_BIN64S)}, |
| {ITM_EQUAL, REC_BIN64_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(EQ_BIN64U_BIN64U)}, |
| {ITM_EQUAL, REC_BIN64_SIGNED, REC_BIN64_UNSIGNED, instrAndText(EQ_BIN64S_BIN64U)}, |
| {ITM_EQUAL, REC_BIN64_UNSIGNED, REC_BIN64_SIGNED, instrAndText(EQ_BIN64U_BIN64S)}, |
| |
| {ITM_EQUAL, REC_DECIMAL_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(EQ_DECU_DECU)}, |
| {ITM_EQUAL, REC_DECIMAL_LSE, REC_DECIMAL_LSE, instrAndText(EQ_DECS_DECS)}, |
| |
| {ITM_EQUAL, REC_FLOAT32, REC_FLOAT32, instrAndText(EQ_FLOAT32_FLOAT32)}, |
| {ITM_EQUAL, REC_FLOAT64, REC_FLOAT64, instrAndText(EQ_FLOAT64_FLOAT64)}, |
| |
| {ITM_EQUAL, REC_DATETIME, REC_DATETIME, instrAndText(EQ_DATETIME_DATETIME)}, |
| |
| {ITM_EQUAL, REC_BYTE_F_ASCII, REC_BYTE_F_ASCII, instrAndText(EQ_ASCII_F_F)}, |
| |
| {ITM_EQUAL, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII, instrAndText(EQ_ASCII_COMP)}, |
| {ITM_EQUAL, REC_BYTE_V_ASCII, REC_BYTE_F_ASCII, instrAndText(EQ_ASCII_COMP)}, |
| {ITM_EQUAL, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII, instrAndText(EQ_ASCII_COMP)}, |
| {ITM_EQUAL, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(EQ_ASCII_COMP)}, |
| {ITM_EQUAL, REC_BYTE_V_ASCII_LONG, REC_BYTE_F_ASCII, instrAndText(EQ_ASCII_COMP)}, |
| {ITM_EQUAL, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(EQ_ASCII_COMP)}, |
| {ITM_EQUAL, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII, instrAndText(EQ_ASCII_COMP)}, |
| {ITM_EQUAL, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII_LONG, instrAndText(EQ_ASCII_COMP)}, |
| |
| {ITM_EQUAL,REC_NCHAR_F_UNICODE,REC_NCHAR_F_UNICODE,instrAndText(EQ_UNICODE_F_F)}, |
| {ITM_EQUAL, REC_NCHAR_F_UNICODE,REC_NCHAR_V_UNICODE,instrAndText(UNICODE_COMP)}, |
| {ITM_EQUAL, REC_NCHAR_V_UNICODE,REC_NCHAR_F_UNICODE,instrAndText(UNICODE_COMP)}, |
| {ITM_EQUAL, REC_NCHAR_V_UNICODE,REC_NCHAR_V_UNICODE,instrAndText(UNICODE_COMP)}, |
| |
| {ITM_EQUAL, REC_BLOB,REC_BLOB,instrAndText(EQ_BLOB)}, |
| |
| {ITM_EQUAL, REC_BOOLEAN, REC_BOOLEAN, instrAndText(EQ_BOOL_BOOL)}, |
| |
| {ITM_NOT_EQUAL, REC_BIN8_SIGNED, REC_BIN8_SIGNED, instrAndText(NE_BIN8S_BIN8S)}, |
| {ITM_NOT_EQUAL, REC_BIN8_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(NE_BIN8U_BIN8U)}, |
| |
| {ITM_NOT_EQUAL, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(NE_BIN16S_BIN16S)}, |
| {ITM_NOT_EQUAL, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(NE_BIN16S_BIN32S)}, |
| {ITM_NOT_EQUAL, REC_BIN16_SIGNED, REC_BPINT_UNSIGNED, instrAndText(NE_BIN16S_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BIN16_SIGNED, REC_BIN16_UNSIGNED, instrAndText(NE_BIN16S_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BIN16_SIGNED, REC_BIN32_UNSIGNED, instrAndText(NE_BIN16S_BIN32U)}, //Was 32S. Error? ANS |
| |
| {ITM_NOT_EQUAL, REC_BPINT_UNSIGNED, REC_BIN16_SIGNED, instrAndText(NE_BIN16U_BIN16S)}, |
| {ITM_NOT_EQUAL, REC_BPINT_UNSIGNED, REC_BIN32_SIGNED, instrAndText(NE_BIN16U_BIN32S)}, |
| {ITM_NOT_EQUAL, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(NE_BIN16U_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(NE_BIN16U_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(NE_BIN16U_BIN32U)}, //Was 32S. Error? ANS |
| |
| {ITM_NOT_EQUAL, REC_BIN16_UNSIGNED, REC_BIN16_SIGNED, instrAndText(NE_BIN16U_BIN16S)}, |
| {ITM_NOT_EQUAL, REC_BIN16_UNSIGNED, REC_BIN32_SIGNED, instrAndText(NE_BIN16U_BIN32S)}, |
| {ITM_NOT_EQUAL, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(NE_BIN16U_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(NE_BIN16U_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(NE_BIN16U_BIN32U)}, //Was 32S. Error? ANS |
| |
| {ITM_NOT_EQUAL, REC_BIN32_SIGNED, REC_BIN16_SIGNED, instrAndText(NE_BIN32S_BIN16S)}, |
| {ITM_NOT_EQUAL, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(NE_BIN32S_BIN32S)}, |
| {ITM_NOT_EQUAL, REC_BIN32_SIGNED, REC_BPINT_UNSIGNED, instrAndText(NE_BIN32S_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BIN32_SIGNED, REC_BIN16_UNSIGNED, instrAndText(NE_BIN32S_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BIN32_SIGNED, REC_BIN32_UNSIGNED, instrAndText(NE_BIN32S_BIN32U)}, //Was 32S. Error? ANS |
| |
| {ITM_NOT_EQUAL, REC_BIN32_UNSIGNED, REC_BIN16_SIGNED, instrAndText(NE_BIN32U_BIN16S)}, |
| {ITM_NOT_EQUAL, REC_BIN32_UNSIGNED, REC_BIN32_SIGNED, instrAndText(NE_BIN32U_BIN32S)}, |
| {ITM_NOT_EQUAL, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(NE_BIN32U_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(NE_BIN32U_BIN16U)}, |
| {ITM_NOT_EQUAL, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(NE_BIN32U_BIN32U)}, //Was 32S. Error? ANS |
| |
| {ITM_NOT_EQUAL, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(NE_BIN64S_BIN64S)}, |
| {ITM_NOT_EQUAL, REC_BIN64_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(NE_BIN64U_BIN64U)}, |
| {ITM_NOT_EQUAL, REC_BIN64_SIGNED, REC_BIN64_UNSIGNED, instrAndText(NE_BIN64S_BIN64U)}, |
| {ITM_NOT_EQUAL, REC_BIN64_UNSIGNED, REC_BIN64_SIGNED, instrAndText(NE_BIN64U_BIN64S)}, |
| |
| {ITM_NOT_EQUAL, REC_DECIMAL_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(NE_DECU_DECU)}, |
| {ITM_NOT_EQUAL, REC_DECIMAL_LSE, REC_DECIMAL_LSE, instrAndText(NE_DECS_DECS)}, |
| |
| {ITM_NOT_EQUAL, REC_FLOAT32, REC_FLOAT32, instrAndText(NE_FLOAT32_FLOAT32)}, |
| {ITM_NOT_EQUAL, REC_FLOAT64, REC_FLOAT64, instrAndText(NE_FLOAT64_FLOAT64)}, |
| |
| {ITM_NOT_EQUAL, REC_DATETIME, REC_DATETIME, instrAndText(NE_DATETIME_DATETIME)}, |
| |
| {ITM_NOT_EQUAL, REC_BYTE_F_ASCII, REC_BYTE_F_ASCII, instrAndText(NE_ASCII_F_F)}, |
| |
| {ITM_NOT_EQUAL, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII, instrAndText(NE_ASCII_COMP)}, |
| {ITM_NOT_EQUAL, REC_BYTE_V_ASCII, REC_BYTE_F_ASCII, instrAndText(NE_ASCII_COMP)}, |
| {ITM_NOT_EQUAL, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII, instrAndText(NE_ASCII_COMP)}, |
| {ITM_NOT_EQUAL, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(NE_ASCII_COMP)}, |
| {ITM_NOT_EQUAL, REC_BYTE_V_ASCII_LONG, REC_BYTE_F_ASCII, instrAndText(NE_ASCII_COMP)}, |
| {ITM_NOT_EQUAL, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(NE_ASCII_COMP)}, |
| {ITM_NOT_EQUAL, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII, instrAndText(NE_ASCII_COMP)}, |
| {ITM_NOT_EQUAL, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII_LONG, instrAndText(NE_ASCII_COMP)}, |
| |
| {ITM_NOT_EQUAL,REC_NCHAR_F_UNICODE,REC_NCHAR_F_UNICODE,instrAndText(NE_UNICODE_F_F)}, |
| {ITM_NOT_EQUAL, REC_NCHAR_F_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_NOT_EQUAL, REC_NCHAR_V_UNICODE, REC_NCHAR_F_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_NOT_EQUAL, REC_NCHAR_V_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| |
| {ITM_NOT_EQUAL, REC_BOOLEAN, REC_BOOLEAN, instrAndText(NE_BOOL_BOOL)}, |
| |
| {ITM_LESS, REC_BIN8_SIGNED, REC_BIN8_SIGNED, instrAndText(LT_BIN8S_BIN8S)}, |
| {ITM_LESS, REC_BIN8_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(LT_BIN8U_BIN8U)}, |
| |
| {ITM_LESS, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(LT_BIN16S_BIN16S)}, |
| {ITM_LESS, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(LT_BIN16S_BIN32S)}, |
| {ITM_LESS, REC_BIN16_SIGNED, REC_BPINT_UNSIGNED, instrAndText(LT_BIN16S_BIN16U)}, |
| {ITM_LESS, REC_BIN16_SIGNED, REC_BIN16_UNSIGNED, instrAndText(LT_BIN16S_BIN16U)}, |
| {ITM_LESS, REC_BIN16_SIGNED, REC_BIN32_UNSIGNED, instrAndText(LT_BIN16S_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS, REC_BPINT_UNSIGNED, REC_BIN16_SIGNED, instrAndText(LT_BIN16U_BIN16S)}, |
| {ITM_LESS, REC_BPINT_UNSIGNED, REC_BIN32_SIGNED, instrAndText(LT_BIN16U_BIN32S)}, |
| {ITM_LESS, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(LT_BIN16U_BIN16U)}, |
| {ITM_LESS, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(LT_BIN16U_BIN16U)}, |
| {ITM_LESS, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(LT_BIN16U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS, REC_BIN16_UNSIGNED, REC_BIN16_SIGNED, instrAndText(LT_BIN16U_BIN16S)}, |
| {ITM_LESS, REC_BIN16_UNSIGNED, REC_BIN32_SIGNED, instrAndText(LT_BIN16U_BIN32S)}, |
| {ITM_LESS, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(LT_BIN16U_BIN16U)}, |
| {ITM_LESS, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(LT_BIN16U_BIN16U)}, |
| {ITM_LESS, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(LT_BIN16U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS, REC_BIN32_SIGNED, REC_BIN16_SIGNED, instrAndText(LT_BIN32S_BIN16S)}, |
| {ITM_LESS, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(LT_BIN32S_BIN32S)}, |
| {ITM_LESS, REC_BIN32_SIGNED, REC_BPINT_UNSIGNED, instrAndText(LT_BIN32S_BIN16U)}, |
| {ITM_LESS, REC_BIN32_SIGNED, REC_BIN16_UNSIGNED, instrAndText(LT_BIN32S_BIN16U)}, |
| {ITM_LESS, REC_BIN32_SIGNED, REC_BIN32_UNSIGNED, instrAndText(LT_BIN32S_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS, REC_BIN32_UNSIGNED, REC_BIN16_SIGNED, instrAndText(LT_BIN32U_BIN16S)}, |
| {ITM_LESS, REC_BIN32_UNSIGNED, REC_BIN32_SIGNED, instrAndText(LT_BIN32U_BIN32S)}, |
| {ITM_LESS, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(LT_BIN32U_BIN16U)}, |
| {ITM_LESS, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(LT_BIN32U_BIN16U)}, |
| {ITM_LESS, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(LT_BIN32U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(LT_BIN64S_BIN64S)}, |
| {ITM_LESS, REC_BIN64_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(LT_BIN64U_BIN64U)}, |
| {ITM_LESS, REC_BIN64_SIGNED, REC_BIN64_UNSIGNED, instrAndText(LT_BIN64S_BIN64U)}, |
| {ITM_LESS, REC_BIN64_UNSIGNED, REC_BIN64_SIGNED, instrAndText(LT_BIN64U_BIN64S)}, |
| |
| {ITM_LESS, REC_DECIMAL_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(LT_DECU_DECU)}, |
| {ITM_LESS, REC_DECIMAL_LSE, REC_DECIMAL_LSE, instrAndText(LT_DECS_DECS)}, |
| |
| {ITM_LESS, REC_FLOAT32, REC_FLOAT32, instrAndText(LT_FLOAT32_FLOAT32)}, |
| {ITM_LESS, REC_FLOAT64, REC_FLOAT64, instrAndText(LT_FLOAT64_FLOAT64)}, |
| |
| {ITM_LESS, REC_DATETIME, REC_DATETIME, instrAndText(LT_DATETIME_DATETIME)}, |
| |
| {ITM_LESS, REC_BYTE_F_ASCII, REC_BYTE_F_ASCII, instrAndText(LT_ASCII_F_F)}, |
| |
| {ITM_LESS, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII, instrAndText(LT_ASCII_COMP)}, |
| {ITM_LESS, REC_BYTE_V_ASCII, REC_BYTE_F_ASCII, instrAndText(LT_ASCII_COMP)}, |
| {ITM_LESS, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII, instrAndText(LT_ASCII_COMP)}, |
| {ITM_LESS, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(LT_ASCII_COMP)}, |
| {ITM_LESS, REC_BYTE_V_ASCII_LONG, REC_BYTE_F_ASCII, instrAndText(LT_ASCII_COMP)}, |
| {ITM_LESS, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(LT_ASCII_COMP)}, |
| {ITM_LESS, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII, instrAndText(LT_ASCII_COMP)}, |
| {ITM_LESS, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII_LONG, instrAndText(LT_ASCII_COMP)}, |
| {ITM_LESS,REC_NCHAR_F_UNICODE,REC_NCHAR_F_UNICODE,instrAndText(LT_UNICODE_F_F)}, |
| {ITM_LESS, REC_NCHAR_F_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_LESS, REC_NCHAR_V_UNICODE, REC_NCHAR_F_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_LESS, REC_NCHAR_V_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| |
| |
| {ITM_LESS_EQ, REC_BIN8_SIGNED, REC_BIN8_SIGNED, instrAndText(LE_BIN8S_BIN8S)}, |
| {ITM_LESS_EQ, REC_BIN8_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(LE_BIN8U_BIN8U)}, |
| |
| {ITM_LESS_EQ, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(LE_BIN16S_BIN16S)}, |
| {ITM_LESS_EQ, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(LE_BIN16S_BIN32S)}, |
| {ITM_LESS_EQ, REC_BIN16_SIGNED, REC_BPINT_UNSIGNED, instrAndText(LE_BIN16S_BIN16U)}, |
| {ITM_LESS_EQ, REC_BIN16_SIGNED, REC_BIN16_UNSIGNED, instrAndText(LE_BIN16S_BIN16U)}, |
| {ITM_LESS_EQ, REC_BIN16_SIGNED, REC_BIN32_UNSIGNED, instrAndText(LE_BIN16S_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS_EQ, REC_BPINT_UNSIGNED, REC_BIN16_SIGNED, instrAndText(LE_BIN16U_BIN16S)}, |
| {ITM_LESS_EQ, REC_BPINT_UNSIGNED, REC_BIN32_SIGNED, instrAndText(LE_BIN16U_BIN32S)}, |
| {ITM_LESS_EQ, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(LE_BIN16U_BIN16U)}, |
| {ITM_LESS_EQ, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(LE_BIN16U_BIN16U)}, |
| {ITM_LESS_EQ, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(LE_BIN16U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS_EQ, REC_BIN16_UNSIGNED, REC_BIN16_SIGNED, instrAndText(LE_BIN16U_BIN16S)}, |
| {ITM_LESS_EQ, REC_BIN16_UNSIGNED, REC_BIN32_SIGNED, instrAndText(LE_BIN16U_BIN32S)}, |
| {ITM_LESS_EQ, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(LE_BIN16U_BIN16U)}, |
| {ITM_LESS_EQ, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(LE_BIN16U_BIN16U)}, |
| {ITM_LESS_EQ, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(LE_BIN16U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS_EQ, REC_BIN32_SIGNED, REC_BIN16_SIGNED, instrAndText(LE_BIN32S_BIN16S)}, |
| {ITM_LESS_EQ, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(LE_BIN32S_BIN32S)}, |
| {ITM_LESS_EQ, REC_BIN32_SIGNED, REC_BPINT_UNSIGNED, instrAndText(LE_BIN32S_BIN16U)}, |
| {ITM_LESS_EQ, REC_BIN32_SIGNED, REC_BIN16_UNSIGNED, instrAndText(LE_BIN32S_BIN16U)}, |
| {ITM_LESS_EQ, REC_BIN32_SIGNED, REC_BIN32_UNSIGNED, instrAndText(LE_BIN32S_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS_EQ, REC_BIN32_UNSIGNED, REC_BIN16_SIGNED, instrAndText(LE_BIN32U_BIN16S)}, |
| {ITM_LESS_EQ, REC_BIN32_UNSIGNED, REC_BIN32_SIGNED, instrAndText(LE_BIN32U_BIN32S)}, |
| {ITM_LESS_EQ, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(LE_BIN32U_BIN16U)}, |
| {ITM_LESS_EQ, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(LE_BIN32U_BIN16U)}, |
| {ITM_LESS_EQ, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(LE_BIN32U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_LESS_EQ, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(LE_BIN64S_BIN64S)}, |
| {ITM_LESS_EQ, REC_BIN64_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(LE_BIN64U_BIN64U)}, |
| {ITM_LESS_EQ, REC_BIN64_SIGNED, REC_BIN64_UNSIGNED, instrAndText(LE_BIN64S_BIN64U)}, |
| {ITM_LESS_EQ, REC_BIN64_UNSIGNED, REC_BIN64_SIGNED, instrAndText(LE_BIN64U_BIN64S)}, |
| |
| {ITM_LESS_EQ, REC_DECIMAL_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(LE_DECU_DECU)}, |
| {ITM_LESS_EQ, REC_DECIMAL_LSE, REC_DECIMAL_LSE, instrAndText(LE_DECS_DECS)}, |
| |
| {ITM_LESS_EQ, REC_FLOAT32, REC_FLOAT32, instrAndText(LE_FLOAT32_FLOAT32)}, |
| {ITM_LESS_EQ, REC_FLOAT64, REC_FLOAT64, instrAndText(LE_FLOAT64_FLOAT64)}, |
| |
| {ITM_LESS_EQ, REC_DATETIME, REC_DATETIME, instrAndText(LE_DATETIME_DATETIME)}, |
| |
| {ITM_LESS_EQ, REC_BYTE_F_ASCII, REC_BYTE_F_ASCII, instrAndText(LE_ASCII_F_F)}, |
| |
| {ITM_LESS_EQ, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII, instrAndText(LE_ASCII_COMP)}, |
| {ITM_LESS_EQ, REC_BYTE_V_ASCII, REC_BYTE_F_ASCII, instrAndText(LE_ASCII_COMP)}, |
| {ITM_LESS_EQ, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII, instrAndText(LE_ASCII_COMP)}, |
| {ITM_LESS_EQ, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(LE_ASCII_COMP)}, |
| {ITM_LESS_EQ, REC_BYTE_V_ASCII_LONG, REC_BYTE_F_ASCII, instrAndText(LE_ASCII_COMP)}, |
| {ITM_LESS_EQ, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(LE_ASCII_COMP)}, |
| {ITM_LESS_EQ, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII, instrAndText(LE_ASCII_COMP)}, |
| {ITM_LESS_EQ, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII_LONG, instrAndText(LE_ASCII_COMP)}, |
| |
| {ITM_LESS_EQ,REC_NCHAR_F_UNICODE,REC_NCHAR_F_UNICODE,instrAndText(LE_UNICODE_F_F)}, |
| {ITM_LESS_EQ, REC_NCHAR_F_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_LESS_EQ, REC_NCHAR_V_UNICODE, REC_NCHAR_F_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_LESS_EQ, REC_NCHAR_V_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| |
| |
| {ITM_GREATER, REC_BIN8_SIGNED, REC_BIN8_SIGNED, instrAndText(GT_BIN8S_BIN8S)}, |
| {ITM_GREATER, REC_BIN8_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(GT_BIN8U_BIN8U)}, |
| |
| {ITM_GREATER, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(GT_BIN16S_BIN16S)}, |
| {ITM_GREATER, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(GT_BIN16S_BIN32S)}, |
| {ITM_GREATER, REC_BIN16_SIGNED, REC_BPINT_UNSIGNED, instrAndText(GT_BIN16S_BIN16U)}, |
| {ITM_GREATER, REC_BIN16_SIGNED, REC_BIN16_UNSIGNED, instrAndText(GT_BIN16S_BIN16U)}, |
| {ITM_GREATER, REC_BIN16_SIGNED, REC_BIN32_UNSIGNED, instrAndText(GT_BIN16S_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER, REC_BPINT_UNSIGNED, REC_BIN16_SIGNED, instrAndText(GT_BIN16U_BIN16S)}, |
| {ITM_GREATER, REC_BPINT_UNSIGNED, REC_BIN32_SIGNED, instrAndText(GT_BIN16U_BIN32S)}, |
| {ITM_GREATER, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(GT_BIN16U_BIN16U)}, |
| {ITM_GREATER, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(GT_BIN16U_BIN16U)}, |
| {ITM_GREATER, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(GT_BIN16U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER, REC_BIN16_UNSIGNED, REC_BIN16_SIGNED, instrAndText(GT_BIN16U_BIN16S)}, |
| {ITM_GREATER, REC_BIN16_UNSIGNED, REC_BIN32_SIGNED, instrAndText(GT_BIN16U_BIN32S)}, |
| {ITM_GREATER, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(GT_BIN16U_BIN16U)}, |
| {ITM_GREATER, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(GT_BIN16U_BIN16U)}, |
| {ITM_GREATER, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(GT_BIN16U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER, REC_BIN32_SIGNED, REC_BIN16_SIGNED, instrAndText(GT_BIN32S_BIN16S)}, |
| {ITM_GREATER, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(GT_BIN32S_BIN32S)}, |
| {ITM_GREATER, REC_BIN32_SIGNED, REC_BPINT_UNSIGNED, instrAndText(GT_BIN32S_BIN16U)}, |
| {ITM_GREATER, REC_BIN32_SIGNED, REC_BIN16_UNSIGNED, instrAndText(GT_BIN32S_BIN16U)}, |
| {ITM_GREATER, REC_BIN32_SIGNED, REC_BIN32_UNSIGNED, instrAndText(GT_BIN32S_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER, REC_BIN32_UNSIGNED, REC_BIN16_SIGNED, instrAndText(GT_BIN32U_BIN16S)}, |
| {ITM_GREATER, REC_BIN32_UNSIGNED, REC_BIN32_SIGNED, instrAndText(GT_BIN32U_BIN32S)}, |
| {ITM_GREATER, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(GT_BIN32U_BIN16U)}, |
| {ITM_GREATER, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(GT_BIN32U_BIN16U)}, |
| {ITM_GREATER, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(GT_BIN32U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(GT_BIN64S_BIN64S)}, |
| {ITM_GREATER, REC_BIN64_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(GT_BIN64U_BIN64U)}, |
| {ITM_GREATER, REC_BIN64_SIGNED, REC_BIN64_UNSIGNED, instrAndText(GT_BIN64S_BIN64U)}, |
| {ITM_GREATER, REC_BIN64_UNSIGNED, REC_BIN64_SIGNED, instrAndText(GT_BIN64U_BIN64S)}, |
| |
| {ITM_GREATER, REC_DECIMAL_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(GT_DECU_DECU)}, |
| {ITM_GREATER, REC_DECIMAL_LSE, REC_DECIMAL_LSE, instrAndText(GT_DECS_DECS)}, |
| |
| {ITM_GREATER, REC_FLOAT32, REC_FLOAT32, instrAndText(GT_FLOAT32_FLOAT32)}, |
| {ITM_GREATER, REC_FLOAT64, REC_FLOAT64, instrAndText(GT_FLOAT64_FLOAT64)}, |
| |
| {ITM_GREATER, REC_DATETIME, REC_DATETIME, instrAndText(GT_DATETIME_DATETIME)}, |
| |
| {ITM_GREATER, REC_BYTE_F_ASCII, REC_BYTE_F_ASCII, instrAndText(GT_ASCII_F_F)}, |
| |
| {ITM_GREATER, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII, instrAndText(GT_ASCII_COMP)}, |
| {ITM_GREATER, REC_BYTE_V_ASCII, REC_BYTE_F_ASCII, instrAndText(GT_ASCII_COMP)}, |
| {ITM_GREATER, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII, instrAndText(GT_ASCII_COMP)}, |
| {ITM_GREATER, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(GT_ASCII_COMP)}, |
| {ITM_GREATER, REC_BYTE_V_ASCII_LONG, REC_BYTE_F_ASCII, instrAndText(GT_ASCII_COMP)}, |
| {ITM_GREATER, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(GT_ASCII_COMP)}, |
| {ITM_GREATER, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII, instrAndText(GT_ASCII_COMP)}, |
| {ITM_GREATER, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII_LONG, instrAndText(GT_ASCII_COMP)}, |
| |
| {ITM_GREATER,REC_NCHAR_F_UNICODE,REC_NCHAR_F_UNICODE,instrAndText(GT_UNICODE_F_F)}, |
| {ITM_GREATER, REC_NCHAR_F_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_GREATER, REC_NCHAR_V_UNICODE, REC_NCHAR_F_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_GREATER, REC_NCHAR_V_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| |
| |
| {ITM_GREATER_EQ, REC_BIN8_SIGNED, REC_BIN8_SIGNED, instrAndText(GE_BIN8S_BIN8S)}, |
| {ITM_GREATER_EQ, REC_BIN8_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(GE_BIN8U_BIN8U)}, |
| |
| {ITM_GREATER_EQ, REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(GE_BIN16S_BIN16S)}, |
| {ITM_GREATER_EQ, REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(GE_BIN16S_BIN32S)}, |
| {ITM_GREATER_EQ, REC_BIN16_SIGNED, REC_BPINT_UNSIGNED, instrAndText(GE_BIN16S_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BIN16_SIGNED, REC_BIN16_UNSIGNED, instrAndText(GE_BIN16S_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BIN16_SIGNED, REC_BIN32_UNSIGNED, instrAndText(GE_BIN16S_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER_EQ, REC_BPINT_UNSIGNED, REC_BIN16_SIGNED, instrAndText(GE_BIN16U_BIN16S)}, |
| {ITM_GREATER_EQ, REC_BPINT_UNSIGNED, REC_BIN32_SIGNED, instrAndText(GE_BIN16U_BIN32S)}, |
| {ITM_GREATER_EQ, REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(GE_BIN16U_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(GE_BIN16U_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(GE_BIN16U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER_EQ, REC_BIN16_UNSIGNED, REC_BIN16_SIGNED, instrAndText(GE_BIN16U_BIN16S)}, |
| {ITM_GREATER_EQ, REC_BIN16_UNSIGNED, REC_BIN32_SIGNED, instrAndText(GE_BIN16U_BIN32S)}, |
| {ITM_GREATER_EQ, REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(GE_BIN16U_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(GE_BIN16U_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(GE_BIN16U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER_EQ, REC_BIN32_SIGNED, REC_BIN16_SIGNED, instrAndText(GE_BIN32S_BIN16S)}, |
| {ITM_GREATER_EQ, REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(GE_BIN32S_BIN32S)}, |
| {ITM_GREATER_EQ, REC_BIN32_SIGNED, REC_BPINT_UNSIGNED, instrAndText(GE_BIN32S_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BIN32_SIGNED, REC_BIN16_UNSIGNED, instrAndText(GE_BIN32S_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BIN32_SIGNED, REC_BIN32_UNSIGNED, instrAndText(GE_BIN32S_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER_EQ, REC_BIN32_UNSIGNED, REC_BIN16_SIGNED, instrAndText(GE_BIN32U_BIN16S)}, |
| {ITM_GREATER_EQ, REC_BIN32_UNSIGNED, REC_BIN32_SIGNED, instrAndText(GE_BIN32U_BIN32S)}, |
| {ITM_GREATER_EQ, REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(GE_BIN32U_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(GE_BIN32U_BIN16U)}, |
| {ITM_GREATER_EQ, REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(GE_BIN32U_BIN32U)}, // Was 32S. Error? ANS |
| |
| {ITM_GREATER_EQ, REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(GE_BIN64S_BIN64S)}, |
| {ITM_GREATER_EQ, REC_BIN64_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(GE_BIN64U_BIN64U)}, |
| {ITM_GREATER_EQ, REC_BIN64_SIGNED, REC_BIN64_UNSIGNED, instrAndText(GE_BIN64S_BIN64U)}, |
| {ITM_GREATER_EQ, REC_BIN64_UNSIGNED, REC_BIN64_SIGNED, instrAndText(GE_BIN64U_BIN64S)}, |
| |
| {ITM_GREATER_EQ, REC_DECIMAL_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(GE_DECU_DECU)}, |
| {ITM_GREATER_EQ, REC_DECIMAL_LSE, REC_DECIMAL_LSE, instrAndText(GE_DECS_DECS)}, |
| |
| {ITM_GREATER_EQ, REC_FLOAT32, REC_FLOAT32, instrAndText(GE_FLOAT32_FLOAT32)}, |
| {ITM_GREATER_EQ, REC_FLOAT64, REC_FLOAT64, instrAndText(GE_FLOAT64_FLOAT64)}, |
| |
| {ITM_GREATER_EQ, REC_DATETIME, REC_DATETIME, instrAndText(GE_DATETIME_DATETIME)}, |
| |
| {ITM_GREATER_EQ, REC_BYTE_F_ASCII, REC_BYTE_F_ASCII, instrAndText(GE_ASCII_F_F)}, |
| |
| {ITM_GREATER_EQ, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII, instrAndText(GE_ASCII_COMP)}, |
| {ITM_GREATER_EQ, REC_BYTE_V_ASCII, REC_BYTE_F_ASCII, instrAndText(GE_ASCII_COMP)}, |
| {ITM_GREATER_EQ, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII, instrAndText(GE_ASCII_COMP)}, |
| {ITM_GREATER_EQ, REC_BYTE_F_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(GE_ASCII_COMP)}, |
| {ITM_GREATER_EQ, REC_BYTE_V_ASCII_LONG, REC_BYTE_F_ASCII, instrAndText(GE_ASCII_COMP)}, |
| {ITM_GREATER_EQ, REC_BYTE_V_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(GE_ASCII_COMP)}, |
| {ITM_GREATER_EQ, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII, instrAndText(GE_ASCII_COMP)}, |
| {ITM_GREATER_EQ, REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII_LONG, instrAndText(GE_ASCII_COMP)}, |
| |
| {ITM_GREATER_EQ,REC_NCHAR_F_UNICODE,REC_NCHAR_F_UNICODE,instrAndText(GE_UNICODE_F_F)}, |
| {ITM_GREATER_EQ, REC_NCHAR_F_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_GREATER_EQ, REC_NCHAR_V_UNICODE, REC_NCHAR_F_UNICODE, instrAndText(UNICODE_COMP)}, |
| {ITM_GREATER_EQ, REC_NCHAR_V_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(UNICODE_COMP)}, |
| |
| }; |
| |
| |
| const ex_comp_clause::CompInstrStruct * ex_comp_clause::getMatchingRow(OperatorTypeEnum op, |
| short datatype1, |
| short datatype2) |
| { |
| Int32 max_array_size = sizeof(compInstrInfo) / sizeof(CompInstrStruct); |
| |
| Int32 i = 0; |
| |
| Int32 found = 0; |
| while ((i < max_array_size) && (!found)) |
| if ((compInstrInfo[i].op == op) && |
| (compInstrInfo[i].type_op1 == datatype1) && |
| (compInstrInfo[i].type_op2 == datatype2)) |
| found = -1; |
| else |
| i++; |
| |
| if (found) |
| { |
| setInstrArrayIndex(i); |
| return &compInstrInfo[i]; |
| } |
| else |
| return 0; |
| } |
| |
| Lng32 ex_comp_clause::findIndexIntoInstrArray(CompInstruction ci) |
| { |
| Int32 max_array_size = sizeof(compInstrInfo) / sizeof(CompInstrStruct); |
| |
| Int32 i = 0; |
| while ((i < max_array_size) && |
| (compInstrInfo[i].instruction != ci)) |
| { |
| i++; |
| } |
| |
| if (i < max_array_size) |
| return i; |
| |
| return -1; // not found |
| } |
| |
| const CompInstruction ex_comp_clause::computeCaseIndex(OperatorTypeEnum op, |
| Attributes * attr1, |
| Attributes * attr2) |
| { |
| CompInstruction instruction = COMP_NOT_SUPPORTED; |
| |
| short type_op1; |
| short type_op2; |
| getCaseDatatypes(attr1->getDatatype(), attr1->getLength(), type_op1, |
| attr2->getDatatype(), attr2->getLength(), type_op2, |
| 0 /* don't need to take into account scale difference here */); |
| |
| const CompInstrStruct * cs = getMatchingRow(op, |
| type_op1, |
| type_op2); |
| if (cs) |
| { |
| instruction = cs->instruction; |
| |
| // Further checks are needed. Do them. |
| if ((attr1->getDatatype() == REC_BYTE_F_ASCII) && |
| (attr2->getDatatype() == REC_BYTE_F_ASCII)) |
| { |
| if (attr1->getLength() != attr2->getLength()) |
| { |
| instruction = ASCII_COMP; |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| } |
| |
| if ((attr1->getDatatype() == REC_NCHAR_F_UNICODE) && |
| (attr2->getDatatype() == REC_NCHAR_F_UNICODE)) |
| { |
| if (attr1->getLength() != attr2->getLength()) |
| { |
| instruction = UNICODE_COMP; |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| } |
| |
| // for all numeric, datetime and interval datatypes, comparison done |
| // only if scale is the same |
| if (((attr1->getDatatype() >= REC_MIN_BINARY) && |
| (attr1->getDatatype() <= REC_MAX_BINARY)) || |
| ((attr1->getDatatype() >= REC_DECIMAL_UNSIGNED) && |
| (attr1->getDatatype() <= REC_DECIMAL_LSE)) || |
| (attr1->getDatatype() == REC_DATETIME) || |
| ((attr1->getDatatype() >= REC_MIN_INTERVAL) && |
| (attr1->getDatatype() <= REC_MAX_INTERVAL))) |
| { |
| // numeric, datetime or interval types |
| if (attr1->getScale() != attr2->getScale()) |
| instruction = COMP_NOT_SUPPORTED; |
| |
| // for decimal datatypes, comparison done only if lengths are same. |
| if ((attr1->getDatatype() >= REC_DECIMAL_UNSIGNED) && |
| (attr1->getDatatype() <= REC_DECIMAL_LSE)) |
| { |
| if (attr1->getLength() != attr2->getLength()) |
| instruction = COMP_NOT_SUPPORTED; |
| } |
| } // numeric, datetime or interval types |
| } // comparison supported |
| |
| if (instruction == COMP_NOT_SUPPORTED) |
| setInstrArrayIndex(-1); |
| |
| return instruction; |
| } |
| |
| void ex_comp_clause::setInstruction() |
| { |
| CompInstruction instruction = COMP_NOT_SUPPORTED; |
| setInstrArrayIndex(-1); |
| |
| if ((getOperand(1)->isComplexType()) || (getOperand(2)->isComplexType())) |
| { |
| // complex comparison supported only if both operands are complex with |
| // same datatype |
| if ((getOperand(1)->isComplexType()) && (getOperand(2)->isComplexType()) && |
| (getOperand(1)->getDatatype() == getOperand(2)->getDatatype())) |
| { |
| instruction = COMP_COMPLEX; |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| } |
| else |
| { |
| // Simple types are handled here. |
| instruction = computeCaseIndex(getOperType(), getOperand(1), getOperand(2)); |
| } // simple type |
| |
| if ((instruction == COMP_NOT_SUPPORTED) && |
| (getInstrArrayIndex() >= 0)) |
| { |
| // this is an error, reset instr array index |
| setInstrArrayIndex(-1); |
| } |
| } |
| |
| void ex_comp_clause::setInstruction(OperatorTypeEnum op, |
| Attributes * attr1, |
| Attributes * attr2) |
| { |
| // Only simple types are handled here. |
| CompInstruction instruction = computeCaseIndex(op, attr1, attr2); |
| |
| if ((instruction == COMP_NOT_SUPPORTED) && |
| (getInstrArrayIndex() >= 0)) |
| { |
| // this is an error, reset instr array index |
| setInstrArrayIndex(-1); |
| } |
| } |
| |
| short ex_comp_clause::isComparisonSupported(OperatorTypeEnum op, |
| Attributes * attr1, |
| Attributes * attr2) |
| { |
| if (computeCaseIndex(op, attr1, attr2) |
| == COMP_NOT_SUPPORTED) |
| return 0; |
| else |
| return -1; |
| } |
| |
| ex_expr::exp_return_type ex_comp_clause::fixup(Space * space, |
| CollHeap * exHeap, |
| char * constants_area, |
| char * temps_area, |
| char * persistentArea, |
| short fixupConstsAndTemps, |
| NABoolean spaceCompOnly) |
| { |
| setInstruction(); |
| return ex_clause::fixup(space, exHeap, constants_area, temps_area, |
| persistentArea, |
| fixupConstsAndTemps, spaceCompOnly); |
| } |
| |
| // Entries in this struct must group same src datatypes together. |
| const ex_conv_clause::ConvInstrStruct ex_conv_clause::convInstrInfo[] = { |
| //----------------------------------------------------------------------- |
| // src datatype tgt datatype instruction and indexStr |
| //----------------------------------------------------------------------- |
| {REC_UNKNOWN, REC_UNKNOWN, instrAndText(CONV_COMPLEX_TO_COMPLEX)}, |
| {REC_UNKNOWN, REC_UNKNOWN, instrAndText(CONV_SIMPLE_TO_COMPLEX)}, |
| {REC_UNKNOWN, REC_UNKNOWN, instrAndText(CONV_COMPLEX_TO_SIMPLE)}, |
| |
| {REC_BPINT_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_BPINTU_BPINTU)}, |
| {REC_BPINT_UNSIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIN16U_BIN16S)}, |
| {REC_BPINT_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIN16U_BIN16U)}, |
| {REC_BPINT_UNSIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIN16U_BIN32S)}, |
| {REC_BPINT_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIN16U_BIN32U)}, |
| {REC_BPINT_UNSIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIN16U_BIN64S)}, |
| {REC_BPINT_UNSIGNED, REC_DECIMAL_LSE, instrAndText(CONV_BIN16U_DECS)}, |
| {REC_BPINT_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_BIN16U_DECS)}, |
| {REC_BPINT_UNSIGNED, REC_FLOAT32, instrAndText(CONV_BIN16U_FLOAT32)}, |
| {REC_BPINT_UNSIGNED, REC_FLOAT64, instrAndText(CONV_BIN16U_FLOAT64)}, |
| {REC_BPINT_UNSIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIN16U_BIGNUM)}, |
| {REC_BPINT_UNSIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIN16U_BIGNUM)}, |
| {REC_BPINT_UNSIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN16U_ASCII)}, |
| {REC_BPINT_UNSIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN16U_ASCII)}, |
| {REC_BPINT_UNSIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_BIN16U_ASCII)}, |
| {REC_BPINT_UNSIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_BIN16U_UNICODE)}, |
| {REC_BPINT_UNSIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_BIN16U_UNICODE)}, |
| |
| {REC_BIN8_SIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIN8S_BIN16S)}, |
| {REC_BIN8_SIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIN8S_BIN32S)}, |
| {REC_BIN8_SIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIN8S_BIN64S)}, |
| {REC_BIN8_SIGNED, REC_BIN8_SIGNED, instrAndText(CONV_BIN8S_BIN8S)}, |
| {REC_BIN8_SIGNED, REC_BIN8_UNSIGNED, instrAndText(CONV_BIN8S_BIN8U)}, |
| {REC_BIN8_SIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN8S_ASCII)}, |
| {REC_BIN8_SIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN8S_ASCII)}, |
| |
| {REC_BIN8_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIN8U_BIN16U)}, |
| {REC_BIN8_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIN8U_BIN32U)}, |
| {REC_BIN8_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(CONV_BIN8U_BIN64U)}, |
| {REC_BIN8_UNSIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIN8U_BIN16S)}, |
| {REC_BIN8_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(CONV_BIN8U_BIN8U)}, |
| {REC_BIN8_UNSIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN8U_ASCII)}, |
| {REC_BIN8_UNSIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN8U_ASCII)}, |
| {REC_BIN8_UNSIGNED, REC_BIN8_SIGNED, instrAndText(CONV_BIN8U_BIN8S)}, |
| |
| {REC_BIN16_SIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_BIN16S_BPINTU)}, |
| {REC_BIN16_SIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIN16S_BIN16S)}, |
| {REC_BIN16_SIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIN16S_BIN16U)}, |
| {REC_BIN16_SIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIN16S_BIN32S)}, |
| {REC_BIN16_SIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIN16S_BIN32U)}, |
| {REC_BIN16_SIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIN16S_BIN64S)}, |
| {REC_BIN16_SIGNED, REC_DECIMAL_LSE, instrAndText(CONV_BIN16S_DECS)}, |
| {REC_BIN16_SIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_BIN16S_DECU)}, |
| {REC_BIN16_SIGNED, REC_FLOAT32, instrAndText(CONV_BIN16S_FLOAT32)}, |
| {REC_BIN16_SIGNED, REC_FLOAT64, instrAndText(CONV_BIN16S_FLOAT64)}, |
| {REC_BIN16_SIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIN16S_BIGNUMU)}, |
| {REC_BIN16_SIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIN16S_BIGNUM)}, |
| {REC_BIN16_SIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN16S_ASCII)}, |
| {REC_BIN16_SIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN16S_ASCII)}, |
| {REC_BIN16_SIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_BIN16S_ASCII)}, |
| {REC_BIN16_SIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_BIN16S_UNICODE)}, |
| {REC_BIN16_SIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_BIN16S_UNICODE)}, |
| |
| {REC_BIN16_SIGNED, REC_BIN8_SIGNED, instrAndText(CONV_BIN16S_BIN8S)}, |
| {REC_BIN16_SIGNED, REC_BIN8_UNSIGNED, instrAndText(CONV_BIN16S_BIN8U)}, |
| |
| {REC_BIN16_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_BIN16U_BPINTU)}, |
| {REC_BIN16_UNSIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIN16U_BIN16S)}, |
| {REC_BIN16_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIN16U_BIN16U)}, |
| {REC_BIN16_UNSIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIN16U_BIN32S)}, |
| {REC_BIN16_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIN16U_BIN32U)}, |
| {REC_BIN16_UNSIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIN16U_BIN64S)}, |
| {REC_BIN16_UNSIGNED, REC_DECIMAL_LSE, instrAndText(CONV_BIN16U_DECS)}, |
| {REC_BIN16_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_BIN16U_DECS)}, |
| {REC_BIN16_UNSIGNED, REC_FLOAT32, instrAndText(CONV_BIN16U_FLOAT32)}, |
| {REC_BIN16_UNSIGNED, REC_FLOAT64, instrAndText(CONV_BIN16U_FLOAT64)}, |
| {REC_BIN16_UNSIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIN16U_BIGNUM)}, |
| {REC_BIN16_UNSIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIN16U_BIGNUM)}, |
| {REC_BIN16_UNSIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN16U_ASCII)}, |
| {REC_BIN16_UNSIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN16U_ASCII)}, |
| {REC_BIN16_UNSIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_BIN16U_ASCII)}, |
| {REC_BIN16_UNSIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_BIN16U_UNICODE)}, |
| {REC_BIN16_UNSIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_BIN16U_UNICODE)}, |
| |
| {REC_BIN16_UNSIGNED, REC_BIN8_SIGNED, instrAndText(CONV_BIN16U_BIN8S)}, |
| {REC_BIN16_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(CONV_BIN16U_BIN8U)}, |
| |
| {REC_BIN32_SIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_BIN32S_BPINTU)}, |
| {REC_BIN32_SIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIN32S_BIN16S)}, |
| {REC_BIN32_SIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIN32S_BIN16U)}, |
| {REC_BIN32_SIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIN32S_BIN32S)}, |
| {REC_BIN32_SIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIN32S_BIN32U)}, |
| {REC_BIN32_SIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIN32S_BIN64S)}, |
| {REC_BIN32_SIGNED, REC_DECIMAL_LSE, instrAndText(CONV_BIN32S_DECS)}, |
| {REC_BIN32_SIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_BIN32S_DECU)}, |
| {REC_BIN32_SIGNED, REC_FLOAT32, instrAndText(CONV_BIN32S_FLOAT32)}, |
| {REC_BIN32_SIGNED, REC_FLOAT64, instrAndText(CONV_BIN32S_FLOAT64)}, |
| {REC_BIN32_SIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIN32S_BIGNUMU)}, |
| {REC_BIN32_SIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIN32S_BIGNUM)}, |
| {REC_BIN32_SIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN32S_ASCII)}, |
| {REC_BIN32_SIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN32S_ASCII)}, |
| {REC_BIN32_SIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_BIN32S_ASCII)}, |
| {REC_BIN32_SIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_BIN32S_UNICODE)}, |
| {REC_BIN32_SIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_BIN32S_UNICODE)}, |
| |
| {REC_BIN32_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_BIN32U_BPINTU)}, |
| {REC_BIN32_UNSIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIN32U_BIN16S)}, |
| {REC_BIN32_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIN32U_BIN16U)}, |
| {REC_BIN32_UNSIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIN32U_BIN32S)}, |
| {REC_BIN32_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIN32U_BIN32U)}, |
| {REC_BIN32_UNSIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIN32U_BIN64S)}, |
| {REC_BIN32_UNSIGNED, REC_DECIMAL_LSE, instrAndText(CONV_BIN32U_DECS)}, |
| {REC_BIN32_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_BIN32U_DECS)}, |
| {REC_BIN32_UNSIGNED, REC_FLOAT32, instrAndText(CONV_BIN32U_FLOAT32)}, |
| {REC_BIN32_UNSIGNED, REC_FLOAT64, instrAndText(CONV_BIN32U_FLOAT64)}, |
| {REC_BIN32_UNSIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIN32U_BIGNUM)}, |
| {REC_BIN32_UNSIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIN32U_BIGNUM)}, |
| {REC_BIN32_UNSIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN32U_ASCII)}, |
| {REC_BIN32_UNSIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN32U_ASCII)}, |
| {REC_BIN32_UNSIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_BIN32U_ASCII)}, |
| {REC_BIN32_UNSIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_BIN32U_UNICODE)}, |
| {REC_BIN32_UNSIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_BIN32U_UNICODE)}, |
| |
| {REC_BIN32_UNSIGNED, REC_BIN8_SIGNED, instrAndText(CONV_NUMERIC_BIN8S)}, |
| {REC_BIN32_UNSIGNED, REC_BIN8_UNSIGNED, instrAndText(CONV_NUMERIC_BIN8U)}, |
| |
| {REC_BIN64_SIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_BIN64S_BPINTU)}, |
| {REC_BIN64_SIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIN64S_BIN16S)}, |
| {REC_BIN64_SIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIN64S_BIN16U)}, |
| {REC_BIN64_SIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIN64S_BIN32S)}, |
| {REC_BIN64_SIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIN64S_BIN32U)}, |
| {REC_BIN64_SIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIN64S_BIN64S)}, |
| {REC_BIN64_SIGNED, REC_BIN64_UNSIGNED, instrAndText(CONV_BIN64S_BIN64U)}, |
| {REC_BIN64_SIGNED, REC_DECIMAL_LSE, instrAndText(CONV_BIN64S_DECS)}, |
| {REC_BIN64_SIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_BIN64S_DECU)}, |
| {REC_BIN64_SIGNED, REC_FLOAT32, instrAndText(CONV_BIN64S_FLOAT32)}, |
| {REC_BIN64_SIGNED, REC_FLOAT64, instrAndText(CONV_BIN64S_FLOAT64)}, |
| {REC_BIN64_SIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIN64S_BIGNUMU)}, |
| {REC_BIN64_SIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIN64S_BIGNUM)}, |
| {REC_BIN64_SIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN64S_ASCII)}, |
| {REC_BIN64_SIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN64S_ASCII)}, |
| {REC_BIN64_SIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_BIN64S_ASCII)}, |
| {REC_BIN64_SIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_BIN64S_UNICODE)}, |
| {REC_BIN64_SIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_BIN64S_UNICODE)}, |
| {REC_BIN64_SIGNED, REC_DATETIME, instrAndText(CONV_BIN64S_DATETIME)}, |
| |
| {REC_BIN64_UNSIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIN64U_BIN64S)}, |
| {REC_BIN64_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(CONV_BIN64U_BIN64U)}, |
| {REC_BIN64_UNSIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIN64U_BIGNUM)}, |
| {REC_BIN64_UNSIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIN64U_BIGNUM)}, |
| {REC_BIN64_UNSIGNED, REC_FLOAT32, instrAndText(CONV_BIN64U_FLOAT32)}, |
| {REC_BIN64_UNSIGNED, REC_FLOAT64, instrAndText(CONV_BIN64U_FLOAT64)}, |
| {REC_BIN64_UNSIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIN64U_ASCII)}, |
| {REC_BIN64_UNSIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIN64U_ASCII)}, |
| |
| {REC_DECIMAL_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_DECS_BIN32U)}, |
| {REC_DECIMAL_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_DECS_BIN32U)}, |
| {REC_DECIMAL_UNSIGNED, REC_BIN16_SIGNED, instrAndText(CONV_DECS_BIN32S)}, |
| {REC_DECIMAL_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_DECS_BIN32U)}, |
| {REC_DECIMAL_UNSIGNED, REC_BIN32_SIGNED, instrAndText(CONV_DECS_BIN32S)}, |
| {REC_DECIMAL_UNSIGNED, REC_BIN64_SIGNED, instrAndText(CONV_DECS_BIN64S)}, |
| {REC_DECIMAL_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_DECS_DECU)}, |
| {REC_DECIMAL_UNSIGNED, REC_DECIMAL_LSE, instrAndText(CONV_DECS_DECS)}, |
| {REC_DECIMAL_UNSIGNED, REC_FLOAT32, instrAndText(CONV_DECS_FLOAT32)}, |
| {REC_DECIMAL_UNSIGNED, REC_FLOAT64, instrAndText(CONV_DECS_FLOAT64)}, |
| {REC_DECIMAL_UNSIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_DECS_BIN32U)}, |
| {REC_DECIMAL_UNSIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_DECS_BIN32S)}, |
| {REC_DECIMAL_UNSIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_DECS_ASCII)}, |
| {REC_DECIMAL_UNSIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_DECS_ASCII)}, |
| {REC_DECIMAL_UNSIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_DECS_ASCII)}, |
| {REC_DECIMAL_UNSIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_DECS_UNICODE)}, |
| {REC_DECIMAL_UNSIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_DECS_UNICODE)}, |
| |
| {REC_DECIMAL_LSE, REC_BPINT_UNSIGNED, instrAndText(CONV_DECS_BIN32U)}, |
| {REC_DECIMAL_LSE, REC_BIN16_SIGNED, instrAndText(CONV_DECS_BIN32S)}, |
| {REC_DECIMAL_LSE, REC_BIN16_UNSIGNED, instrAndText(CONV_DECS_BIN32U)}, |
| {REC_DECIMAL_LSE, REC_BIN32_SIGNED, instrAndText(CONV_DECS_BIN32S)}, |
| {REC_DECIMAL_LSE, REC_BIN32_UNSIGNED, instrAndText(CONV_DECS_BIN32U)}, |
| {REC_DECIMAL_LSE, REC_BIN64_SIGNED, instrAndText(CONV_DECS_BIN64S)}, |
| {REC_DECIMAL_LSE, REC_DECIMAL_LSE, instrAndText(CONV_DECS_DECS)}, |
| {REC_DECIMAL_LSE, REC_DECIMAL_UNSIGNED, instrAndText(CONV_DECS_DECU)}, |
| {REC_DECIMAL_LSE, REC_FLOAT32, instrAndText(CONV_DECS_FLOAT32)}, |
| {REC_DECIMAL_LSE, REC_FLOAT64, instrAndText(CONV_DECS_FLOAT64)}, |
| {REC_DECIMAL_LSE, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_DECS_BIN32U)}, |
| {REC_DECIMAL_LSE, REC_NUM_BIG_SIGNED, instrAndText(CONV_DECS_BIN32S)}, |
| {REC_DECIMAL_LSE, REC_DECIMAL_LS, instrAndText(CONV_DECS_ASCII)}, |
| {REC_DECIMAL_LSE, REC_BYTE_F_ASCII, instrAndText(CONV_DECS_ASCII)}, |
| {REC_DECIMAL_LSE, REC_BYTE_V_ASCII, instrAndText(CONV_DECS_ASCII)}, |
| {REC_DECIMAL_LSE, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_DECS_ASCII)}, |
| {REC_DECIMAL_LSE, REC_NCHAR_F_UNICODE, instrAndText(CONV_DECS_UNICODE)}, |
| {REC_DECIMAL_LSE, REC_NCHAR_V_UNICODE, instrAndText(CONV_DECS_UNICODE)}, |
| |
| {REC_FLOAT32, REC_BPINT_UNSIGNED, instrAndText(CONV_FLOAT32_BPINTU)}, |
| {REC_FLOAT32, REC_BIN16_SIGNED, instrAndText(CONV_FLOAT32_BIN16S)}, |
| {REC_FLOAT32, REC_BIN16_UNSIGNED, instrAndText(CONV_FLOAT32_BIN16U)}, |
| {REC_FLOAT32, REC_BIN32_SIGNED, instrAndText(CONV_FLOAT32_BIN32S)}, |
| {REC_FLOAT32, REC_BIN32_UNSIGNED, instrAndText(CONV_FLOAT32_BIN32U)}, |
| {REC_FLOAT32, REC_BIN64_SIGNED, instrAndText(CONV_FLOAT32_BIN64S)}, |
| {REC_FLOAT32, REC_BIN64_UNSIGNED, instrAndText(CONV_FLOAT32_BIN64U)}, |
| {REC_FLOAT32, REC_DECIMAL_LSE, instrAndText(CONV_FLOAT32_DECS)}, |
| {REC_FLOAT32, REC_DECIMAL_UNSIGNED, instrAndText(CONV_FLOAT32_DECU)}, |
| {REC_FLOAT32, REC_FLOAT32, instrAndText(CONV_FLOAT32_FLOAT32)}, |
| {REC_FLOAT32, REC_FLOAT64, instrAndText(CONV_FLOAT32_FLOAT64)}, |
| {REC_FLOAT32, REC_BYTE_F_ASCII, instrAndText(CONV_FLOAT32_ASCII)}, |
| {REC_FLOAT32, REC_BYTE_V_ASCII, instrAndText(CONV_FLOAT32_ASCII)}, |
| {REC_FLOAT32, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_FLOAT32_ASCII)}, |
| {REC_FLOAT32, REC_NCHAR_F_UNICODE, instrAndText(CONV_FLOAT32_UNICODE)}, |
| {REC_FLOAT32, REC_NCHAR_V_UNICODE, instrAndText(CONV_FLOAT32_UNICODE)}, |
| |
| {REC_FLOAT64, REC_BPINT_UNSIGNED, instrAndText(CONV_FLOAT64_BPINTU)}, |
| {REC_FLOAT64, REC_BIN16_SIGNED, instrAndText(CONV_FLOAT64_BIN16S)}, |
| {REC_FLOAT64, REC_BIN16_UNSIGNED, instrAndText(CONV_FLOAT64_BIN16U)}, |
| {REC_FLOAT64, REC_BIN32_SIGNED, instrAndText(CONV_FLOAT64_BIN32S)}, |
| {REC_FLOAT64, REC_BIN32_UNSIGNED, instrAndText(CONV_FLOAT64_BIN32U)}, |
| {REC_FLOAT64, REC_BIN64_SIGNED, instrAndText(CONV_FLOAT64_BIN64S)}, |
| {REC_FLOAT64, REC_BIN64_UNSIGNED, instrAndText(CONV_FLOAT64_BIN64U)}, |
| {REC_FLOAT64, REC_DECIMAL_LSE, instrAndText(CONV_FLOAT64_DECS)}, |
| {REC_FLOAT64, REC_DECIMAL_UNSIGNED, instrAndText(CONV_FLOAT64_DECU)}, |
| {REC_FLOAT64, REC_FLOAT32, instrAndText(CONV_FLOAT64_FLOAT32)}, |
| {REC_FLOAT64, REC_FLOAT64, instrAndText(CONV_FLOAT64_FLOAT64)}, |
| {REC_FLOAT64, REC_BYTE_F_ASCII, instrAndText(CONV_FLOAT64_ASCII)}, |
| {REC_FLOAT64, REC_BYTE_V_ASCII, instrAndText(CONV_FLOAT64_ASCII)}, |
| {REC_FLOAT64, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_FLOAT64_ASCII)}, |
| {REC_FLOAT64, REC_NCHAR_F_UNICODE, instrAndText(CONV_FLOAT64_UNICODE)}, |
| {REC_FLOAT64, REC_NCHAR_V_UNICODE, instrAndText(CONV_FLOAT64_UNICODE)}, |
| |
| {REC_NUM_BIG_UNSIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_BIGNUM_BIN16U)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIGNUM_BIN16S)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIGNUM_BIN16U)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIGNUM_BIN32S)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIGNUM_BIN32U)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIGNUM_BIN64S)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BIN64_UNSIGNED, instrAndText(CONV_BIGNUM_BIN64U)}, |
| {REC_NUM_BIG_UNSIGNED, REC_DECIMAL_LSE, instrAndText(CONV_BIGNUM_DECS)}, |
| {REC_NUM_BIG_UNSIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_BIGNUM_DECU)}, |
| {REC_NUM_BIG_UNSIGNED, REC_FLOAT32, instrAndText(CONV_BIGNUM_FLOAT32)}, |
| {REC_NUM_BIG_UNSIGNED, REC_FLOAT64, instrAndText(CONV_BIGNUM_FLOAT64)}, |
| {REC_NUM_BIG_UNSIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIGNUM_BIGNUM)}, |
| {REC_NUM_BIG_UNSIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIGNUM_BIGNUM)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIGNUM_ASCII)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIGNUM_ASCII)}, |
| {REC_NUM_BIG_UNSIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_BIGNUM_ASCII)}, |
| {REC_NUM_BIG_UNSIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_BIGNUM_UNICODE)}, |
| {REC_NUM_BIG_UNSIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_BIGNUM_UNICODE)}, |
| |
| {REC_NUM_BIG_SIGNED, REC_BPINT_UNSIGNED, instrAndText(CONV_BIGNUM_BIN16U)}, |
| {REC_NUM_BIG_SIGNED, REC_BIN16_SIGNED, instrAndText(CONV_BIGNUM_BIN16S)}, |
| {REC_NUM_BIG_SIGNED, REC_BIN16_UNSIGNED, instrAndText(CONV_BIGNUM_BIN16U)}, |
| {REC_NUM_BIG_SIGNED, REC_BIN32_SIGNED, instrAndText(CONV_BIGNUM_BIN32S)}, |
| {REC_NUM_BIG_SIGNED, REC_BIN32_UNSIGNED, instrAndText(CONV_BIGNUM_BIN32U)}, |
| {REC_NUM_BIG_SIGNED, REC_BIN64_SIGNED, instrAndText(CONV_BIGNUM_BIN64S)}, |
| {REC_NUM_BIG_SIGNED, REC_BIN64_UNSIGNED, instrAndText(CONV_BIGNUM_BIN64U)}, |
| {REC_NUM_BIG_SIGNED, REC_DECIMAL_LSE, instrAndText(CONV_BIGNUM_DECS)}, |
| {REC_NUM_BIG_SIGNED, REC_DECIMAL_UNSIGNED, instrAndText(CONV_BIGNUM_DECU)}, |
| {REC_NUM_BIG_SIGNED, REC_FLOAT32, instrAndText(CONV_BIGNUM_FLOAT32)}, |
| {REC_NUM_BIG_SIGNED, REC_FLOAT64, instrAndText(CONV_BIGNUM_FLOAT64)}, |
| {REC_NUM_BIG_SIGNED, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_BIGNUM_BIGNUM)}, |
| {REC_NUM_BIG_SIGNED, REC_NUM_BIG_SIGNED, instrAndText(CONV_BIGNUM_BIGNUM)}, |
| {REC_NUM_BIG_SIGNED, REC_BYTE_F_ASCII, instrAndText(CONV_BIGNUM_ASCII)}, |
| {REC_NUM_BIG_SIGNED, REC_BYTE_V_ASCII, instrAndText(CONV_BIGNUM_ASCII)}, |
| {REC_NUM_BIG_SIGNED, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_BIGNUM_ASCII)}, |
| {REC_NUM_BIG_SIGNED, REC_NCHAR_F_UNICODE, instrAndText(CONV_BIGNUM_UNICODE)}, |
| {REC_NUM_BIG_SIGNED, REC_NCHAR_V_UNICODE, instrAndText(CONV_BIGNUM_UNICODE)}, |
| |
| // leading sign seperate decimal is identical to ascii representation. |
| // Thus, use instrAndText(CONV_ASCII_DEC) to convert it to decimal |
| {REC_DECIMAL_LS, REC_DECIMAL_LSE, instrAndText(CONV_ASCII_DEC)}, |
| {REC_DECIMAL_LS, REC_DECIMAL_LS, instrAndText(CONV_DECLS_DECLS)}, |
| {REC_DECIMAL_LS, REC_BYTE_F_ASCII, instrAndText(CONV_DECLS_ASCII)}, |
| {REC_DECIMAL_LS, REC_DECIMAL_UNSIGNED, instrAndText(CONV_DECLS_DECU)}, |
| |
| {REC_DATETIME, REC_DATETIME, instrAndText(CONV_DATETIME_DATETIME)}, |
| {REC_DATETIME, REC_BYTE_F_ASCII, instrAndText(CONV_DATETIME_ASCII)}, |
| {REC_DATETIME, REC_BYTE_V_ASCII, instrAndText(CONV_DATETIME_ASCII)}, |
| {REC_DATETIME, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_DATETIME_ASCII)}, |
| {REC_DATETIME, REC_NCHAR_F_UNICODE, instrAndText(CONV_DATETIME_UNICODE)}, |
| {REC_DATETIME, REC_NCHAR_V_UNICODE, instrAndText(CONV_DATETIME_UNICODE)}, |
| |
| {REC_DATETIME, REC_BIN64_SIGNED, instrAndText(CONV_DATETIME_BIN64S)}, |
| |
| {REC_INT_YEAR, REC_INT_MONTH, instrAndText(CONV_INTERVALY_INTERVALMO)}, |
| |
| {REC_INT_YEAR, REC_BYTE_F_ASCII, instrAndText(CONV_INTERVAL_ASCII)}, |
| {REC_INT_YEAR, REC_BYTE_V_ASCII, instrAndText(CONV_INTERVAL_ASCII)}, |
| {REC_INT_YEAR, REC_NCHAR_F_UNICODE, instrAndText(CONV_INTERVAL_UNICODE)}, |
| {REC_INT_YEAR, REC_NCHAR_V_UNICODE, instrAndText(CONV_INTERVAL_UNICODE)}, |
| |
| {REC_INT_MONTH, REC_INT_YEAR, instrAndText(CONV_INTERVALMO_INTERVALY)}, |
| |
| {REC_INT_DAY, REC_INT_HOUR, instrAndText(CONV_INTERVALD_INTERVALH)}, |
| {REC_INT_DAY, REC_INT_MINUTE, instrAndText(CONV_INTERVALD_INTERVALM)}, |
| {REC_INT_DAY, REC_INT_SECOND, instrAndText(CONV_INTERVALD_INTERVALS)}, |
| |
| {REC_INT_HOUR, REC_INT_DAY, instrAndText(CONV_INTERVALH_INTERVALD)}, |
| {REC_INT_HOUR, REC_INT_MINUTE, instrAndText(CONV_INTERVALH_INTERVALM)}, |
| {REC_INT_HOUR, REC_INT_SECOND, instrAndText(CONV_INTERVALH_INTERVALS)}, |
| |
| {REC_INT_MINUTE, REC_INT_DAY, instrAndText(CONV_INTERVALM_INTERVALD)}, |
| {REC_INT_MINUTE, REC_INT_HOUR, instrAndText(CONV_INTERVALM_INTERVALH)}, |
| {REC_INT_MINUTE, REC_INT_SECOND, instrAndText(CONV_INTERVALM_INTERVALS)}, |
| |
| {REC_INT_SECOND, REC_INT_DAY, instrAndText(CONV_INTERVALS_INTERVALD)}, |
| {REC_INT_SECOND, REC_INT_HOUR, instrAndText(CONV_INTERVALS_INTERVALH)}, |
| {REC_INT_SECOND, REC_INT_MINUTE, instrAndText(CONV_INTERVALS_INTERVALM)}, |
| |
| // on the next one, we have to consider scale difference also to distinguish |
| // between CONV_INTERVALS_INTERVALS_DIV and CONV_INTERVALS_INTERVALS_MULT |
| {REC_INT_SECOND, REC_INT_SECOND, instrAndText(CONV_INTERVALS_INTERVALS_DIV)}, |
| {REC_INT_SECOND, REC_INT_SECOND, instrAndText(CONV_INTERVALS_INTERVALS_MULT)}, |
| |
| {REC_BYTE_F_ASCII, REC_BPINT_UNSIGNED, instrAndText(CONV_ASCII_BIN16U)}, |
| {REC_BYTE_F_ASCII, REC_BIN8_SIGNED, instrAndText(CONV_ASCII_BIN8S)}, |
| {REC_BYTE_F_ASCII, REC_BIN8_UNSIGNED, instrAndText(CONV_ASCII_BIN8U)}, |
| {REC_BYTE_F_ASCII, REC_BIN16_SIGNED, instrAndText(CONV_ASCII_BIN16S)}, |
| {REC_BYTE_F_ASCII, REC_BIN16_UNSIGNED, instrAndText(CONV_ASCII_BIN16U)}, |
| {REC_BYTE_F_ASCII, REC_BIN32_SIGNED, instrAndText(CONV_ASCII_BIN32S)}, |
| {REC_BYTE_F_ASCII, REC_BIN32_UNSIGNED, instrAndText(CONV_ASCII_BIN32U)}, |
| {REC_BYTE_F_ASCII, REC_BIN64_SIGNED, instrAndText(CONV_ASCII_BIN64S)}, |
| {REC_BYTE_F_ASCII, REC_BIN64_UNSIGNED, instrAndText(CONV_ASCII_BIN64U)}, |
| {REC_BYTE_F_ASCII, REC_DECIMAL_LSE, instrAndText(CONV_ASCII_DEC)}, |
| {REC_BYTE_F_ASCII, REC_DECIMAL_UNSIGNED, instrAndText(CONV_ASCII_DEC)}, |
| |
| {REC_BYTE_F_ASCII, REC_FLOAT32, instrAndText(CONV_ASCII_FLOAT32)}, |
| {REC_BYTE_F_ASCII, REC_FLOAT64, instrAndText(CONV_ASCII_FLOAT64)}, |
| |
| {REC_BYTE_F_ASCII, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_ASCII_BIGNUM)}, |
| {REC_BYTE_F_ASCII, REC_NUM_BIG_SIGNED, instrAndText(CONV_ASCII_BIGNUM)}, |
| {REC_BYTE_F_ASCII, REC_BYTE_F_ASCII, instrAndText(CONV_ASCII_F_F)}, |
| {REC_BYTE_F_ASCII, REC_BYTE_V_ASCII, instrAndText(CONV_ASCII_F_V)}, |
| {REC_BYTE_F_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_ASCII_F_V)}, |
| {REC_BYTE_F_ASCII, REC_BYTE_V_ANSI, instrAndText(CONV_ASCII_TO_ANSI_V)}, |
| {REC_BYTE_F_ASCII, REC_DATETIME, instrAndText(CONV_ASCII_DATETIME)}, |
| |
| {REC_BYTE_F_ASCII, REC_INT_YEAR, instrAndText(CONV_ASCII_INTERVAL)}, |
| {REC_BYTE_F_ASCII, REC_NCHAR_F_UNICODE, instrAndText(CONV_ASCII_UNICODE_F)}, |
| {REC_BYTE_F_ASCII, REC_NCHAR_V_UNICODE, instrAndText(CONV_ASCII_UNICODE_V)}, |
| {REC_BYTE_F_ASCII, REC_NCHAR_V_ANSI_UNICODE, instrAndText(CONV_ASCII_TO_ANSI_V_UNICODE)}, |
| |
| {REC_BYTE_F_ASCII, REC_BOOLEAN, instrAndText(CONV_ASCII_BOOL)}, |
| {REC_NCHAR_F_UNICODE, REC_NCHAR_F_UNICODE, instrAndText(CONV_UNICODE_F_F)}, |
| {REC_NCHAR_F_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(CONV_UNICODE_F_V)}, |
| {REC_NCHAR_F_UNICODE, REC_BYTE_F_ASCII, instrAndText(CONV_UNICODE_F_ASCII_F)}, |
| {REC_NCHAR_F_UNICODE, REC_MBYTE_F_SJIS, instrAndText(CONV_UNICODE_F_SJIS_F)}, |
| {REC_NCHAR_F_UNICODE, REC_MBYTE_V_SJIS, instrAndText(CONV_UNICODE_F_SJIS_V)}, |
| {REC_NCHAR_F_UNICODE, REC_MBYTE_LOCALE_F, instrAndText(CONV_UNICODE_F_MBYTE_LOCALE_F)}, |
| {REC_NCHAR_F_UNICODE, REC_SBYTE_LOCALE_F, instrAndText(CONV_UNICODE_F_SBYTE_LOCALE_F)}, |
| {REC_NCHAR_F_UNICODE, REC_DATETIME, instrAndText(CONV_UNICODE_DATETIME)}, |
| {REC_NCHAR_F_UNICODE, REC_BIN16_SIGNED, instrAndText(CONV_UNICODE_BIN16S)}, |
| {REC_NCHAR_F_UNICODE, REC_BIN16_UNSIGNED, instrAndText(CONV_UNICODE_BIN16U)}, |
| {REC_NCHAR_F_UNICODE, REC_BPINT_UNSIGNED, instrAndText(CONV_UNICODE_BIN16U)}, |
| {REC_NCHAR_F_UNICODE, REC_BIN32_UNSIGNED, instrAndText(CONV_UNICODE_BIN32U)}, |
| {REC_NCHAR_F_UNICODE, REC_BIN32_SIGNED, instrAndText(CONV_UNICODE_BIN32S)}, |
| {REC_NCHAR_F_UNICODE, REC_BIN64_SIGNED, instrAndText(CONV_UNICODE_BIN64S)}, |
| {REC_NCHAR_F_UNICODE, REC_FLOAT32, instrAndText(CONV_UNICODE_FLOAT32)}, |
| {REC_NCHAR_F_UNICODE, REC_FLOAT64, instrAndText(CONV_UNICODE_FLOAT64)}, |
| {REC_NCHAR_F_UNICODE, REC_DECIMAL_LSE, instrAndText(CONV_UNICODE_DEC)}, |
| {REC_NCHAR_F_UNICODE, REC_DECIMAL_UNSIGNED, instrAndText(CONV_UNICODE_DEC)}, |
| {REC_NCHAR_F_UNICODE, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_UNICODE_BIGNUM)}, |
| {REC_NCHAR_F_UNICODE, REC_NUM_BIG_SIGNED, instrAndText(CONV_UNICODE_BIGNUM)}, |
| {REC_NCHAR_F_UNICODE, REC_INT_YEAR, instrAndText(CONV_UNICODE_INTERVAL)}, |
| {REC_NCHAR_F_UNICODE, REC_BYTE_V_ASCII, instrAndText(CONV_UNICODE_F_ASCII_V)}, |
| {REC_NCHAR_F_UNICODE, REC_NCHAR_V_ANSI_UNICODE,instrAndText(CONV_UNICODE_TO_ANSI_V_UNICODE)}, |
| {REC_NCHAR_F_UNICODE, REC_BYTE_V_ANSI, instrAndText(CONV_UNICODE_F_ANSI_V)}, |
| |
| {REC_NCHAR_V_UNICODE, REC_BYTE_F_ASCII, instrAndText(CONV_UNICODE_V_ASCII_F)}, |
| {REC_NCHAR_V_UNICODE, REC_MBYTE_F_SJIS, instrAndText(CONV_UNICODE_V_SJIS_F)}, |
| {REC_NCHAR_V_UNICODE, REC_MBYTE_V_SJIS, instrAndText(CONV_UNICODE_V_SJIS_V)}, |
| {REC_NCHAR_V_UNICODE, REC_NCHAR_F_UNICODE, instrAndText(CONV_UNICODE_V_F)}, |
| {REC_NCHAR_V_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(CONV_UNICODE_V_V)}, |
| {REC_NCHAR_V_UNICODE, REC_MBYTE_LOCALE_F, instrAndText(CONV_UNICODE_V_MBYTE_LOCALE_F)}, |
| {REC_NCHAR_V_UNICODE, REC_SBYTE_LOCALE_F, instrAndText(CONV_UNICODE_V_SBYTE_LOCALE_F)}, |
| {REC_NCHAR_V_UNICODE, REC_DATETIME, instrAndText(CONV_UNICODE_DATETIME)}, |
| {REC_NCHAR_V_UNICODE, REC_BIN16_SIGNED, instrAndText(CONV_UNICODE_BIN16S)}, |
| {REC_NCHAR_V_UNICODE, REC_BIN16_UNSIGNED, instrAndText(CONV_UNICODE_BIN16U)}, |
| {REC_NCHAR_V_UNICODE, REC_BPINT_UNSIGNED, instrAndText(CONV_UNICODE_BIN16U)}, |
| {REC_NCHAR_V_UNICODE, REC_BIN32_UNSIGNED, instrAndText(CONV_UNICODE_BIN32U)}, |
| {REC_NCHAR_V_UNICODE, REC_BIN32_SIGNED, instrAndText(CONV_UNICODE_BIN32S)}, |
| {REC_NCHAR_V_UNICODE, REC_BIN64_SIGNED, instrAndText(CONV_UNICODE_BIN64S)}, |
| {REC_NCHAR_V_UNICODE, REC_FLOAT32, instrAndText(CONV_UNICODE_FLOAT32)}, |
| {REC_NCHAR_V_UNICODE, REC_FLOAT64, instrAndText(CONV_UNICODE_FLOAT64)}, |
| {REC_NCHAR_V_UNICODE, REC_DECIMAL_LSE, instrAndText(CONV_UNICODE_DEC)}, |
| {REC_NCHAR_V_UNICODE, REC_DECIMAL_UNSIGNED, instrAndText(CONV_UNICODE_DEC)}, |
| {REC_NCHAR_V_UNICODE, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_UNICODE_BIGNUM)}, |
| {REC_NCHAR_V_UNICODE, REC_NUM_BIG_SIGNED, instrAndText(CONV_UNICODE_BIGNUM)}, |
| {REC_NCHAR_V_UNICODE, REC_INT_YEAR, instrAndText(CONV_UNICODE_INTERVAL)}, |
| {REC_NCHAR_V_UNICODE, REC_BYTE_V_ASCII, instrAndText(CONV_UNICODE_V_ASCII_V)}, |
| {REC_NCHAR_V_UNICODE, REC_NCHAR_V_ANSI_UNICODE,instrAndText(CONV_UNICODE_TO_ANSI_V_UNICODE)}, |
| {REC_NCHAR_V_UNICODE, REC_BYTE_V_ANSI, instrAndText(CONV_UNICODE_V_ANSI_V)}, |
| |
| |
| {REC_BYTE_V_ASCII, REC_BPINT_UNSIGNED, instrAndText(CONV_ASCII_BIN16U)}, |
| {REC_BYTE_V_ASCII, REC_BIN8_SIGNED, instrAndText(CONV_ASCII_BIN8S)}, |
| {REC_BYTE_V_ASCII, REC_BIN8_UNSIGNED, instrAndText(CONV_ASCII_BIN8U)}, |
| {REC_BYTE_V_ASCII, REC_BIN16_SIGNED, instrAndText(CONV_ASCII_BIN16S)}, |
| {REC_BYTE_V_ASCII, REC_BIN16_UNSIGNED, instrAndText(CONV_ASCII_BIN16U)}, |
| {REC_BYTE_V_ASCII, REC_BIN32_SIGNED, instrAndText(CONV_ASCII_BIN32S)}, |
| {REC_BYTE_V_ASCII, REC_BIN32_UNSIGNED, instrAndText(CONV_ASCII_BIN32U)}, |
| {REC_BYTE_V_ASCII, REC_BIN64_SIGNED, instrAndText(CONV_ASCII_BIN64S)}, |
| {REC_BYTE_V_ASCII, REC_BIN64_UNSIGNED, instrAndText(CONV_ASCII_BIN64U)}, |
| {REC_BYTE_V_ASCII, REC_DECIMAL_LSE, instrAndText(CONV_ASCII_DEC)}, |
| {REC_BYTE_V_ASCII, REC_DECIMAL_UNSIGNED, instrAndText(CONV_ASCII_DEC)}, |
| |
| {REC_BYTE_V_ASCII, REC_FLOAT32, instrAndText(CONV_ASCII_FLOAT32)}, |
| {REC_BYTE_V_ASCII, REC_FLOAT64, instrAndText(CONV_ASCII_FLOAT64)}, |
| |
| {REC_BYTE_V_ASCII, REC_DATETIME, instrAndText(CONV_ASCII_DATETIME)}, |
| {REC_BYTE_V_ASCII, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_ASCII_BIGNUM)}, |
| {REC_BYTE_V_ASCII, REC_NUM_BIG_SIGNED, instrAndText(CONV_ASCII_BIGNUM)}, |
| {REC_BYTE_V_ASCII, REC_BYTE_F_ASCII, instrAndText(CONV_ASCII_V_F)}, |
| {REC_BYTE_V_ASCII, REC_BYTE_V_ASCII, instrAndText(CONV_ASCII_V_V)}, |
| {REC_BYTE_V_ASCII, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_ASCII_V_V)}, |
| {REC_BYTE_V_ASCII, REC_BYTE_V_ANSI, instrAndText(CONV_ASCII_TO_ANSI_V)}, |
| |
| {REC_BYTE_V_ASCII, REC_INT_YEAR, instrAndText(CONV_ASCII_INTERVAL)}, |
| |
| {REC_BYTE_V_ASCII, REC_NCHAR_F_UNICODE, instrAndText(CONV_ASCII_UNICODE_F)}, |
| {REC_BYTE_V_ASCII, REC_NCHAR_V_UNICODE, instrAndText(CONV_ASCII_UNICODE_V)}, |
| {REC_BYTE_V_ASCII, REC_NCHAR_V_ANSI_UNICODE, instrAndText(CONV_ASCII_TO_ANSI_V_UNICODE)}, |
| |
| {REC_BYTE_V_ASCII, REC_BOOLEAN, instrAndText(CONV_ASCII_BOOL)}, |
| |
| {REC_BYTE_V_ASCII_LONG, REC_BPINT_UNSIGNED, instrAndText(CONV_ASCII_BIN16U)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BIN16_SIGNED, instrAndText(CONV_ASCII_BIN16S)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BIN16_UNSIGNED, instrAndText(CONV_ASCII_BIN16U)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BIN32_SIGNED, instrAndText(CONV_ASCII_BIN32S)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BIN32_UNSIGNED, instrAndText(CONV_ASCII_BIN32U)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BIN64_SIGNED, instrAndText(CONV_ASCII_BIN64S)}, |
| {REC_BYTE_V_ASCII_LONG, REC_DECIMAL_LSE, instrAndText(CONV_ASCII_DEC)}, |
| {REC_BYTE_V_ASCII_LONG, REC_DECIMAL_UNSIGNED, instrAndText(CONV_ASCII_DEC)}, |
| |
| {REC_BYTE_V_ASCII_LONG, REC_FLOAT32, instrAndText(CONV_ASCII_FLOAT32)}, |
| {REC_BYTE_V_ASCII_LONG, REC_FLOAT64, instrAndText(CONV_ASCII_FLOAT64)}, |
| |
| {REC_BYTE_V_ASCII_LONG, REC_DATETIME, instrAndText(CONV_ASCII_DATETIME)}, |
| {REC_BYTE_V_ASCII_LONG, REC_NUM_BIG_UNSIGNED, instrAndText(CONV_ASCII_BIGNUM)}, |
| {REC_BYTE_V_ASCII_LONG, REC_NUM_BIG_SIGNED, instrAndText(CONV_ASCII_BIGNUM)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BYTE_F_ASCII, instrAndText(CONV_ASCII_V_F)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII, instrAndText(CONV_ASCII_V_V)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_ASCII_V_V)}, |
| {REC_BYTE_V_ASCII_LONG, REC_BYTE_V_ANSI, instrAndText(CONV_ASCII_TO_ANSI_V)}, |
| |
| {REC_BYTE_V_ANSI, REC_BYTE_F_ASCII, instrAndText(CONV_ANSI_V_TO_ASCII_F)}, |
| {REC_BYTE_V_ANSI, REC_BYTE_V_ASCII, instrAndText(CONV_ANSI_V_TO_ASCII_V)}, |
| {REC_BYTE_V_ANSI, REC_BYTE_V_ASCII_LONG, instrAndText(CONV_ANSI_V_TO_ASCII_V)}, |
| {REC_BYTE_V_ANSI, REC_BYTE_V_ANSI, instrAndText(CONV_ANSI_V_TO_ANSI_V)}, |
| |
| {REC_NCHAR_V_ANSI_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(CONV_ANSI_V_UNICODE_TO_UNICODE_V)}, |
| {REC_NCHAR_V_ANSI_UNICODE, REC_NCHAR_V_ANSI_UNICODE, instrAndText(CONV_ANSI_V_UNICODE_TO_ANSI_V_UNICODE)}, |
| {REC_NCHAR_V_ANSI_UNICODE, REC_BYTE_V_ASCII, instrAndText(CONV_ANSI_V_UNICODE_TO_ASCII_V)}, |
| {REC_NCHAR_V_ANSI_UNICODE, REC_BYTE_F_ASCII, instrAndText(CONV_ANSI_V_UNICODE_TO_ASCII_F)}, |
| {REC_NCHAR_V_ANSI_UNICODE, REC_NCHAR_F_UNICODE, instrAndText(CONV_ANSI_V_UNICODE_TO_UNICODE_F)}, |
| {REC_NCHAR_V_ANSI_UNICODE, REC_NCHAR_V_UNICODE, instrAndText(CONV_ANSI_V_UNICODE_TO_UNICODE_V)}, |
| |
| {REC_BLOB, REC_BLOB, instrAndText(CONV_BLOB_BLOB)}, |
| {REC_BLOB, REC_BYTE_F_ASCII, instrAndText(CONV_BLOB_ASCII_F)}, |
| |
| {REC_CLOB, REC_CLOB, instrAndText(CONV_BLOB_BLOB)}, |
| {REC_CLOB, REC_BYTE_F_ASCII, instrAndText(CONV_BLOB_ASCII_F)}, |
| |
| {REC_BOOLEAN, REC_BOOLEAN, instrAndText(CONV_BOOL_BOOL)}, |
| {REC_BOOLEAN, REC_BYTE_F_ASCII, instrAndText(CONV_BOOL_ASCII)}, |
| {REC_BOOLEAN, REC_BYTE_V_ASCII, instrAndText(CONV_BOOL_ASCII)}, |
| |
| }; |
| |
| Lng32 ex_conv_clause::findIndexIntoInstrArray(ConvInstruction ci) |
| { |
| Int32 max_array_size = sizeof(convInstrInfo) / sizeof(ConvInstrStruct); |
| |
| Int32 i = 0; |
| while ((i < max_array_size) && |
| (convInstrInfo[i].instruction != ci)) |
| { |
| i++; |
| } |
| |
| if (i < max_array_size) |
| return i; |
| |
| return -1; // not found |
| } |
| |
| bool ex_conv_clause::sv_instrOffsetIndexPopulated = false; |
| short ex_conv_clause::sv_MaxOpTypeValue = -1; |
| int *ex_conv_clause::sv_convIndexSparse = 0; |
| |
| /* |
| * Scans convInstrInfo[] and populates a |
| * sparsely populated index: sv_convIndexSparse. |
| * |
| * For a given op type: op_type, |
| * if (sv_convIndexSparse[op_type>] != -1) then |
| * it contains the offset into the first row of |
| * convInstrInfo[] |
| */ |
| void ex_conv_clause::populateInstrOffsetIndex() |
| { |
| if (sv_instrOffsetIndexPopulated) { |
| return; |
| } |
| |
| typedef struct convInstrIndexStruct { |
| short type_op1; |
| short offset; |
| } convInstrIndexDef; |
| |
| short lv_MaxIndex = -1; |
| |
| // Currently, the number of distinct 'type_op1' values in the convInstrInf[] is 32 |
| const int lv_MaxIndexCapacity = 100; |
| convInstrIndexDef lv_convIndex[lv_MaxIndexCapacity]; |
| |
| Int32 i = 0; |
| Int32 lv_source_type = -1; |
| Int32 lv_max_array_size = sizeof(ex_conv_clause::convInstrInfo) / sizeof(ex_conv_clause::ConvInstrStruct); |
| |
| // collect distinct type_op1 values and their 1st offset in convInstrInfo[] |
| while (i < lv_max_array_size) { |
| if (ex_conv_clause::convInstrInfo[i].type_op1 != lv_source_type) { |
| lv_source_type = ex_conv_clause::convInstrInfo[i].type_op1; |
| if ((lv_source_type > -1) && |
| (lv_MaxIndex < (lv_MaxIndexCapacity - 1))) { |
| lv_convIndex[++lv_MaxIndex].type_op1 = lv_source_type; |
| lv_convIndex[lv_MaxIndex].offset = i; |
| } |
| } |
| i++; |
| } |
| |
| // Find the max op type value in lv_convIndex |
| int j = 0; |
| while (j <= lv_MaxIndex) { |
| if (sv_MaxOpTypeValue < lv_convIndex[j].type_op1) { |
| sv_MaxOpTypeValue = lv_convIndex[j].type_op1; |
| } |
| j++; |
| } |
| |
| // just in case some op type has been assigned a pretty large value |
| // we dont want to allocate a very large sparse value |
| if (sv_MaxOpTypeValue > 8000) { |
| sv_MaxOpTypeValue = 8000; |
| } |
| |
| // Allocate a sparsely populated array |
| int *lv_convIndexSparse = (int *) calloc(sizeof(int), |
| (sv_MaxOpTypeValue+1)); |
| // Initialize to -1 |
| for (j = 0; j <= sv_MaxOpTypeValue; j++) { |
| lv_convIndexSparse[j] = -1; |
| } |
| |
| // Setup the sparsely populated array |
| j = 0; |
| while (j <= lv_MaxIndex) { |
| lv_convIndexSparse[lv_convIndex[j].type_op1] = lv_convIndex[j].offset; |
| j++; |
| } |
| |
| sv_convIndexSparse = lv_convIndexSparse; |
| sv_instrOffsetIndexPopulated = true; |
| } |
| |
| /* returns the offset into the convInstrInfo[] (the first row where the |
| * src data type equals the parameter pv_op1) |
| */ |
| int ex_conv_clause::getInstrOffset(short pv_op1) |
| { |
| if ((pv_op1 < 0) || |
| (pv_op1 > sv_MaxOpTypeValue)) { |
| return -1; |
| } |
| |
| return sv_convIndexSparse[pv_op1]; |
| } |
| |
| ConvInstruction ex_conv_clause::findInstruction(short sourceType, Lng32 sourceLen, |
| short targetType, Lng32 targetLen, |
| Lng32 scaleDifference) |
| { |
| ConvInstruction instruction = CONV_NOT_SUPPORTED; |
| setInstrArrayIndex(-1); |
| |
| getConvCaseDatatypes(sourceType, sourceLen, sourceType, |
| targetType, targetLen, targetType, scaleDifference); |
| |
| Int32 max_array_size = sizeof(convInstrInfo) / sizeof(ConvInstrStruct); |
| |
| Int32 i = 0; |
| i = getInstrOffset(sourceType); |
| if (i < 0) { |
| i = 0; |
| while ((i < max_array_size) && (convInstrInfo[i].type_op1 != sourceType)) { |
| i++; |
| } |
| } |
| |
| NABoolean done = FALSE; |
| while ((!done) && (i < max_array_size)) { |
| if (convInstrInfo[i].type_op1 != sourceType) |
| done = TRUE; |
| else if (convInstrInfo[i].type_op2 == targetType) { |
| done = TRUE; |
| instruction = convInstrInfo[i].instruction; |
| setInstrArrayIndex(i); |
| } |
| else |
| i++; |
| }; // while |
| |
| if (instruction == CONV_INTERVALS_INTERVALS_DIV) |
| { |
| |
| // have to look at scale difference to distinguish whether |
| // to divide or multiply by the scale factor |
| if (scaleDifference < 0) |
| { |
| instruction = CONV_INTERVALS_INTERVALS_MULT; |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| } |
| |
| // if this is a conversion from numeric to tinyint and not handled |
| // above, then add a generic conv to tinyint index. |
| // At runtime, actual conversion will be done based on source datatype. |
| // This is done to handle the case where target is a key column used |
| // in a predicate and conversion is being done to its datatype. |
| // In this case, we dont want to return a conversion error. |
| // See handling of dataConversionErrorFlag in exp_conv.cpp. |
| if (instruction == CONV_NOT_SUPPORTED) |
| { |
| if ((DFS2REC::isNumeric(sourceType)) && |
| (DFS2REC::isTinyint(targetType))) |
| { |
| if (targetType == REC_BIN8_SIGNED) |
| { |
| instruction = CONV_NUMERIC_BIN8S; |
| } |
| else |
| { |
| instruction = CONV_NUMERIC_BIN8U; |
| } |
| |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| } |
| |
| return (enum ConvInstruction)instruction; |
| |
| }; |
| |
| NABoolean ex_conv_clause::isConversionSupported |
| (short sourceType, Lng32 sourceLen, short targetType, Lng32 targetLen) |
| { |
| ConvInstruction ci = |
| findInstruction(sourceType, sourceLen, targetType, targetLen, 0); |
| if (ci == CONV_NOT_SUPPORTED) |
| return FALSE; |
| else |
| return TRUE; |
| } |
| |
| void ex_conv_clause::setInstruction() { |
| ConvInstruction instruction = CONV_NOT_SUPPORTED; |
| |
| // Test added to allow conditional union to be rowset-aware |
| if((getOperand(0)->getRowsetSize() > 0) && (getOperand(1)->getRowsetSize() > 0)) |
| { |
| instruction = CONV_ASCII_F_F; |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| |
| SimpleType *op0 = (SimpleType *) getOperand(0); |
| SimpleType *op1 = (SimpleType *) getOperand(1); |
| if (!(op0->getUseTotalRowsetSize())) { |
| op0->setLength(sizeof(Lng32) + (op0->getLength() * op0->getRowsetSize())); |
| op0->setUseTotalRowsetSize(); |
| op1->setUseTotalRowsetSize(); |
| } |
| op1->setLength(op0->getLength()); |
| } |
| else |
| instruction = findInstruction(getOperand(1)->getDatatype(), |
| getOperand(1)->getLength(), |
| getOperand(0)->getDatatype(), |
| getOperand(0)->getLength(), |
| getOperand(1)->getScale() - getOperand(0)->getScale()); |
| |
| if (instruction == CONV_NOT_SUPPORTED) |
| { |
| if ((getOperand(0)->isComplexType()) && !(getOperand(1)->isComplexType())) |
| { |
| instruction = CONV_SIMPLE_TO_COMPLEX; |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| else if (! (getOperand(0)->isComplexType()) && (getOperand(1)->isComplexType())) |
| { |
| instruction = CONV_COMPLEX_TO_SIMPLE; |
| setInstrArrayIndex(findIndexIntoInstrArray(instruction)); |
| } |
| } |
| |
| if ((instruction == CONV_NOT_SUPPORTED) && |
| (getInstrArrayIndex() >= 0)) |
| { |
| // this is an error, reset instr array index |
| setInstrArrayIndex(-1); |
| } |
| }; |
| |
| ex_expr::exp_return_type ex_conv_clause::fixup(Space * space, |
| CollHeap * exHeap, |
| char * constants_area, |
| char * temps_area, |
| char * persistentArea, |
| short fixupConstsAndTemps, |
| NABoolean spaceCompOnly) |
| { |
| setInstruction(); |
| return ex_clause::fixup(space, exHeap, constants_area, temps_area, |
| persistentArea, |
| fixupConstsAndTemps, spaceCompOnly); |
| } |
