自学教程：C++ DatumGetInt64函数代码示例

void GpPersistentTablespaceNode_GetValues(	Datum							*values,	Oid 							*filespaceOid,	Oid 							*tablespaceOid,	PersistentFileSysState			*persistentState,	int64							*createMirrorDataLossTrackingSessionNum,	MirroredObjectExistenceState	*mirrorExistenceState,	int32							*reserved,	TransactionId					*parentXid,	int64							*persistentSerialNum){    *filespaceOid = DatumGetObjectId(values[Anum_gp_persistent_tablespace_node_filespace_oid - 1]);    *tablespaceOid = DatumGetObjectId(values[Anum_gp_persistent_tablespace_node_tablespace_oid - 1]);    *persistentState = DatumGetInt16(values[Anum_gp_persistent_tablespace_node_persistent_state - 1]);    *createMirrorDataLossTrackingSessionNum = DatumGetInt64(values[Anum_gp_persistent_tablespace_node_create_mirror_data_loss_tracking_session_num - 1]);    *mirrorExistenceState = DatumGetInt16(values[Anum_gp_persistent_tablespace_node_mirror_existence_state - 1]);	*reserved = DatumGetInt32(values[Anum_gp_persistent_tablespace_node_reserved - 1]);	*parentXid = (TransactionId)DatumGetInt32(values[Anum_gp_persistent_tablespace_node_parent_xid - 1]);    *persistentSerialNum = DatumGetInt64(values[Anum_gp_persistent_tablespace_node_persistent_serial_num - 1]);}

/* * Evaluate the limit/offset expressions --- done at start of each scan. * * This is also a handy place to reset the current-position state info. */static voidrecompute_limits(LimitState *node){	ExprContext *econtext = node->ps.ps_ExprContext;	Datum		val;	bool		isNull;	if (node->limitOffset)	{		val = ExecEvalExprSwitchContext(node->limitOffset,										econtext,										&isNull,										NULL);		/* Interpret NULL offset as no offset */		if (isNull)			node->offset = 0;		else		{			node->offset = DatumGetInt64(val);			if (node->offset < 0)				node->offset = 0;		}	}	else	{		/* No OFFSET supplied */		node->offset = 0;	}	if (node->limitCount)	{		val = ExecEvalExprSwitchContext(node->limitCount,										econtext,										&isNull,										NULL);		/* Interpret NULL count as no count (LIMIT ALL) */		if (isNull)		{			node->count = 0;			node->noCount = true;		}		else		{			node->count = DatumGetInt64(val);			if (node->count < 0)				node->count = 0;			node->noCount = false;		}	}	else	{		/* No COUNT supplied */		node->count = 0;		node->noCount = true;	}	/* Reset position to start-of-scan */	node->position = 0;	node->subSlot = NULL;}

