| /********************************************************************** |
| // @@@ 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: CmpMessage.cpp |
| * Description: |
| * |
| * Created: 5/6/98 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| **************************************************************************** |
| */ |
| |
| // ----------------------------------------------------------------------- |
| |
| #include "Platform.h" |
| |
| |
| |
| #include "CmpMessage.h" |
| #include "NAExecTrans.h" |
| #include "time.h" |
| #include "charinfo.h" |
| #include "FragmentDir.h" |
| #include "ComSysUtils.h" |
| |
| // ----------------------------------------------------------------------- |
| // methods for CmpMessageObj |
| // ----------------------------------------------------------------------- |
| |
| // ----------------------------------------------------------------------- |
| // helper routines for CmpMessageObj class |
| // ----------------------------------------------------------------------- |
| |
| IpcMessageObjSize CmpMessageObj::packIntoBuffer(IpcMessageBufferPtr& buffer, |
| char* strPtr) |
| { |
| CmpMsgBufLenType length; |
| if (strPtr==NULL) |
| length=0; |
| else |
| length=str_len(strPtr)+1; // 1 is for the null-terminator char |
| |
| // NOT a recursive call. |
| IpcMessageObjSize result = ::packIntoBuffer(buffer,length); |
| |
| if (strPtr!=NULL) |
| str_cpy_all((char*)buffer,strPtr,length); |
| buffer += length; |
| return result+length; |
| } |
| |
| IpcMessageObjSize CmpMessageObj::packIntoBuffer(IpcMessageBufferPtr& buffer, |
| void* strPtr, Lng32 sz) |
| { |
| |
| // NOT a recursive call. |
| IpcMessageObjSize result = ::packIntoBuffer(buffer,sz); |
| |
| if (strPtr!=NULL) |
| str_cpy_all((char*)buffer,(char*)strPtr,sz); |
| buffer += sz; |
| return result+sz; |
| } |
| |
| void CmpMessageObj::unpackBuffer(IpcConstMessageBufferPtr& buffer, |
| char* &strPtr, |
| CollHeap* h) |
| { |
| NADELETEBASIC(strPtr,h); |
| |
| CmpMsgBufLenType length; |
| // NOT a recursive call. |
| ::unpackBuffer(buffer,length); |
| if (length==0) |
| strPtr = NULL; |
| else { |
| strPtr = new(h) char[length]; |
| assert(strPtr!=NULL); |
| str_cpy_all((char*)strPtr,(char*) buffer,length); |
| buffer += length; |
| } |
| } |
| |
| void CmpMessageObj::unpackBuffer(IpcConstMessageBufferPtr& buffer, |
| char* strPtr, ULng32 maxSize, |
| ULng32& sizeMoved) |
| { |
| CmpMsgBufLenType length; |
| // NOT a recursive call. |
| ::unpackBuffer(buffer,length); |
| assert(length <= maxSize); |
| if ( length > 0 ) |
| { |
| str_cpy_all((char*)strPtr,(char*) buffer,length); |
| buffer += length; |
| } |
| sizeMoved = length; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // constructors |
| // ----------------------------------------------------------------------- |
| |
| CmpMessageObj::CmpMessageObj(IpcMessageObjType t, CollHeap* h) : |
| IpcMessageObj(t,EXECMPIPCVERSION) |
| { |
| h_ = h; |
| |
| NA_timeval tp; |
| NA_gettimeofday(&tp, 0); |
| |
| id_ = tp.tv_sec * 1000000 + tp.tv_usec; |
| |
| } |
| |
| IpcMessageRefCount CmpMessageObj::decrRefCount() |
| { |
| if (getRefCount()==1) |
| { |
| if (h_) |
| { |
| destroyMe(); |
| h_->deallocateMemory(this); |
| } |
| else |
| delete this; |
| return 0; |
| } |
| |
| return IpcMessageObj::decrRefCount(); |
| } |
| |
| IpcMessageObjSize CmpMessageObj::mypackedLength(void) |
| { |
| IpcMessageObjSize size = baseClassPackedLength(); |
| size += sizeof(id_); |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageObj::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size = packBaseClassIntoMessage(buffer); |
| size += packIntoBuffer(buffer,(ID)id_); |
| return size; |
| } |
| |
| void CmpMessageObj::unpackMyself(IpcMessageObjType, |
| IpcMessageObjVersion, |
| NABoolean, |
| IpcMessageObjSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| unpackBaseClass(buffer); |
| |
| unpackBuffer(buffer, id_); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for CmpMessageRequestBasic |
| // ----------------------------------------------------------------------- |
| |
| CmpMessageRequestBasic::CmpMessageRequestBasic(MessageTypeEnum t, |
| CollHeap* h) : |
| CmpMessageObj(t,h) |
| { |
| } |
| |
| CmpMessageRequestBasic::~CmpMessageRequestBasic() |
| { |
| } |
| |
| IpcMessageObjSize CmpMessageRequestBasic::mypackedLength(void) |
| { |
| IpcMessageObjSize size = CmpMessageObj::mypackedLength(); |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageRequestBasic::packMyself |
| (IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size = CmpMessageObj::packMyself(buffer); |
| return size; |
| } |
| |
| void CmpMessageRequestBasic::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageObj::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for CmpMessageReplyBasic |
| // ----------------------------------------------------------------------- |
| CmpMessageReplyBasic::CmpMessageReplyBasic(MessageTypeEnum t, ID id, |
| CollHeap* h) : |
| CmpMessageObj(t,h), |
| request_(id) |
| { |
| } |
| |
| IpcMessageObjSize CmpMessageReplyBasic::mypackedLength(void) |
| { |
| IpcMessageObjSize size = CmpMessageObj::mypackedLength(); |
| size += sizeof(request_); |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageReplyBasic::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size = CmpMessageObj::packMyself(buffer); |
| size += packIntoBuffer(buffer,request_); |
| return size; |
| } |
| |
| void CmpMessageReplyBasic::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageObj::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| unpackBuffer(buffer, request_); |
| } |
| |
| CmpCompileInfo::CmpCompileInfo(char * sourceStr, Lng32 sourceStrLen, |
| Lng32 sourceStrCharSet, |
| char * schemaName, Lng32 schemaNameLen, |
| ULng32 inputArrayMaxsize, short atomicity) |
| : flags_(0), |
| sqltext_(sourceStr), sqlTextLen_(sourceStrLen), |
| sqlTextCharSet_(sourceStrCharSet), |
| schemaName_(schemaName), schemaNameLen_(schemaNameLen), |
| inputArrayMaxsize_(inputArrayMaxsize), |
| unused2_(0) |
| { |
| if (atomicity == 1) { |
| flags_ |= ROWSET_ATOMICITY_SPECIFIED; |
| flags_ &= ~ROWSET_NOT_ATOMIC; |
| } |
| else if (atomicity == 2) { |
| flags_ |= ROWSET_ATOMICITY_SPECIFIED; |
| flags_ |= ROWSET_NOT_ATOMIC; |
| } |
| else |
| flags_ &= ~ROWSET_ATOMICITY_SPECIFIED; |
| str_pad(fillerBytes_, FILLERSIZE, '\0'); |
| } |
| |
| CmpCompileInfo::CmpCompileInfo() |
| : flags_(0), |
| sqltext_(NULL), |
| sqlTextLen_(0), |
| sqlTextCharSet_(0), |
| schemaName_(NULL), |
| schemaNameLen_(0), |
| inputArrayMaxsize_(0) |
| { |
| str_pad(fillerBytes_, FILLERSIZE, '\0'); |
| } |
| |
| void CmpCompileInfo::init() |
| { |
| flags_ = 0; |
| sqltext_ = NULL; |
| sqlTextLen_ = 0; |
| sqlTextCharSet_ = 0; |
| schemaName_ = NULL; |
| schemaNameLen_ = 0; |
| inputArrayMaxsize_ = 0; |
| } |
| |
| Lng32 CmpCompileInfo::getLength() |
| { |
| Lng32 sizeOfThis = getClassSize(); |
| Lng32 totalLength = ROUND8(sizeOfThis) + getVarLength(); |
| return totalLength; |
| } |
| |
| Lng32 CmpCompileInfo::getVarLength() |
| { |
| return ROUND8(sqlTextLen_) + |
| ROUND8(schemaNameLen_); |
| } |
| |
| void CmpCompileInfo::packVars(char * buffer, CmpCompileInfo *ci, |
| Lng32 &nextOffset) |
| { |
| if (sqltext_ && (sqlTextLen_ > 0)) |
| { |
| str_cpy_all(&buffer[nextOffset], sqltext_, sqlTextLen_); |
| ci->sqltext_ = (char *)((long)nextOffset); |
| nextOffset += ROUND8(sqlTextLen_); |
| } |
| |
| if (schemaName_ && (schemaNameLen_ > 0)) |
| { |
| str_cpy_all(&buffer[nextOffset], (char *)schemaName_, schemaNameLen_); |
| ci->schemaName_ = (char *)((long)nextOffset); |
| nextOffset += ROUND8(schemaNameLen_); |
| } |
| } |
| |
| void CmpCompileInfo::pack(char * buffer) |
| { |
| CmpCompileInfo * ci = (CmpCompileInfo *)buffer; |
| |
| Lng32 classSize = getClassSize(); |
| Lng32 nextOffset = 0; |
| str_cpy_all(buffer, (char *)this, classSize); |
| |
| nextOffset += ROUND8(classSize); |
| |
| packVars(buffer, ci, nextOffset); |
| } |
| |
| void CmpCompileInfo::unpack(char * base) |
| { |
| if (sqltext_) |
| { |
| sqltext_ = base + (Lng32)((Long)sqltext_); |
| } |
| |
| if (schemaName_) |
| { |
| schemaName_ = base + (Lng32)(Long)schemaName_; |
| } |
| |
| } |
| |
| void CmpCompileInfo::getUnpackedFields(char* &sqltext, |
| char* &schemaName) |
| { |
| char * base = (char *)this; |
| |
| if (sqltext_) |
| { |
| sqltext = base + (Lng32)(Long)sqltext_; |
| } |
| |
| if (schemaName_) |
| { |
| schemaName = base + (Lng32)(Long)schemaName_; |
| } |
| |
| } |
| |
| const short CmpCompileInfo::getRowsetAtomicity() |
| { |
| // 0 denotes unspecified, 1 denotes atomic and 2 denotes not_atomic |
| |
| if (!(flags_ & ROWSET_ATOMICITY_SPECIFIED)) |
| return 0; |
| // The previous bit shows that atomicity has been specified. |
| // Read the next bit to distinguish between ATOMIC and NOT ATOMIC |
| if (flags_ & ROWSET_NOT_ATOMIC) |
| return 2; |
| else |
| return 1; |
| } |
| |
| const short CmpCompileInfo::getHoldableAttr() |
| { |
| if (isAnsiHoldable()) |
| return SQLCLIDEV_ANSI_HOLDABLE; |
| else |
| if (isPubsubHoldable()) |
| return SQLCLIDEV_PUBSUB_HOLDABLE; |
| else |
| return SQLCLIDEV_NONHOLDABLE; |
| } |
| |
| // --------------------------------------------------------- |
| // methos for CmpDDLwithStatusInfo |
| // --------------------------------------------------------- |
| CmpDDLwithStatusInfo::CmpDDLwithStatusInfo() |
| : CmpCompileInfo() |
| { |
| statusFlags_ = 0; |
| step_ = 0; |
| substep_ = 0; |
| statusFlags_ = 0; |
| msgLen_ = 0; |
| blackBoxLen_ = 0; |
| blackBox_ = NULL; |
| }; |
| |
| CmpDDLwithStatusInfo::CmpDDLwithStatusInfo(char * sourceStr, Lng32 sourceStrLen, |
| Lng32 sourceStrCharSet, |
| char * schemaName, Lng32 schemaNameLen) |
| : CmpCompileInfo(sourceStr, sourceStrLen, sourceStrCharSet, |
| schemaName, schemaNameLen, |
| 0, 0) |
| { |
| statusFlags_ = 0; |
| step_ = 0; |
| substep_ = 0; |
| statusFlags_ = 0; |
| msgLen_ = 0; |
| blackBoxLen_ = 0; |
| blackBox_ = NULL; |
| }; |
| |
| void CmpDDLwithStatusInfo::copyStatusInfo(CmpDDLwithStatusInfo *from) |
| { |
| if (! from) |
| return; |
| |
| statusFlags_ = from->statusFlags_; |
| step_ = from->step_; |
| substep_ = from->substep_; |
| statusFlags_ = from->statusFlags_; |
| } |
| |
| Lng32 CmpDDLwithStatusInfo::getLength() |
| { |
| Lng32 sizeOfThis = getClassSize(); |
| Lng32 totalLength = ROUND8(sizeOfThis) + getVarLength(); |
| |
| if ((blackBoxLen_ > 0) && (blackBox_)) |
| totalLength += ROUND8(blackBoxLen_); |
| return totalLength; |
| } |
| |
| void CmpDDLwithStatusInfo::pack(char * buffer) |
| { |
| CmpDDLwithStatusInfo * ci = (CmpDDLwithStatusInfo *)buffer; |
| |
| Lng32 classSize = getClassSize(); |
| Lng32 nextOffset = 0; |
| str_cpy_all(buffer, (char *)this, classSize); |
| |
| nextOffset += ROUND8(classSize); |
| |
| packVars(buffer, ci, nextOffset); |
| |
| if (blackBox_ && (blackBoxLen_ > 0)) |
| { |
| str_cpy_all(&buffer[nextOffset], blackBox_, blackBoxLen_); |
| ci->blackBox_ = (char *)((long)nextOffset); |
| nextOffset += ROUND8(blackBoxLen_); |
| } |
| |
| } |
| |
| void CmpDDLwithStatusInfo::unpack(char * base) |
| { |
| CmpCompileInfo::unpack(base); |
| |
| if (blackBox_) |
| { |
| blackBox_ = base + (Lng32)((Long)blackBox_); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for CmpMessageReply |
| // ----------------------------------------------------------------------- |
| |
| CmpMessageReply::CmpMessageReply(MessageTypeEnum e, |
| ID request, |
| CollHeap* h, |
| char* preAllocatedData, |
| ULng32 preAllocatedSize, |
| CollHeap* outh) : |
| CmpMessageReplyBasic(e,request, h) |
| { |
| data_ = 0; |
| sz_ = 0; |
| dataAllocated_ = FALSE; |
| preAllocatedData_ = preAllocatedData; |
| preAllocatedSize_ = preAllocatedSize; |
| outh_ = outh; |
| } |
| |
| void CmpMessageReply::destroyMe() |
| { |
| if ( dataAllocated_) |
| NADELETEBASIC(data_, outh_); |
| } |
| |
| CmpMessageReply::~CmpMessageReply() |
| { |
| destroyMe(); |
| } |
| |
| IpcMessageObjSize CmpMessageReply::mypackedLength() |
| { |
| IpcMessageObjSize size = CmpMessageReplyBasic::mypackedLength(); |
| size += sizeof(sz_); |
| advanceSize(size,data_,sz_); |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageReply::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size= CmpMessageReplyBasic::packMyself(buffer); |
| size += ::packIntoBuffer(buffer,sz_); |
| size += packIntoBuffer(buffer,data_,sz_); |
| return size; |
| } |
| |
| void CmpMessageReply::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageReplyBasic::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| ::unpackBuffer(buffer, sz_); |
| if ( !dataAllocated_ ) |
| // This is to avoid the deallocate of space insize unpackBuffer for data_, |
| // if the data is not allocated internally, should not delete it either. |
| data_ = 0; |
| if ( preAllocatedData_ && preAllocatedSize_ >= sz_ ) |
| { |
| // use the preAllocatedData_ to hold the reply |
| ULng32 temp; |
| unpackBuffer(buffer, preAllocatedData_, preAllocatedSize_, temp); |
| data_ = preAllocatedData_; |
| dataAllocated_ = FALSE; |
| } |
| else |
| { |
| unpackBuffer(buffer, data_, outh_); |
| dataAllocated_ = TRUE; |
| } |
| } |
| |
| void CmpMessageReplyCode::destroyMe() |
| { |
| CmpMessageReply::destroyMe(); |
| |
| if (fragmentDir_) |
| delete fragmentDir_; |
| |
| fragmentDir_ = NULL; |
| } |
| |
| CmpMessageReplyCode::~CmpMessageReplyCode() |
| { |
| destroyMe(); |
| } |
| |
| IpcMessageObjSize CmpMessageReplyCode::mypackedLength() |
| { |
| if (fragmentDir_ == NULL) |
| return CmpMessageReply::mypackedLength(); |
| |
| IpcMessageObjSize size = CmpMessageReplyBasic::mypackedLength(); |
| size += sizeof(getSize()); |
| size += sizeof(getSize()) + getSize(); |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageReplyCode::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| if (fragmentDir_ == NULL) |
| return CmpMessageReply::packMyself(buffer); |
| |
| IpcMessageObjSize size= CmpMessageReplyBasic::packMyself(buffer); |
| size += ::packIntoBuffer(buffer,getSize()); |
| |
| // copy the objects of all spaces into one big buffer |
| size += ::packIntoBuffer(buffer,getSize()); |
| if (getSize() > 0) |
| { |
| Lng32 outputLengthSoFar = 0; |
| ULng32 out_buflen = getSize(); |
| for (CollIndex i = 0; i < fragmentDir_->entries(); i++) |
| { |
| // copy the next space into the buffer |
| if (fragmentDir_->getSpace(i)->makeContiguous( |
| &buffer[outputLengthSoFar], |
| out_buflen - outputLengthSoFar) == 0) |
| return 0; |
| outputLengthSoFar += fragmentDir_->getFragmentLength(i); |
| } |
| |
| size += getSize(); |
| } |
| |
| return size; |
| } |
| |
| IpcMessageObjSize |
| CmpMessageReplyCode::copyFragsToBuffer(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size = 0; |
| if (getSize() > 0) |
| { |
| Lng32 outputLengthSoFar = 0; |
| ULng32 out_buflen = getSize(); |
| for (CollIndex i = 0; i < fragmentDir_->entries(); i++) |
| { |
| // copy the next space into the buffer |
| if (fragmentDir_->getSpace(i)->makeContiguous( |
| &buffer[outputLengthSoFar], |
| out_buflen - outputLengthSoFar) == 0) |
| return 0; |
| outputLengthSoFar += fragmentDir_->getFragmentLength(i); |
| } |
| |
| size += getSize(); |
| } |
| |
| return size; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // methods for CmpMessageRequest |
| // ----------------------------------------------------------------------- |
| |
| CmpMessageRequest::CmpMessageRequest(MessageTypeEnum e, |
| char* data, |
| CmpMsgBufLenType l, |
| CollHeap* h, Lng32 cs, |
| const char *parentQid, Lng32 parentQidLen) : |
| CmpMessageRequestBasic(e,h) |
| { |
| data_ = 0; |
| sz_ = 0; |
| flags_ = 0; |
| copyToString(data_, sz_, data, l); |
| charSet_ = cs==SQLCHARSETCODE_UNKNOWN ? CharInfo::findLocaleCharSet() : cs; |
| parentQid_ = parentQid; |
| parentQidLen_ = parentQidLen; |
| allocated_ = FALSE; |
| } |
| |
| void CmpMessageRequest::destroyMe() |
| { |
| NADELETEBASIC(data_, getHeap()); |
| if (allocated_ && parentQid_ != NULL) |
| { |
| NADELETEBASIC(parentQid_, getHeap()); |
| parentQid_ = NULL; |
| parentQidLen_ = 0; |
| } |
| } |
| |
| void CmpMessageRequest::copyToString(char* &dest, CmpMsgBufLenType& sz, |
| char* source, CmpMsgBufLenType sz1) |
| { |
| NADELETEBASIC(dest, getHeap()); |
| if ( source ) |
| { |
| sz = sz1 + 1; |
| dest = new (getHeap()) char[sz]; |
| str_cpy_all(dest, source, sz1); |
| dest[sz1] = 0; |
| } |
| else |
| { |
| sz = 0; |
| dest = 0; |
| } |
| } |
| |
| IpcMessageObjSize CmpMessageRequest::mypackedLength() |
| { |
| IpcMessageObjSize size = CmpMessageRequestBasic::mypackedLength(); |
| size += sizeof(sz_); |
| size += sizeof(flags_); |
| size += sizeof(charSet_); |
| advanceSize(size, data_, sz_); |
| size += sizeof(parentQidLen_); |
| size += parentQidLen_; |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageRequest::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size= CmpMessageRequestBasic::packMyself(buffer); |
| size += ::packIntoBuffer(buffer, sz_); |
| size += ::packIntoBuffer(buffer, flags_); |
| size += ::packIntoBuffer(buffer, charSet_); |
| size += packIntoBuffer(buffer, data_, sz_); |
| size += ::packIntoBuffer(buffer, parentQidLen_); |
| if (parentQidLen_ != 0 && parentQid_ != NULL) |
| size += packStrIntoBuffer(buffer, (char *)parentQid_, parentQidLen_); |
| return size; |
| } |
| |
| void CmpMessageRequest::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageRequestBasic::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| ::unpackBuffer(buffer, sz_); |
| ::unpackBuffer(buffer, flags_); |
| ::unpackBuffer(buffer, charSet_); |
| unpackBuffer(buffer, data_, getHeap()); |
| ::unpackBuffer(buffer, parentQidLen_); |
| if (parentQidLen_ != 0) |
| { |
| allocated_ = TRUE; |
| parentQid_ = new ((NAHeap *)(getHeap())) char[parentQidLen_+1]; |
| unpackStrFromBuffer(buffer, (char *)parentQid_, parentQidLen_); |
| *((char *)(parentQid_+ parentQidLen_)) = '\0'; |
| } |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Methods for CmpMessageEnvs |
| // ----------------------------------------------------------------------- |
| |
| CmpMessageEnvs::CmpMessageEnvs(EnvsOperatorEnum o, |
| char ** inEnviron, |
| NABoolean emptyOne, CollHeap* h): |
| CmpMessageObj(ENVS_REFRESH,h),envs_(0),operator_(o), cwd_(0) |
| { |
| if (emptyOne) |
| // This is just to create an empty CmpMessageEnvs object in arkcmp |
| // side. The contents will later be filled in unpack method to |
| // get the data passed from executor. In arkcmp, this object will |
| // be created in (CmpConnection::actOnReceive) and processed. The |
| // contents will be used in ProcessEnvs object to set up the exact |
| // environment variables. |
| return; |
| |
| // Create a CmpMessageEnvs from executor side to include the environmental |
| // information to be sent to arkcmp. |
| // The storage allocated will later be deallocated in destroyMe() method. |
| // setup envs_ |
| Lng32 count = 0; |
| char ** e = NULL; |
| if (inEnviron) |
| { |
| e = inEnviron; |
| |
| for (count=0; e[count]; count++); |
| } |
| |
| nEnvs_ = count; |
| envs_ = new(getHeap()) char*[nEnvs_]; |
| for (count=0; ((e != NULL) && (count < nEnvs_)); count++) |
| { |
| Lng32 l = str_len(e[count])+1; |
| envs_[count] = new(getHeap()) char[l]; |
| str_cpy_all(envs_[count], e[count], l); |
| } |
| |
| if (inEnviron) |
| { |
| // setup cwd_ |
| char cwd[500]; |
| getcwd(cwd, 500); |
| Lng32 l = str_len(cwd)+1; |
| cwd_ = new(getHeap()) char[l]; |
| str_cpy_all(cwd_, cwd, l); |
| //free(cwd); // free the one from getcwd() function, |
| //supposed to be from malloc. |
| } |
| else |
| cwd_ = NULL; |
| |
| |
| // if a transaction is active, get the transid by calling |
| // the CLI procedure. |
| |
| Int64 transid = -1; |
| if (NAExecTrans(0, transid)) |
| { |
| activeTrans_ = 1; |
| transId_ = transid; |
| } |
| else |
| { |
| transId_ = -1 ; |
| activeTrans_ = 0; |
| } |
| } |
| |
| IpcMessageObjSize CmpMessageEnvs::mypackedLength() |
| { |
| IpcMessageObjSize size = CmpMessageObj::mypackedLength(); |
| size += sizeof(operator_); |
| size += sizeof(nEnvs_); |
| for(Int32 i=0;i<nEnvs_; i++) |
| advanceSize(size, envs_[i]); |
| advanceSize(size, cwd_); |
| size += sizeof(activeTrans_); |
| advanceSize(size, transId_); |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageEnvs::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size= CmpMessageObj::packMyself(buffer); |
| size += ::packIntoBuffer(buffer,operator_); |
| size += ::packIntoBuffer(buffer, nEnvs_); |
| for ( Int32 i=0; i < nEnvs_; i++ ) |
| size += packIntoBuffer(buffer, envs_[i]); |
| size += packIntoBuffer(buffer, cwd_); |
| size += ::packIntoBuffer(buffer, activeTrans_); |
| size += packIntoBuffer(buffer, transId_); |
| return size; |
| } |
| |
| void CmpMessageEnvs::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageObj::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| ::unpackBuffer(buffer, operator_); |
| ::unpackBuffer(buffer, nEnvs_); |
| if (nEnvs_) |
| { |
| envs_ = new(getHeap()) char*[nEnvs_]; |
| for (Int32 i=0; i < nEnvs_; i++) |
| { |
| envs_[i] = 0; |
| unpackBuffer(buffer, envs_[i],getHeap()); |
| } |
| } |
| else |
| envs_ = 0; |
| |
| unpackBuffer(buffer, cwd_, getHeap()); |
| ::unpackBuffer(buffer, activeTrans_); |
| unpackBuffer(buffer, transId_); |
| } |
| |
| void CmpMessageEnvs::destroyMe() |
| { |
| } |
| |
| CmpMessageEnvs::~CmpMessageEnvs() |
| { |
| destroyMe(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Methods for CmpMessageISPRequest |
| // ----------------------------------------------------------------------- |
| |
| CmpMessageISPRequest::CmpMessageISPRequest(char* procName, |
| void* inputExpr, |
| ULng32 inputExprSize, |
| void* outputExpr, |
| ULng32 outputExprSize, |
| void* keyExpr, |
| ULng32 keyExprSize, |
| void* inputData, |
| ULng32 inputDataSize, |
| ULng32 outputRowSize, |
| ULng32 outputTotalSize, |
| CollHeap* h, |
| const char *parentQid, |
| Lng32 parentQidLen) |
| : CmpMessageRequest(INTERNALSP_REQUEST, NULL, 0, h, SQLCHARSETCODE_UNKNOWN, parentQid, parentQidLen) |
| { |
| procName_ = procName; |
| inputExpr_ = inputExpr; |
| inputExprSize_ = inputExprSize; |
| outputExpr_ = outputExpr; |
| outputExprSize_ = outputExprSize; |
| keyExpr_ = keyExpr; |
| keyExprSize_ = keyExprSize; |
| inputData_ = inputData; |
| inputDataSize_ = inputDataSize; |
| keyDataSize_ = 0; |
| keyData_ = 0; |
| outputRowSize_ = outputRowSize; |
| outputTotalSize_ = outputTotalSize; |
| allocated_ = FALSE; |
| } |
| |
| CmpMessageISPRequest::~CmpMessageISPRequest() |
| { |
| destroyMe(); |
| } |
| |
| void CmpMessageISPRequest::destroyMe() |
| { |
| if (allocated_) |
| { |
| NADELETEBASIC(procName_, getHeap()); |
| NADELETEBASIC((char*)inputExpr_, getHeap()); |
| NADELETEBASIC((char*)outputExpr_, getHeap()); |
| NADELETEBASIC((char*)keyExpr_, getHeap()); |
| NADELETEBASIC((char*)inputData_, getHeap()); |
| } |
| } |
| |
| IpcMessageObjSize CmpMessageISPRequest::mypackedLength() |
| { |
| IpcMessageObjSize size = CmpMessageRequest::mypackedLength(); |
| advanceSize(size, procName_); |
| size += sizeof(inputExprSize_); |
| advanceSize(size,inputExpr_,inputExprSize_); |
| size += sizeof(outputExprSize_); |
| advanceSize(size,outputExpr_,outputExprSize_); |
| size += sizeof(keyExprSize_); |
| advanceSize(size,keyExpr_,keyExprSize_); |
| size += sizeof(inputDataSize_); |
| advanceSize(size,inputData_,inputDataSize_); |
| size += sizeof(outputRowSize_); |
| size += sizeof(outputTotalSize_); |
| |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageISPRequest::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size= CmpMessageRequest::packMyself(buffer); |
| size += packIntoBuffer(buffer, procName_); |
| |
| size += ::packIntoBuffer(buffer,inputExprSize_); |
| size += packIntoBuffer(buffer, inputExpr_, inputExprSize_); |
| size += ::packIntoBuffer(buffer,outputExprSize_); |
| size += packIntoBuffer(buffer, outputExpr_, outputExprSize_); |
| size += ::packIntoBuffer(buffer, keyExprSize_); |
| size += packIntoBuffer(buffer, keyExpr_, keyExprSize_); |
| size += ::packIntoBuffer(buffer,inputDataSize_); |
| size += packIntoBuffer(buffer, inputData_, inputDataSize_); |
| size += ::packIntoBuffer(buffer,outputRowSize_); |
| size += ::packIntoBuffer(buffer,outputTotalSize_); |
| |
| return size; |
| } |
| |
| void CmpMessageISPRequest::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| allocated_ = TRUE; // so that the allocated storages will be destroyed later. |
| CmpMessageRequest::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| unpackBuffer(buffer, procName_, getHeap()); |
| ::unpackBuffer(buffer, inputExprSize_); |
| unpackBuffer(buffer, inputExpr_, getHeap()); |
| ::unpackBuffer(buffer, outputExprSize_); |
| unpackBuffer(buffer, outputExpr_, getHeap()); |
| ::unpackBuffer(buffer, keyExprSize_); |
| unpackBuffer(buffer, keyExpr_, getHeap()); |
| ::unpackBuffer(buffer, inputDataSize_); |
| unpackBuffer(buffer, inputData_, getHeap()); |
| ::unpackBuffer(buffer, outputRowSize_); |
| ::unpackBuffer(buffer, outputTotalSize_); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Methods for CmpMessageISPGetNext |
| // ----------------------------------------------------------------------- |
| |
| CmpMessageISPGetNext::CmpMessageISPGetNext(ULng32 bufSize, |
| ID ispRequest, |
| Lng32 serialNo, |
| CollHeap* h, |
| const char *parentQid, |
| Lng32 parentQidLen) |
| : CmpMessageRequest(INTERNALSP_GETNEXT, NULL, 0, h, SQLCHARSETCODE_UNKNOWN, parentQid, parentQidLen) |
| { |
| bufSize_ = bufSize; |
| ispRequest_ = ispRequest; |
| serialNo_ = serialNo; |
| } |
| |
| CmpMessageISPGetNext::~CmpMessageISPGetNext() |
| { |
| } |
| |
| IpcMessageObjSize CmpMessageISPGetNext::mypackedLength() |
| { |
| IpcMessageObjSize size = CmpMessageRequest::mypackedLength(); |
| size += sizeof(bufSize_); |
| size += sizeof(ispRequest_); |
| size += sizeof(serialNo_); |
| |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageISPGetNext::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size= CmpMessageRequest::packMyself(buffer); |
| |
| size += ::packIntoBuffer(buffer,bufSize_); |
| size += ::packIntoBuffer(buffer,ispRequest_); |
| size += ::packIntoBuffer(buffer,serialNo_); |
| |
| return size; |
| } |
| |
| void CmpMessageISPGetNext::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageRequest::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| ::unpackBuffer(buffer, bufSize_); |
| ::unpackBuffer(buffer, ispRequest_); |
| ::unpackBuffer(buffer, serialNo_); |
| |
| } |
| |
| IpcMessageObjSize CmpMessageReplyISP::mypackedLength() |
| { |
| IpcMessageObjSize size = CmpMessageReply::mypackedLength(); |
| size += sizeof(areMore_); |
| |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageReplyISP::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size= CmpMessageReply::packMyself(buffer); |
| |
| size += ::packIntoBuffer(buffer,areMore_); |
| |
| return size; |
| } |
| |
| void CmpMessageReplyISP::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageReply::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| ::unpackBuffer(buffer, areMore_); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| // Methods for CmpMessageConnectionType |
| // ----------------------------------------------------------------------- |
| |
| CmpMessageConnectionType::CmpMessageConnectionType(ConnectionTypeEnum t, |
| CollHeap* h) |
| : CmpMessageRequestBasic(CONNECTION_TYPE, h) |
| { |
| type_ = t; |
| } |
| |
| IpcMessageObjSize CmpMessageConnectionType::mypackedLength() |
| { |
| IpcMessageObjSize size = CmpMessageRequestBasic::mypackedLength(); |
| size += sizeof(Lng32); |
| |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageConnectionType::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size= CmpMessageRequestBasic::packMyself(buffer); |
| |
| Lng32 t = (Lng32) type_; |
| size += ::packIntoBuffer(buffer,t); |
| |
| return size; |
| } |
| |
| void CmpMessageConnectionType::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageRequestBasic::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| Lng32 t; |
| ::unpackBuffer(buffer, t); |
| type_ = (( t==DMLDDL ) ? DMLDDL : ISP); |
| } |
| |
| IpcMessageObjSize CmpMessageEndSession::mypackedLength() |
| { |
| IpcMessageObjSize size = CmpMessageObj::mypackedLength(); |
| size += sizeof(flags_); |
| return size; |
| } |
| |
| IpcMessageObjSize CmpMessageEndSession::packMyself(IpcMessageBufferPtr& buffer) |
| { |
| IpcMessageObjSize size= CmpMessageObj::packMyself(buffer); |
| size += ::packIntoBuffer(buffer, flags_); |
| return size; |
| } |
| |
| void CmpMessageEndSession::unpackMyself(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr& buffer) |
| { |
| CmpMessageObj::unpackMyself(objType, objVersion, sameEndianness, |
| objSize, buffer); |
| ::unpackBuffer(buffer, flags_); |
| } |
| |
| |
| |
| |
| |