| /********************************************************************** |
| // @@@ 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: ComTdbUdr.cpp |
| * Description: |
| * |
| * Created: 2/8/2000 |
| * Language: C++ |
| * |
| * |
| * |
| **************************************************************************** |
| */ |
| |
| #include "ComTdbUdr.h" |
| |
| // --------------------------------------------------------------------- |
| // ComTdbUdr::ComTdbUdr() |
| // --------------------------------------------------------------------- |
| ComTdbUdr::ComTdbUdr(char *sqlName, |
| char *routineName, |
| char *routineSignature, |
| char *containerName, |
| char *externalPath, |
| char *librarySqlName, |
| |
| char *runtimeOptions, |
| char *runtimeOptionDelimiters, |
| |
| ULng32 flags, |
| ULng32 numInputValues, |
| ULng32 numOutputValues, |
| ULng32 numParams, |
| ULng32 maxResultSets, |
| ULng32 stateAreaSize, |
| short udrType, |
| short languageType, |
| short paramStyle, |
| short sqlAccessMode, |
| short transactionAttrs, |
| UInt16 externalSecurity, |
| Int32 routineOwnerId, |
| Cardinality estimatedRowCount, |
| ex_cri_desc *criDescParent, |
| ex_cri_desc *criDescReturned, |
| ex_cri_desc *workCriDesc, |
| queue_index downQueueMaxSize, |
| queue_index upQueueMaxSize, |
| |
| Lng32 numOutputBuffers, |
| ULng32 outputBufferSize, |
| ULng32 requestBufferSize, |
| ULng32 replyBufferSize, |
| |
| ex_expr *inputExpr, |
| ex_expr *outputExpr, |
| ex_expr *scanExpr, |
| ex_expr *projExpr, |
| |
| unsigned short requestTuppIndex, |
| unsigned short replyTuppIndex, |
| ULng32 requestRowLen, |
| ULng32 replyRowLen, |
| ULng32 outputRowLen, |
| |
| ULng32 numChildInputs, |
| ex_expr ** childInputExprs, |
| ComTdb ** childTdbs, |
| |
| Queue *optionalData, |
| |
| Int32 udrSerInvocationInfoLen, |
| char *udrSerInvocationInfo, |
| Int32 udrSerPlanInfoLen, |
| char *udrSerPlanInfo, |
| |
| Int32 javaDebugPort, |
| Int32 javaDebugTimeout, |
| |
| Space *space |
| ) |
| : ComTdb(ex_UDR, eye_UDR, estimatedRowCount, criDescParent, |
| criDescReturned, downQueueMaxSize, upQueueMaxSize, |
| numOutputBuffers, outputBufferSize), |
| |
| sqlName_(sqlName), |
| routineName_(routineName), |
| routineSignature_(routineSignature), |
| containerName_(containerName), |
| externalPath_(externalPath), |
| librarySqlName_(librarySqlName), |
| |
| runtimeOptions_(runtimeOptions), |
| runtimeOptionDelimiters_(runtimeOptionDelimiters), |
| |
| flags_(flags), |
| numInputValues_(numInputValues), |
| numOutputValues_(numOutputValues), |
| numParams_(numParams), |
| maxResultSets_(maxResultSets), |
| stateAreaSize_(stateAreaSize), |
| udrType_(udrType), |
| languageType_(languageType), |
| paramStyle_(paramStyle), |
| sqlAccessMode_(sqlAccessMode), |
| transactionAttrs_(transactionAttrs), |
| externalSecurity_(externalSecurity), |
| routineOwnerId_(routineOwnerId), |
| requestSqlBufferSize_(requestBufferSize), |
| replySqlBufferSize_(replyBufferSize), |
| |
| workCriDesc_(workCriDesc), |
| inputExpr_(inputExpr), |
| outputExpr_(outputExpr), |
| scanExpr_(scanExpr), |
| projExpr_(projExpr), |
| requestTuppIndex_(requestTuppIndex), |
| replyTuppIndex_(replyTuppIndex), |
| requestRowLen_(requestRowLen), |
| replyRowLen_(replyRowLen), |
| outputRowLen_(outputRowLen), |
| optionalData_(optionalData), |
| udrSerInvocationInfoLen_(udrSerInvocationInfoLen), |
| udrSerInvocationInfo_(udrSerInvocationInfo), |
| udrSerPlanInfoLen_(udrSerPlanInfoLen), |
| udrSerPlanInfo_(udrSerPlanInfo), |
| javaDebugPort_(javaDebugPort), |
| javaDebugTimeout_(javaDebugTimeout), |
| |
| numChildTableInputs_((Int16) numChildInputs), |
| childInputExprs_(space,(void **)childInputExprs,numChildInputs), |
| childTdbs_(space,(void **)childTdbs,numChildInputs) |
| { |
| // |
| // Allocate an array of pointers to the param info objects |
| // |
| paramInfo_ = (UdrFormalParamInfoPtr *) |
| (space->allocateAlignedSpace(numParams_ * sizeof(UdrFormalParamInfoPtr))); |
| for (UInt32 i = 0; i < numParams_; i++) |
| { |
| paramInfo_[i] = (UdrFormalParamInfoPtrPtr)NULL; |
| } |
| |
| // |
| // Allocate an array of pointers to the Child Table info objects |
| // |
| udrChildTableDescInfo_ = (UdrTableDescInfoPtr *) |
| (space->allocateAlignedSpace(numChildInputs * sizeof(UdrTableDescInfoPtr))); |
| for (UInt32 i = 0; i < numChildInputs; i++) |
| { |
| udrChildTableDescInfo_[i] = (UdrFormalParamInfoPtrPtr)NULL; |
| } |
| } |
| |
| ComTdbUdr::~ComTdbUdr() |
| { |
| } |
| |
| Long ComTdbUdr::pack(void *space) |
| { |
| sqlName_.pack(space); |
| routineName_.pack(space); |
| routineSignature_.pack(space); |
| containerName_.pack(space); |
| externalPath_.pack(space); |
| librarySqlName_.pack(space); |
| runtimeOptions_.pack(space); |
| runtimeOptionDelimiters_.pack(space); |
| workCriDesc_.pack(space); |
| inputExpr_.pack(space); |
| outputExpr_.pack(space); |
| scanExpr_.pack(space); |
| projExpr_.pack(space); |
| |
| // |
| // The NAVersionedObject array templates use long values to index |
| // into the array, so we cast numParams_ to long here. This is assumed |
| // not to be a problem because other parts of the system do not store |
| // param count as unsigned long. E.g. the PARAMS table stores column |
| // number as INT. |
| // |
| paramInfo_.pack(space, (Lng32) numParams_); |
| |
| optionalData_.pack(space); |
| udrSerInvocationInfo_.pack(space); |
| udrSerPlanInfo_.pack(space); |
| udrChildTableDescInfo_.pack(space,(Lng32)numChildTableInputs_); |
| childInputExprs_.pack(space,(Lng32)numChildTableInputs_); |
| childTdbs_.pack(space,(Lng32)numChildTableInputs_); |
| |
| return ComTdb::pack(space); |
| } |
| |
| Lng32 ComTdbUdr::unpack(void *base, void *reallocator) |
| { |
| if (sqlName_.unpack(base)) return -1; |
| if (routineName_.unpack(base)) return -1; |
| if (routineSignature_.unpack(base)) return -1; |
| if (containerName_.unpack(base)) return -1; |
| if (externalPath_.unpack(base)) return -1; |
| if (librarySqlName_.unpack(base)) return -1; |
| if (runtimeOptions_.unpack(base)) return -1; |
| if (runtimeOptionDelimiters_.unpack(base)) return -1; |
| if (workCriDesc_.unpack(base, reallocator)) return -1; |
| if (inputExpr_.unpack(base, reallocator)) return -1; |
| if (outputExpr_.unpack(base, reallocator)) return -1; |
| if (scanExpr_.unpack(base, reallocator)) return -1; |
| if (projExpr_.unpack(base, reallocator)) return -1; |
| |
| // |
| // The NAVersionedObject array templates use long values to index |
| // into the array, so we cast numParams_ to long here. This is assumed |
| // not to be a problem because other parts of the system do not store |
| // param count as unsigned long. E.g. the PARAMS table stores column |
| // number as INT. |
| // |
| if (paramInfo_.unpack(base, (Lng32) numParams_, reallocator)) |
| return -1; |
| |
| if (optionalData_.unpack(base, reallocator)) |
| return -1; |
| if (udrChildTableDescInfo_.unpack(base,(Lng32)numChildTableInputs_,reallocator)) |
| return -1; |
| if (childInputExprs_.unpack(base,(Lng32)numChildTableInputs_,reallocator)) |
| return -1; |
| if (childTdbs_.unpack(base,(Lng32)numChildTableInputs_,reallocator)) |
| return -1; |
| if (udrSerInvocationInfo_.unpack(base)) |
| return -1; |
| if (udrSerPlanInfo_.unpack(base)) |
| return -1; |
| |
| return ComTdb::unpack(base, reallocator); |
| } |
| |
| void ComTdbUdr::displayContents(Space *space, ULng32 flag) |
| { |
| ComTdb::displayContents(space, flag & 0xFFFFFFFE); |
| |
| if (flag & 0x00000008) |
| { |
| const size_t sz = sizeof(short); |
| char buf[512]; |
| |
| str_sprintf(buf, "\nFor ComTdbUdr :"); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| Lng32 lowFlags = (Lng32) (flags_ % 65536); |
| Lng32 highFlags = (Lng32) ((flags_ - lowFlags) / 65536); |
| str_sprintf(buf, "flags = %x%x", highFlags, lowFlags); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| if (sqlName_) |
| { |
| char *s = sqlName_; |
| str_sprintf(buf, "routineName = %s", s); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| } |
| |
| if (routineName_) |
| { |
| char *s = routineName_; |
| str_sprintf(buf, "externalName = %s", s); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| } |
| |
| if (containerName_) |
| { |
| char *s = containerName_; |
| str_sprintf(buf, "externalFile = %s", s); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| } |
| |
| if (externalPath_) |
| { |
| char *s = externalPath_; |
| str_sprintf(buf, "externalPath = %s", s); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| } |
| |
| if (librarySqlName_) |
| { |
| char *s = librarySqlName_; |
| str_sprintf(buf, "librarySqlName = %s", s); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| } |
| |
| // Some strings come from the user and there is no limit on the |
| // maximum length. For these strings we will print two lines, the |
| // first a header line and the second the actual string. For |
| // example, the Java signature will look like this in the SHOWPLAN |
| // output: |
| // |
| // signature = |
| // (Ljava/lang/Float;[Ljava/lang/Float;)V |
| // |
| const char *s1; |
| const char *s2; |
| |
| if (routineSignature_) |
| { |
| s1 = "\nsignature = "; |
| s2 = routineSignature_; |
| space->allocateAndCopyToAlignedSpace(s1, str_len(s1), sz); |
| space->allocateAndCopyToAlignedSpace(s2, str_len(s2), sz); |
| } |
| |
| if (runtimeOptions_) |
| { |
| s1 = "\nruntimeOptions = "; |
| s2 = runtimeOptions_; |
| space->allocateAndCopyToAlignedSpace(s1, str_len(s1), sz); |
| space->allocateAndCopyToAlignedSpace(s2, str_len(s2), sz); |
| } |
| |
| if (runtimeOptionDelimiters_) |
| { |
| s1 = "\noptionDelimiters = "; |
| s2 = runtimeOptionDelimiters_; |
| space->allocateAndCopyToAlignedSpace(s1, str_len(s1), sz); |
| space->allocateAndCopyToAlignedSpace(s2, str_len(s2), sz); |
| } |
| |
| str_sprintf(buf, "\nnumParameters = %d, maxResultSets = %d", |
| numParams_, maxResultSets_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "numInputValues = %d, numOutputValues = %d", |
| numInputValues_, numOutputValues_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "requestBufferSize = %d, replyBufferSize = %d", |
| requestSqlBufferSize_, replySqlBufferSize_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "requestRowLength = %d, replyRowLength = %d", |
| requestRowLen_, replyRowLen_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "outputRowLen = %d, stateAreaSize = %d", |
| outputRowLen_, stateAreaSize_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "requestTuppIndex = %d, replyTuppIndex = %d", |
| (Int32) requestTuppIndex_, (Int32) replyTuppIndex_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "udrType = %d, languageType = %d", |
| (Int32) udrType_, (Int32) languageType_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "parameterStyle = %d, sqlAccessMode = %d", |
| (Int32) paramStyle_, (Int32) sqlAccessMode_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "transactionAttributes = %d", (Int32) transactionAttrs_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, "externalSecurity = %d, routineOwnerId = %d", |
| (Int32) externalSecurity_, (Int32) routineOwnerId_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| UInt32 i; |
| for (i = 0; i < numParams_; i++) |
| { |
| const UdrFormalParamInfo *p = paramInfo_[i]; |
| |
| str_sprintf(buf, "\nParameter %d", (Int32) i); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, " name [%s]", p->getParamName()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, " flags %x, type %d", p->getFlags(), |
| (Int32) p->getType()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| str_sprintf(buf, " precision %d, scale %d, charset %d, collation %d", |
| (Int32) p->getPrecision(), (Int32) p->getScale(), |
| (Int32) p->getEncodingCharSet(), (Int32) p->getCollation()); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| } |
| |
| Queue *optData = getOptionalData(); |
| if (optData) |
| { |
| UInt32 dataElems = optData->numEntries(); |
| str_sprintf(buf, "\nNumber of optional data elements: %d", |
| (Int32) dataElems); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| const char *s = NULL; |
| i = 0; |
| |
| optData->position(); |
| while ((s = (const char *) optData->getNext()) != NULL) |
| { |
| // Each data element is prefixed by a 4-byte length field |
| UInt32 len = 0; |
| str_cpy_all((char *)&len, s, 4); |
| |
| str_sprintf(buf, "\nOptional data %d (length %d):", |
| (Int32) i++, (Int32) len); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| |
| if (len > 0) |
| { |
| // Create a buffer containing at most 200 bytes of data |
| if (len > 200) |
| len = 200; |
| char truncatedBuf[201]; |
| str_cpy_all(truncatedBuf, s + 4, len); |
| truncatedBuf[len] = 0; |
| |
| // Change NULL bytes and non-ASCII characters to '.' for |
| // display purposes |
| for (UInt32 j = 0; j < len; j++) |
| { |
| if (truncatedBuf[j] == 0 || !isascii(truncatedBuf[j])) |
| truncatedBuf[j] = '.'; |
| } |
| |
| space->allocateAndCopyToAlignedSpace(truncatedBuf, len, sz); |
| } |
| } |
| } |
| if (javaDebugPort_ > 0) |
| { |
| str_sprintf(buf, "\njavaDebugPort = %d, javaDebugTimeout = %d", |
| javaDebugPort_, javaDebugTimeout_); |
| space->allocateAndCopyToAlignedSpace(buf, str_len(buf), sz); |
| } |
| |
| } // if (flag & 0x00000008) |
| |
| if (flag & 0x00000001) |
| { |
| displayExpression(space,flag); |
| displayChildren(space,flag); |
| } |
| } |
| |
| |
| |