void GpPersistentRelationNode_GetValues(	Datum									*values,	Oid 									*tablespaceOid,	Oid 									*databaseOid,	Oid 									*relfilenodeOid,	int32									*segmentFileNum,	PersistentFileSysRelStorageMgr			*relationStorageManager,	PersistentFileSysState					*persistentState,	int64									*createMirrorDataLossTrackingSessionNum,	MirroredObjectExistenceState			*mirrorExistenceState,	MirroredRelDataSynchronizationState 	*mirrorDataSynchronizationState,	bool									*mirrorBufpoolMarkedForScanIncrementalResync,	int64									*mirrorBufpoolResyncChangedPageCount,	XLogRecPtr								*mirrorBufpoolResyncCkptLoc,	BlockNumber								*mirrorBufpoolResyncCkptBlockNum,	int64									*mirrorAppendOnlyLossEof,	int64									*mirrorAppendOnlyNewEof,	PersistentFileSysRelBufpoolKind 		*relBufpoolKind,	TransactionId							*parentXid,	int64									*persistentSerialNum){	*tablespaceOid = DatumGetObjectId(values[Anum_gp_persistent_relation_node_tablespace_oid - 1]);	*databaseOid = DatumGetObjectId(values[Anum_gp_persistent_relation_node_database_oid - 1]);	*relfilenodeOid = DatumGetObjectId(values[Anum_gp_persistent_relation_node_relfilenode_oid - 1]);	*segmentFileNum = DatumGetInt32(values[Anum_gp_persistent_relation_node_segment_file_num - 1]);	*relationStorageManager = (PersistentFileSysRelStorageMgr)DatumGetInt16(values[Anum_gp_persistent_relation_node_relation_storage_manager - 1]);	*persistentState = (PersistentFileSysState)DatumGetInt16(values[Anum_gp_persistent_relation_node_persistent_state - 1]);	*createMirrorDataLossTrackingSessionNum = DatumGetInt64(values[Anum_gp_persistent_relation_node_create_mirror_data_loss_tracking_session_num - 1]);	*mirrorExistenceState = (MirroredObjectExistenceState)DatumGetInt16(values[Anum_gp_persistent_relation_node_mirror_existence_state - 1]);	*mirrorDataSynchronizationState = (MirroredRelDataSynchronizationState)DatumGetInt16(values[Anum_gp_persistent_relation_node_mirror_data_synchronization_state - 1]);	*mirrorBufpoolMarkedForScanIncrementalResync = DatumGetBool(values[Anum_gp_persistent_relation_node_mirror_bufpool_marked_for_scan_incremental_resync - 1]);	*mirrorBufpoolResyncChangedPageCount = DatumGetInt64(values[Anum_gp_persistent_relation_node_mirror_bufpool_resync_changed_page_count - 1]);	*mirrorBufpoolResyncCkptLoc = *((XLogRecPtr*) DatumGetPointer(values[Anum_gp_persistent_relation_node_mirror_bufpool_resync_ckpt_loc - 1]));	*mirrorBufpoolResyncCkptBlockNum = (BlockNumber)DatumGetInt32(values[Anum_gp_persistent_relation_node_mirror_bufpool_resync_ckpt_block_num - 1]);	*mirrorAppendOnlyLossEof = DatumGetInt64(values[Anum_gp_persistent_relation_node_mirror_append_only_loss_eof - 1]);	*mirrorAppendOnlyNewEof = DatumGetInt64(values[Anum_gp_persistent_relation_node_mirror_append_only_new_eof - 1]);	*relBufpoolKind = (PersistentFileSysRelBufpoolKind)DatumGetInt32(values[Anum_gp_persistent_relation_node_relation_bufpool_kind - 1]);	*parentXid = (TransactionId)DatumGetInt32(values[Anum_gp_persistent_relation_node_parent_xid - 1]);	*persistentSerialNum = DatumGetInt64(values[Anum_gp_persistent_relation_node_persistent_serial_num - 1]);}

static PyObject *PLyLong_FromInt64(PLyDatumToOb *arg, Datum d){	/* on 32 bit platforms "long" may be too small */	if (sizeof(int64) > sizeof(long))		return PyLong_FromLongLong(DatumGetInt64(d));	else		return PyLong_FromLong(DatumGetInt64(d));}

/* * GetFastSequences * * Get a list of consecutive sequence numbers. The starting sequence * number is the maximal value between 'lastsequence' + 1 and minSequence. * The length of the list is given. * * If there is not such an entry for objid in the table, create * one here. * * The existing entry for objid in the table is updated with a new * lastsequence value. */int64 GetFastSequences(Oid objid, int64 objmod,					   int64 minSequence, int64 numSequences){	Relation gp_fastsequence_rel;	TupleDesc tupleDesc;	HeapTuple tuple;	cqContext	 cqc;	int64 firstSequence = minSequence;	Datum lastSequenceDatum;	int64 newLastSequence;	gp_fastsequence_rel = heap_open(FastSequenceRelationId, RowExclusiveLock);	tupleDesc = RelationGetDescr(gp_fastsequence_rel);		tuple = caql_getfirst(			caql_addrel(cqclr(&cqc), gp_fastsequence_rel),			cql("SELECT * FROM gp_fastsequence "				" WHERE objid = :1 "				" AND objmod = :2 "				" FOR UPDATE ",				ObjectIdGetDatum(objid),				Int64GetDatum(objmod)));	if (!HeapTupleIsValid(tuple))	{		newLastSequence = firstSequence + numSequences - 1;	}	else	{		bool isNull;		lastSequenceDatum = heap_getattr(tuple, Anum_gp_fastsequence_last_sequence,										tupleDesc, &isNull);				if (isNull)			ereport(ERROR,					(errcode(ERRCODE_UNDEFINED_OBJECT),					 errmsg("got an invalid lastsequence number: NULL")));				if (DatumGetInt64(lastSequenceDatum) + 1 > firstSequence)			firstSequence = DatumGetInt64(lastSequenceDatum) + 1;		newLastSequence = firstSequence + numSequences - 1;	}		update_fastsequence(gp_fastsequence_rel, tuple, tupleDesc,						objid, objmod, newLastSequence);	if (HeapTupleIsValid(tuple))	{		heap_freetuple(tuple);	}			/* Refer to the comment at the end of InsertFastSequenceEntry. */	heap_close(gp_fastsequence_rel, RowExclusiveLock);	return firstSequence;}

