| /********************************************************************** |
| // @@@ 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 @@@ |
| **********************************************************************/ |
| #ifndef EXP_TUPLE_DESC_H |
| #define EXP_TUPLE_DESC_H |
| |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: <file> |
| * Description: |
| * |
| * Created: 5/30/96 |
| * Language: C++ |
| * |
| * |
| * |
| * |
| ***************************************************************************** |
| */ |
| |
| #include "ExpAlignedFormat.h" |
| |
| // Forward external references |
| class Attributes; |
| class ex_clause; |
| |
| // ----------------------------------------------------------------------- |
| // Classes defined in this file |
| // ----------------------------------------------------------------------- |
| class ExpTupleDesc; |
| |
| // --------------------------------------------------------------------- |
| // Template instantiation to produce a 64-bit pointer emulator class |
| // for ExTupleDesc |
| // --------------------------------------------------------------------- |
| typedef NAVersionedObjectPtrTempl<ExpTupleDesc> ExpTupleDescPtr; |
| typedef NAVersionedObjectPtrArrayTempl<ExpTupleDescPtr> ExpTupleDescPtrPtr; |
| typedef NAVersionedObjectPtrTempl<Attributes> AttributesPtr; |
| typedef NAVersionedObjectPtrArrayTempl<AttributesPtr> AttributesPtrPtr; |
| |
| |
| |
| #define NEG_BIT_MASK 0x0080 //the first bit in a byte - used for finding |
| //out whether the negative bit in a number |
| //is flipped |
| |
| // Size of each VOA array entry for SQLMX_FORMAT. |
| // The SQLMX_ALIGNED_FORMAT has its own constant in ExpAlignedFormat.h |
| static const UInt32 ExpVoaSize = sizeof(Int32); |
| static const UInt32 ExpOffsetMax = UINT_MAX; |
| |
| |
| //////////////////////////////////////////////////////////////////// |
| // |
| // class ExpTupleDesc |
| // |
| //////////////////////////////////////////////////////////////////// |
| class ExpTupleDesc : public NAVersionedObject |
| { |
| public: |
| // |
| // Format of data in tuple: |
| // |
| // PACKED_FORMAT: records stored in tables created on SQL/MP. |
| // Fields stored without any alignment. |
| // If nullable field, null indicator bytes are |
| // stored just before the actual data. |
| // Null indicator length = 2. |
| // If variable length field, the varchar length |
| // bytes are stored just before the actual varchar data. |
| // Varchar indicator length = 2. |
| // Varchars are NOT stored in exploded format. |
| // |
| // SQLMX_KEY_FORMAT: |
| // Fields aligned like PACKED_FORMAT plus (no VOA) |
| // varchars are blank padded to max len. Used to |
| // build key buffers for SQL/MX and SQL/MP tables. |
| // |
| // SQLARK_EXPLODED_FORMAT: |
| // All fields aligned on their appropriate byte boundary. |
| // Int16 aligned on 2 byte, Int32 on 4 byte and Int64 |
| // on 8-byte boundary. |
| // If nullable field, null indicator bytes are |
| // stored just before the actual data. |
| // Null indicator length = 2. |
| // If variable length field, the varchar length |
| // bytes are stored just before the actual varchar data. |
| // Varchar indicator length = 2 or 4. |
| // Varchars stored in exploded format(blankpadded |
| // to max len). |
| // |
| // SQLMX_FORMAT: |
| // Records stored in tables created within SQL/MX. |
| // Fields are stored as follows (without any alignment): |
| // all fixed fields stored first, then all variable |
| // length fields. |
| // There is an additional VariableOffsetArray that is |
| // stored on disk. This array is the # of variable |
| // length fields + 1 (for the first fixed field). Each |
| // VOA entry is 4 bytes. |
| // |
| // SQLMX_ALIGNED_FORMAT: |
| // Records are padded if needed to 4 byte boundaries. |
| // Fixed fields are re-arranged and grouped based on their |
| // alignment boundaries. |
| // Added fixed length columns follow the original fixed |
| // fields and are in the logical order they were added. |
| // Null bitmap at the beginning of record to record |
| // null column values. |
| // For more details see exp/ExpAlignedFormat.h |
| // |
| enum TupleDataFormat |
| { UNINITIALIZED_FORMAT, |
| OBSOLETE_SIMULATOR_FORMAT, |
| PACKED_FORMAT, SQLMX_KEY_FORMAT, |
| SQLARK_EXPLODED_FORMAT, |
| SQLMX_FORMAT, |
| SQLMX_ALIGNED_FORMAT |
| }; |
| |
| enum TupleDescConstants |
| { |
| // Size of each VOA (variable offset array) entry for SQLMX_FORMAT records |
| // data. This includes the first fixed field offset (i.e., VOA[0]) |
| EXP_VOA_SIZE = sizeof(UInt32) |
| ,NULL_INDICATOR_LENGTH = sizeof(Int16) |
| ,VC_ACTUAL_LENGTH = sizeof(UInt16) // varchar actual length |
| ,SQLMX_VC_ACTUAL_LENGTH = sizeof(UInt32) // SQLMX_FORMAT varchar data len |
| ,KEY_NULL_INDICATOR_LENGTH = sizeof(Int16) // Key null indicator length |
| }; |
| |
| // Format of tuple descriptor. |
| // LONG_FORMAT: Contains information about the tuple and each attribute |
| // that it contains. |
| // 'this' class is followed by an array of size numAttrs_. |
| // The array is followed by numAttrs_ Attributes. Each array |
| // entry points to the corresponding Attribute. The array |
| // is needed because the size of all Attributes may not be |
| // the same. See file exp_attrs.h for details on Attributes |
| // class. |
| // |
| // SHORT_FORMAT: Only contains 'this' class. |
| // |
| enum TupleDescFormat |
| { SHORT_FORMAT, LONG_FORMAT |
| }; |
| |
| private: |
| enum flagsType |
| { |
| PACKED = 0x0001, |
| VAR_FIELD_PRESENT = 0x0002, |
| ADDED_COLUMN = 0x0004, |
| TDM_FLOAT_PRESENT = 0x0008, |
| KEY_SHIFT = 0x0010, // key fields may be shifted |
| // thus pCode can not be relied on |
| ADDED_FIXED_PRESENT = 0x0020 |
| }; |
| |
| // Optional array of numAttrs_ Attributes pointers. |
| // Each entry points to the corresponding Attributes structure. |
| AttributesPtrPtr attrs_; // 00-07 |
| |
| // number of attributes/fields/columns/entries in this tuple |
| UInt32 numAttrs_; // 08-11 |
| |
| // total length of the generated tuple descriptor. Includes |
| // sizeof(this) + size of Attributes array + size of all |
| // Attributes. |
| UInt32 tupleDescLength_; // 12-15 |
| |
| // total max length of data in this tuple |
| UInt32 tupleDataLength_; // 16-19 |
| |
| Int16 /*TupleDataFormat*/ tupleDataFormat_; // 20-21 |
| Int16 /*TupleDescFormat*/ tupleDescFormat_; // 22-23 |
| UInt32 flags_; // 24-27 |
| // --------------------------------------------------------------------- |
| // Fillers for potential future extensions without changing class size. |
| // When a new member is added, size of this filler should be reduced so |
| // that the size of the object remains the same (and is modulo 8). |
| // --------------------------------------------------------------------- |
| char fillers_[4]; // 28-31 |
| |
| Int16 packed() |
| { |
| return (Int16)(flags_ & PACKED); |
| } |
| |
| public: |
| |
| ExpTupleDesc(UInt32 num_attrs, |
| Attributes ** attrs, |
| UInt32 tupleDataLength, |
| TupleDataFormat tdataF, |
| TupleDescFormat tdescF, |
| Space * space); |
| |
| |
| ExpTupleDesc(UInt32 num_attrs, |
| AttributesPtr * attrs, |
| UInt32 tupleDataLength, |
| TupleDataFormat tdataF, |
| TupleDescFormat tdescF); |
| |
| |
| ExpTupleDesc(); |
| |
| ~ExpTupleDesc(); |
| |
| |
| UInt32 numAttrs(){return numAttrs_;} |
| |
| |
| /* Attributes** */ AttributesPtr * attrs(){return attrs_;} |
| |
| |
| Attributes * getAttr(UInt32 attr_num) {return attrs_[attr_num];} |
| |
| |
| virtual Long pack(void *); |
| |
| |
| virtual Int32 unpack(void *, void * reallocator); |
| |
| //////////////////////////////////////////////////////// |
| // Computes offsets of all attributes in the attrs array. |
| // start_offset could be passed in optionally indicating |
| // offsets computation to start there. |
| //////////////////////////////////////////////////////// |
| static Int16 computeOffsets(UInt32 num_attr, |
| Attributes ** attrs, |
| TupleDataFormat tf, |
| UInt32 & datalen, |
| UInt32 startOffset = 0, |
| UInt32 * rtnFlags = NULL, |
| TupleDataFormat * outTf = NULL, |
| ExpHdrInfo * hdrInfo = NULL, |
| UInt32 * headerSizePtr = NULL, |
| UInt32 * VarSizePtr = NULL); |
| |
| |
| //////////////////////////////////////////////////////// |
| // Computes offsets of a single attribute. |
| // start_offset could be passed in optionally indicating |
| // offsets computation to start there. |
| //////////////////////////////////////////////////////// |
| static Int16 computeOffsets(Attributes * attr, |
| TupleDataFormat tf, |
| UInt32 & datalen, |
| UInt32 startOffset = 0); |
| |
| |
| //////////////////////////////////////////////////////// |
| // Class method that centralizes SQLARK_EXPLODED_FORMAT tuple |
| // format offset calculations. Returns aligned column offset. |
| //////////////////////////////////////////////////////// |
| static UInt32 sqlarkExplodedOffsets( |
| UInt32 offset, |
| UInt32 length, |
| Int16 dataType, |
| NABoolean isNullable, |
| UInt32 * nullIndicatorOffset = NULL, |
| UInt32 * vcIndicatorOffset = NULL, |
| UInt32 vcIndicatorSize = ExpTupleDesc::VC_ACTUAL_LENGTH); |
| |
| Int16 operator==(ExpTupleDesc * td); |
| |
| // assigns the atp and atp_index value to all attributes |
| void assignAtpAndIndex(Int16 atp, Int16 atp_index); |
| |
| |
| UInt32 tupleDescLength() {return tupleDescLength_;} |
| |
| |
| UInt32 tupleDataLength() {return tupleDataLength_;} |
| |
| |
| void setAddedField() |
| { flags_ |= ADDED_COLUMN; } |
| |
| |
| Int16 addedFieldPresent() |
| { return (Int16)(flags_ & ADDED_COLUMN); } |
| |
| void setAddedFixed() |
| { flags_ |= ADDED_FIXED_PRESENT; } |
| |
| |
| Int16 addedFixedPresent() |
| { return (Int16)(flags_ & ADDED_FIXED_PRESENT); } |
| |
| NABoolean variableFieldPresent() |
| { return( (flags_ & (UInt32)VAR_FIELD_PRESENT) != 0 ); } |
| |
| NABoolean tandemFloatPresent() |
| { return( (flags_ & (UInt32)TDM_FLOAT_PRESENT) != 0 ); } |
| |
| // Check if key fields may be shifted due to an added column or not. |
| NABoolean isKeyShifted() |
| { return( (flags_ & KEY_SHIFT) > 0 ); } |
| |
| void setFlags(UInt32 newFlags) { flags_ = newFlags; } |
| |
| Int16 tupleFormat() { return tupleDataFormat_; }; |
| |
| const char *tupleFormatStr() { |
| switch(tupleDataFormat_) { |
| case UNINITIALIZED_FORMAT: |
| return "Uninitialized"; |
| case OBSOLETE_SIMULATOR_FORMAT: |
| return "Simulator"; |
| case PACKED_FORMAT: |
| return "Packed"; |
| case SQLMX_KEY_FORMAT: |
| return "Key"; |
| case SQLARK_EXPLODED_FORMAT: |
| return "Exploded"; |
| case SQLMX_FORMAT: |
| return "SqlMX"; |
| case SQLMX_ALIGNED_FORMAT: |
| return "Aligned"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| NABoolean isSQLMXTable() |
| { return tupleDataFormat_ == (Int16) ExpTupleDesc::SQLMX_FORMAT; } |
| |
| NABoolean isSQLMXAlignedTable() |
| { return tupleDataFormat_ == (Int16)ExpTupleDesc::SQLMX_ALIGNED_FORMAT; } |
| |
| NABoolean isSQLPackedTable() |
| { return tupleDataFormat_ == (Int16) ExpTupleDesc::PACKED_FORMAT; } |
| |
| // computeFirstFixedOffset |
| // Called at compile time to compute the offset to the first fixed |
| // field. |
| // For SQLMX_FORMAT set it to the minimum that it can be - right |
| // after VOA[0]. |
| // For SQLMX_ALIGNED_FORMAT see notes in ExpAlignedFormat.h |
| static UInt32 computeFirstFixedOffset(Int32 ffAlignSize, |
| UInt32 startOffset, |
| UInt32 voaIdxOffset, |
| TupleDataFormat tdf, |
| UInt32 nullableFieldCount, |
| ExpHdrInfo * hdrInfo, |
| UInt32 & headerSize, |
| UInt32 & bitmapOffset) |
| |
| { |
| if ( tdf == ExpTupleDesc::SQLMX_ALIGNED_FORMAT ) |
| { |
| return ExpAlignedFormat::computeFirstFixedOffset( ffAlignSize, |
| startOffset, |
| voaIdxOffset, |
| nullableFieldCount, |
| hdrInfo, |
| headerSize, |
| bitmapOffset ); |
| } |
| else |
| { |
| headerSize = ExpVoaSize; // First fixed field offset |
| |
| if (hdrInfo != NULL) |
| { |
| hdrInfo->setValues(headerSize); // first fixed field offset area |
| } |
| |
| return voaIdxOffset + headerSize; |
| } |
| } |
| |
| static UInt32 read4( char *tempPtr ) |
| { |
| // use 'unsigned char *' so that the value is not sign extended. |
| UChar *dataPtr = (UChar *)tempPtr; |
| |
| #ifdef NA_BIG_ENDIAN |
| return (dataPtr[0] << 24) | |
| (dataPtr[1] << 16) | |
| (dataPtr[2] << 8) | |
| (dataPtr[3]); |
| #else |
| return (dataPtr[3] << 24) | |
| (dataPtr[2] << 16) | |
| (dataPtr[1] << 8) | |
| (dataPtr[0]); |
| #endif |
| } |
| |
| static UInt32 read2( char *tempPtr ) |
| { |
| // use 'unsigned char *' so that the value is not sign extended. |
| UChar *dataPtr = (UChar *)tempPtr; |
| |
| #ifdef NA_BIG_ENDIAN |
| return (unsigned short )((dataPtr[0] << 8) | dataPtr[1]); |
| #else |
| return (unsigned short )((dataPtr[1] << 8) | dataPtr[0]); |
| #endif |
| } |
| |
| static void write4( char *dataPtr, |
| UInt32 value ) |
| { |
| #ifdef NA_BIG_ENDIAN |
| dataPtr[0] = (char)(value >> 24); |
| dataPtr[1] = (char)(value >> 16); |
| dataPtr[2] = (char)(value >> 8); |
| dataPtr[3] = (char)value; |
| #else |
| dataPtr[3] = (char)(value >> 24); |
| dataPtr[2] = (char)(value >> 16); |
| dataPtr[1] = (char)(value >> 8); |
| dataPtr[0] = (char)value; |
| #endif |
| } |
| |
| static void write2( char *dataPtr, |
| unsigned short value ) |
| { |
| #ifdef NA_BIG_ENDIAN |
| dataPtr[0] = (char)(value >> 8); |
| dataPtr[1] = (char)value; |
| #else |
| dataPtr[1] = (char)(value >> 8); |
| dataPtr[0] = (char)value; |
| #endif |
| } |
| |
| // If filler bytes are needed to extend a record to a 4-byte multiple |
| // then the bytes are stored specific to each data format. |
| UInt32 getNumberFillerBytes( char * dataPtr ) |
| { |
| if ( isSQLMXAlignedTable() ) |
| return ((ExpAlignedFormat *)dataPtr)->getNumberFillerBytes(); |
| else |
| return 0; // no filler bytes |
| } |
| |
| // If there were filler bytes added to the row length, subtract them out |
| // and return the true length of the data. |
| UInt32 getActualDataLength( char * dataPtr, |
| UInt32 dataLen ) |
| { |
| if ( isSQLMXAlignedTable() ) |
| return( dataLen - ((ExpAlignedFormat *)dataPtr)->getNumberFillerBytes()); |
| else |
| return dataLen; // no filler bytes |
| } |
| |
| // |
| // Get the size of each header and voa entry dependent on the table row |
| // format. |
| static UInt32 getVoaSize( TupleDataFormat tdf ) |
| { |
| return (( tdf == SQLMX_ALIGNED_FORMAT ) |
| ? ExpAlignedFormat::OFFSET_SIZE : ExpVoaSize ); |
| } |
| |
| UInt32 getVoaSize() |
| { |
| return getVoaSize( (TupleDataFormat)tupleDataFormat_ ); |
| } |
| |
| UInt32 adjustDataLength( char * dataPtr, |
| UInt32 currLength ) |
| { |
| if ( isSQLMXAlignedTable() ) |
| return ExpAlignedFormat::adjustDataLength( dataPtr, |
| currLength, |
| ExpAlignedFormat::ALIGNMENT ); |
| else |
| // no resizing needed since fields are packed |
| return currLength; |
| } |
| |
| // Determine which disk format we are working with and return the first |
| // field offset based on the disk format. |
| static UInt32 getFirstFixedOffset( char * dataPtr, |
| TupleDataFormat tdf ) |
| { |
| if ( tdf == ExpTupleDesc::SQLMX_ALIGNED_FORMAT ) |
| return ( ExpAlignedFormat::getFirstFixedOffset( dataPtr ) ); |
| else |
| return ( *(UInt32 *)dataPtr ); |
| } |
| |
| // Set the first fixed field's offset. |
| static void setFirstFixedOffset( char * dataPtr, |
| UInt32 firstFixedOffset, |
| TupleDataFormat tdf ) |
| { |
| if ( tdf == ExpTupleDesc::SQLMX_ALIGNED_FORMAT ) |
| ExpAlignedFormat::setFirstFixedOffset( dataPtr, firstFixedOffset ); |
| else |
| *((UInt32 *)dataPtr) = firstFixedOffset; |
| } |
| |
| // Determine which disk format we are working with and return the first |
| // field offset based on the disk format. |
| UInt32 getFirstVariableOffset( char * dataPtr, |
| UInt32 firstFixedOffset ) |
| { |
| UInt32 offset = 0; |
| if ( variableFieldPresent() ) |
| { |
| if ( isSQLMXAlignedTable() ) |
| { |
| offset = ExpAlignedFormat::getFirstVariableOffset( dataPtr, |
| firstFixedOffset |
| ); |
| } |
| else |
| { |
| // One would think this could not happen if variableFieldPresent() were |
| // true, but that is not the case when there are added columns in the |
| // table and the data row is a "short" row where no variable length |
| // columns exist. |
| if ( firstFixedOffset == ExpVoaSize ) // fixed fields only |
| offset = 0; |
| else // variable fields present |
| offset = *(UInt32 *)(dataPtr + ExpVoaSize); |
| } |
| } |
| return offset; |
| } |
| |
| static char getNullChar() |
| { return (char)'\377'; } |
| |
| static char getZeroChar() |
| { return (char)'\0'; } |
| |
| // Determine the data format we are working with and set the appropriate |
| // null indicator correctly. |
| // This assumes we are pointing to the null indicator bytes for MX format |
| // or the bitmap itself for MX Aligned format. |
| static void setNullValue( char * dataPtr, |
| Int16 nullBitIndex, |
| TupleDataFormat tdf ) |
| { |
| if ( tdf == ExpTupleDesc::SQLMX_ALIGNED_FORMAT ) |
| { |
| ExpAlignedFormat::setNullBit( dataPtr, nullBitIndex ); |
| } |
| else |
| { |
| dataPtr[0] = '\377'; |
| dataPtr[1] = '\377'; |
| } |
| } |
| |
| // |
| // Set the null indicator. |
| static void setNullValue( char * dataPtr, |
| Int16 nullBitIndex ) |
| { |
| if ( nullBitIndex >= 0 ) |
| { |
| ExpAlignedFormat::setNullBit( dataPtr, nullBitIndex ); |
| } |
| else |
| { |
| dataPtr[0] = '\377'; |
| dataPtr[1] = '\377'; |
| } |
| } |
| |
| // Determine the data format we are working with and set the appropriate |
| // null indicator correctly. |
| static void clearNullValue( char * dataPtr, |
| Int16 nullBitIndex, |
| TupleDataFormat tdf ) |
| { |
| if ( tdf == ExpTupleDesc::SQLMX_ALIGNED_FORMAT ) |
| { |
| ExpAlignedFormat::clearNullBit( dataPtr, nullBitIndex ); |
| } |
| else |
| { |
| dataPtr[0] = '\0'; |
| dataPtr[1] = '\0'; |
| } |
| } |
| |
| // Determine the data format we are working with and set the appropriate |
| // null indicator correctly. |
| static void clearNullValue( char * dataPtr, |
| Int16 nullBitIndex ) |
| { |
| if ( nullBitIndex >= 0 ) |
| { |
| ExpAlignedFormat::clearNullBit( dataPtr, nullBitIndex ); |
| } |
| else |
| { |
| dataPtr[0] = '\0'; |
| dataPtr[1] = '\0'; |
| } |
| } |
| |
| // Based on the data format, determine if the value is NULL or not. |
| static NABoolean isNullValue( char * nullDataPtr, |
| Int16 nullBitIdx, |
| TupleDataFormat tdf ) |
| { |
| if ( tdf == ExpTupleDesc::SQLMX_ALIGNED_FORMAT ) |
| { |
| return ( ExpAlignedFormat::isNullValue( nullDataPtr, nullBitIdx ) ); |
| } |
| else |
| { |
| // NSK and NT have different byte orderings. |
| return ((nullDataPtr)[1] & NEG_BIT_MASK); // sign bit is flipped |
| } |
| } |
| |
| // Null bit index is set to [0,n] for aligned format, |
| // and all other formats it is initialized to -1. |
| static NABoolean isNullValue( char * nullDataPtr, |
| Int16 nullBitIdx ) |
| { |
| if ( nullBitIdx >= 0 ) |
| { |
| return ( ExpAlignedFormat::isNullValue( nullDataPtr, nullBitIdx ) ); |
| } |
| else |
| { |
| return ((nullDataPtr)[0] & NEG_BIT_MASK); |
| } |
| } |
| |
| // |
| // Method to determine if a variable field offset is valid or not. |
| // If not valid then the offset must be read from the VOA entry. |
| static |
| NABoolean isValidVariableOffset(UInt32 offset) |
| { return (offset != ExpOffsetMax); } |
| |
| static void setVoaValue( char * dataPtr, |
| UInt32 voaEntryOffset, |
| UInt32 voaEntryValue, |
| TupleDataFormat tdf) |
| { |
| if (voaEntryOffset != ExpOffsetMax) |
| { |
| if ( tdf == SQLMX_ALIGNED_FORMAT ) |
| { |
| ((ExpAlignedFormat *)dataPtr)->setVoaOffset(voaEntryOffset, |
| voaEntryValue); |
| } |
| else if ( tdf == SQLMX_FORMAT ) |
| { |
| str_cpy_all(dataPtr + voaEntryOffset,(char *)&voaEntryValue,ExpVoaSize); |
| } |
| else |
| { |
| // should never be here |
| assert( 0 ); |
| } |
| } |
| } |
| |
| // Set a variable length field's offset value in it's VOA entry. |
| // The size of the voa entry is the same as the size of the variable |
| // length fields "length" bytes. |
| static void setVoaValue( char * dataPtr, |
| UInt32 voaEntryOffset, |
| UInt32 voaEntryValue, |
| Int16 vcIndLen) |
| { |
| if (voaEntryOffset != ExpOffsetMax) |
| { |
| if ( vcIndLen == sizeof(Int16) ) |
| { |
| ((ExpAlignedFormat *)dataPtr)->setVoaOffset(voaEntryOffset, |
| voaEntryValue); |
| } |
| else if ( vcIndLen == sizeof(Int32) ) |
| { |
| str_cpy_all(dataPtr + voaEntryOffset,(char *)&voaEntryValue,ExpVoaSize); |
| } |
| else |
| { |
| // should never be here |
| assert( 0 ); |
| } |
| } |
| } |
| |
| void setVoaValue( char * dataPtr, |
| UInt32 voaEntryOffset, |
| UInt32 voaEntryValue ) |
| { |
| ExpTupleDesc::setVoaValue( dataPtr, |
| voaEntryOffset, |
| voaEntryValue, |
| getTupleDataFormat() ); |
| } |
| |
| // Get the offset value out of the VOA entry based on tuple data format. |
| static UInt32 getVoaOffset( char * dataPtr, |
| UInt32 voaEntryOffset, |
| TupleDataFormat tdf ) |
| { |
| UInt32 offset = 0; |
| if (voaEntryOffset != ExpOffsetMax) |
| { |
| if ( SQLMX_ALIGNED_FORMAT == tdf ) |
| { |
| offset = ((ExpAlignedFormat *)dataPtr)->getVoaEntry( voaEntryOffset ); |
| } |
| else |
| { |
| offset = *(UInt32 *)(dataPtr + voaEntryOffset); |
| } |
| } |
| return offset; |
| } |
| |
| static |
| UInt32 getVoaOffset( char *dataPtr, |
| UInt32 voaEntryOffset, |
| Int32 voaSize ) |
| { |
| UInt32 offset = 0; |
| |
| if (voaSize == ExpVoaSize) // non-aligned format |
| { |
| offset = *(UInt32 *)(dataPtr + voaEntryOffset); |
| } |
| else |
| { |
| offset = (UInt32)((ExpAlignedFormat *)dataPtr)->getVoaEntry( voaEntryOffset ); |
| } |
| |
| return offset; |
| } |
| |
| UInt32 getVoaOffset( char * dataPtr, |
| UInt32 voaEntryOffset ) |
| { |
| return ExpTupleDesc::getVoaOffset( dataPtr, |
| voaEntryOffset, |
| getTupleDataFormat() ); |
| } |
| |
| // Return the offset to the start of the variable field, |
| // i.e., at the start of the vcIndLen. |
| // If the offset is -1, it must read the offset from the voa entry |
| static |
| UInt32 getVarOffset( char * dataPtr, |
| UInt32 offset, |
| UInt32 voaEntryOffset, |
| UInt32 vcIndLen, |
| UInt32 nullIndLen |
| ) |
| { |
| UInt32 varLenIndOffset; |
| |
| if (offset == ExpOffsetMax) |
| { |
| // indirect varchar |
| varLenIndOffset = getVoaOffset( dataPtr, voaEntryOffset, vcIndLen ) |
| + nullIndLen; |
| } |
| else |
| { |
| // offset is valid, go back vcIndLen bytes |
| varLenIndOffset = offset - vcIndLen; |
| } |
| |
| return varLenIndOffset; |
| } |
| |
| // Compute the target varchar offset. |
| // For tgt in disk format, compute offset based on loop variable. |
| // Update the VOA entry. |
| static |
| Int32 getTgtVarOffset( char *dataPtr, |
| Int32 offset, |
| Int32 voaEntryOffset, |
| UInt32 vcIndLen, |
| UInt32 nullIndLen, |
| Int32 &varOffset, |
| UInt32 len) |
| { |
| char *tgt = dataPtr; |
| Int32 tgtOffset = offset; |
| |
| if (voaEntryOffset > 0) // disk format |
| { |
| if ( tgtOffset >= 0 ) // If tgtOffset is valid ... use it. |
| { |
| tgtOffset -= vcIndLen; |
| if ( voaEntryOffset >= 0 ) // if first varchar, setup loop variable? |
| varOffset = tgtOffset - nullIndLen; |
| } |
| else // indirect varchar, get offset from loop variable. |
| tgtOffset = varOffset + nullIndLen; // skip over the null indicator len |
| |
| setVoaValue(tgt, voaEntryOffset, varOffset, (UInt32)vcIndLen); |
| |
| varOffset += len + nullIndLen + vcIndLen; |
| } |
| else |
| { |
| tgtOffset -= vcIndLen; |
| } |
| |
| return tgtOffset; |
| } |
| |
| static |
| UInt32 getVarLength( char * dataPtr, |
| Int32 vcIndLen ) |
| { |
| UInt32 varLen = 0; |
| |
| if (vcIndLen == sizeof(Int16)) |
| varLen = read2(dataPtr); |
| else |
| varLen = read4(dataPtr); |
| |
| return varLen; |
| } |
| |
| static void setVarLength( char * dataPtr, |
| UInt32 varLength, |
| Int32 vcIndLen ) |
| { |
| if (vcIndLen == sizeof(Int16)) |
| write2(dataPtr, (UInt16)varLength); |
| else |
| write4(dataPtr, varLength); |
| } |
| |
| // Return the number of bytes used to store the length for variable fields |
| static Int32 getVarLenBytes( TupleDataFormat tdf ) |
| { |
| return( tdf == SQLMX_FORMAT |
| ? ExpTupleDesc::SQLMX_VC_ACTUAL_LENGTH |
| : ( tdf == SQLMX_ALIGNED_FORMAT |
| ? (Int32) ExpAlignedFormat::VARIABLE_LEN_SIZE |
| : (Int32) ExpTupleDesc::VC_ACTUAL_LENGTH ) ); |
| } |
| |
| // Return the number of bytes used to store the null indicator based on |
| // the tuple data format. |
| static Int32 getNullIndBytes(TupleDataFormat tdf) |
| { |
| return( tdf == SQLMX_ALIGNED_FORMAT |
| ? (Int32) ExpAlignedFormat::NULL_IND_SIZE |
| : (Int32) ExpTupleDesc::NULL_INDICATOR_LENGTH ); |
| } |
| |
| static |
| UInt32 getVarLength( char * dataPtr, TupleDataFormat tdf ) |
| { |
| if (tdf == ExpTupleDesc::SQLMX_ALIGNED_FORMAT || |
| tdf == ExpTupleDesc::SQLARK_EXPLODED_FORMAT) |
| return getVarLength(dataPtr, sizeof(Int16)); |
| else |
| return getVarLength(dataPtr, sizeof(Int32)); |
| } |
| |
| TupleDataFormat getTupleDataFormat() |
| { return (TupleDataFormat)tupleDataFormat_; } |
| |
| static NABoolean isDiskFormat(TupleDataFormat tdf ) |
| { |
| return ( ((tdf == SQLMX_ALIGNED_FORMAT) || (tdf == SQLMX_FORMAT)) |
| ? TRUE : FALSE ); |
| } |
| |
| static NABoolean isAlignedFormat(TupleDataFormat tdf) |
| { return ( SQLMX_ALIGNED_FORMAT == tdf ); } |
| |
| static NABoolean isHeaderClauseNeeded( TupleDataFormat tdf ) |
| { |
| return ( tdf == SQLMX_ALIGNED_FORMAT ); |
| } |
| |
| |
| void display(const char* title = NULL); |
| |
| // --------------------------------------------------------------------- |
| // Redefinition of methods inherited from NAVersionedObject. |
| // --------------------------------------------------------------------- |
| virtual unsigned char getClassVersionID() |
| { |
| return 1; |
| } |
| |
| virtual void populateImageVersionIDArray() |
| { |
| setImageVersionID(0,getClassVersionID()); |
| } |
| |
| virtual Int16 getClassSize() { return (Int16)sizeof(*this); } |
| // --------------------------------------------------------------------- |
| |
| }; |
| |
| |
| #endif |
