| /********************************************************************* |
| // @@@ 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: RoutineDesc.cpp |
| * Description: A routine descriptor |
| * Created: 6/29/09 |
| * Language: C++ |
| * |
| * |
| ************************************************************************** |
| */ |
| |
| #include "AllItemExpr.h" |
| #include "AllRelExpr.h" |
| #include "BindWA.h" |
| #include "ComOperators.h" |
| #include "RoutineDesc.h" |
| #include "ItemColRef.h" |
| #include "ParNameLocList.h" |
| #include "Sqlcomp.h" |
| #include "ex_error.h" |
| #include "Cost.h" |
| |
| // ----------------------------------------------------------------------- |
| // Constructors (but note that much more useful stuff goes on in |
| // static createRoutineDesc in BindRelExpr.C) |
| // ----------------------------------------------------------------------- |
| |
| |
| // ----------------------------------------------------------------------- |
| //! RoutineDesc::RoutineDesc Constructor |
| // Without any action parameters |
| // (but note that much more useful stuff goes on in |
| // populateRoutineDesc() and createRoutineParams() |
| // ----------------------------------------------------------------------- |
| RoutineDesc::RoutineDesc(BindWA *bindWA, NARoutine *routine) |
| : invocationNum_(bindWA->getRoutineInvocationNum()), |
| actionNameAsGiven_("", bindWA->wHeap()), |
| routine_(routine), |
| digits_(-1), |
| locale_(0), |
| colUDFInParamList_(0, bindWA->wHeap()), |
| colUDFOutputList_(0, bindWA->wHeap()), |
| isUUDF_(FALSE), |
| udfOutColStatDescList_ (bindWA->wHeap()), |
| actionOutColStatDescList_ (bindWA->wHeap()) |
| |
| { |
| action_=NULL; |
| processRoutineCosting(&udfInitialRowCost_, &udfNormalRowCost_, |
| &udfFanOut_, routine); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| //! RoutineDesc::RoutineDesc Constructor |
| // With action parameters |
| // ----------------------------------------------------------------------- |
| RoutineDesc::RoutineDesc(BindWA *bindWA, NARoutine *routine, NARoutine *action) |
| : invocationNum_(bindWA->getRoutineInvocationNum()), |
| actionNameAsGiven_("", bindWA->wHeap()), |
| routine_(routine), |
| action_(action), |
| digits_(-1), |
| locale_(0), |
| colUDFInParamList_(0, bindWA->wHeap()), |
| colUDFOutputList_(0, bindWA->wHeap()), |
| isUUDF_(action==NULL? FALSE : TRUE), |
| analysis_(NULL), |
| udfOutColStatDescList_ (bindWA->wHeap()), |
| actionOutColStatDescList_ (bindWA->wHeap()) |
| |
| { |
| processRoutineCosting(&udfInitialRowCost_, &udfNormalRowCost_, |
| &udfFanOut_, routine); |
| processRoutineCosting(&actionInitialRowCost_, &actionNormalRowCost_, |
| &actionFanOut_, action); |
| } |
| |
| // ----------------------------------------------------------------------- |
| //! RoutineDesc::RoutineDesc Constructor |
| // Without action parameters |
| // ----------------------------------------------------------------------- |
| RoutineDesc::RoutineDesc(CollHeap* h, NARoutine *routine) |
| : invocationNum_(0), |
| actionNameAsGiven_("", h), |
| routine_(routine), |
| digits_(-1), |
| locale_(0), |
| colUDFInParamList_(0, h), |
| colUDFOutputList_(0, h), |
| isUUDF_(FALSE), |
| udfOutColStatDescList_ (h), |
| actionOutColStatDescList_ (h) |
| { |
| action_=NULL; |
| processRoutineCosting(&udfInitialRowCost_, &udfNormalRowCost_, |
| &udfFanOut_, routine); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| //! RoutineDesc::RoutineDesc Constructor |
| // With action parameters |
| // ----------------------------------------------------------------------- |
| RoutineDesc::RoutineDesc(CollHeap* h, NARoutine *routine, NARoutine *action) |
| : invocationNum_(0), |
| actionNameAsGiven_("", h), |
| routine_(routine), |
| action_(action), |
| digits_(-1), |
| locale_(0), |
| colUDFInParamList_(0, h), |
| colUDFOutputList_(0, h), |
| isUUDF_(action==NULL? FALSE : TRUE), |
| analysis_(NULL), |
| colActionInParamList_(0, h), |
| colActionOutputList_(0, h), |
| udfOutColStatDescList_ (h), |
| actionOutColStatDescList_ (h) |
| {} |
| |
| // ----------------------------------------------------------------------- |
| //! RoutineDesc::RoutineDesc Copy Constructor |
| // ----------------------------------------------------------------------- |
| RoutineDesc::RoutineDesc(const RoutineDesc &rdesc, CollHeap *h) |
| : invocationNum_(rdesc.invocationNum_), |
| actionNameAsGiven_(rdesc.actionNameAsGiven_, h), |
| routine_(rdesc.routine_), // Pointer to cached object |
| analysis_(NULL), |
| action_(rdesc.action_), // Pointer to cached object |
| digits_(rdesc.digits_), |
| locale_(rdesc.locale_), |
| isUUDF_(rdesc.isUUDF_), |
| colUDFInParamList_(rdesc.colUDFInParamList_, h), |
| colUDFOutputList_(rdesc.colUDFOutputList_, h), |
| udfFanOut_(rdesc.udfFanOut_), |
| udfInitialRowCost_ (rdesc.udfInitialRowCost_), |
| udfNormalRowCost_ (rdesc.udfNormalRowCost_), |
| udfOutColStatDescList_ (rdesc.udfOutColStatDescList_,h), |
| colActionInParamList_(rdesc.colActionInParamList_, h), |
| colActionOutputList_(rdesc.colActionOutputList_, h), |
| actionFanOut_(rdesc.actionFanOut_), |
| actionInitialRowCost_ (rdesc.actionInitialRowCost_), |
| actionNormalRowCost_ (rdesc.actionNormalRowCost_), |
| actionOutColStatDescList_ (rdesc.actionOutColStatDescList_,h) |
| {} |
| |
| // ----------------------------------------------------------------------- |
| // ! Print function for RoutineDesc |
| // ----------------------------------------------------------------------- |
| void RoutineDesc::print(FILE* ofd, const char* indent, const char* title) |
| { |
| #ifndef NDEBUG |
| BUMP_INDENT(indent); |
| cout << title << " " << this << " NARoutine=" << (void*)routine_ |
| << " actionNARoutine=" << (void*)action_ << " invocation=" |
| << invocationNum_ << " isUUDF_ =" << isUUDF_ |
| << "actionNameAsGiven=" << actionNameAsGiven_ << endl; |
| ValueIdList emptySelectList; |
| colUDFInParamList_.print(ofd, indent, "RoutineDesc::colUDFInParamList_"); |
| colUDFOutputList_.print(ofd, indent, "RoutineDesc::colUDFOutputList_"); |
| colActionInParamList_.print(ofd, indent, "RoutineDesc::colActionaramList_"); |
| colActionOutputList_.print(ofd, indent, "RoutineDesc::colActionputList_"); |
| udfOutColStatDescList_.print(emptySelectList, ofd, indent, "RoutineDesc::udfOutColStatDescList_"); |
| actionOutColStatDescList_.print(emptySelectList, ofd, indent, "RoutineDesc::actionOutColStatDescList_"); |
| |
| #endif |
| } // RoutineDesc::print() |
| |
| |
| // ----------------------------------------------------------------------- |
| // ! getExternalName function for RoutineDesc |
| // ----------------------------------------------------------------------- |
| const ComString &RoutineDesc::getExternalName() const |
| { |
| if (isUUDF_) |
| { |
| return action_->getExternalName(); |
| } |
| else |
| { |
| return routine_->getExternalName(); |
| } |
| } // RoutineDesc::getExternalName() |
| |
| |
| // ----------------------------------------------------------------------- |
| // ! createRoutineParams function for RoutineDesc |
| // Instantiates Formal Routines parameters, binds them and adds them to |
| // the appropriate input/output list depending on the parameter type. |
| // ----------------------------------------------------------------------- |
| |
| NABoolean RoutineDesc::createRoutineParams(BindWA *bindWA, RDParamHandling pHandling) |
| { |
| |
| NARoutine *routine = NULL; |
| ValueIdList *inParamList = NULL; |
| ValueIdList *outputList = NULL; |
| |
| switch ( pHandling ) |
| { |
| case RD_UDFONLY: |
| routine = routine_; |
| inParamList = &colUDFInParamList_; |
| outputList = &colUDFOutputList_; |
| break; |
| case RD_ACTIONONLY: |
| routine = action_; |
| inParamList = &colActionInParamList_; |
| outputList = &colActionOutputList_; |
| break; |
| case RD_AUTOMATIC: |
| routine = isUUDF_ ? action_ : routine_; |
| inParamList = isUUDF_ ? &colActionInParamList_ : &colUDFInParamList_; |
| outputList = isUUDF_ ? &colActionOutputList_ : &colUDFOutputList_; |
| break; |
| } |
| |
| if (routine == NULL ) return FALSE; |
| |
| |
| // Depending on the state of the isUUDF flag, we will either |
| // access the UDF or the Action lists. |
| |
| |
| |
| for (CollIndex i = 0; i < (CollIndex ) routine->getParamCount(); i++) { |
| if (createRoutineParam(bindWA, i, routine, inParamList, outputList) == FALSE) |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // ! createRoutineParam function for RoutineDesc |
| // Instantiates a Formal Routines parameter, binds it and adds it to |
| // the appropriate input/output list depending on the parameter type. |
| // ----------------------------------------------------------------------- |
| |
| NABoolean RoutineDesc::createRoutineParam(BindWA *bindWA, CollIndex i, |
| NARoutine *routine, |
| ValueIdList *inParamList, |
| ValueIdList *outputList) |
| { |
| if (!routine || !inParamList || !outputList) return FALSE; |
| if (i < 0 || i >= (CollIndex) routine->getParamCount()) return FALSE; |
| |
| const NAColumnArray & params = routine->getParams(); |
| ColStatDescList &colStsDescList = getEffOutParamColStatDescList(); |
| |
| RoutineParam *routineParam = new (bindWA->wHeap()) RoutineParam(params[i], |
| i, |
| this); |
| |
| if ( routineParam == NULL ) return FALSE; |
| |
| |
| if ((params[i]->getColName() == "INVAL" ) || |
| (params[i]->getColName() == "" )) |
| { |
| |
| NAString tmpStr(CmpCommon::statementHeap()); |
| char num[50]; |
| |
| tmpStr += routine->getExternalName(); |
| if (routineParam->getParamMode() == COM_OUTPUT_COLUMN) |
| tmpStr += "_OUTPUT_"; |
| else |
| tmpStr += "_INPUT_"; |
| sprintf(num, "%d", i); |
| tmpStr += num; |
| routineParam->setName(tmpStr); |
| } |
| |
| routineParam->bindNode(bindWA); |
| |
| if (bindWA->errStatus()) return FALSE; |
| |
| const char *colName = routineParam->getName(); |
| const Int32 nameLen = routineParam->getName().length(); |
| |
| UInt32 numUecs = routine->getUecValues().entries(); |
| HistogramSharedPtr emptyHist(new (HISTHEAP) Histogram(HISTHEAP)); |
| |
| // Set up the costing for the output column |
| CostScalar fanOut(routine->getUdfFanOut()); |
| |
| if (routineParam->getParamMode() == COM_OUTPUT_COLUMN) |
| { |
| outputList->insert(routineParam->getValueId()); |
| |
| // For now we only setup costing information for UDFs |
| |
| if (numUecs != 0 && (i <= numUecs)) |
| { |
| ComUID id(ColStats::nextFakeHistogramID()); |
| |
| ColStatsSharedPtr outputStats( |
| new (HISTHEAP) ColStats(id, |
| routine->getUecValues()[i], |
| fanOut, |
| fanOut, |
| FALSE, |
| FALSE, |
| emptyHist, |
| FALSE, |
| 1.0, |
| 1.0, |
| 0, |
| HISTHEAP, |
| TRUE// allowMinusOne |
| )); |
| |
| // Setting this flag will ensure that the compiler does not start |
| // to look for this column name in the NAColumn. As there does not |
| // exist a column for a constant |
| outputStats->setVirtualColForHist(TRUE); |
| outputStats->setIsCompressed(TRUE); |
| |
| ColStatDescSharedPtr tmpColStatDescPtr(new (HISTHEAP) |
| ColStatDesc(outputStats, |
| routineParam->getValueId(), |
| HISTHEAP), HISTHEAP); |
| |
| colStsDescList.insert(tmpColStatDescPtr); |
| } |
| } |
| else |
| { |
| inParamList->insert(routineParam->getValueId()); |
| } |
| return TRUE; |
| } // RoutineDesc::createRoutineParam() |
| |
| |
| // ----------------------------------------------------------------------- |
| // ! populateRoutineDesc() function for RoutineDesc |
| // Instantiates a Formal Routines parameter, binds it and adds it to |
| // the appropriate input/output list depending on the parameter type. |
| // ----------------------------------------------------------------------- |
| NABoolean RoutineDesc::populateRoutineDesc(BindWA *bindWA, |
| NABoolean createRETDesc) |
| { |
| |
| |
| // The input and output parameters will be mapped in from naRoutine or |
| // actionNaRoutine. The RoutineDesc holds an instance for each. |
| // This means that if we have an Action, its inputs and outputs will |
| // overlay those of the UDF itself. |
| |
| // Instantiate the Formal parameters for the UDF |
| // For each NAColumn, allocate a RoutineParam, bind the RoutineParam, |
| // and add the ValueId to the RoutineDesc. |
| |
| if ( createRoutineParams(bindWA, RD_UDFONLY ) == FALSE) |
| { |
| bindWA->setErrStatus(); |
| return FALSE; |
| } |
| |
| // Instantiate the Formal parameters for the Action |
| if (isUUDF_ == TRUE) |
| { |
| if ( createRoutineParams(bindWA, RD_ACTIONONLY) == FALSE) |
| { |
| bindWA->setErrStatus(); |
| return FALSE; |
| } |
| } |
| |
| |
| // Allocate a RETDesc, attach it to the BindScope. This should |
| // only be done for RelExprs.. |
| if (createRETDesc == TRUE) |
| { |
| bindWA->getCurrentScope()->setRETDesc(new (bindWA->wHeap()) |
| RETDesc(bindWA, this)); |
| |
| } |
| |
| |
| return TRUE; |
| |
| } // RoutineDesc::populateRoutineDesc() |
| |
| |
| // ----------------------------------------------------------------------- |
| // ! processRoutineCosting() function for RoutineDesc |
| // Process the costVectors of the UDF, or Action. The cost data is |
| // copied over from the NARoutine and we apply DEFAULTs to them if they |
| // are out of range. |
| // ----------------------------------------------------------------------- |
| void RoutineDesc::processRoutineCosting(SimpleCostVector *initial, |
| SimpleCostVector *normal, |
| Int32 *fanOut, |
| NARoutine *routine) |
| { |
| |
| if (routine == NULL ) return; |
| |
| // Initialize the cost vectors |
| *initial = routine->getInitialRowCostVector(); |
| *normal = routine->getNormalRowCostVector(); |
| *fanOut = routine->getUdfFanOut(); |
| |
| // Check to see if we need to use costs from CQDs |
| |
| if (initial->getCPUTime() == csMinusOne ) |
| { |
| CostScalar initCpuCost((double) (ActiveSchemaDB()->getDefaults()). |
| getAsULong(INITIAL_UDF_CPU_COST) |
| ); |
| initial->setCPUTime(initCpuCost); |
| } |
| |
| if (initial->getIOTime() == csMinusOne) |
| { |
| CostScalar initIOCost((double) (ActiveSchemaDB()->getDefaults()). |
| getAsULong(INITIAL_UDF_IO_COST) |
| ); |
| initial->setIOTime(initIOCost); |
| } |
| |
| if (initial->getMessageTime() == csMinusOne) |
| { |
| CostScalar initMsgCost((double) (ActiveSchemaDB()->getDefaults()). |
| getAsULong(INITIAL_UDF_MSG_COST) |
| ); |
| initial->setMSGTime(initMsgCost); |
| } |
| |
| |
| if (normal->getCPUTime() == csMinusOne ) |
| { |
| CostScalar initCpuCost((double) (ActiveSchemaDB()->getDefaults()). |
| getAsULong(NORMAL_UDF_CPU_COST) |
| ); |
| normal->setCPUTime(initCpuCost); |
| } |
| |
| if (normal->getIOTime() == csMinusOne) |
| { |
| CostScalar initIOCost((double) (ActiveSchemaDB()->getDefaults()). |
| getAsULong(NORMAL_UDF_IO_COST) |
| ); |
| normal->setIOTime(initIOCost); |
| } |
| |
| if (normal->getMessageTime() == csMinusOne) |
| { |
| CostScalar initMsgCost((double) (ActiveSchemaDB()->getDefaults()). |
| getAsULong(NORMAL_UDF_MSG_COST) |
| ); |
| normal->setMSGTime(initMsgCost); |
| } |
| |
| if ( *fanOut == -1) |
| { |
| *fanOut = (ActiveSchemaDB()->getDefaults()).getAsULong(UDF_FANOUT); |
| } |
| } // RoutineDesc::processRoutineCosting() |