void GpPersistentFilespaceNode_GetValues(	Datum							*values,	Oid 							*filespaceOid,	int16							*dbId1,	char							locationBlankPadded1[FilespaceLocationBlankPaddedWithNullTermLen],	int16							*dbId2,	char							locationBlankPadded2[FilespaceLocationBlankPaddedWithNullTermLen],	PersistentFileSysState			*persistentState,	int64							*createMirrorDataLossTrackingSessionNum,	MirroredObjectExistenceState	*mirrorExistenceState,	int32							*reserved,	TransactionId					*parentXid,	int64							*persistentSerialNum){	char *locationPtr;	int locationLen;    *filespaceOid = DatumGetObjectId(values[Anum_gp_persistent_filespace_node_filespace_oid - 1]);    *dbId1 = DatumGetInt16(values[Anum_gp_persistent_filespace_node_db_id_1 - 1]);	locationPtr = TextDatumGetCString(values[Anum_gp_persistent_filespace_node_location_1 - 1]);;	locationLen = strlen(locationPtr);	if (locationLen != FilespaceLocationBlankPaddedWithNullTermLen - 1)		elog(ERROR, "Expected filespace location 1 to be %d characters and found %d",			 FilespaceLocationBlankPaddedWithNullTermLen - 1,			 locationLen);			 	memcpy(locationBlankPadded1, locationPtr, FilespaceLocationBlankPaddedWithNullTermLen);    *dbId2 = DatumGetInt16(values[Anum_gp_persistent_filespace_node_db_id_2 - 1]);	locationPtr = TextDatumGetCString(values[Anum_gp_persistent_filespace_node_location_2 - 1]);	locationLen = strlen(locationPtr);	if (locationLen != FilespaceLocationBlankPaddedWithNullTermLen - 1)		elog(ERROR, "Expected filespace location 2 to be %d characters and found %d",			 FilespaceLocationBlankPaddedWithNullTermLen - 1,			 locationLen);			 	memcpy(locationBlankPadded2, locationPtr, FilespaceLocationBlankPaddedWithNullTermLen);    *persistentState = DatumGetInt16(values[Anum_gp_persistent_filespace_node_persistent_state - 1]);    *createMirrorDataLossTrackingSessionNum = DatumGetInt64(values[Anum_gp_persistent_filespace_node_create_mirror_data_loss_tracking_session_num - 1]);    *mirrorExistenceState = DatumGetInt16(values[Anum_gp_persistent_filespace_node_mirror_existence_state - 1]);	*reserved = DatumGetInt32(values[Anum_gp_persistent_filespace_node_reserved - 1]);	*parentXid = (TransactionId)DatumGetInt32(values[Anum_gp_persistent_filespace_node_parent_xid - 1]);    *persistentSerialNum = DatumGetInt64(values[Anum_gp_persistent_filespace_node_persistent_serial_num - 1]);}

/* * load_consumer_offsets * * Load all offsets for all of this consumer's partitions */static voidload_consumer_offsets(KafkaConsumer *consumer, struct rd_kafka_metadata_topic *meta, int64_t offset){	MemoryContext old;	ScanKeyData skey[1];	HeapTuple tup = NULL;	HeapScanDesc scan;	Relation offsets = open_pipeline_kafka_offsets();	TupleTableSlot *slot = MakeSingleTupleTableSlot(RelationGetDescr(offsets));	int i;	ScanKeyInit(&skey[0], OFFSETS_ATTR_CONSUMER, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(consumer->id));	scan = heap_beginscan(offsets, GetTransactionSnapshot(), 1, skey);	old = MemoryContextSwitchTo(CacheMemoryContext);	consumer->offsets = palloc0(meta->partition_cnt * sizeof(int64_t));	MemoryContextSwitchTo(old);	/* by default, begin consuming from the end of a stream */	for (i = 0; i < meta->partition_cnt; i++)		consumer->offsets[i] = offset;	consumer->num_partitions = meta->partition_cnt;	while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)	{		Datum d;		bool isnull;		int partition;		ExecStoreTuple(tup, slot, InvalidBuffer, false);		d = slot_getattr(slot, OFFSETS_ATTR_PARTITION, &isnull);		partition = DatumGetInt32(d);		if(partition > consumer->num_partitions)			elog(ERROR, "invalid partition id: %d", partition);		if (offset == RD_KAFKA_OFFSET_NULL)		{			d = slot_getattr(slot, OFFSETS_ATTR_OFFSET, &isnull);			if (isnull)				offset = RD_KAFKA_OFFSET_END;			else				offset = DatumGetInt64(d);		}		consumer->offsets[partition] = DatumGetInt64(offset);	}	ExecDropSingleTupleTableSlot(slot);	heap_endscan(scan);	heap_close(offsets, RowExclusiveLock);}

