You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafodion.apache.org by an...@apache.org on 2016/08/02 23:24:37 UTC
[05/10] incubator-trafodion git commit: metadata access performance
improvement for accessing traf objects
http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/19c96b1e/core/sql/optimizer/NATable.cpp
----------------------------------------------------------------------
diff --git a/core/sql/optimizer/NATable.cpp b/core/sql/optimizer/NATable.cpp
index 098e514..eb68a51 100644
--- a/core/sql/optimizer/NATable.cpp
+++ b/core/sql/optimizer/NATable.cpp
@@ -45,7 +45,6 @@
#include "NATable.h"
#include "Sqlcomp.h"
#include "Const.h"
-#include "desc.h"
#include "dfs2rec.h"
#include "hs_read.h"
#include "parser.h"
@@ -84,6 +83,7 @@
#include "ComUser.h"
#include "ComSmallDefs.h"
#include "CmpMain.h"
+#include "TrafDDLdesc.h"
#define MAX_NODE_NAME 9
#define MAX_PRECISION_ALLOWED 18
@@ -96,7 +96,7 @@
#include "SqlParserGlobals.h"
-extern desc_struct *generateSpecialDesc(const CorrName& corrName);
+extern TrafDesc *generateSpecialDesc(const CorrName& corrName);
#include "CmpMemoryMonitor.h"
@@ -1871,7 +1871,7 @@ NABoolean checkColumnTypeForSupportability(const NAColumnArray & partColArray, c
// -----------------------------------------------------------------------
#pragma nowarn(1506) // warning elimination
static RangePartitionBoundaries * createRangePartitionBoundaries
- (desc_struct * part_desc_list,
+ (TrafDesc * part_desc_list,
Lng32 numberOfPartitions,
const NAColumnArray & partColArray,
NAMemory* heap)
@@ -1883,8 +1883,8 @@ static RangePartitionBoundaries * createRangePartitionBoundaries
// first partition and the last element is the descriptor
// for the last partition, in partitioning key sequence.
// ---------------------------------------------------------------------
- desc_struct * partns_desc = part_desc_list;
- CMPASSERT(partns_desc->body.partns_desc.primarypartition);
+ TrafDesc * partns_desc = part_desc_list;
+ CMPASSERT(partns_desc->partnsDesc()->primarypartition);
// Check all the partitioning keys. If any of them are not
@@ -1893,7 +1893,7 @@ static RangePartitionBoundaries * createRangePartitionBoundaries
// Skip past the primary partition, so that a meaningful first
// key value can be used for the error message.
- char* key = (partns_desc->header.next) ->body.partns_desc.firstkey;
+ char* key = (partns_desc->next) ->partnsDesc()->firstkey;
if ( !checkColumnTypeForSupportability(partColArray, key) )
return NULL;
@@ -1920,14 +1920,14 @@ static RangePartitionBoundaries * createRangePartitionBoundaries
// string in the SMD.
// NOTE: The RangePartitionBoundaries is 0 based.
// ---------------------------------------------------------------------
- partns_desc = partns_desc->header.next; // skip the primary partition
+ partns_desc = partns_desc->next; // skip the primary partition
Lng32 counter = 1;
char* encodedKey;
while (partns_desc AND (counter < numberOfPartitions))
{
- encodedKey = partns_desc->body.partns_desc.encodedkey;
- size_t encodedKeyLen = partns_desc->body.partns_desc.encodedkeylen;
+ encodedKey = partns_desc->partnsDesc()->encodedkey;
+ size_t encodedKeyLen = partns_desc->partnsDesc()->encodedkeylen;
if(heap != CmpCommon::statementHeap())
{
@@ -1938,19 +1938,19 @@ static RangePartitionBoundaries * createRangePartitionBoundaries
//to make it "\0\0".
encodedKey = new(heap) char [encodedKeyLen+2];
encodedKey[encodedKeyLen] = encodedKey[encodedKeyLen+1] = '\0';
- str_cpy_all(encodedKey, partns_desc->body.partns_desc.encodedkey,
+ str_cpy_all(encodedKey, partns_desc->partnsDesc()->encodedkey,
encodedKeyLen);
}
ItemExpr *rangePartBoundValues = NULL;
- if (partns_desc->body.partns_desc.firstkey)
+ if (partns_desc->partnsDesc()->firstkey)
// Extract and parse the partition boundary values, producing an
// ItemExprList of the boundary values.
//
rangePartBoundValues = getRangePartitionBoundaryValues(
- partns_desc->body.partns_desc.firstkey,
- partns_desc->body.partns_desc.firstkeylen,
+ partns_desc->partnsDesc()->firstkey,
+ partns_desc->partnsDesc()->firstkeylen,
heap);
else
rangePartBoundValues = getRangePartitionBoundaryValuesFromEncodedKeys(
@@ -1980,7 +1980,7 @@ static RangePartitionBoundaries * createRangePartitionBoundaries
// ERROR 1123 Unable to process the partition key values...
*CmpCommon::diags()
<< DgSqlCode(-1123)
- << DgString0(partns_desc->body.partns_desc.firstkey)
+ << DgString0(partns_desc->partnsDesc()->firstkey)
<< DgTableName(tableName);
delete partBounds;
//coverity[leaked_storage]
@@ -1992,7 +1992,7 @@ static RangePartitionBoundaries * createRangePartitionBoundaries
rangePartBoundValues,
encodedKey);
- partns_desc = partns_desc->header.next;
+ partns_desc = partns_desc->next;
} // end while (partns_desc)
// ---------------------------------------------------------------------
@@ -2016,7 +2016,7 @@ static RangePartitionBoundaries * createRangePartitionBoundaries
// This method is used for creating a rangePartitioningFunction.
// -----------------------------------------------------------------------
static PartitioningFunction * createRangePartitioningFunction
- (desc_struct * part_desc_list,
+ (TrafDesc * part_desc_list,
const NAColumnArray & partKeyColArray,
NodeMap* nodeMap,
NAMemory* heap)
@@ -2024,12 +2024,12 @@ static PartitioningFunction * createRangePartitioningFunction
// ---------------------------------------------------------------------
// Compute the number of partitions.
// ---------------------------------------------------------------------
- desc_struct * partns_desc = part_desc_list;
+ TrafDesc * partns_desc = part_desc_list;
Lng32 numberOfPartitions = 0;
while (partns_desc)
{
numberOfPartitions++;
- partns_desc = partns_desc->header.next;
+ partns_desc = partns_desc->next;
}
// ---------------------------------------------------------------------
@@ -2078,19 +2078,19 @@ static PartitioningFunction * createRangePartitioningFunction
// -----------------------------------------------------------------------
// LCOV_EXCL_START :cnu
static PartitioningFunction * createRoundRobinPartitioningFunction
- (desc_struct * part_desc_list,
+ (TrafDesc * part_desc_list,
NodeMap* nodeMap,
NAMemory* heap)
{
// ---------------------------------------------------------------------
// Compute the number of partitions.
// ---------------------------------------------------------------------
- desc_struct * partns_desc = part_desc_list;
+ TrafDesc * partns_desc = part_desc_list;
Lng32 numberOfPartitions = 0;
while (partns_desc)
{
numberOfPartitions++;
- partns_desc = partns_desc->header.next;
+ partns_desc = partns_desc->next;
}
// ---------------------------------------------------------------------
@@ -2115,7 +2115,7 @@ static PartitioningFunction * createRoundRobinPartitioningFunction
// This method is used for creating a HashDistPartitioningFunction.
// -----------------------------------------------------------------------
static PartitioningFunction * createHashDistPartitioningFunction
- (desc_struct * part_desc_list,
+ (TrafDesc * part_desc_list,
const NAColumnArray & partKeyColArray,
NodeMap* nodeMap,
NAMemory* heap)
@@ -2123,12 +2123,12 @@ static PartitioningFunction * createHashDistPartitioningFunction
// ---------------------------------------------------------------------
// Compute the number of partitions.
// ---------------------------------------------------------------------
- desc_struct * partns_desc = part_desc_list;
+ TrafDesc * partns_desc = part_desc_list;
Lng32 numberOfPartitions = 0;
while (partns_desc)
{
numberOfPartitions++;
- partns_desc = partns_desc->header.next;
+ partns_desc = partns_desc->next;
}
// ---------------------------------------------------------------------
@@ -2148,7 +2148,7 @@ static PartitioningFunction * createHashDistPartitioningFunction
// This method is used for creating a Hash2PartitioningFunction.
// -----------------------------------------------------------------------
static PartitioningFunction * createHash2PartitioningFunction
- (desc_struct * part_desc_list,
+ (TrafDesc * part_desc_list,
const NAColumnArray & partKeyColArray,
NodeMap* nodeMap,
NAMemory* heap)
@@ -2156,12 +2156,12 @@ static PartitioningFunction * createHash2PartitioningFunction
// ---------------------------------------------------------------------
// Compute the number of partitions.
// ---------------------------------------------------------------------
- desc_struct * partns_desc = part_desc_list;
+ TrafDesc * partns_desc = part_desc_list;
Lng32 numberOfPartitions = 0;
while (partns_desc)
{
numberOfPartitions++;
- partns_desc = partns_desc->header.next;
+ partns_desc = partns_desc->next;
}
// ---------------------------------------------------------------------
@@ -2195,16 +2195,16 @@ static PartitioningFunction * createHash2PartitioningFunction
static
-NodeMap* createNodeMapForHbase(desc_struct* desc, const NATable* table,
+NodeMap* createNodeMapForHbase(TrafDesc* desc, const NATable* table,
int numSaltBuckets, NAMemory* heap)
{
Int32 partns = 0;
Int32 numRegions = 0;
- desc_struct* hrk = desc;
+ TrafDesc* hrk = desc;
while ( hrk ) {
numRegions++;
- hrk=hrk->header.next;
+ hrk=hrk->next;
}
if (numSaltBuckets <= 1)
@@ -2240,13 +2240,13 @@ NodeMap* createNodeMapForHbase(desc_struct* desc, const NATable* table,
static
PartitioningFunction*
-createHash2PartitioningFunctionForHBase(desc_struct* desc,
+createHash2PartitioningFunctionForHBase(TrafDesc* desc,
const NATable * table,
int numSaltBuckets,
NAMemory* heap)
{
- desc_struct* hrk = desc;
+ TrafDesc* hrk = desc;
NodeMap* nodeMap = createNodeMapForHbase(desc, table, numSaltBuckets, heap);
@@ -2479,23 +2479,23 @@ createRangePartitioningFunctionForSingleRegionHBase(
}
- struct desc_struct* head = NULL;
- struct desc_struct* tail = NULL;
+ struct TrafDesc* head = NULL;
+ struct TrafDesc* tail = NULL;
Int32 i=0;
for ( i=0; i<regionsToFake; i++ ) {
if ( tail == NULL ) {
- head = tail = new (heap) struct desc_struct;
+ head = tail = new (heap) TrafPartnsDesc();
// to satisfy createRangePartitionBoundaries() in NATable.cpp
- tail->body.partns_desc.primarypartition = 1;
+ tail->partnsDesc()->primarypartition = 1;
} else {
- tail->header.next = new (heap) struct desc_struct;
- tail = tail->header.next;
+ tail->next = new (heap) TrafPartnsDesc();
+ tail = tail->next;
}
- tail->header.next = NULL;
+ tail->next = NULL;
NAString firstkey('(');
for ( Int32 i=0; i<keys; i++ ) {
@@ -2523,14 +2523,14 @@ createRangePartitioningFunctionForSingleRegionHBase(
Int32 len = firstkey.length();
- tail->body.partns_desc.firstkeylen = len;
- tail->body.partns_desc.firstkey = new (heap) char[len];
- memcpy(tail->body.partns_desc.firstkey, firstkey.data(), len);
+ tail->partnsDesc()->firstkeylen = len;
+ tail->partnsDesc()->firstkey = new (heap) char[len];
+ memcpy(tail->partnsDesc()->firstkey, firstkey.data(), len);
// For now, assume firstkey == encodedkey
- tail->body.partns_desc.encodedkeylen = len;
- tail->body.partns_desc.encodedkey = new (heap) char[len];
- memcpy(tail->body.partns_desc.encodedkey, firstkey.data(), len);
+ tail->partnsDesc()->encodedkeylen = len;
+ tail->partnsDesc()->encodedkey = new (heap) char[len];
+ memcpy(tail->partnsDesc()->encodedkey, firstkey.data(), len);
}
@@ -2543,43 +2543,43 @@ createRangePartitioningFunctionForSingleRegionHBase(
}
void
-populatePartnDescOnEncodingKey( struct desc_struct* prevEndKey,
- struct desc_struct* tail,
- struct desc_struct* hrk,
+populatePartnDescOnEncodingKey( struct TrafDesc* prevEndKey,
+ struct TrafDesc* tail,
+ struct TrafDesc* hrk,
NAMemory* heap)
{
if (!prevEndKey) {
// the start key of the first partitions has all zeroes in it
- Int32 len = hrk->body.hbase_region_desc.endKeyLen;
+ Int32 len = hrk->hbaseRegionDesc()->endKeyLen;
- tail->body.partns_desc.encodedkeylen = len;
- tail->body.partns_desc.encodedkey = new (heap) char[len];
- memset(tail->body.partns_desc.encodedkey, 0, len);
+ tail->partnsDesc()->encodedkeylen = len;
+ tail->partnsDesc()->encodedkey = new (heap) char[len];
+ memset(tail->partnsDesc()->encodedkey, 0, len);
}
else {
// the beginning key of this partition is the end key of
// the previous one
// (HBase returns end keys, we need begin keys here)
- Int32 len = prevEndKey->body.hbase_region_desc.endKeyLen;
+ Int32 len = prevEndKey->hbaseRegionDesc()->endKeyLen;
// For HBase regions, we don't have the text representation
// (value, value, ... value) of the boundary, just the encoded
// key.
- tail->body.partns_desc.encodedkeylen = len;
- tail->body.partns_desc.encodedkey = new (heap) char[len];
- memcpy(tail->body.partns_desc.encodedkey,
- prevEndKey->body.hbase_region_desc.endKey, len);
+ tail->partnsDesc()->encodedkeylen = len;
+ tail->partnsDesc()->encodedkey = new (heap) char[len];
+ memcpy(tail->partnsDesc()->encodedkey,
+ prevEndKey->hbaseRegionDesc()->endKey, len);
}
}
void
-populatePartnDescOnFirstKey( struct desc_struct* ,
- struct desc_struct* tail,
- struct desc_struct* hrk,
+populatePartnDescOnFirstKey( struct TrafDesc* ,
+ struct TrafDesc* tail,
+ struct TrafDesc* hrk,
NAMemory* heap)
{
- char* buf = hrk->body.hbase_region_desc.beginKey;
- Int32 len = hrk->body.hbase_region_desc.beginKeyLen;
+ char* buf = hrk->hbaseRegionDesc()->beginKey;
+ Int32 len = hrk->hbaseRegionDesc()->beginKeyLen;
NAString firstkey('(');
firstkey.append('\'');
@@ -2588,51 +2588,49 @@ populatePartnDescOnFirstKey( struct desc_struct* ,
firstkey.append(')');
Int32 keyLen = firstkey.length();
- tail->body.partns_desc.firstkeylen = keyLen;
- tail->body.partns_desc.firstkey = new (heap) char[keyLen];
- memcpy(tail->body.partns_desc.firstkey, firstkey.data(), keyLen);
+ tail->partnsDesc()->firstkeylen = keyLen;
+ tail->partnsDesc()->firstkey = new (heap) char[keyLen];
+ memcpy(tail->partnsDesc()->firstkey, firstkey.data(), keyLen);
- tail->body.partns_desc.encodedkeylen = keyLen;
- tail->body.partns_desc.encodedkey = new (heap) char[keyLen];
- memcpy(tail->body.partns_desc.encodedkey, firstkey.data(), keyLen);
+ tail->partnsDesc()->encodedkeylen = keyLen;
+ tail->partnsDesc()->encodedkey = new (heap) char[keyLen];
+ memcpy(tail->partnsDesc()->encodedkey, firstkey.data(), keyLen);
}
-typedef void (*populatePartnDescT)( struct desc_struct* prevEndKey,
- struct desc_struct* tail,
- struct desc_struct* hrk,
+typedef void (*populatePartnDescT)( struct TrafDesc* prevEndKey,
+ struct TrafDesc* tail,
+ struct TrafDesc* hrk,
NAMemory* heap);
-static struct desc_struct*
-convertRangeDescToPartnsDesc(desc_struct* desc, populatePartnDescT funcPtr, NAMemory* heap)
+static struct TrafDesc*
+convertRangeDescToPartnsDesc(TrafDesc* desc, populatePartnDescT funcPtr, NAMemory* heap)
{
- desc_struct* hrk = desc;
- desc_struct* prevEndKey = NULL;
+ TrafDesc* hrk = desc;
+ TrafDesc* prevEndKey = NULL;
- struct desc_struct* head = NULL;
- struct desc_struct* tail = NULL;
+ struct TrafDesc* head = NULL;
+ struct TrafDesc* tail = NULL;
Int32 i=0;
while ( hrk ) {
- struct desc_struct *newNode = new (heap) struct desc_struct;
- memset(&newNode->header, 0, sizeof(newNode->header));
- memset(&newNode->body.partns_desc, 0, sizeof(tail->body.partns_desc));
- newNode->header.nodetype = DESC_PARTNS_TYPE;
+ struct TrafDesc *newNode =
+ TrafAllocateDDLdesc(DESC_PARTNS_TYPE, NULL);
if ( tail == NULL ) {
head = tail = newNode;
// to satisfy createRangePartitionBoundaries() in NATable.cpp
- tail->body.partns_desc.primarypartition = 1;
+ tail->partnsDesc()->primarypartition = 1;
} else {
- tail->header.next = newNode;
- tail = tail->header.next;
+ tail->next = newNode;
+ tail = tail->next;
}
(*funcPtr)(prevEndKey, tail, hrk, heap);
prevEndKey = hrk;
- hrk = hrk->header.next;
+ hrk = hrk->next;
}
return head;
@@ -2642,14 +2640,14 @@ convertRangeDescToPartnsDesc(desc_struct* desc, populatePartnDescT funcPtr, NAMe
static
PartitioningFunction*
createRangePartitioningFunctionForMultiRegionHBase(Int32 partns,
- desc_struct* desc,
+ TrafDesc* desc,
const NATable* table,
const NAColumnArray & partKeyColArray,
NAMemory* heap)
{
NodeMap* nodeMap = createNodeMapForHbase(desc, table, -1, heap);
- struct desc_struct*
+ struct TrafDesc*
partns_desc = ( table->isHbaseCellTable() || table->isHbaseRowTable()) ?
convertRangeDescToPartnsDesc(desc, populatePartnDescOnFirstKey, heap)
:
@@ -2663,13 +2661,13 @@ createRangePartitioningFunctionForMultiRegionHBase(Int32 partns,
heap);
}
-Int32 findDescEntries(desc_struct* desc)
+Int32 findDescEntries(TrafDesc* desc)
{
Int32 partns = 0;
- desc_struct* hrk = desc;
+ TrafDesc* hrk = desc;
while ( hrk ) {
partns++;
- hrk = hrk->header.next;
+ hrk = hrk->next;
}
return partns;
}
@@ -2680,7 +2678,7 @@ Int32 findDescEntries(desc_struct* desc)
//
static
PartitioningFunction*
-createRangePartitioningFunctionForHBase(desc_struct* desc,
+createRangePartitioningFunctionForHBase(TrafDesc* desc,
const NATable* table,
const NAColumnArray & partKeyColArray,
NAMemory* heap)
@@ -2723,7 +2721,7 @@ static PartitioningFunction * createHivePartitioningFunction
// associated with this table or index.
// -----------------------------------------------------------------------
#pragma nowarn(1506) // warning elimination
-static void createNodeMap (desc_struct* part_desc_list,
+static void createNodeMap (TrafDesc* part_desc_list,
NodeMap* nodeMap,
NAMemory* heap,
char * tableName,
@@ -2733,7 +2731,7 @@ static void createNodeMap (desc_struct* part_desc_list,
// Loop over all partitions creating a DP2 node map entry for each
// partition.
// ---------------------------------------------------------------------
- desc_struct* partns_desc = part_desc_list;
+ TrafDesc* partns_desc = part_desc_list;
CollIndex currentPartition = 0;
if(NOT partns_desc)
{
@@ -2744,11 +2742,11 @@ static void createNodeMap (desc_struct* part_desc_list,
else{
while (partns_desc)
{
- NodeMapEntry entry(partns_desc->body.partns_desc.partitionname,
- partns_desc->body.partns_desc.givenname,
+ NodeMapEntry entry(partns_desc->partnsDesc()->partitionname,
+ partns_desc->partnsDesc()->givenname,
heap,tableIdent);
nodeMap->setNodeMapEntry(currentPartition,entry,heap);
- partns_desc = partns_desc->header.next;
+ partns_desc = partns_desc->next;
currentPartition++;
}
}
@@ -2887,7 +2885,7 @@ static void createNodeMap (hive_tbl_desc* hvt_desc,
// on the local node.
//-------------------------------------------------------------------------
#pragma nowarn(262) // warning elimination
-static NABoolean checkRemote(desc_struct* part_desc_list,
+static NABoolean checkRemote(TrafDesc* part_desc_list,
char * tableName)
{
return TRUE;
@@ -2895,19 +2893,17 @@ static NABoolean checkRemote(desc_struct* part_desc_list,
#pragma warn(262) // warning elimination
-// warning elimination (removed "inline")
static NAString makeTableName(const NATable *table,
- const columns_desc_struct *column_desc)
+ const TrafColumnsDesc *column_desc)
{
return NAString(
- table ?
- table->getTableName().getQualifiedNameAsAnsiString().data() :
- column_desc->tablename ?
- column_desc->tablename : "");
+ table ?
+ table->getTableName().getQualifiedNameAsAnsiString().data() : "");
}
+
// warning elimination (removed "inline")
static NAString makeColumnName(const NATable *table,
- const columns_desc_struct *column_desc)
+ const TrafColumnsDesc *column_desc)
{
NAString nam(makeTableName(table, column_desc));
if (!nam.isNull()) nam += ".";
@@ -2916,9 +2912,9 @@ static NAString makeColumnName(const NATable *table,
}
// -----------------------------------------------------------------------
-// Method for creating NAType from desc_struct.
+// Method for creating NAType from TrafDesc.
// -----------------------------------------------------------------------
-NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
+NABoolean createNAType(TrafColumnsDesc *column_desc /*IN*/,
const NATable *table /*IN*/,
NAType *&type /*OUT*/,
NAMemory *heap /*IN*/,
@@ -2930,7 +2926,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
//
#define REC_INTERVAL REC_MIN_INTERVAL
- DataType datatype = column_desc->datatype;
+ Int16 datatype = column_desc->datatype;
if (REC_MIN_INTERVAL <= datatype && datatype <= REC_MAX_INTERVAL)
datatype = REC_INTERVAL;
@@ -2938,7 +2934,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
if ( DFS2REC::isAnyCharacter(column_desc->datatype) )
{
- if ( CharInfo::isCharSetSupported(column_desc->character_set) == FALSE ) {
+ if ( CharInfo::isCharSetSupported(column_desc->characterSet()) == FALSE ) {
if (!errorCode)
{
*CmpCommon::diags() << DgSqlCode(-4082)
@@ -2951,7 +2947,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
return TRUE; // error
}
- if ( CharInfo::is_NCHAR_MP(column_desc->character_set) )
+ if ( CharInfo::is_NCHAR_MP(column_desc->characterSet()) )
charCount /= SQL_DBCHAR_SIZE;
}
@@ -2960,7 +2956,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
case REC_BPINT_UNSIGNED :
type = new (heap)
- SQLBPInt(column_desc->precision, column_desc->null_flag, FALSE, heap);
+ SQLBPInt(column_desc->precision, column_desc->isNullable(), FALSE, heap);
break;
case REC_BIN8_SIGNED:
@@ -2970,13 +2966,13 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->precision,
column_desc->scale,
TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
else
type = new (heap)
SQLTiny(TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -2987,13 +2983,13 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->precision,
column_desc->scale,
FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
else
type = new (heap)
SQLTiny(FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3005,13 +3001,13 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->precision,
column_desc->scale,
TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
else
type = new (heap)
SQLSmall(TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3022,13 +3018,13 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->precision,
column_desc->scale,
FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
else
type = new (heap)
SQLSmall(FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3040,13 +3036,13 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->precision,
column_desc->scale,
TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
else
type = new (heap)
SQLInt(TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3057,13 +3053,13 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->precision,
column_desc->scale,
FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
else
type = new (heap)
SQLInt(FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3074,13 +3070,13 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->precision,
column_desc->scale,
TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
else
type = new (heap)
SQLLargeInt(TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3091,13 +3087,13 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->precision,
column_desc->scale,
FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
else
type = new (heap)
SQLLargeInt(FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3106,7 +3102,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
SQLDecimal(column_desc->length,
column_desc->scale,
FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3115,7 +3111,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
SQLDecimal(column_desc->length,
column_desc->scale,
TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3125,7 +3121,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->scale,
TRUE, // is a real bignum
FALSE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
@@ -3135,65 +3131,65 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
column_desc->scale,
TRUE, // is a real bignum
TRUE,
- column_desc->null_flag,
+ column_desc->isNullable(),
heap
);
break;
case REC_FLOAT32:
type = new (heap)
- SQLReal(column_desc->null_flag, heap, column_desc->precision);
+ SQLReal(column_desc->isNullable(), heap, column_desc->precision);
break;
case REC_FLOAT64:
type = new (heap)
- SQLDoublePrecision(column_desc->null_flag, heap, column_desc->precision);
+ SQLDoublePrecision(column_desc->isNullable(), heap, column_desc->precision);
break;
case REC_BYTE_F_DOUBLE:
charCount /= SQL_DBCHAR_SIZE; // divide the storage length by 2
type = new (heap)
SQLChar(charCount,
- column_desc->null_flag,
- column_desc->upshift,
- column_desc->caseinsensitive,
+ column_desc->isNullable(),
+ column_desc->isUpshifted(),
+ column_desc->isCaseInsensitive(),
FALSE,
- column_desc->character_set,
- column_desc->collation_sequence,
+ column_desc->characterSet(),
+ column_desc->collationSequence(),
CharInfo::IMPLICIT
);
break;
case REC_BYTE_F_ASCII:
- if (column_desc->character_set == CharInfo::UTF8 ||
- (column_desc->character_set == CharInfo::SJIS &&
+ if (column_desc->characterSet() == CharInfo::UTF8 ||
+ (column_desc->characterSet() == CharInfo::SJIS &&
column_desc->encoding_charset == CharInfo::SJIS))
{
- Lng32 maxBytesPerChar = CharInfo::maxBytesPerChar(column_desc->character_set);
+ Lng32 maxBytesPerChar = CharInfo::maxBytesPerChar(column_desc->characterSet());
Lng32 sizeInChars = charCount ; // Applies when CharLenUnit == BYTES
if ( column_desc->precision > 0 )
sizeInChars = column_desc->precision;
type = new (heap)
SQLChar(CharLenInfo(sizeInChars, charCount/*in_bytes*/),
- column_desc->null_flag,
- column_desc->upshift,
- column_desc->caseinsensitive,
+ column_desc->isNullable(),
+ column_desc->isUpshifted(),
+ column_desc->isCaseInsensitive(),
FALSE, // varLenFlag
- column_desc->character_set,
- column_desc->collation_sequence,
+ column_desc->characterSet(),
+ column_desc->collationSequence(),
CharInfo::IMPLICIT, // Coercibility
- column_desc->encoding_charset
+ column_desc->encodingCharset()
);
}
else // keep the old behavior
type = new (heap)
SQLChar(charCount,
- column_desc->null_flag,
- column_desc->upshift,
- column_desc->caseinsensitive,
+ column_desc->isNullable(),
+ column_desc->isUpshifted(),
+ column_desc->isCaseInsensitive(),
FALSE,
- column_desc->character_set,
- column_desc->collation_sequence,
+ column_desc->characterSet(),
+ column_desc->collationSequence(),
CharInfo::IMPLICIT
);
break;
@@ -3202,32 +3198,32 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
charCount /= SQL_DBCHAR_SIZE; // divide the storage length by 2
// fall thru
case REC_BYTE_V_ASCII:
- if (column_desc->character_set == CharInfo::SJIS ||
- column_desc->character_set == CharInfo::UTF8)
+ if (column_desc->characterSet() == CharInfo::SJIS ||
+ column_desc->characterSet() == CharInfo::UTF8)
{
- Lng32 maxBytesPerChar = CharInfo::maxBytesPerChar(column_desc->character_set);
+ Lng32 maxBytesPerChar = CharInfo::maxBytesPerChar(column_desc->characterSet());
Lng32 sizeInChars = charCount ; // Applies when CharLenUnit == BYTES
if ( column_desc->precision > 0 )
sizeInChars = column_desc->precision;
type = new (heap)
SQLVarChar(CharLenInfo(sizeInChars, charCount/*in_bytes*/),
- column_desc->null_flag,
- column_desc->upshift,
- column_desc->caseinsensitive,
- column_desc->character_set,
- column_desc->collation_sequence,
+ column_desc->isNullable(),
+ column_desc->isUpshifted(),
+ column_desc->isCaseInsensitive(),
+ column_desc->characterSet(),
+ column_desc->collationSequence(),
CharInfo::IMPLICIT, // Coercibility
- column_desc->encoding_charset
+ column_desc->encodingCharset()
);
}
else // keep the old behavior
type = new (heap)
SQLVarChar(charCount,
- column_desc->null_flag,
- column_desc->upshift,
- column_desc->caseinsensitive,
- column_desc->character_set,
- column_desc->collation_sequence,
+ column_desc->isNullable(),
+ column_desc->isUpshifted(),
+ column_desc->isCaseInsensitive(),
+ column_desc->characterSet(),
+ column_desc->collationSequence(),
CharInfo::IMPLICIT
);
break;
@@ -3236,33 +3232,33 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
type = new (heap)
SQLLongVarChar(charCount,
FALSE,
- column_desc->null_flag,
- column_desc->upshift,
- column_desc->caseinsensitive,
- column_desc->character_set,
- column_desc->collation_sequence,
+ column_desc->isNullable(),
+ column_desc->isUpshifted(),
+ column_desc->isCaseInsensitive(),
+ column_desc->characterSet(),
+ column_desc->collationSequence(),
CharInfo::IMPLICIT
);
break;
case REC_DATETIME:
type = DatetimeType::constructSubtype(
- column_desc->null_flag,
- column_desc->datetimestart,
- column_desc->datetimeend,
+ column_desc->isNullable(),
+ column_desc->datetimeStart(),
+ column_desc->datetimeEnd(),
column_desc->datetimefractprec,
heap
);
CMPASSERT(type);
if (!type->isSupportedType())
{
- column_desc->defaultClass = COM_NO_DEFAULT; // can't set a default for these, either.
+ column_desc->setDefaultClass(COM_NO_DEFAULT); // can't set a default for these, either.
// 4030 Column is an unsupported combination of datetime fields
if (!errorCode)
{
*CmpCommon::diags() << DgSqlCode(4030)
<< DgColumnName(makeColumnName(table, column_desc))
- << DgInt0(column_desc->datetimestart)
- << DgInt1(column_desc->datetimeend)
+ << DgInt0(column_desc->datetimeStart())
+ << DgInt1(column_desc->datetimeEnd())
<< DgInt2(column_desc->datetimefractprec);
}
else
@@ -3273,10 +3269,10 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
break;
case REC_INTERVAL:
type = new (heap)
- SQLInterval(column_desc->null_flag,
- column_desc->datetimestart,
+ SQLInterval(column_desc->isNullable(),
+ column_desc->datetimeStart(),
column_desc->intervalleadingprec,
- column_desc->datetimeend,
+ column_desc->datetimeEnd(),
column_desc->datetimefractprec,
heap
);
@@ -3285,7 +3281,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
return TRUE; // error
if (!type->isSupportedType())
{
- column_desc->defaultClass = COM_NO_DEFAULT; // can't set a default for these, either.
+ column_desc->setDefaultClass(COM_NO_DEFAULT); // can't set a default for these, either.
if (!errorCode)
*CmpCommon::diags() << DgSqlCode(3044) << DgString0(column_desc->colname);
else
@@ -3297,18 +3293,18 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
case REC_BLOB :
type = new (heap)
SQLBlob(column_desc->precision,Lob_Invalid_Storage,
- column_desc->null_flag);
+ column_desc->isNullable());
break;
case REC_CLOB :
type = new (heap)
SQLClob(column_desc->precision,Lob_Invalid_Storage,
- column_desc->null_flag);
+ column_desc->isNullable());
break;
case REC_BOOLEAN :
{
- type = new (heap) SQLBooleanNative(column_desc->null_flag);
+ type = new (heap) SQLBooleanNative(column_desc->isNullable());
}
break;
@@ -3393,7 +3389,7 @@ NABoolean createNAType(columns_desc_struct *column_desc /*IN*/,
// one for each column_desc in the list supplied as input.
// -----------------------------------------------------------------------
#pragma nowarn(1506) // warning elimination
-NABoolean createNAColumns(desc_struct *column_desc_list /*IN*/,
+NABoolean createNAColumns(TrafDesc *column_desc_list /*IN*/,
NATable *table /*IN*/,
NAColumnArray &colArray /*OUT*/,
NAMemory *heap /*IN*/)
@@ -3402,7 +3398,7 @@ NABoolean createNAColumns(desc_struct *column_desc_list /*IN*/,
ColumnClass colClass;
while (column_desc_list)
{
- columns_desc_struct * column_desc = &column_desc_list->body.columns_desc;
+ TrafColumnsDesc * column_desc = column_desc_list->columnsDesc();
NABoolean isMvSystemAdded = FALSE;
NABoolean hasSystemColumnAsUserColumn = FALSE;
@@ -3461,7 +3457,7 @@ NABoolean createNAColumns(desc_struct *column_desc_list /*IN*/,
NABoolean isSaltColumn = FALSE;
NABoolean isDivisioningColumn = FALSE;
- if (column_desc->defaultClass == COM_ALWAYS_COMPUTE_COMPUTED_COLUMN_DEFAULT)
+ if (column_desc->defaultClass() == COM_ALWAYS_COMPUTE_COMPUTED_COLUMN_DEFAULT)
{
if (column_desc->colFlags & SEABASE_COLUMN_IS_SALT)
isSaltColumn = TRUE;
@@ -3502,16 +3498,16 @@ NABoolean createNAColumns(desc_struct *column_desc_list /*IN*/,
heap,
table,
colClass,
- column_desc->defaultClass,
+ column_desc->defaultClass(),
defaultValue,
heading,
- column_desc->upshift,
+ column_desc->isUpshifted(),
((column_desc->colclass == 'A') ||
(column_desc->colclass == 'C')),
COM_UNKNOWN_DIRECTION,
FALSE,
NULL,
- column_desc->stored_on_disk,
+ TRUE, // stored on disk
computed_column_text,
isSaltColumn,
isDivisioningColumn,
@@ -3561,7 +3557,7 @@ NABoolean createNAColumns(desc_struct *column_desc_list /*IN*/,
colArray.insert(newColumn);
- column_desc_list = column_desc_list->header.next;
+ column_desc_list = column_desc_list->next;
} // end while
return FALSE; // no error
@@ -3790,7 +3786,7 @@ NABoolean createNAColumns(struct hive_column_desc* hcolumn /*IN*/,
COM_NULL_DEFAULT ,//defaultClass,
(char*)"", // defaultValue,
(char*)"", // heading,
- FALSE, // column_desc->upshift,
+ FALSE, // column_desc->isUpshifted(),
FALSE, // added column
COM_UNKNOWN_DIRECTION,
FALSE, // isOptional
@@ -3821,30 +3817,30 @@ NABoolean createNAColumns(struct hive_column_desc* hcolumn /*IN*/,
-NABoolean createNAKeyColumns(desc_struct *keys_desc_list /*IN*/,
+NABoolean createNAKeyColumns(TrafDesc *keys_desc_list /*IN*/,
NAColumnArray &colArray /*IN*/,
NAColumnArray &keyColArray /*OUT*/,
CollHeap *heap /*IN*/)
{
- const desc_struct *keys_desc = keys_desc_list;
+ const TrafDesc *keys_desc = keys_desc_list;
while (keys_desc)
{
- Int32 tablecolnumber = keys_desc->body.keys_desc.tablecolnumber;
+ Int32 tablecolnumber = keys_desc->keysDesc()->tablecolnumber;
NAColumn *indexColumn = colArray.getColumn(tablecolnumber);
SortOrdering order = NOT_ORDERED;
keyColArray.insert(indexColumn);
- order = keys_desc->body.keys_desc.ordering ? DESCENDING : ASCENDING;
+ order = keys_desc->keysDesc()->isDescending() ? DESCENDING : ASCENDING;
keyColArray.setAscending(keyColArray.entries()-1, order == ASCENDING);
// Remember that this columns is part of the clustering
// key and remember its key ordering (asc or desc)
indexColumn->setClusteringKey(order);
- keys_desc = keys_desc->header.next;
+ keys_desc = keys_desc->next;
} // end while (keys_desc)
return FALSE;
@@ -3893,7 +3889,7 @@ void processDuplicateNames(NAHashDictionaryIterator<NAString, Int32> &Iter,
// -----------------------------------------------------------------------
#pragma nowarn(1506) // warning elimination
static
-NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
+NABoolean createNAFileSets(TrafDesc * table_desc /*IN*/,
const NATable * table /*IN*/,
const NAColumnArray & colArray /*IN*/,
NAFileSetList & indexes /*OUT*/,
@@ -3919,17 +3915,16 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
NAList<NAString *> stringList (CmpCommon::statementHeap());
- desc_struct *indexes_desc = table_desc->body.table_desc.indexes_desc;
+ TrafDesc *indexes_desc = table_desc->tableDesc()->indexes_desc;
- while (indexes_desc AND indexes_desc->body.indexes_desc.keytag)
- indexes_desc = indexes_desc->header.next;
+ while (indexes_desc AND indexes_desc->indexesDesc()->keytag)
+ indexes_desc = indexes_desc->next;
// must have a clustering key if not view
- CMPASSERT((indexes_desc AND !indexes_desc->body.indexes_desc.keytag) OR
- (table_desc->body.table_desc.views_desc));
+ CMPASSERT((indexes_desc AND !indexes_desc->indexesDesc()->keytag) OR
+ (table_desc->tableDesc()->views_desc));
NABoolean isTheClusteringKey = TRUE;
- NABoolean isVerticalPartition;
NABoolean hasRemotePartition = FALSE;
CollIndex numClusteringKeyColumns = 0;
NABoolean tableAlignedRowFormat = table->isSQLMXAlignedTable();
@@ -3988,13 +3983,10 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
NAColumnArray saveNAColumns(CmpCommon::statementHeap());// save NAColums of secondary index columns
NAColumnArray partitioningKeyColumns(CmpCommon::statementHeap());// the partitioning key columns
PartitioningFunction * partFunc = NULL;
- // is this an index or is it really a VP?
- isVerticalPartition = indexes_desc->body.indexes_desc.isVerticalPartition;
- NABoolean isPacked = indexes_desc->body.indexes_desc.isPacked;
- NABoolean indexAlignedRowFormat = (indexes_desc->body.indexes_desc.rowFormat == COM_ALIGNED_FORMAT_TYPE);
+ NABoolean isPacked = FALSE;
+ NABoolean indexAlignedRowFormat = (indexes_desc->indexesDesc()->rowFormat() == COM_ALIGNED_FORMAT_TYPE);
- NABoolean isNotAvailable =
- indexes_desc->body.indexes_desc.notAvailable;
+ NABoolean isNotAvailable = FALSE;
ItemExprList hbaseSaltColumnList(CmpCommon::statementHeap());
Int64 numOfSaltedPartitions = 0;
@@ -4002,7 +3994,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// ---------------------------------------------------------------------
// loop over the clustering key columns of the index
// ---------------------------------------------------------------------
- const desc_struct *keys_desc = indexes_desc->body.indexes_desc.keys_desc;
+ const TrafDesc *keys_desc = indexes_desc->indexesDesc()->keys_desc;
while (keys_desc)
{
// Add an index/VP key column.
@@ -4015,7 +4007,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// key columns used to find the base table record. This is
// true for both SQL/MP and SQL/MX tables at this time.
// To make these assumptions is not optimal, but the
- // desc_structs that are used as input are a historical
+ // TrafDescs that are used as input are a historical
// leftover from SQL/MP and therefore aren't set up very
// well to describe index columns and index keys. Some day
// we might consider a direct conversion from the MX catalog
@@ -4026,17 +4018,17 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// of a unique alternate index (which ARE described in the
// keys_desc) get deleted later.
- Int32 tablecolnumber = keys_desc->body.keys_desc.tablecolnumber;
+ Int32 tablecolnumber = keys_desc->keysDesc()->tablecolnumber;
indexColumn = colArray.getColumn(tablecolnumber);
if ((table->isHbaseTable()) &&
- ((indexes_desc->body.indexes_desc.keytag != 0) ||
+ ((indexes_desc->indexesDesc()->keytag != 0) ||
(indexAlignedRowFormat && indexAlignedRowFormat != tableAlignedRowFormat)))
{
newIndexColumn = new(heap) NAColumn(*indexColumn);
- newIndexColumn->setIndexColName(keys_desc->body.keys_desc.keyname);
- newIndexColumn->setHbaseColFam(keys_desc->body.keys_desc.hbaseColFam);
- newIndexColumn->setHbaseColQual(keys_desc->body.keys_desc.hbaseColQual);
+ newIndexColumn->setIndexColName(keys_desc->keysDesc()->keyname);
+ newIndexColumn->setHbaseColFam(keys_desc->keysDesc()->hbaseColFam);
+ newIndexColumn->setHbaseColQual(keys_desc->keysDesc()->hbaseColQual);
newIndexColumn->resetSerialization();
saveNAColumns.insert(indexColumn);
newColumns.insert(newIndexColumn);
@@ -4050,7 +4042,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// assume at first that all columns are key columns
// and we make adjustments later
indexKeyColumns.insert(indexColumn);
- order = keys_desc->body.keys_desc.ordering ?
+ order = keys_desc->keysDesc()->isDescending() ?
DESCENDING : ASCENDING;
indexKeyColumns.setAscending(indexKeyColumns.entries() - 1,
order == ASCENDING);
@@ -4109,7 +4101,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
allColumns.insert(indexColumn);
}
- keys_desc = keys_desc->header.next;
+ keys_desc = keys_desc->next;
} // end while (keys_desc)
// ---------------------------------------------------------------------
@@ -4117,32 +4109,32 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// These columns get added to the list of all the columns for the index/
// VP. Their length also contributes to the total record length.
// ---------------------------------------------------------------------
- const desc_struct *non_keys_desc =
- indexes_desc->body.indexes_desc.non_keys_desc;
+ const TrafDesc *non_keys_desc =
+ indexes_desc->indexesDesc()->non_keys_desc;
while (non_keys_desc)
{
- Int32 tablecolnumber = non_keys_desc->body.keys_desc.tablecolnumber;
+ Int32 tablecolnumber = non_keys_desc->keysDesc()->tablecolnumber;
indexColumn = colArray.getColumn(tablecolnumber);
if ((table->isHbaseTable()) &&
- ((indexes_desc->body.indexes_desc.keytag != 0) ||
+ ((indexes_desc->indexesDesc()->keytag != 0) ||
(indexAlignedRowFormat && indexAlignedRowFormat != tableAlignedRowFormat)))
{
newIndexColumn = new(heap) NAColumn(*indexColumn);
- if (non_keys_desc->body.keys_desc.keyname)
- newIndexColumn->setIndexColName(non_keys_desc->body.keys_desc.keyname);
- newIndexColumn->setHbaseColFam(non_keys_desc->body.keys_desc.hbaseColFam);
- newIndexColumn->setHbaseColQual(non_keys_desc->body.keys_desc.hbaseColQual);
+ if (non_keys_desc->keysDesc()->keyname)
+ newIndexColumn->setIndexColName(non_keys_desc->keysDesc()->keyname);
+ newIndexColumn->setHbaseColFam(non_keys_desc->keysDesc()->hbaseColFam);
+ newIndexColumn->setHbaseColQual(non_keys_desc->keysDesc()->hbaseColQual);
newIndexColumn->resetSerialization();
indexColumn = newIndexColumn;
newColumns.insert(newIndexColumn);
}
allColumns.insert(indexColumn);
- non_keys_desc = non_keys_desc->header.next;
+ non_keys_desc = non_keys_desc->next;
} // end while (non_keys_desc)
- desc_struct *files_desc;
+ TrafDesc *files_desc;
NABoolean isSystemTable;
if (isTheClusteringKey)
{
@@ -4161,15 +4153,15 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
}
} // end for
- files_desc = table_desc->body.table_desc.files_desc;
- isSystemTable = table_desc->body.table_desc.issystemtablecode;
+ files_desc = table_desc->tableDesc()->files_desc;
+ isSystemTable = table_desc->tableDesc()->isSystemTableCode();
// Record length of clustering key is the same as that of the base table record
- indexes_desc->body.indexes_desc.record_length = table_desc->body.table_desc.record_length;
+ indexes_desc->indexesDesc()->record_length = table_desc->tableDesc()->record_length;
} // endif (isTheClusteringKey)
else
{
- if (indexes_desc->body.indexes_desc.unique)
+ if (indexes_desc->indexesDesc()->isUnique())
{
// As mentioned above, if this is a unique index,
// the last numClusteringKeyColumns are actually not
@@ -4187,8 +4179,8 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// indexKeyColumns.removeAt(indexKeyColumns.entries() - 1);
}
- files_desc = indexes_desc->body.indexes_desc.files_desc;
- isSystemTable = indexes_desc->body.indexes_desc.issystemtablecode;
+ files_desc = indexes_desc->indexesDesc()->files_desc;
+ isSystemTable = indexes_desc->indexesDesc()->isSystemTableCode();
} // endif (NOT isTheClusteringKey)
@@ -4204,9 +4196,10 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// We will ASSUME here that NonStop SQL/MP or the simulator will not
// put anything into partitioning keys desc and only SQL/MX will. So
// we don't have to deal with keytag columns here.
+ //
+ // Partitioning Keys Desc is not set and returned for traf tables.
// -------------------------------------------------------------------
- const desc_struct *partitioning_keys_desc =
- indexes_desc->body.indexes_desc.partitioning_keys_desc;
+ const TrafDesc *partitioning_keys_desc = NULL;
// the key columns that build the salt column for HBase table
NAColumnArray hbaseSaltOnColumns(CmpCommon::statementHeap());
@@ -4217,16 +4210,16 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
while (keys_desc)
{
Int32 tablecolnumber = keys_desc
- ->body.keys_desc.tablecolnumber;
+ ->keysDesc()->tablecolnumber;
indexColumn = colArray.getColumn(tablecolnumber);
partitioningKeyColumns.insert(indexColumn);
SortOrdering order = keys_desc
- ->body.keys_desc.ordering ?
- DESCENDING : ASCENDING;
+ ->keysDesc()->isDescending() ?
+ DESCENDING : ASCENDING;
partitioningKeyColumns.setAscending
(partitioningKeyColumns.entries() - 1,
order == ASCENDING);
- keys_desc = keys_desc->header.next;
+ keys_desc = keys_desc->next;
} // end while (keys_desc)
}
else {
@@ -4254,29 +4247,26 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// NB: Just in case, we made a call to setupClusterInfo at the
// beginning of this function.
- desc_struct * partns_desc;
+ TrafDesc * partns_desc;
Int32 indexLevels = 1;
- Int32 blockSize = indexes_desc->body.indexes_desc.blocksize;
+ Int32 blockSize = indexes_desc->indexesDesc()->blocksize;
if (files_desc)
{
if( (table->getSpecialType() != ExtendedQualName::VIRTUAL_TABLE AND
-/*
- table->getSpecialType() != ExtendedQualName::ISP_TABLE AND
-*/
(NOT table->isHbaseTable()))
- OR files_desc->body.files_desc.partns_desc )
+ OR files_desc->filesDesc()->partns_desc )
{
nodeMap = new (heap) NodeMap(heap);
- createNodeMap(files_desc->body.files_desc.partns_desc,
+ createNodeMap(files_desc->filesDesc()->partns_desc,
nodeMap,
heap,
- table_desc->body.table_desc.tablename,
+ table_desc->tableDesc()->tablename,
cmpCurrentContext->getTableIdent());
tableIdList.insert(CollIndex(cmpCurrentContext->getTableIdent()));
}
// Check whether the index has any remote partitions.
- if (checkRemote(files_desc->body.files_desc.partns_desc,
- indexes_desc->body.indexes_desc.indexname))
+ if (checkRemote(files_desc->filesDesc()->partns_desc,
+ indexes_desc->indexesDesc()->indexname))
hasRemotePartition = TRUE;
else
hasRemotePartition = FALSE;
@@ -4285,12 +4275,12 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// partitioned same as the indexes, hence we used table partitioning
// to create partitionining function. But this is not true. Hence
// we now use the indexes partitioning function
- switch (indexes_desc->body.indexes_desc.partitioningScheme)
+ switch (indexes_desc->indexesDesc()->partitioningScheme())
{
case COM_ROUND_ROBIN_PARTITIONING :
// Round Robin partitioned table
partFunc = createRoundRobinPartitioningFunction(
- files_desc->body.files_desc.partns_desc,
+ files_desc->filesDesc()->partns_desc,
nodeMap,
heap);
break;
@@ -4298,7 +4288,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
case COM_HASH_V1_PARTITIONING :
// Hash partitioned table
partFunc = createHashDistPartitioningFunction(
- files_desc->body.files_desc.partns_desc,
+ files_desc->filesDesc()->partns_desc,
partitioningKeyColumns,
nodeMap,
heap);
@@ -4307,7 +4297,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
case COM_HASH_V2_PARTITIONING :
// Hash partitioned table
partFunc = createHash2PartitioningFunction(
- files_desc->body.files_desc.partns_desc,
+ files_desc->filesDesc()->partns_desc,
partitioningKeyColumns,
nodeMap,
heap);
@@ -4325,8 +4315,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// values as MP Stored Text.
//
- desc_struct* hbd =
- ((table_desc_struct*)table_desc)->hbase_regionkey_desc;
+ TrafDesc* hbd = table_desc->tableDesc()->hbase_regionkey_desc;
// splits will be 1 for single partitioned table.
Int32 splits = findDescEntries(hbd);
@@ -4339,7 +4328,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
if ( hbd )
if ( doHash2 ) {
partFunc = createHash2PartitioningFunctionForHBase(
- ((table_desc_struct*)table_desc)->hbase_regionkey_desc,
+ table_desc->tableDesc()->hbase_regionkey_desc,
table,
numOfSaltedPartitions,
heap);
@@ -4348,15 +4337,15 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
}
else
partFunc = createRangePartitioningFunctionForHBase(
- ((table_desc_struct*)table_desc)->hbase_regionkey_desc,
- table,
- partitioningKeyColumns,
- heap);
+ table_desc->tableDesc()->hbase_regionkey_desc,
+ table,
+ partitioningKeyColumns,
+ heap);
else {
// no region descriptor, range partitioned or single partition table
partFunc = createRangePartitioningFunction(
- files_desc->body.files_desc.partns_desc,
+ files_desc->filesDesc()->partns_desc,
partitioningKeyColumns,
nodeMap,
heap);
@@ -4392,14 +4381,14 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// currently we save the indexLevels in the fileset. Since there
// is a indexLevel for each file that belongs to the fileset,
// we get the biggest of this indexLevels and save in the fileset.
- partns_desc = files_desc->body.files_desc.partns_desc;
+ partns_desc = files_desc->filesDesc()->partns_desc;
if(partns_desc)
{
while (partns_desc)
{
- if ( indexLevels < partns_desc->body.partns_desc.indexlevel)
- indexLevels = partns_desc->body.partns_desc.indexlevel;
- partns_desc = partns_desc->header.next;
+ if ( indexLevels < partns_desc->partnsDesc()->indexlevel)
+ indexLevels = partns_desc->partnsDesc()->indexlevel;
+ partns_desc = partns_desc->next;
}
}
@@ -4415,21 +4404,19 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// Create fully qualified ANSI name from indexname, the PHYSICAL name.
// If this descriptor was created for a sql/mp table, then the
// indexname is a fully qualified NSK name (\sys.$vol.subvol.name).
- QualifiedName qualIndexName(indexes_desc->body.indexes_desc.indexname,
+ QualifiedName qualIndexName(indexes_desc->indexesDesc()->indexname,
1, heap, bindWA);
// This ext_indexname is expected to be set up correctly as an
// EXTERNAL-format name (i.e., dquoted if any delimited identifiers)
// by sqlcat/read*.cpp. The ...AsAnsiString() is just-in-case (MP?).
NAString extIndexName(
- indexes_desc->body.indexes_desc.ext_indexname ?
- (NAString)indexes_desc->body.indexes_desc.ext_indexname :
qualIndexName.getQualifiedNameAsAnsiString(),
CmpCommon::statementHeap());
QualifiedName qualExtIndexName;
- //if (indexes_desc->body.indexes_desc.isVolatile)
+ //if (indexes_desc->indexesDesc()->isVolatile)
if (table->getSpecialType() != ExtendedQualName::VIRTUAL_TABLE)
qualExtIndexName = QualifiedName(extIndexName, 1, heap, bindWA);
else
@@ -4437,7 +4424,7 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
// for volatile tables, set the object part as the external name.
// cat/sch parts are internal and should not be shown.
- if (indexes_desc->body.indexes_desc.isVolatile)
+ if (indexes_desc->indexesDesc()->isVolatile())
{
ComObjectName con(extIndexName);
extIndexName = con.getObjectNamePartAsAnsiString();
@@ -4446,12 +4433,12 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
if (partFunc)
numberOfFiles = partFunc->getCountOfPartitions();
- CMPASSERT(indexes_desc->body.indexes_desc.blocksize > 0);
+ CMPASSERT(indexes_desc->indexesDesc()->blocksize > 0);
NAList<HbaseCreateOption*>* hbaseCreateOptions = NULL;
- if ((indexes_desc->body.indexes_desc.hbaseCreateOptions) &&
+ if ((indexes_desc->indexesDesc()->hbaseCreateOptions) &&
(CmpSeabaseDDL::genHbaseCreateOptions
- (indexes_desc->body.indexes_desc.hbaseCreateOptions,
+ (indexes_desc->indexesDesc()->hbaseCreateOptions,
hbaseCreateOptions,
heap,
NULL,
@@ -4466,833 +4453,816 @@ NABoolean createNAFileSets(desc_struct * table_desc /*IN*/,
newIndex = new (heap)
NAFileSet(
qualIndexName, // QN containing "\NSK.$VOL", FUNNYSV, FUNNYNM
- //(indexes_desc->body.indexes_desc.isVolatile ?
qualExtIndexName, // :
- //qualIndexName),
extIndexName, // string containing Ansi name CAT.SCH."indx"
- files_desc ? files_desc->body.files_desc.fileorganization
- : KEY_SEQUENCED_FILE,
+ KEY_SEQUENCED_FILE,
isSystemTable,
numberOfFiles,
- MAXOF(table_desc->body.table_desc.rowcount,0),
- indexes_desc->body.indexes_desc.record_length,
+ 100,
+ indexes_desc->indexesDesc()->record_length,
blockSize,
indexLevels,
allColumns,
indexKeyColumns,
partitioningKeyColumns,
partFunc,
- indexes_desc->body.indexes_desc.keytag,
- uint32ArrayToInt64(
- indexes_desc->body.indexes_desc.redeftime),
- files_desc ? files_desc->body.files_desc.audit : 0,
- files_desc ? files_desc->body.files_desc.auditcompress : 0,
- files_desc ? files_desc->body.files_desc.compressed : 0,
- files_desc ? (ComCompressionType)files_desc->body.files_desc.dcompressed : COM_NO_COMPRESSION,
- files_desc ? files_desc->body.files_desc.icompressed : 0,
- files_desc ? files_desc->body.files_desc.buffered: 0,
- files_desc ? files_desc->body.files_desc.clearOnPurge: 0,
- isPacked,
+ indexes_desc->indexesDesc()->keytag,
+ 0,
+ files_desc ? files_desc->filesDesc()->isAudited() : 0,
+ 0,
+ 0,
+ COM_NO_COMPRESSION,
+ 0,
+ 0,
+ 0,
+ isPacked,
hasRemotePartition,
- ((indexes_desc->body.indexes_desc.keytag != 0) &&
- (indexes_desc->body.indexes_desc.unique != 0)),
- files_desc ? files_desc->body.files_desc.decoupledPartitionKeyList: 0,
- files_desc ? files_desc->body.files_desc.fileCode : 0,
- (indexes_desc->body.indexes_desc.isVolatile != 0),
- (indexes_desc->body.indexes_desc.isInMemoryObjectDefn != 0),
- indexes_desc->body.indexes_desc.indexUID,
- indexes_desc->body.indexes_desc.keys_desc,
+ ((indexes_desc->indexesDesc()->keytag != 0) &&
+ (indexes_desc->indexesDesc()->isUnique())),
+ 0,
+ 0,
+ (indexes_desc->indexesDesc()->isVolatile()),
+ (indexes_desc->indexesDesc()->isInMemoryObject()),
+ indexes_desc->indexesDesc()->indexUID,
+ indexes_desc->indexesDesc()->keys_desc,
NULL, // no Hive stats
- indexes_desc->body.indexes_desc.numSaltPartns,
+ indexes_desc->indexesDesc()->numSaltPartns,
hbaseCreateOptions,
heap);
-
- if (isNotAvailable)
- newIndex->setNotAvailable(TRUE);
-
- newIndex->setRowFormat(indexes_desc->body.indexes_desc.rowFormat);
- // Mark each NAColumn in the list
- indexKeyColumns.setIndexKey();
- if ((table->isHbaseTable()) && (indexes_desc->body.indexes_desc.keytag != 0))
- saveNAColumns.setIndexKey();
-
- if (indexes_desc->body.indexes_desc.isCreatedExplicitly)
- newIndex->setIsCreatedExplicitly(TRUE);
-
- //if index is unique and is on one column, then mark column as unique
- if ((indexes_desc->body.indexes_desc.unique) &&
- (indexKeyColumns.entries() == 1))
- indexKeyColumns[0]->setIsUnique();
- partitioningKeyColumns.setPartitioningKey();
-
- // If it is a VP add it to the list of VPs.
- // Otherwise, add it to the list of indices.
- if (isVerticalPartition)
- vertParts.insert(newIndex); // >>>> RETURN VALUE
- else
- {
- indexes.insert(newIndex);
- }
-
- //
- // advance to the next index
- //
- if (isTheClusteringKey)
- {
- clusteringIndex = newIndex; // >>>> RETURN VALUE
- // switch to the alternate indexes by starting over again
- isTheClusteringKey = FALSE;
- indexes_desc = table_desc->body.table_desc.indexes_desc;
- }
- else
- {
- // simply advance to the next in the list
- indexes_desc = indexes_desc->header.next;
- }
+ if (isNotAvailable)
+ newIndex->setNotAvailable(TRUE);
- // skip the clustering index, if we encounter it again
- if (indexes_desc AND !indexes_desc->body.indexes_desc.keytag)
- indexes_desc = indexes_desc->header.next;
- } // end while (indexes_desc)
+ newIndex->setRowFormat(indexes_desc->indexesDesc()->rowFormat());
+ // Mark each NAColumn in the list
+ indexKeyColumns.setIndexKey();
+ if ((table->isHbaseTable()) && (indexes_desc->indexesDesc()->keytag != 0))
+ saveNAColumns.setIndexKey();
- // logic related to indexes hiding
- return FALSE;
-} // static createNAFileSets()
-#pragma warn(1506) // warning elimination
+ if (indexes_desc->indexesDesc()->isExplicit())
+ newIndex->setIsCreatedExplicitly(TRUE);
+ //if index is unique and is on one column, then mark column as unique
+ if ((indexes_desc->indexesDesc()->isUnique()) &&
+ (indexKeyColumns.entries() == 1))
+ indexKeyColumns[0]->setIsUnique();
-// for Hive tables
-NABoolean createNAFileSets(hive_tbl_desc* hvt_desc /*IN*/,
- const NATable * table /*IN*/,
- const NAColumnArray & colArray /*IN*/,
- NAFileSetList & indexes /*OUT*/,
- NAFileSetList & vertParts /*OUT*/,
- NAFileSet * & clusteringIndex /*OUT*/,
- LIST(CollIndex) & tableIdList /*OUT*/,
- NAMemory* heap,
- BindWA * bindWA,
- Int32 *maxIndexLevelsPtr = NULL)
-{
- NABoolean isTheClusteringKey = TRUE;
- NABoolean isVerticalPartition;
- NABoolean hasRemotePartition = FALSE;
- CollIndex numClusteringKeyColumns = 0;
+ partitioningKeyColumns.setPartitioningKey();
- // Set up global cluster information. This global information always
- // gets put on the context heap.
- //
- // Note that this function call will probably not do anything, since
- // this cluster information is set up when arkcmp is created; however,
- // it's certainly better to have this call here, rather than in a
- // doubly-nested loop below where it used to be ...
+ indexes.insert(newIndex);
- // $$$ probably not necessary to call this even once ...
- setUpClusterInfo(CmpCommon::contextHeap());
+ //
+ // advance to the next index
+ //
+ if (isTheClusteringKey)
+ {
+ clusteringIndex = newIndex; // >>>> RETURN VALUE
+ // switch to the alternate indexes by starting over again
+ isTheClusteringKey = FALSE;
+ indexes_desc = table_desc->tableDesc()->indexes_desc;
+ }
+ else
+ {
+ // simply advance to the next in the list
+ indexes_desc = indexes_desc->next;
+ }
- // only one set of key columns to handle for hive
+ // skip the clustering index, if we encounter it again
+ if (indexes_desc AND !indexes_desc->indexesDesc()->keytag)
+ indexes_desc = indexes_desc->next;
+ } // end while (indexes_desc)
+
+ // logic related to indexes hiding
+ return FALSE;
+ } // static createNAFileSets()
+ #pragma warn(1506) // warning elimination
+
+
+ // for Hive tables
+ NABoolean createNAFileSets(hive_tbl_desc* hvt_desc /*IN*/,
+ const NATable * table /*IN*/,
+ const NAColumnArray & colArray /*IN*/,
+ NAFileSetList & indexes /*OUT*/,
+ NAFileSetList & vertParts /*OUT*/,
+ NAFileSet * & clusteringIndex /*OUT*/,
+ LIST(CollIndex) & tableIdList /*OUT*/,
+ NAMemory* heap,
+ BindWA * bindWA,
+ Int32 *maxIndexLevelsPtr = NULL)
+ {
+ NABoolean isTheClusteringKey = TRUE;
+ NABoolean hasRemotePartition = FALSE;
+ CollIndex numClusteringKeyColumns = 0;
+
+ // Set up global cluster information. This global information always
+ // gets put on the context heap.
+ //
+ // Note that this function call will probably not do anything, since
+ // this cluster information is set up when arkcmp is created; however,
+ // it's certainly better to have this call here, rather than in a
+ // doubly-nested loop below where it used to be ...
- Lng32 numberOfFiles = 1; // always at least 1
- // NAColumn * indexColumn; // an index/VP key column
- NAFileSet * newIndex; // a new file set
+ // $$$ probably not necessary to call this even once ...
+ setUpClusterInfo(CmpCommon::contextHeap());
- // all columns that belong to an index
- NAColumnArray allColumns(CmpCommon::statementHeap());
+ // only one set of key columns to handle for hive
- // the index key columns - the SORT columns
- NAColumnArray indexKeyColumns(CmpCommon::statementHeap());
+ Lng32 numberOfFiles = 1; // always at least 1
+ // NAColumn * indexColumn; // an index/VP key column
+ NAFileSet * newIndex; // a new file set
- // the partitioning key columns - the BUCKETING columns
- NAColumnArray partitioningKeyColumns(CmpCommon::statementHeap());
+ // all columns that belong to an index
+ NAColumnArray allColumns(CmpCommon::statementHeap());
- PartitioningFunction * partFunc = NULL;
- // is this an index or is it really a VP?
+ // the index key columns - the SORT columns
+ NAColumnArray indexKeyColumns(CmpCommon::statementHeap());
- isVerticalPartition = FALSE;
- NABoolean isPacked = FALSE;
+ // the partitioning key columns - the BUCKETING columns
+ NAColumnArray partitioningKeyColumns(CmpCommon::statementHeap());
- NABoolean isNotAvailable = FALSE;
+ PartitioningFunction * partFunc = NULL;
+ // is this an index or is it really a VP?
- // ---------------------------------------------------------------------
- // loop over the clustering key columns of the index
- // ---------------------------------------------------------------------
- const hive_bkey_desc *hbk_desc = hvt_desc->getBucketingKeys();
+ NABoolean isPacked = FALSE;
- Int32 numBucketingColumns = 0;
+ NABoolean isNotAvailable = FALSE;
- while (hbk_desc)
- {
- NAString colName(hbk_desc->name_);
- colName.toUpper();
+ // ---------------------------------------------------------------------
+ // loop over the clustering key columns of the index
+ // ---------------------------------------------------------------------
+ const hive_bkey_desc *hbk_desc = hvt_desc->getBucketingKeys();
- NAColumn* bucketingColumn = colArray.getColumn(colName);
+ Int32 numBucketingColumns = 0;
- if ( bucketingColumn ) {
- partitioningKeyColumns.insert(bucketingColumn);
- numBucketingColumns++;
- }
+ while (hbk_desc)
+ {
+ NAString colName(hbk_desc->name_);
+ colName.toUpper();
- hbk_desc = hbk_desc->next_;
- } // end while (hvk_desc)
+ NAColumn* bucketingColumn = colArray.getColumn(colName);
- const hive_skey_desc *hsk_desc = hvt_desc->getSortKeys();
- if ( hsk_desc == NULL ) {
- // assume all columns are index key columns
- for (CollIndex i=0; i<colArray.entries(); i++ )
- indexKeyColumns.insert(colArray[i]);
- } else {
- while (hsk_desc)
- {
- NAString colName(hsk_desc->name_);
- colName.toUpper();
+ if ( bucketingColumn ) {
+ partitioningKeyColumns.insert(bucketingColumn);
+ numBucketingColumns++;
+ }
- NAColumn* sortKeyColumn = colArray.getColumn(colName);
+ hbk_desc = hbk_desc->next_;
+ } // end while (hvk_desc)
- if ( sortKeyColumn ) {
+ const hive_skey_desc *hsk_desc = hvt_desc->getSortKeys();
+ if ( hsk_desc == NULL ) {
+ // assume all columns are index key columns
+ for (CollIndex i=0; i<colArray.entries(); i++ )
+ indexKeyColumns.insert(colArray[i]);
+ } else {
+ while (hsk_desc)
+ {
+ NAString colName(hsk_desc->name_);
+ colName.toUpper();
- indexKeyColumns.insert(sortKeyColumn);
- indexKeyColumns.setAscending(indexKeyColumns.entries() - 1,
- hsk_desc->orderInt_);
- }
+ NAColumn* sortKeyColumn = colArray.getColumn(colName);
- hsk_desc = hsk_desc->next_;
- } // end while (hsk_desc)
- }
+ if ( sortKeyColumn ) {
+ indexKeyColumns.insert(sortKeyColumn);
+ indexKeyColumns.setAscending(indexKeyColumns.entries() - 1,
+ hsk_desc->orderInt_);
+ }
- // ---------------------------------------------------------------------
- // Loop over the non key columns.
- // ---------------------------------------------------------------------
- for (CollIndex i=0; i<colArray.entries(); i++)
- {
- allColumns.insert(colArray[i]);
- }
+ hsk_desc = hsk_desc->next_;
+ } // end while (hsk_desc)
+ }
- //increment for each table/index to create unique identifier
- cmpCurrentContext->incrementTableIdent();
- // collect file stats from HDFS for the table
- const hive_sd_desc *sd_desc = hvt_desc->getSDs();
- HHDFSTableStats * hiveHDFSTableStats = new(heap) HHDFSTableStats(heap);
- hiveHDFSTableStats->
- setPortOverride(CmpCommon::getDefaultLong(HIVE_LIB_HDFS_PORT_OVERRIDE));
+ // ---------------------------------------------------------------------
+ // Loop over the non key columns.
+ // ---------------------------------------------------------------------
+ for (CollIndex i=0; i<colArray.entries(); i++)
+ {
+ allColumns.insert(colArray[i]);
+ }
- // create file-level statistics and estimate total row count and record length
- hiveHDFSTableStats->populate(hvt_desc);
- if (hiveHDFSTableStats->hasError())
- {
- *CmpCommon::diags() << DgSqlCode(-1200)
- << DgString0(hiveHDFSTableStats->getDiags().getErrMsg())
- << DgTableName(table->getTableName().getQualifiedNameAsAnsiString());
- return TRUE;
- }
+ //increment for each table/index to create unique identifier
+ cmpCurrentContext->incrementTableIdent();
- if ((hiveHDFSTableStats->isOrcFile()) &&
- (CmpCommon::getDefault(TRAF_ENABLE_ORC_FORMAT) == DF_OFF))
- {
- *CmpCommon::diags() << DgSqlCode(-3069)
- << DgTableName(table->getTableName().getQualifiedNameAsAnsiString());
- return TRUE;
- }
+ // collect file stats from HDFS for the table
+ const hive_sd_desc *sd_desc = hvt_desc->getSDs();
+ HHDFSTableStats * hiveHDFSTableStats = new(heap) HHDFSTableStats(heap);
+ hiveHDFSTableStats->
+ setPortOverride(CmpCommon::getDefaultLong(HIVE_LIB_HDFS_PORT_OVERRIDE));
-#ifndef NDEBUG
- NAString logFile =
- ActiveSchemaDB()->getDefaults().getValue(HIVE_HDFS_STATS_LOG_FILE);
- if (logFile.length())
- {
- FILE *ofd = fopen(logFile, "a");
- if (ofd)
- {
- hiveHDFSTableStats->print(ofd);
- fclose(ofd);
- }
- }
- // for release code, would need to sandbox the ability to write
- // files, e.g. to a fixed log directory
-#endif
+ // create file-level statistics and estimate total row count and record length
+ hiveHDFSTableStats->populate(hvt_desc);
+ if (hiveHDFSTableStats->hasError())
+ {
+ *CmpCommon::diags() << DgSqlCode(-1200)
+ << DgString0(hiveHDFSTableStats->getDiags().getErrMsg())
+ << DgTableName(table->getTableName().getQualifiedNameAsAnsiString());
+ return TRUE;
+ }
+ if ((hiveHDFSTableStats->isOrcFile()) &&
+ (CmpCommon::getDefault(TRAF_ENABLE_ORC_FORMAT) == DF_OFF))
+ {
+ *CmpCommon::diags() << DgSqlCode(-3069)
+ << DgTableName(table->getTableName().getQualifiedNameAsAnsiString());
+ return TRUE;
+ }
- // Create a node map for partitioning function.
- NodeMap* nodeMap = new (heap) NodeMap(heap, NodeMap::HIVE);
+ #ifndef NDEBUG
+ NAString logFile =
+ ActiveSchemaDB()->getDefaults().getValue(HIVE_HDFS_STATS_LOG_FILE);
+ if (logFile.length())
+ {
+ FILE *ofd = fopen(logFile, "a");
+ if (ofd)
+ {
+ hiveHDFSTableStats->print(ofd);
+ fclose(ofd);
+ }
+ }
+ // for release code, would need to sandbox the ability to write
+ // files, e.g. to a fixed log directory
+ #endif
- createNodeMap(hvt_desc,
- nodeMap,
- heap,
- (char*)(table->getTableName().getObjectName().data()),
- cmpCurrentContext->getTableIdent());
- tableIdList.insert(CollIndex(cmpCurrentContext->getTableIdent()));
- // For the time being, set it up as Hash2 partitioned table
-
- Int32 numBuckets = hvt_desc->getSDs()->buckets_;
+ // Create a node map for partitioning function.
+ NodeMap* nodeMap = new (heap) NodeMap(heap, NodeMap::HIVE);
- if (numBuckets>1 && partitioningKeyColumns.entries()>0) {
- if ( CmpCommon::getDefault(HIVE_USE_HASH2_AS_PARTFUNCION) == DF_ON )
- partFunc = createHash2PartitioningFunction
- (numBuckets, partitioningKeyColumns, nodeMap, heap);
- else
- partFunc = createHivePartitioningFunction
- (numBuckets, partitioningKeyColumns, nodeMap, heap);
- } else
- partFunc = new (heap)
- SinglePartitionPartitioningFunction(nodeMap, heap);
+ createNodeMap(hvt_desc,
+ nodeMap,
+ heap,
+ (char*)(table->getTableName().getObjectName().data()),
+ cmpCurrentContext->getTableIdent());
+ tableIdList.insert(CollIndex(cmpCurrentContext->getTableIdent()));
- // NB: Just in case, we made a call to setupClusterInfo at the
- // beginning of this function.
- // desc_struct * partns_desc;
- Int32 indexLevels = 1;
-
+ // For the time being, set it up as Hash2 partitioned table
- // add a new access path
- //
- // $$$ The estimated number of records should be available from
- // $$$ a FILES descriptor. If it is not available, it may have
- // $$$ to be computed by examining the EOFs of each individual
- // $$$ file that belongs to the file set.
+ Int32 numBuckets = hvt_desc->getSDs()->buckets_;
- // Create fully qualified ANSI name from indexname, the PHYSICAL name.
- // If this descriptor was created for a sql/mp table, then the
- // indexname is a fully qualified NSK name (\sys.$vol.subvol.name).
- QualifiedName qualIndexName(
- (char*)(table->getTableName().getObjectName().data()),
- "HIVE", "", heap);
+ if (numBuckets>1 && partitioningKeyColumns.entries()>0) {
+ if ( CmpCommon::getDefault(HIVE_USE_HASH2_AS_PARTFUNCION) == DF_ON )
+ partFunc = createHash2PartitioningFunction
+ (numBuckets, partitioningKeyColumns, nodeMap, heap);
+ else
+ partFunc = createHivePartitioningFunction
+ (numBuckets, partitioningKeyColumns, nodeMap, heap);
+ } else
+ partFunc = new (heap)
+ SinglePartitionPartitioningFunction(nodeMap, heap);
- // This ext_indexname is expected to be set up correctly as an
- // EXTERNAL-format name (i.e., dquoted if any delimited identifiers)
- // by sqlcat/read*.cpp. The ...AsAnsiString() is just-in-case (MP?).
- NAString extIndexName(
- qualIndexName.getQualifiedNameAsAnsiString(),
- CmpCommon::statementHeap());
+ // NB: Just in case, we made a call to setupClusterInfo at the
+ // beginning of this function.
+ // TrafDesc * partns_desc;
+ Int32 indexLevels = 1;
- QualifiedName qualExtIndexName = QualifiedName(extIndexName, 1, heap, bindWA);
+ // add a new access path
+ //
+ // $$$ The estimated number of records should be available from
+ // $$$ a FILES descriptor. If it is not available, it may have
+ // $$$ to be computed by examining the EOFs of each individual
+ // $$$ file that belongs to the file set.
- if (partFunc)
- numberOfFiles = partFunc->getCountOfPartitions();
+ // Create fully qualified ANSI name from indexname, the PHYSICAL name.
+ // If this descriptor was created for a sql/mp table, then the
+ // indexname is a fully qualified NSK name (\sys.$vol.subvol.name).
+ QualifiedName qualIndexName(
+ (char*)(table->getTableName().getObjectName().data()),
+ "HIVE", "", heap);
- Int64 estimatedRC = 0;
- Int64 estimatedRecordLength = 0;
+ // This ext_indexname is expected to be set up correctly as an
+ // EXTERNAL-format name (i.e., dquoted if any delimited identifiers)
+ // by sqlcat/read*.cpp. The ...AsAnsiString() is just-in-case (MP?).
+ NAString extIndexName(
+ qualIndexName.getQualifiedNameAsAnsiString(),
+ CmpCommon::statementHeap());
- if ( !sd_desc->isTrulyText() ) {
- //
- // Poor man's estimation by assuming the record length in hive is the
- // same as SQ's. We can do better once we know how the binary data is
- // stored in hdfs.
- //
- estimatedRecordLength = colArray.getTotalStorageSize();
- estimatedRC = hiveHDFSTableStats->getTotalSize() / estimatedRecordLength;
- } else {
- // use the information estimated during populate() call
- estimatedRC = hiveHDFSTableStats->getEstimatedRowCount();
- estimatedRecordLength =
- Lng32(MINOF(hiveHDFSTableStats->getEstimatedRecordLength(),
- hiveHDFSTableStats->getEstimatedBlockSize()-100));
- }
+ QualifiedName qualExtIndexName = QualifiedName(extIndexName, 1, heap, bindWA);
- ((NATable*)table)-> setOriginalRowCount((double)estimatedRC);
- newIndex = new (heap)
- NAFileSet(
- qualIndexName, // QN containing "\NSK.$VOL", FUNNYSV, FUNNYNM
- //(indexes_desc->body.indexes_desc.isVolatile ?
- qualExtIndexName, // :
- //qualIndexName),
- extIndexName, // string containing Ansi name CAT.SCH."indx"
+ if (partFunc)
+ numberOfFiles = partFunc->getCountOfPartitions();
- // The real orginization is a hybrid of KEY_SEQ and HASH.
- // Well, we just take the KEY_SEQ for now.
- KEY_SEQUENCED_FILE,
+ Int64 estimatedRC = 0;
+ Int64 estimatedRecordLength = 0;
- FALSE, // isSystemTable
- numberOfFiles,
+ if ( !sd_desc->isTrulyText() ) {
+ //
+ // Poor man's estimation by assuming the record length in hive is the
+ // same as SQ's. We can do better once we know how the binary data is
+ // stored in hdfs.
+ //
+ estimatedRecordLength = colArray.getTotalStorageSize();
+ estimatedRC = hiveHDFSTableStats->getTotalSize() / estimatedRecordLength;
+ } else {
+ // use the information estimated during populate() call
+ estimatedRC = hiveHDFSTableStats->getEstimatedRowCount();
+ estimatedRecordLength =
+ Lng32(MINOF(hiveHDFSTableStats->getEstimatedRecordLength(),
+ hiveHDFSTableStats->getEstimatedBlockSize()-100));
+ }
- // HIVE-TBD
- Cardinality(estimatedRC),
- Lng32(estimatedRecordLength),
+ ((NATable*)table)-> setOriginalRowCount((double)estimatedRC);
+
+ newIndex = new (heap)
+ NAFileSet(
+ qualIndexName, // QN containing "\NSK.$VOL", FUNNYSV, FUNNYNM
+ qualExtIndexName, // :
+ extIndexName, // string containing Ansi name CAT.SCH."indx"
+
+ // The real orginization is a hybrid of KEY_SEQ and HASH.
+ // Well, we just take the KEY_SEQ for now.
+ KEY_SEQUENCED_FILE,
+
+ FALSE, // isSystemTable
+ numberOfFiles,
+
+ // HIVE-TBD
+ Cardinality(estimatedRC),
+ Lng32(estimatedRecordLength),
+
+ //hvt_desc->getBlockSize(),
+ (Lng32)hiveHDFSTableStats->getEstimatedBlockSize(),
+
+ indexLevels, // HIVE-TBD
+ allColumns,
+ indexKeyColumns,
+ partitioningKeyColumns,
+ partFunc,
+ 0, // indexes_desc->indexesDesc()->keytag,
+
+ hvt_desc->redeftime(),
+
+ 1, // files_desc->filesDesc()->audit
+ 0, // files_desc->filesDesc()->auditcompress
+ 0, // files_desc->filesDesc()->compressed
+ COM_NO_COMPRESSION,
+ 0, // files_desc->filesDesc()->icompressed
+ 0, // files_desc->filesDesc()->buffered:
+ 0, // files_desc->filesDesc()->clearOnPurge: 0,
+ isPacked,
+ hasRemotePartition,
+ 0, // not a unique secondary index
+ 0, // isDecoupledRangePartitioned
+ 0, // file code
+ 0, // not a volatile
+ 0, // inMemObjectDefn
+ 0,
+ NULL, // indexes_desc->indexesDesc()->keys_desc,
+ hiveHDFSTableStats,
+ 0, // saltPartns
+ NULL, //hbaseCreateOptions
+ heap);
+
+ if (isNotAvailable)
+ newIndex->setNotAvailable(TRUE);
+
+ // Mark each NAColumn in the list
+ indexKeyColumns.setIndexKey();
+
+ partitioningKeyColumns.setPartitioningKey();
+
+ // If it is a VP add it to the list of VPs.
+ // Otherwise, add it to the list of indices.
+ indexes.insert(newIndex);
+
+ clusteringIndex = newIndex;
+
+
+ return FALSE;
+ } // static createNAFileSets()
+
+ #pragma warn(1506) // warning elimination
+
+ // -----------------------------------------------------------------------
+ // Mark columns named in PRIMARY KEY constraint (these will be different
+ // from clustering key columns when the PK is droppable), for Binder error 4033.
+ // -----------------------------------------------------------------------
+ static void markPKCols(const TrafConstrntsDesc * constrnt /*IN*/,
+ const NAColumnArray& columnArray /*IN*/)
+ {
+ TrafDesc *keycols_desc = constrnt->constr_key_cols_desc;
+ while (keycols_desc)
+ {
+ TrafConstrntKeyColsDesc *key =
+ keycols_desc->constrntKeyColsDesc();
+ // Lookup by name (not position: key->position is pos *within the PK*)
+ NAColumn *nacol = columnArray.getColumn(key->colname);
+ if(nacol != NULL)
+ nacol->setPrimaryKey();
+ keycols_desc = keycols_desc->next;
+ }
+ } // static markPKCols
+
+ // -----------------------------------------------------------------------
+ // Insert MP CHECK CONSTRAINT text into NATable::checkConstraints_.
+ // -----------------------------------------------------------------------
+ static NABoolean
+ createConstraintInfo(const TrafDesc * table_desc /*IN*/,
+ const QualifiedName& tableQualName /*IN*/,
+ const NAColumnArray& columnArray /*IN*/,
+ CheckConstraintList& checkConstraints /*OUT*/,
+ AbstractRIConstraintList& uniqueConstraints,
+ AbstractRIConstraintList& refConstraints,
+ NAMemory* heap,
+ BindWA *bindWA)
+ {
+ TrafDesc *constrnts_desc = table_desc->tableDesc()->constrnts_desc;
+
+ while (constrnts_desc)
+ {
+ TrafConstrntsDesc *constrntHdr = constrnts_desc->constrntsDesc();
- //hvt_desc->getB
<TRUNCATED>