| /********************************************************************** |
| // @@@ 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 <stdio.h> |
| #include <stdlib.h> |
| |
| #include "exp_stdh.h" |
| #include "exp_expr.h" |
| #include "ExpPCode.h" |
| #include "ExpPCodeOptimizations.h" |
| |
| void setVCLength(char * VCLen, Lng32 VCLenSize, ULng32 value); |
| |
| |
| // ----------------------------------------------------------------------- |
| // This method returns the virtual function table pointer for an object |
| // with the given class ID; used by NAVersionedObject::driveUnpack(). |
| // ----------------------------------------------------------------------- |
| char *ex_expr::findVTblPtr(short classID) |
| { |
| char *vtblPtr; |
| switch (classID) |
| { |
| case exp_INPUT_OUTPUT: |
| GetVTblPtr(vtblPtr, InputOutputExpr); |
| break; |
| case exp_AGGR: |
| GetVTblPtr(vtblPtr, AggrExpr); |
| break; |
| case exp_LEAN_EXPR: |
| GetVTblPtr(vtblPtr, ex_expr_lean); |
| break; |
| default: |
| GetVTblPtr(vtblPtr, ex_expr); |
| break; |
| } |
| return vtblPtr; |
| } |
| |
| Lng32 ex_expr::initExpr() |
| { |
| Lng32 rc = 0; |
| |
| ex_clause *currClause = clauses_; |
| |
| while( currClause != NULL ) |
| { |
| rc = currClause->initClause(); |
| if (rc) |
| return rc; |
| |
| currClause = currClause->getNextClause(); |
| } |
| |
| return rc; |
| } |
| |
| // lean expressions are not used not tested |
| void ex_expr_lean::displayContents(Space * space, short mode, |
| const char * displayStr, |
| ULng32 flag) |
| { |
| char buf[200]; |
| |
| str_sprintf(buf, "Expression: %s", displayStr); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| str_sprintf(buf, " Total Expr Len: %d, Consts Area Len: %d", getLength(), getConstsLength()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| str_sprintf(buf, " Temps Area Len: %d, Persistent Area Len: %d", getTempsLength(), persistentLength()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| str_sprintf(buf, " PCode Expr Length: %d\n", getPCodeSize()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| |
| if (flag & 0x00000002) |
| { |
| // Clear the fixup flag, since the expression has not been fixed up |
| // (pCodeGenerate undoes, the fixup of Const and Temp offsets.) |
| // |
| setFixupConstsAndTemps(0); |
| |
| if (getPCodeBinary()) |
| { |
| str_sprintf(buf, " PCode:\n"); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| // PCode::displayContents(getPCodeObject()->getPCIList(), space); |
| |
| PCodeBinary *pCode = getPCodeBinary(); |
| |
| // skip over the ATP's |
| Int32 length = *(pCode++); |
| pCode += (2 * length); |
| |
| while (pCode[0] != PCIT::END) |
| { |
| Int32 opcode = *(pCode++); |
| |
| str_sprintf(buf, " %s ", PCIT::instructionString(PCIT::Instruction(opcode))); |
| |
| Lng32 pcodeLength = PCode::getInstructionLength(pCode-1) - 1; |
| |
| char tbuf[256]; |
| char operandBuf[32]; |
| for (Int32 i=0; i<pcodeLength; i++) |
| { |
| PCIT::operandString(pCode[i], operandBuf); |
| str_sprintf(tbuf, "%s ", operandBuf); |
| str_cat(buf, tbuf, buf); |
| } |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| |
| pCode += pcodeLength; |
| } // while |
| |
| str_sprintf(buf, "\n"); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| } |
| } |
| } |
| // make a 'lean' copy of 'this' and point it back to itself. Supports all |
| // expressions. Do not copy clauses_ or pCodeObject_. Caller is responsible |
| // for proper deallocation of memory. |
| void ex_expr::makeLeanCopyAll(Space * space) |
| { |
| if (getPCodeSegment() != NULL) { |
| Int32 pCodeSize = getPCodeSize(); |
| NABoolean evalFlag = pCode_->containsClauseEval(); |
| PCodeBinary* pCode = getPCodeBinary(); |
| PCodeBinary* code; |
| |
| pCode_ = new(space) PCodeSegment(); |
| code = (PCodeBinary*) (new(space) char[pCodeSize]); |
| |
| str_cpy_all((char*)code, (char*)pCode, pCodeSize); |
| |
| pCode_.getPointer()->setPCodeSegmentSize(pCodeSize); |
| pCode_.getPointer()->setContainsClauseEval(evalFlag); |
| |
| setPCodeBinary(code); |
| } |
| |
| if (constantsArea_) { |
| char* area = space->allocateAlignedSpace(constantsAreaLength_); |
| str_cpy_all(area, constantsArea_, constantsAreaLength_); |
| setConstantsArea(area); |
| } |
| |
| if (tempsArea_) { |
| char* area = space->allocateAlignedSpace(tempsAreaLength_); |
| setTempsArea(area); |
| } |
| |
| if (persistentArea_) { |
| char* area = space->allocateAlignedSpace(persistentLength_); |
| persistentArea_ = area; |
| } |
| |
| if (persistentInitializationArea_) { |
| char* area = space->allocateAlignedSpace(persistentLength_); |
| str_cpy_all(area, persistentInitializationArea_, persistentLength_); |
| persistentInitializationArea_ = area; |
| } |
| } |
| |
| // make a 'lean' copy of 'this' to 'other'. |
| // Do not copy clauses_ or pCodeObject_. |
| void ex_expr::makeLeanCopy(ex_expr_lean * other, Space * space) |
| { |
| // *((ex_expr_base*)other) = *((ex_expr_base*)this); |
| |
| PCodeBinary * pCodeS = (PCodeBinary*) |
| space->allocateAlignedSpace(sizeof(PCodeBinary) + |
| pCode_->getPCodeSegmentSize()); |
| str_cpy_all((char*)&pCodeS[1], (char*)pCode_->getPCodeBinary(), |
| pCode_->getPCodeSegmentSize()); |
| pCodeS[0] = pCode_->getPCodeSegmentSize(); |
| other->setPCodeLean(pCodeS); |
| // other->setPCodeSize(pCode_->getPCodeSegmentSize()); |
| |
| other->constantsAreaLength_ = constantsAreaLength_; |
| other->tempsAreaLength_ = tempsAreaLength_; |
| other->persistentLength_ = persistentLength_; |
| |
| if (constantsArea_) |
| { |
| other->setConstantsArea(space->allocateAlignedSpace(constantsAreaLength_)); |
| str_cpy_all(other->getConstantsArea(), constantsArea_, |
| constantsAreaLength_); |
| } |
| |
| if (tempsArea_) |
| { |
| other->setTempsArea(space->allocateAlignedSpace(tempsAreaLength_)); |
| } |
| |
| if (persistentArea_) |
| { |
| other->persistentArea_ = space->allocateAlignedSpace(persistentLength_); |
| } |
| } |
| void ex_expr::displayContents(Space * space, short mode, const char * displayStr,ULng32 flag) |
| { |
| char buf[100] = {0}; // Soln 10-041117-1848 |
| |
| ULng32 exprLen = getLength(); |
| |
| str_sprintf(buf, "Expression: %s", displayStr); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| str_sprintf(buf, "Expr Len: %d, Consts Len: %d", exprLen, getConstsLength()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| str_sprintf(buf, "flags_ = %x ",flags_ ); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| |
| if (flag & 0x00000004) |
| { |
| Int32 i = 1; |
| ex_clause * clause = getClauses(); |
| while (clause) |
| { |
| clause->displayContents(space, 0, i, constantsArea_); |
| |
| clause = clause->getNextClause(); |
| i++; |
| } |
| } |
| |
| if (flag & 0x00000002) |
| { |
| if (getPCodeBinary()) |
| { |
| str_sprintf(buf, " PCode:\n"); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf),sizeof(short)); |
| str_sprintf(buf, "PCode Expr Length: %d", getPCodeSize()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf),sizeof(short)); |
| |
| PCodeCfg* cfg = new(heap_) PCodeCfg(this, heap_); |
| cfg->generateShowPlan(getPCodeBinary(), space); |
| NADELETE(cfg, PCodeCfg, heap_); |
| } |
| else if ((flag & 0x00000010) && |
| (getPCodeBinary())) |
| { |
| str_sprintf(buf, " PCode:\n"); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| str_sprintf(buf, "PCode Expr Length: %d", getPCodeSize()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| |
| PCode::displayContents(getPCodeBinary(), space); |
| } |
| else |
| { |
| // Clear the fixup flag, since the expression has not been fixed up |
| // (pCodeGenerate undoes, the fixup of Const and Temp offsets.) |
| // |
| setFixupConstsAndTemps(0); |
| |
| // re-generate pcode for showplan |
| setPCodeGenCompile(0); |
| setPCodeObject(0); |
| pCode_ = 0; |
| Space tempSpace; //create pcode stuff in a different space |
| //the space in PCode::displayContents is used for |
| //creating text for the showplan |
| UInt32 f = 0; |
| ex_expr_base::setForShowplan(f, TRUE); |
| pCodeGenerate(&tempSpace, &tempSpace, f); |
| |
| if(getPCodeObject()) |
| { |
| str_sprintf(buf, " PCode:\n"); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| str_sprintf(buf, "PCode Expr Length: %d", getPCodeSize()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sizeof(short)); |
| |
| PCode::displayContents(getPCodeObject()->getPCIList(), space); |
| } |
| } |
| } |
| } |
| |
| char *ex_expr::getPersistentData(Int32 offset) |
| { |
| return persistentArea_ + offset; |
| } |
| |
| // error denoted by negative return code |
| int ex_expr::formatARow2(const char** srcFldsPtr, |
| const int* srcFldsLength, |
| const int * srcFieldsConvIndex, |
| char* formattedRow, |
| int& formattedRowLength, |
| int numAttrs, |
| AttributesPtr * attrs, |
| ExpTupleDesc *tupleDesc, |
| UInt16 firstFixedOffset, |
| UInt16 bitmapEntryOffset, |
| UInt16 bitmapOffset, |
| NABoolean sysKeyTable, |
| CollHeap *heap, |
| ComDiagsArea **diags) |
| { |
| |
| formattedRowLength = tupleDesc->tupleDataLength(); //need to fix this later for other types |
| //char *sourceData = (char*)asciiRow; |
| //char *sourceDataEnd =(char*)asciiRow + rowLength; |
| //assert (sourceDataEnd); |
| |
| |
| //set the headers in tuple. |
| ExpTupleDesc::setFirstFixedOffset(formattedRow, |
| firstFixedOffset, |
| tupleDesc->getTupleDataFormat()); |
| |
| //Bitmap offset value is zero if bitmap is not preset. But bitmap offset |
| //still exists. |
| ExpAlignedFormat::setBitmapOffset(formattedRow + bitmapEntryOffset, |
| - bitmapOffset); |
| |
| |
| char *targetData = NULL; |
| |
| //for varchars |
| UInt32 vcActualLen = 0; |
| UInt32 voaOffset = 0; |
| UInt32 vOffset = 0; |
| Int32 vcLenIndOffset = 0; |
| bool firstvc = true; |
| char paddedTimestampVal[27] = "2000-01-01 00:00:00.000000" ; |
| |
| |
| int startCol = 0; |
| if (sysKeyTable) |
| { |
| startCol =1; |
| } |
| for(int index= startCol; index < numAttrs ; index++) |
| { |
| //Attributes * attr = myTdb().getOutputAttr(index); |
| Attributes * attr = attrs[index]; |
| //loop thru all the columns in the row. For each column, |
| //find its corresponding offset in ascii row. Corresponding |
| //offset is identified and converted. |
| |
| char * srcColData = (char*)srcFldsPtr[index - startCol]; |
| int srcColLen = srcFldsLength[index - startCol]; |
| |
| //set null bit map if column is nullable. |
| //if ( attr->getDefaultClass() == Attributes::DEFAULT_NULL ) |
| // ExpAlignedFormat::setNullValue( formattedRow, attr->getNullBitIndex() ); |
| |
| if (! srcColLen ) |
| { |
| ExpAlignedFormat::setNullValue( formattedRow, attr->getNullBitIndex() ); |
| continue; |
| } |
| |
| if((!firstvc) && attr->getVCIndicatorLength() > 0) |
| targetData = (char*) formattedRow + vOffset; |
| else |
| targetData = (char*) formattedRow + attr->getOffset(); |
| |
| if (attr->getDatatype() == REC_DATETIME && srcColLen == 10) |
| { |
| srcColData = &(paddedTimestampVal[0]); |
| srcColLen = 26; |
| } |
| |
| ex_expr::exp_return_type err = convDoIt(srcColData, |
| srcColLen, |
| REC_BYTE_F_ASCII, |
| 0,0, |
| targetData, |
| attr->getLength(), |
| attr->getDatatype(), |
| attr->getPrecision(), |
| attr->getScale(), |
| (char*)&vcActualLen, |
| sizeof(vcActualLen), |
| heap, |
| diags, |
| (ConvInstruction)srcFieldsConvIndex[index] |
| ); |
| |
| if(err == ex_expr::EXPR_ERROR) return -1; |
| |
| //update var fields parameters and adjust for subsequent var columns. |
| if(attr->getVCIndicatorLength() > 0) |
| { |
| if(firstvc) |
| { |
| voaOffset = attr->getVoaOffset(); |
| vOffset = attr->getOffset(); |
| vcLenIndOffset = attr->getVCLenIndOffset(); |
| } |
| //obtain actual len of varchar field and update VCIndicatorLength |
| setVCLength(formattedRow + vcLenIndOffset, |
| attr->getVCIndicatorLength(), vcActualLen); |
| |
| //update voa offset location with value of offset |
| ExpTupleDesc::setVoaValue(formattedRow, voaOffset, |
| vcLenIndOffset, tupleDesc->getTupleDataFormat()); |
| |
| //update all offset vars for next varchar column |
| ExpAlignedFormat::incrVoaOffset(voaOffset); |
| vcLenIndOffset += (vcActualLen + attr->getVCIndicatorLength()); |
| vOffset = vcLenIndOffset + attr->getVCIndicatorLength(); //vcIndLen remains same. |
| firstvc = false; |
| |
| //update formatted row length to reflect actual len |
| formattedRowLength = vcLenIndOffset; |
| } |
| |
| } |
| |
| //finally adjust the data length to alignment size. See header file for more info. |
| formattedRowLength = ExpAlignedFormat::adjustDataLength(formattedRow, |
| formattedRowLength, |
| ExpAlignedFormat::ALIGNMENT, |
| TRUE); |
| return 0; |
| }; |
| |
| void AggrExpr::displayContents(Space * space, short mode, const char * displayStr, |
| ULng32 flag) |
| { |
| char buf[100]; |
| |
| if (initExpr_) |
| { |
| str_sprintf(buf, "%s::initExpr_", displayStr); |
| |
| initExpr_->displayContents(space, mode, buf, flag); |
| } |
| |
| if (finalNullExpr_) |
| { |
| str_sprintf(buf, "%s::finalNullExpr_", displayStr); |
| |
| finalNullExpr_->displayContents(space, mode, buf, flag); |
| } |
| |
| if (finalExpr_) |
| { |
| str_sprintf(buf, "%s::finalExpr_", displayStr); |
| |
| finalExpr_->displayContents(space, mode, buf, flag); |
| } |
| |
| if (groupingExpr_) |
| { |
| str_sprintf(buf, "%s::groupingExpr_", displayStr); |
| |
| groupingExpr_->displayContents(space, mode, buf, flag); |
| } |
| |
| if (perrecExpr_) |
| { |
| str_sprintf(buf, "%s::perrecExpr_", displayStr); |
| |
| perrecExpr_->displayContents(space, mode, buf, flag); |
| } |
| |
| } |
| |
| |