static intbtint8fastcmp(Datum x, Datum y, SortSupport ssup){	int64		a = DatumGetInt64(x);	int64		b = DatumGetInt64(y);	if (a > b)		return 1;	else if (a == b)		return 0;	else		return -1;}

static intbtint8fastcmp(Datum x, Datum y, SortSupport ssup){	int64		a = DatumGetInt64(x);	int64		b = DatumGetInt64(y);	if (a > b)		return A_GREATER_THAN_B;	else if (a == b)		return 0;	else		return A_LESS_THAN_B;}

/* int8_cash() * Convert int8 (bigint) to cash */Datumint8_cash(PG_FUNCTION_ARGS){	int64		amount = PG_GETARG_INT64(0);	Cash		result;	int			fpoint;	int64		scale;	int			i;	struct lconv *lconvert = PGLC_localeconv();	/* see comments about frac_digits in cash_in() */	fpoint = lconvert->frac_digits;	if (fpoint < 0 || fpoint > 10)		fpoint = 2;	/* compute required scale factor */	scale = 1;	for (i = 0; i < fpoint; i++)		scale *= 10;	/* compute amount * scale, checking for overflow */	result = DatumGetInt64(DirectFunctionCall2(int8mul, Int64GetDatum(amount),											   Int64GetDatum(scale)));	PG_RETURN_CASH(result);}

/* numeric_cash() * Convert numeric to cash. */Datumnumeric_cash(PG_FUNCTION_ARGS){	Datum		amount = PG_GETARG_DATUM(0);	Cash		result;	int			fpoint;	int64		scale;	int			i;	Datum		numeric_scale;	struct lconv *lconvert = PGLC_localeconv();	/* see comments about frac_digits in cash_in() */	fpoint = lconvert->frac_digits;	if (fpoint < 0 || fpoint > 10)		fpoint = 2;	/* compute required scale factor */	scale = 1;	for (i = 0; i < fpoint; i++)		scale *= 10;	/* multiply the input amount by scale factor */	numeric_scale = DirectFunctionCall1(int8_numeric, Int64GetDatum(scale));	amount = DirectFunctionCall2(numeric_mul, amount, numeric_scale);	/* note that numeric_int8 will round to nearest integer for us */	result = DatumGetInt64(DirectFunctionCall1(numeric_int8, amount));	PG_RETURN_CASH(result);}

static void PersistentStore_ExtractOurTupleData(	PersistentStoreData 	*storeData,	Datum					*values,	int64					*persistentSerialNum){	*persistentSerialNum = DatumGetInt64(values[storeData->attNumPersistentSerialNum - 1]);}

void GpPersistentTablespaceNode_GetValues(	Datum							*values,	Oid 							*filespaceOid,	Oid 							*tablespaceOid,	PersistentFileSysState			*persistentState,	int32							*reserved,	TransactionId					*parentXid,	int64							*persistentSerialNum,	ItemPointerData 				*previousFreeTid,	bool							*sharedStorage){    *filespaceOid = DatumGetObjectId(values[Anum_gp_persistent_tablespace_node_filespace_oid - 1]);    *tablespaceOid = DatumGetObjectId(values[Anum_gp_persistent_tablespace_node_tablespace_oid - 1]);    *persistentState = DatumGetInt16(values[Anum_gp_persistent_tablespace_node_persistent_state - 1]);	*reserved = DatumGetInt32(values[Anum_gp_persistent_tablespace_node_reserved - 1]);	*parentXid = (TransactionId)DatumGetInt32(values[Anum_gp_persistent_tablespace_node_parent_xid - 1]);    *persistentSerialNum = DatumGetInt64(values[Anum_gp_persistent_tablespace_node_persistent_serial_num - 1]);    *previousFreeTid = *((ItemPointer) DatumGetPointer(values[Anum_gp_persistent_tablespace_node_previous_free_tid - 1]));	*sharedStorage = true;}

