DatumStreamWrite *
create_datumstreamwrite(
char *compName,
int32 compLevel,
bool checksum,
int32 safeFSWriteSize,
int32 maxsz,
Form_pg_attribute attr,
char *relname,
char *title)
{
DatumStreamWrite *acc = palloc0(sizeof(DatumStreamWrite));
int32 initialMaxDatumPerBlock;
int32 maxDatumPerBlock;
PGFunction *compressionFunctions;
CompressionState *compressionState;
CompressionState *verifyBlockCompressionState;
init_datumstream_info(
&acc->typeInfo,
&acc->datumStreamVersion,
&acc->rle_want_compression,
&acc->delta_want_compression,
&acc->ao_attr,
&acc->maxAoBlockSize,
compName,
compLevel,
checksum,
safeFSWriteSize,
maxsz,
attr);
compressionFunctions = NULL;
compressionState = NULL;
verifyBlockCompressionState = NULL;
if (acc->ao_attr.compress)
{
/*
* BULK compression.
*/
compressionFunctions = get_funcs_for_compression(acc->ao_attr.compressType);
if (compressionFunctions != NULL)
{
TupleDesc td = CreateTupleDesc(1, false, &attr);
StorageAttributes sa;
sa.comptype = acc->ao_attr.compressType;
sa.complevel = acc->ao_attr.compressLevel;
sa.blocksize = acc->maxAoBlockSize;
compressionState =
callCompressionConstructor(
compressionFunctions[COMPRESSION_CONSTRUCTOR], td, &sa, /* compress */ true);
determine_datumstream_compression_overflow(
&acc->ao_attr,
compressionState->desired_sz,
acc->maxAoBlockSize);
if (gp_appendonly_verify_write_block)
{
verifyBlockCompressionState =
callCompressionConstructor(
compressionFunctions[COMPRESSION_CONSTRUCTOR], td, &sa, /* compress */ false);
}
}
}
AppendOnlyStorageWrite_Init(
&acc->ao_write,
/* memoryContext */ NULL,
acc->maxAoBlockSize,
relname,
title,
&acc->ao_attr);
acc->ao_write.compression_functions = compressionFunctions;
acc->ao_write.compressionState = compressionState;
acc->ao_write.verifyWriteCompressionState = verifyBlockCompressionState;
acc->title = title;
/*
* Temporarily set the firstRowNum for the block so that we can
* calculate the correct header length.
*/
AppendOnlyStorageWrite_SetFirstRowNum(&acc->ao_write, 1);
switch (acc->datumStreamVersion)
{
case DatumStreamVersion_Original:
initialMaxDatumPerBlock = MAXDATUM_PER_AOCS_ORIG_BLOCK;
maxDatumPerBlock = MAXDATUM_PER_AOCS_ORIG_BLOCK;
acc->maxAoHeaderSize = AoHeader_Size(
/* isLong */ false,
checksum,
/* hasFirstRowNum */ true);
break;
case DatumStreamVersion_Dense:
case DatumStreamVersion_Dense_Enhanced:
initialMaxDatumPerBlock = INITIALDATUM_PER_AOCS_DENSE_BLOCK;
maxDatumPerBlock = MAXDATUM_PER_AOCS_DENSE_BLOCK;
acc->maxAoHeaderSize = AoHeader_Size(
/* isLong */ true,
checksum,
/* hasFirstRowNum */ true);
break;
default:
ereport(ERROR,
(errmsg("Unexpected datum stream version %d",
acc->datumStreamVersion)));
initialMaxDatumPerBlock = 0;
/* Quiet down compiler. */
maxDatumPerBlock = 0;
break;
/* Never reached. */
}
DatumStreamBlockWrite_Init(
&acc->blockWrite,
&acc->typeInfo,
acc->datumStreamVersion,
acc->rle_want_compression,
acc->delta_want_compression,
initialMaxDatumPerBlock,
maxDatumPerBlock,
acc->maxAoBlockSize - acc->maxAoHeaderSize,
/* errdetailCallback */ datumstreamwrite_detail_callback,
/* errdetailArg */ (void *) acc,
/* errcontextCallback */ datumstreamwrite_context_callback,
/* errcontextArg */ (void *) acc);
return acc;
}
TupleTableSlot* BuildModelInfoTupleTableSlot(ModelInfo *modelInfo){
TupleTableSlot *resultSlot;
HeapTuple tuple;
TupleDesc tdesc;
Datum *values;
bool *isNull;
Form_pg_attribute *attrs;
// open the relation pg_model to lend the TupleDescriptor from it
Relation rel = heap_open(ModelRelationId, 0);
// we have to copy the lent TupleDesc, otherwise the relation pg_model won't talk to us later
tdesc = CreateTupleDescCopy(rel->rd_att);
/*hsdesc = heap_beginscan(rel, SnapshotNow, 0, NULL);
tuple = heap_getnext(hsdesc, ForwardScanDirection);
resultSlot = MakeSingleTupleTableSlot(tdesc);*/
attrs = palloc(sizeof(FormData_pg_attribute)*7);
attrs[0] = tdesc->attrs[0]; //name
attrs[1] = tdesc->attrs[4]; //algorithm
attrs[2] = tdesc->attrs[2]; //time
attrs[3] = tdesc->attrs[3]; //measure
attrs[4] = tdesc->attrs[6]; //aggtype
attrs[5] = tdesc->attrs[5]; //granularity
attrs[6] = tdesc->attrs[9]; //timestamp
tdesc = CreateTupleDesc(7, false, attrs);
resultSlot = MakeSingleTupleTableSlot(tdesc);
values = (Datum *)palloc(sizeof(Datum)*7);
isNull = (bool *)palloc0(sizeof(bool)*7);
if(modelInfo->modelName){
values[0] = PointerGetDatum(modelInfo->modelName);
}else{
// if a model is not stored, it has no name
isNull[0] = true;
}
values[1] = PointerGetDatum(getModelTypeAsString((ModelType)(modelInfo->forecastMethod)));
isNull[1] = false;
values[2] = Int16GetDatum(modelInfo->time->resorigcol);
isNull[2] = false;
values[3] = Int16GetDatum(modelInfo->measure->resorigcol);
isNull[3] = false;
values[4] = ObjectIdGetDatum(modelInfo->aggType);
isNull[4] = false;
values[5] = Int16GetDatum(modelInfo->granularity);
isNull[5] = false;
values[6] = Int32GetDatum(modelInfo->timestamp);
isNull[6] = false;
tuple = heap_form_tuple(tdesc, values, isNull);
if(tuple){
ExecStoreTuple(tuple, resultSlot, InvalidBuffer, false);
}
// if(hsdesc){
// heap_endscan(hsdesc);
// }
heap_close(rel, 0);
return resultSlot;
}