/* * Examine parameters and prepare for a sample scan. */static voidsystem_rows_beginsamplescan(SampleScanState *node,							Datum *params,							int nparams,							uint32 seed){	SystemRowsSamplerData *sampler = (SystemRowsSamplerData *) node->tsm_state;	int64		ntuples = DatumGetInt64(params[0]);	if (ntuples < 0)		ereport(ERROR,				(errcode(ERRCODE_INVALID_TABLESAMPLE_ARGUMENT),				 errmsg("sample size must not be negative")));	sampler->seed = seed;	sampler->ntuples = ntuples;	sampler->donetuples = 0;	sampler->lt = InvalidOffsetNumber;	sampler->doneblocks = 0;	/* lb will be initialized during first NextSampleBlock call */	/* we intentionally do not change nblocks/firstblock/step here */	/*	 * We *must* use pagemode visibility checking in this module, so force	 * that even though it's currently default.	 */	node->use_pagemode = true;}

long long * all_referenced_files(int * countOut){	char query[128];	snprintf(query, 128, "SELECT file_id FROM "WDB_SCHEMA".file_blob");	SPI_connect();	int result = SPI_execute(query, true, 0);	if ( SPI_OK_SELECT != result )		ereport(ERROR, (errcode( ERRCODE_RAISE_EXCEPTION ),	errmsg("Error when reading from file_blob")));	* countOut = SPI_processed;	long long * ret = (long long *) SPI_palloc(sizeof(long long) * (* countOut));	int i;	for ( i = 0; i < * countOut; ++ i )	{		bool isNull; // unused		Datum d = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, & isNull);		ret[i] = DatumGetInt64(d);	}	SPI_finish();	return ret;}

/* * lock_shard_resources allows shard resources  to be locked * remotely to serialise non-commutative writes on shards. * * This function does not sort the array to avoid deadlock, callers * must ensure a consistent order. */Datumlock_shard_resources(PG_FUNCTION_ARGS){	LOCKMODE lockMode = IntToLockMode(PG_GETARG_INT32(0));	ArrayType *shardIdArrayObject = PG_GETARG_ARRAYTYPE_P(1);	Datum *shardIdArrayDatum = NULL;	int shardIdCount = 0;	int shardIdIndex = 0;	if (ARR_NDIM(shardIdArrayObject) == 0)	{		ereport(ERROR, (errmsg("no locks specified")));	}	/* we don't want random users to block writes */	EnsureSuperUser();	shardIdCount = ArrayObjectCount(shardIdArrayObject);	shardIdArrayDatum = DeconstructArrayObject(shardIdArrayObject);	for (shardIdIndex = 0; shardIdIndex < shardIdCount; shardIdIndex++)	{		int64 shardId = DatumGetInt64(shardIdArrayDatum[shardIdIndex]);		LockShardResource(shardId, lockMode);	}	PG_RETURN_VOID();}

/* * Extract an int64 value from a DefElem. */int64defGetInt64(DefElem *def){	if (def->arg == NULL)		ereport(ERROR,				(errcode(ERRCODE_SYNTAX_ERROR),				 errmsg("%s requires a numeric value",						def->defname)));	switch (nodeTag(def->arg))	{		case T_Integer:			return (int64) intVal(def->arg);		case T_Float:			/*			 * Values too large for int4 will be represented as Float			 * constants by the lexer.	Accept these if they are valid int8			 * strings.			 */			return DatumGetInt64(DirectFunctionCall1(int8in,										 CStringGetDatum(strVal(def->arg))));		default:			ereport(ERROR,					(errcode(ERRCODE_SYNTAX_ERROR),					 errmsg("%s requires a numeric value",							def->defname)));	}	return 0;					/* keep compiler quiet */}

/* ---------------- *		index_getbitmap - get all tuples at once from an index scan * * Adds the TIDs of all heap tuples satisfying the scan keys to a bitmap. * Since there's no interlock between the index scan and the eventual heap * access, this is only safe to use with MVCC-based snapshots: the heap * item slot could have been replaced by a newer tuple by the time we get * to it. * * Returns the number of matching tuples found.  (Note: this might be only * approximate, so it should only be used for statistical purposes.) * ---------------- */int64index_getbitmap(IndexScanDesc scan, TIDBitmap *bitmap){	FmgrInfo   *procedure;	int64		ntids;	Datum		d;	SCAN_CHECKS;	GET_SCAN_PROCEDURE(amgetbitmap);	/* just make sure this is false... */	scan->kill_prior_tuple = false;	/*	 * have the am's getbitmap proc do all the work.	 */	d = FunctionCall2(procedure,					  PointerGetDatum(scan),					  PointerGetDatum(bitmap));	ntids = DatumGetInt64(d);	/* If int8 is pass-by-ref, must free the result to avoid memory leak */#ifndef USE_FLOAT8_BYVAL	pfree(DatumGetPointer(d));#endif	pgstat_count_index_tuples(scan->indexRelation, ntids);	return ntids;}

int64_t HdfsTell(FsysName protocol, hdfsFS fileSystem, hdfsFile file){	FunctionCallInfoData fcinfo;	FileSystemUdfData fsysUdf;	FmgrInfo *fsysFunc = FsysInterfaceGetFunc(protocol, FSYS_FUNC_TELL);#ifdef USE_ASSERT_CHECKING    if (testmode_fault(gp_fsys_fault_inject_percent))        return -1;#endif	fsysUdf.type = T_FileSystemFunctionData;	fsysUdf.fsys_hdfs = fileSystem;	fsysUdf.fsys_hfile = file;	InitFunctionCallInfoData(/* FunctionCallInfoData */ fcinfo,							 /* FmgrInfo */ fsysFunc,							 /* nArgs */ 0, 							 /* Call Context */ (Node *) (&fsysUdf),							 /* ResultSetInfo */ NULL);	Datum d = FunctionCallInvoke(&fcinfo);	return DatumGetInt64(d);}

doublepgr_SPI_getFloat8(HeapTuple *tuple, TupleDesc *tupdesc, Column_info_t info) {    Datum binval;    bool isnull;    double value = 0.0;    binval = SPI_getbinval(*tuple, *tupdesc, info.colNumber, &isnull);    if (isnull)        elog(ERROR, "Unexpected Null value in column %s", info.name);    switch (info.type) {        case INT2OID:            value = (double) DatumGetInt16(binval);            break;        case INT4OID:            value = (double) DatumGetInt32(binval);            break;        case INT8OID:            value = (double) DatumGetInt64(binval);            break;        case FLOAT4OID:            value = (double) DatumGetFloat4(binval);            break;        case FLOAT8OID:            value = DatumGetFloat8(binval);            break;        default:            elog(ERROR,                    "Unexpected Column type of %s. Expected ANY-NUMERICAL",                    info.name);    }    PGR_DBG("Variable: %s Value: %lf", info.name, value);    return value;}

int64_tpgr_SPI_getBigInt(HeapTuple *tuple, TupleDesc *tupdesc, Column_info_t info) {    Datum binval;    bool isnull;    int64_t value = 0;    binval = SPI_getbinval(*tuple, *tupdesc, info.colNumber, &isnull);    if (isnull)        elog(ERROR, "Unexpected Null value in column %s", info.name);    switch (info.type) {        case INT2OID:            value = (int64_t) DatumGetInt16(binval);            break;        case INT4OID:            value = (int64_t) DatumGetInt32(binval);            break;        case INT8OID:            value = DatumGetInt64(binval);            break;        default:            elog(ERROR,                    "Unexpected Column type of %s. Expected ANY-INTEGER",                    info.name);    }    PGR_DBG("Variable: %s Value: %lld", info.name, value);    return value;}

/* * Initialize workspace for a worker process: create the schema if it doesn't * already exist. */static voidinitialize_worker_spi(worktable *table){	int			ret;	int			ntup;	bool		isnull;	StringInfoData buf;	SetCurrentStatementStartTimestamp();	StartTransactionCommand();	SPI_connect();	PushActiveSnapshot(GetTransactionSnapshot());	pgstat_report_activity(STATE_RUNNING, "initializing spi_worker schema");	/* XXX could we use CREATE SCHEMA IF NOT EXISTS? */	initStringInfo(&buf);	appendStringInfo(&buf, "select count(*) from pg_namespace where nspname = '%s'",					 table->schema);	ret = SPI_execute(buf.data, true, 0);	if (ret != SPI_OK_SELECT)		elog(FATAL, "SPI_execute failed: error code %d", ret);	if (SPI_processed != 1)		elog(FATAL, "not a singleton result");	ntup = DatumGetInt64(SPI_getbinval(SPI_tuptable->vals[0],									   SPI_tuptable->tupdesc,									   1, &isnull));	if (isnull)		elog(FATAL, "null result");	if (ntup == 0)	{		resetStringInfo(&buf);		appendStringInfo(&buf,						 "CREATE SCHEMA /"%s/" "						 "CREATE TABLE /"%s/" ("			   "		type text CHECK (type IN ('total', 'delta')), "						 "		value	integer)"				  "CREATE UNIQUE INDEX /"%s_unique_total/" ON /"%s/" (type) "						 "WHERE type = 'total'",					   table->schema, table->name, table->name, table->name);		/* set statement start time */		SetCurrentStatementStartTimestamp();		ret = SPI_execute(buf.data, false, 0);		if (ret != SPI_OK_UTILITY)			elog(FATAL, "failed to create my schema");	}	SPI_finish();	PopActiveSnapshot();	CommitTransactionCommand();	pgstat_report_activity(STATE_IDLE, NULL);}

static void PersistentStore_ExtractOurTupleData(	PersistentStoreData 	*storeData,	Datum					*values,	int64					*persistentSerialNum,	ItemPointer				previousFreeTid){	*persistentSerialNum = DatumGetInt64(values[storeData->attNumPersistentSerialNum - 1]);	*previousFreeTid = *((ItemPointer) DatumGetPointer(values[storeData->attNumPreviousFreeTid - 1]));}

Datumorafce_dump(PG_FUNCTION_ARGS){	Oid		valtype = get_fn_expr_argtype(fcinfo->flinfo, 0);	List	*args;	int16	typlen;	bool	typbyval;	Size	length;	Datum	value;	int		format;	StringInfoData	str;	if (!fcinfo->flinfo || !fcinfo->flinfo->fn_expr)		elog(ERROR, "function is called from invalid context");	if (PG_ARGISNULL(0))		elog(ERROR, "argument is NULL");	value = PG_GETARG_DATUM(0);	format = PG_GETARG_IF_EXISTS(1, INT32, 10);	args = ((FuncExpr *) fcinfo->flinfo->fn_expr)->args;	valtype = exprType((Node *) list_nth(args, 0));	get_typlenbyval(valtype, &typlen, &typbyval);	length = datumGetSize(value, typbyval, typlen);	initStringInfo(&str);	appendStringInfo(&str, "Typ=%d Len=%d: ", valtype, (int) length);	if (!typbyval)	{		appendDatum(&str, DatumGetPointer(value), length, format);	}	else if (length <= 1)	{		char	v = DatumGetChar(value);		appendDatum(&str, &v, sizeof(char), format);	}	else if (length <= 2)	{		int16	v = DatumGetInt16(value);		appendDatum(&str, &v, sizeof(int16), format);	}	else if (length <= 4)	{		int32	v = DatumGetInt32(value);		appendDatum(&str, &v, sizeof(int32), format);	}	else	{		int64	v = DatumGetInt64(value);		appendDatum(&str, &v, sizeof(int64), format);	}	PG_RETURN_TEXT_P(cstring_to_text(str.data));}

/** * Convert postgres Datum into a ConcreteValue object. */AbstractValueSPtr AbstractPGValue::DatumToValue(bool inMemoryIsWritable,    Oid inTypeID, Datum inDatum) const {            // First check if datum is rowtype    if (type_is_rowtype(inTypeID)) {        HeapTupleHeader pgTuple = DatumGetHeapTupleHeader(inDatum);        return AbstractValueSPtr(new PGValue<HeapTupleHeader>(pgTuple));    } else if (type_is_array(inTypeID)) {        ArrayType *pgArray = DatumGetArrayTypeP(inDatum);                if (ARR_NDIM(pgArray) != 1)            throw std::invalid_argument("Multidimensional arrays not yet supported");                if (ARR_HASNULL(pgArray))            throw std::invalid_argument("Arrays with NULLs not yet supported");                switch (ARR_ELEMTYPE(pgArray)) {            case FLOAT8OID: {                MemHandleSPtr memoryHandle(new PGArrayHandle(pgArray));                                if (inMemoryIsWritable) {                    return AbstractValueSPtr(                        new ConcreteValue<Array<double> >(                            Array<double>(memoryHandle,                                boost::extents[ ARR_DIMS(pgArray)[0] ])                            )                        );                } else {                    return AbstractValueSPtr(                        new ConcreteValue<Array_const<double> >(                            Array_const<double>(memoryHandle,                                boost::extents[ ARR_DIMS(pgArray)[0] ])                            )                        );                }            }        }    }    switch (inTypeID) {        case BOOLOID: return AbstractValueSPtr(            new ConcreteValue<bool>( DatumGetBool(inDatum) ));        case INT2OID: return AbstractValueSPtr(            new ConcreteValue<int16_t>( DatumGetInt16(inDatum) ));        case INT4OID: return AbstractValueSPtr(            new ConcreteValue<int32_t>( DatumGetInt32(inDatum) ));        case INT8OID: return AbstractValueSPtr(            new ConcreteValue<int64_t>( DatumGetInt64(inDatum) ));        case FLOAT4OID: return AbstractValueSPtr(            new ConcreteValue<float>( DatumGetFloat4(inDatum) ));        case FLOAT8OID: return AbstractValueSPtr(            new ConcreteValue<double>( DatumGetFloat8(inDatum) ));    }        return AbstractValueSPtr();}

/* * Sample size estimation. */static voidsystem_rows_samplescangetsamplesize(PlannerInfo *root,									RelOptInfo *baserel,									List *paramexprs,									BlockNumber *pages,									double *tuples){	Node	   *limitnode;	int64		ntuples;	double		npages;	/* Try to extract an estimate for the limit rowcount */	limitnode = (Node *) linitial(paramexprs);	limitnode = estimate_expression_value(root, limitnode);	if (IsA(limitnode, Const) &&		!((Const *) limitnode)->constisnull)	{		ntuples = DatumGetInt64(((Const *) limitnode)->constvalue);		if (ntuples < 0)		{			/* Default ntuples if the value is bogus */			ntuples = 1000;		}	}	else	{		/* Default ntuples if we didn't obtain a non-null Const */		ntuples = 1000;	}	/* Clamp to the estimated relation size */	if (ntuples > baserel->tuples)		ntuples = (int64) baserel->tuples;	ntuples = clamp_row_est(ntuples);	if (baserel->tuples > 0 && baserel->pages > 0)	{		/* Estimate number of pages visited based on tuple density */		double		density = baserel->tuples / (double) baserel->pages;		npages = ntuples / density;	}	else	{		/* For lack of data, assume one tuple per page */		npages = ntuples;	}	/* Clamp to sane value */	npages = clamp_row_est(Min((double) baserel->pages, npages));	*pages = npages;	*tuples = ntuples;}

void GpRelationNode_GetValues(	Datum							*values,	Oid 							*relfilenodeOid,	int32							*segmentFileNum,	int64							*createMirrorDataLossTrackingSessionNum,	ItemPointer		 				persistentTid,	int64							*persistentSerialNum){	*relfilenodeOid = DatumGetObjectId(values[Anum_gp_relation_node_relfilenode_oid - 1]);	*segmentFileNum = DatumGetInt32(values[Anum_gp_relation_node_segment_file_num - 1]);	*createMirrorDataLossTrackingSessionNum = DatumGetInt64(values[Anum_gp_relation_node_create_mirror_data_loss_tracking_session_num - 1]);	*persistentTid = *((ItemPointer) DatumGetPointer(values[Anum_gp_relation_node_persistent_tid - 1]));	*persistentSerialNum = DatumGetInt64(values[Anum_gp_relation_node_persistent_serial_num - 1]);}

Datumnextval_mirror(PG_FUNCTION_ARGS){	Oid			relid = PG_GETARG_OID(0);	int64		result;	result = DatumGetInt64(DirectFunctionCall1(nextval_oid,											   ObjectIdGetDatum(relid)));	saveSequenceUpdate(relid, result, true);	PG_RETURN_INT64(result);}

/** * @brief Parse int64 expression */int64ParseInt64(char *value, int64 minValue){    int64	i;    if (pg_strcasecmp(value, "INFINITE") == 0)        return INT64CONST(0x7FFFFFFFFFFFFFFF);    i = DatumGetInt64(DirectFunctionCall1(int8in, CStringGetDatum(value)));    if (i < minValue)        ereport(ERROR,                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),                 errmsg("value /"%s/" is out of range", value)));    return i;}

void GpRelfileNode_GetValues(	Datum							*values,	Oid 							*relfilenodeOid,	int32							*segmentFileNum,	ItemPointer		 				persistentTid,	int64							*persistentSerialNum){	*relfilenodeOid = DatumGetObjectId(values[Anum_gp_relfile_node_relfilenode_oid - 1]);	*segmentFileNum = DatumGetInt32(values[Anum_gp_relfile_node_segment_file_num - 1]);	*persistentTid = *((ItemPointer) DatumGetPointer(values[Anum_gp_relfile_node_persistent_tid - 1]));	*persistentSerialNum = DatumGetInt64(values[Anum_gp_relfile_node_persistent_serial_num - 1]);}