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

//.........这里部分代码省略.........		confkeyArray = construct_array(fkdatums, foreignNKeys,									   INT2OID, 2, true, 's');		for (i = 0; i < foreignNKeys; i++)			fkdatums[i] = ObjectIdGetDatum(pfEqOp[i]);		conpfeqopArray = construct_array(fkdatums, foreignNKeys,										 OIDOID, sizeof(Oid), true, 'i');		for (i = 0; i < foreignNKeys; i++)			fkdatums[i] = ObjectIdGetDatum(ppEqOp[i]);		conppeqopArray = construct_array(fkdatums, foreignNKeys,										 OIDOID, sizeof(Oid), true, 'i');		for (i = 0; i < foreignNKeys; i++)			fkdatums[i] = ObjectIdGetDatum(ffEqOp[i]);		conffeqopArray = construct_array(fkdatums, foreignNKeys,										 OIDOID, sizeof(Oid), true, 'i');	}	else	{		confkeyArray = NULL;		conpfeqopArray = NULL;		conppeqopArray = NULL;		conffeqopArray = NULL;	}	/* initialize nulls and values */	for (i = 0; i < Natts_pg_constraint; i++)	{		nulls[i] = false;		values[i] = (Datum) 0;	}	values[Anum_pg_constraint_conname - 1] = NameGetDatum(&cname);	values[Anum_pg_constraint_connamespace - 1] = ObjectIdGetDatum(constraintNamespace);	values[Anum_pg_constraint_contype - 1] = CharGetDatum(constraintType);	values[Anum_pg_constraint_condeferrable - 1] = BoolGetDatum(isDeferrable);	values[Anum_pg_constraint_condeferred - 1] = BoolGetDatum(isDeferred);	values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(relId);	values[Anum_pg_constraint_contypid - 1] = ObjectIdGetDatum(domainId);	values[Anum_pg_constraint_confrelid - 1] = ObjectIdGetDatum(foreignRelId);	values[Anum_pg_constraint_confupdtype - 1] = CharGetDatum(foreignUpdateType);	values[Anum_pg_constraint_confdeltype - 1] = CharGetDatum(foreignDeleteType);	values[Anum_pg_constraint_confmatchtype - 1] = CharGetDatum(foreignMatchType);	if (conkeyArray)		values[Anum_pg_constraint_conkey - 1] = PointerGetDatum(conkeyArray);	else		nulls[Anum_pg_constraint_conkey - 1] = true;	if (confkeyArray)		values[Anum_pg_constraint_confkey - 1] = PointerGetDatum(confkeyArray);	else		nulls[Anum_pg_constraint_confkey - 1] = true;	if (conpfeqopArray)		values[Anum_pg_constraint_conpfeqop - 1] = PointerGetDatum(conpfeqopArray);	else		nulls[Anum_pg_constraint_conpfeqop - 1] = 'n';	if (conppeqopArray)		values[Anum_pg_constraint_conppeqop - 1] = PointerGetDatum(conppeqopArray);	else		nulls[Anum_pg_constraint_conppeqop - 1] = 'n';	if (conffeqopArray)		values[Anum_pg_constraint_conffeqop - 1] = PointerGetDatum(conffeqopArray);	else		nulls[Anum_pg_constraint_conffeqop - 1] = 'n';

//.........这里部分代码省略.........							variadicType = get_element_type(allParams[i]);							if (!OidIsValid(variadicType))								elog(ERROR, "variadic parameter is not an array");							break;					}					break;				default:					elog(ERROR, "invalid parameter mode '%c'", modes[i]);					break;			}		}	}	/*	 * All seems OK; prepare the data to be inserted into pg_proc.	 */	for (i = 0; i < Natts_pg_proc; ++i)	{		nulls[i] = false;		values[i] = (Datum) 0;		replaces[i] = true;	}	namestrcpy(&procname, procedureName);	values[Anum_pg_proc_proname - 1] = NameGetDatum(&procname);	values[Anum_pg_proc_pronamespace - 1] = ObjectIdGetDatum(procNamespace);	values[Anum_pg_proc_proowner - 1] = ObjectIdGetDatum(proowner);	values[Anum_pg_proc_prolang - 1] = ObjectIdGetDatum(languageObjectId);	values[Anum_pg_proc_procost - 1] = Float4GetDatum(procost);	values[Anum_pg_proc_prorows - 1] = Float4GetDatum(prorows);	values[Anum_pg_proc_provariadic - 1] = ObjectIdGetDatum(variadicType);	values[Anum_pg_proc_protransform - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_proc_proisagg - 1] = BoolGetDatum(isAgg);	values[Anum_pg_proc_proiswindow - 1] = BoolGetDatum(isWindowFunc);	values[Anum_pg_proc_prosecdef - 1] = BoolGetDatum(security_definer);	values[Anum_pg_proc_proisstrict - 1] = BoolGetDatum(isStrict);	values[Anum_pg_proc_proretset - 1] = BoolGetDatum(returnsSet);	values[Anum_pg_proc_provolatile - 1] = CharGetDatum(volatility);	values[Anum_pg_proc_pronargs - 1] = UInt16GetDatum(parameterCount);	values[Anum_pg_proc_pronargdefaults - 1] = UInt16GetDatum(list_length(parameterDefaults));	values[Anum_pg_proc_prorettype - 1] = ObjectIdGetDatum(returnType);	values[Anum_pg_proc_proargtypes - 1] = PointerGetDatum(parameterTypes);	if (allParameterTypes != PointerGetDatum(NULL))		values[Anum_pg_proc_proallargtypes - 1] = allParameterTypes;	else		nulls[Anum_pg_proc_proallargtypes - 1] = true;	if (parameterModes != PointerGetDatum(NULL))		values[Anum_pg_proc_proargmodes - 1] = parameterModes;	else		nulls[Anum_pg_proc_proargmodes - 1] = true;	if (parameterNames != PointerGetDatum(NULL))		values[Anum_pg_proc_proargnames - 1] = parameterNames;	else		nulls[Anum_pg_proc_proargnames - 1] = true;	if (parameterDefaults != NIL)		values[Anum_pg_proc_proargdefaults - 1] = CStringGetTextDatum(nodeToString(parameterDefaults));	else		nulls[Anum_pg_proc_proargdefaults - 1] = true;	values[Anum_pg_proc_prosrc - 1] = CStringGetTextDatum(prosrc);	if (probin)		values[Anum_pg_proc_probin - 1] = CStringGetTextDatum(probin);	else		nulls[Anum_pg_proc_probin - 1] = true;	if (proconfig != PointerGetDatum(NULL))		values[Anum_pg_proc_proconfig - 1] = proconfig;

static Datum _Boolean_coerceObject(Type self, jobject booleanObj){	return BoolGetDatum(booleanObj == 0 ? false : JNI_callBooleanMethod(booleanObj, s_Boolean_booleanValue) == JNI_TRUE);}

/* ---------------------------------------------------------------- *		TypeShellMake * *		This procedure inserts a "shell" tuple into the pg_type relation. *		The type tuple inserted has valid but dummy values, and its *		"typisdefined" field is false indicating it's not really defined. * *		This is used so that a tuple exists in the catalogs.  The I/O *		functions for the type will link to this tuple.  When the full *		CREATE TYPE command is issued, the bogus values will be replaced *		with correct ones, and "typisdefined" will be set to true. * ---------------------------------------------------------------- */OidTypeShellMake(const char *typeName, Oid typeNamespace, Oid ownerId){	Relation	pg_type_desc;	TupleDesc	tupDesc;	int			i;	HeapTuple	tup;	Datum		values[Natts_pg_type];	bool		nulls[Natts_pg_type];	Oid			typoid;	NameData	name;	Assert(PointerIsValid(typeName));	/*	 * open pg_type	 */	pg_type_desc = heap_open(TypeRelationId, RowExclusiveLock);	tupDesc = pg_type_desc->rd_att;	/*	 * initialize our *nulls and *values arrays	 */	for (i = 0; i < Natts_pg_type; ++i)	{		nulls[i] = false;		values[i] = (Datum) NULL;		/* redundant, but safe */	}	/*	 * initialize *values with the type name and dummy values	 *	 * The representational details are the same as int4 ... it doesn't really	 * matter what they are so long as they are consistent.  Also note that we	 * give it typtype = TYPTYPE_PSEUDO as extra insurance that it won't be	 * mistaken for a usable type.	 */	i = 0;	namestrcpy(&name, typeName);	values[i++] = NameGetDatum(&name);	/* typname */	values[i++] = ObjectIdGetDatum(typeNamespace);		/* typnamespace */	values[i++] = ObjectIdGetDatum(ownerId);	/* typowner */	values[i++] = Int16GetDatum(sizeof(int4));	/* typlen */	values[i++] = BoolGetDatum(true);	/* typbyval */	values[i++] = CharGetDatum(TYPTYPE_PSEUDO); /* typtype */	values[i++] = CharGetDatum(TYPCATEGORY_PSEUDOTYPE); /* typcategory */	values[i++] = BoolGetDatum(false);	/* typispreferred */	values[i++] = BoolGetDatum(false);	/* typisdefined */	values[i++] = CharGetDatum(DEFAULT_TYPDELIM);		/* typdelim */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typrelid */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typelem */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typarray */	values[i++] = ObjectIdGetDatum(F_SHELL_IN); /* typinput */	values[i++] = ObjectIdGetDatum(F_SHELL_OUT);		/* typoutput */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typreceive */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typsend */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typmodin */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typmodout */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typanalyze */	values[i++] = CharGetDatum('i');	/* typalign */	values[i++] = CharGetDatum('p');	/* typstorage */	values[i++] = BoolGetDatum(false);	/* typnotnull */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typbasetype */	values[i++] = Int32GetDatum(-1);	/* typtypmod */	values[i++] = Int32GetDatum(0);		/* typndims */	values[i++] = ObjectIdGetDatum(InvalidOid); /* typcollation */	nulls[i++] = true;			/* typdefaultbin */	nulls[i++] = true;			/* typdefault */	/*	 * create a new type tuple	 */	tup = heap_form_tuple(tupDesc, values, nulls);	/* Use binary-upgrade override for pg_type.oid, if supplied. */	if (IsBinaryUpgrade && OidIsValid(binary_upgrade_next_pg_type_oid))	{		HeapTupleSetOid(tup, binary_upgrade_next_pg_type_oid);		binary_upgrade_next_pg_type_oid = InvalidOid;	}	/*	 * insert the tuple in the relation and get the tuple's oid.	 */	typoid = simple_heap_insert(pg_type_desc, tup);	CatalogUpdateIndexes(pg_type_desc, tup);//.........这里部分代码省略.........

//.........这里部分代码省略.........							 false,		/* isStrict (not needed for agg) */							 PROVOLATILE_IMMUTABLE,		/* volatility (not														 * needed for agg) */							 PROPARALLEL_UNSAFE,							 parameterTypes,	/* paramTypes */							 allParameterTypes, /* allParamTypes */							 parameterModes,	/* parameterModes */							 parameterNames,	/* parameterNames */							 parameterDefaults, /* parameterDefaults */							 PointerGetDatum(NULL),		/* trftypes */							 PointerGetDatum(NULL),		/* proconfig */							 1, /* procost */							 0);	/* prorows */	procOid = myself.objectId;	/*	 * Okay to create the pg_aggregate entry.	 */	/* initialize nulls and values */	for (i = 0; i < Natts_pg_aggregate; i++)	{		nulls[i] = false;		values[i] = (Datum) NULL;	}	values[Anum_pg_aggregate_aggfnoid - 1] = ObjectIdGetDatum(procOid);	values[Anum_pg_aggregate_aggkind - 1] = CharGetDatum(aggKind);	values[Anum_pg_aggregate_aggnumdirectargs - 1] = Int16GetDatum(numDirectArgs);	values[Anum_pg_aggregate_aggtransfn - 1] = ObjectIdGetDatum(transfn);	values[Anum_pg_aggregate_aggfinalfn - 1] = ObjectIdGetDatum(finalfn);	values[Anum_pg_aggregate_aggmtransfn - 1] = ObjectIdGetDatum(mtransfn);	values[Anum_pg_aggregate_aggminvtransfn - 1] = ObjectIdGetDatum(minvtransfn);	values[Anum_pg_aggregate_aggmfinalfn - 1] = ObjectIdGetDatum(mfinalfn);	values[Anum_pg_aggregate_aggfinalextra - 1] = BoolGetDatum(finalfnExtraArgs);	values[Anum_pg_aggregate_aggmfinalextra - 1] = BoolGetDatum(mfinalfnExtraArgs);	values[Anum_pg_aggregate_aggsortop - 1] = ObjectIdGetDatum(sortop);	values[Anum_pg_aggregate_aggtranstype - 1] = ObjectIdGetDatum(aggTransType);	values[Anum_pg_aggregate_aggtransspace - 1] = Int32GetDatum(aggTransSpace);	values[Anum_pg_aggregate_aggmtranstype - 1] = ObjectIdGetDatum(aggmTransType);	values[Anum_pg_aggregate_aggmtransspace - 1] = Int32GetDatum(aggmTransSpace);	if (agginitval)		values[Anum_pg_aggregate_agginitval - 1] = CStringGetTextDatum(agginitval);	else		nulls[Anum_pg_aggregate_agginitval - 1] = true;	if (aggminitval)		values[Anum_pg_aggregate_aggminitval - 1] = CStringGetTextDatum(aggminitval);	else		nulls[Anum_pg_aggregate_aggminitval - 1] = true;	aggdesc = heap_open(AggregateRelationId, RowExclusiveLock);	tupDesc = aggdesc->rd_att;	tup = heap_form_tuple(tupDesc, values, nulls);	simple_heap_insert(aggdesc, tup);	CatalogUpdateIndexes(aggdesc, tup);	heap_close(aggdesc, RowExclusiveLock);	/*	 * Create dependencies for the aggregate (above and beyond those already	 * made by ProcedureCreate).  Note: we don't need an explicit dependency	 * on aggTransType since we depend on it indirectly through transfn.	 * Likewise for aggmTransType if any.	 */

//.........这里部分代码省略.........										 OIDOID, sizeof(Oid), true, 'i');	}	else	{		confkeyArray = NULL;		conpfeqopArray = NULL;		conppeqopArray = NULL;		conffeqopArray = NULL;	}	if (exclOp != NULL)	{		Datum	   *opdatums;		opdatums = (Datum *) palloc(constraintNKeys * sizeof(Datum));		for (i = 0; i < constraintNKeys; i++)			opdatums[i] = ObjectIdGetDatum(exclOp[i]);		conexclopArray = construct_array(opdatums, constraintNKeys,										 OIDOID, sizeof(Oid), true, 'i');	}	else		conexclopArray = NULL;	/* initialize nulls and values */	for (i = 0; i < Natts_pg_constraint; i++)	{		nulls[i] = false;		values[i] = (Datum) NULL;	}	values[Anum_pg_constraint_conname - 1] = NameGetDatum(&cname);	values[Anum_pg_constraint_connamespace - 1] = ObjectIdGetDatum(constraintNamespace);	values[Anum_pg_constraint_contype - 1] = CharGetDatum(constraintType);	values[Anum_pg_constraint_condeferrable - 1] = BoolGetDatum(isDeferrable);	values[Anum_pg_constraint_condeferred - 1] = BoolGetDatum(isDeferred);	values[Anum_pg_constraint_convalidated - 1] = BoolGetDatum(isValidated);	values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(relId);	values[Anum_pg_constraint_contypid - 1] = ObjectIdGetDatum(domainId);	values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(indexRelId);	values[Anum_pg_constraint_confrelid - 1] = ObjectIdGetDatum(foreignRelId);	values[Anum_pg_constraint_confupdtype - 1] = CharGetDatum(foreignUpdateType);	values[Anum_pg_constraint_confdeltype - 1] = CharGetDatum(foreignDeleteType);	values[Anum_pg_constraint_confmatchtype - 1] = CharGetDatum(foreignMatchType);	values[Anum_pg_constraint_conislocal - 1] = BoolGetDatum(conIsLocal);	values[Anum_pg_constraint_coninhcount - 1] = Int32GetDatum(conInhCount);	values[Anum_pg_constraint_conisonly - 1] = BoolGetDatum(conIsOnly);	if (conkeyArray)		values[Anum_pg_constraint_conkey - 1] = PointerGetDatum(conkeyArray);	else		nulls[Anum_pg_constraint_conkey - 1] = true;	if (confkeyArray)		values[Anum_pg_constraint_confkey - 1] = PointerGetDatum(confkeyArray);	else		nulls[Anum_pg_constraint_confkey - 1] = true;	if (conpfeqopArray)		values[Anum_pg_constraint_conpfeqop - 1] = PointerGetDatum(conpfeqopArray);	else		nulls[Anum_pg_constraint_conpfeqop - 1] = true;	if (conppeqopArray)		values[Anum_pg_constraint_conppeqop - 1] = PointerGetDatum(conppeqopArray);	else		nulls[Anum_pg_constraint_conppeqop - 1] = true;

Datumpg_control_checkpoint(PG_FUNCTION_ARGS){	Datum		values[19];	bool		nulls[19];	TupleDesc	tupdesc;	HeapTuple	htup;	ControlFileData *ControlFile;	XLogSegNo	segno;	char		xlogfilename[MAXFNAMELEN];	bool		crc_ok;	/*	 * Construct a tuple descriptor for the result row.  This must match this	 * function's pg_proc entry!	 */	tupdesc = CreateTemplateTupleDesc(18);	TupleDescInitEntry(tupdesc, (AttrNumber) 1, "checkpoint_lsn",					   LSNOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 2, "redo_lsn",					   LSNOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 3, "redo_wal_file",					   TEXTOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 4, "timeline_id",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 5, "prev_timeline_id",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 6, "full_page_writes",					   BOOLOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 7, "next_xid",					   TEXTOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 8, "next_oid",					   OIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 9, "next_multixact_id",					   XIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 10, "next_multi_offset",					   XIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 11, "oldest_xid",					   XIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 12, "oldest_xid_dbid",					   OIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 13, "oldest_active_xid",					   XIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 14, "oldest_multi_xid",					   XIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 15, "oldest_multi_dbid",					   OIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 16, "oldest_commit_ts_xid",					   XIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 17, "newest_commit_ts_xid",					   XIDOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 18, "checkpoint_time",					   TIMESTAMPTZOID, -1, 0);	tupdesc = BlessTupleDesc(tupdesc);	/* Read the control file. */	ControlFile = get_controlfile(DataDir, &crc_ok);	if (!crc_ok)		ereport(ERROR,				(errmsg("calculated CRC checksum does not match value stored in file")));	/*	 * Calculate name of the WAL file containing the latest checkpoint's REDO	 * start point.	 */	XLByteToSeg(ControlFile->checkPointCopy.redo, segno, wal_segment_size);	XLogFileName(xlogfilename, ControlFile->checkPointCopy.ThisTimeLineID,				 segno, wal_segment_size);	/* Populate the values and null arrays */	values[0] = LSNGetDatum(ControlFile->checkPoint);	nulls[0] = false;	values[1] = LSNGetDatum(ControlFile->checkPointCopy.redo);	nulls[1] = false;	values[2] = CStringGetTextDatum(xlogfilename);	nulls[2] = false;	values[3] = Int32GetDatum(ControlFile->checkPointCopy.ThisTimeLineID);	nulls[3] = false;	values[4] = Int32GetDatum(ControlFile->checkPointCopy.PrevTimeLineID);	nulls[4] = false;	values[5] = BoolGetDatum(ControlFile->checkPointCopy.fullPageWrites);	nulls[5] = false;	values[6] = CStringGetTextDatum(psprintf("%u:%u",											 EpochFromFullTransactionId(ControlFile->checkPointCopy.nextFullXid),											 XidFromFullTransactionId(ControlFile->checkPointCopy.nextFullXid)));	nulls[6] = false;	values[7] = ObjectIdGetDatum(ControlFile->checkPointCopy.nextOid);	nulls[7] = false;	values[8] = TransactionIdGetDatum(ControlFile->checkPointCopy.nextMulti);	nulls[8] = false;	values[9] = TransactionIdGetDatum(ControlFile->checkPointCopy.nextMultiOffset);//.........这里部分代码省略.........

//.........这里部分代码省略.........			LWLockAcquire(FirstBufMappingLock + i, LW_SHARED);		/*		 * Scan though all the buffers, saving the relevant fields in the		 * fctx->record structure.		 */		for (i = 0, bufHdr = BufferDescriptors; i < NBuffers; i++, bufHdr++)		{			/* Lock each buffer header before inspecting. */			LockBufHdr(bufHdr);			fctx->record[i].bufferid = BufferDescriptorGetBuffer(bufHdr);			fctx->record[i].relfilenode = bufHdr->tag.rnode.relNode;			fctx->record[i].reltablespace = bufHdr->tag.rnode.spcNode;			fctx->record[i].reldatabase = bufHdr->tag.rnode.dbNode;			fctx->record[i].forknum = bufHdr->tag.forkNum;			fctx->record[i].blocknum = bufHdr->tag.blockNum;			fctx->record[i].usagecount = bufHdr->usage_count;			if (bufHdr->flags & BM_DIRTY)				fctx->record[i].isdirty = true;			else				fctx->record[i].isdirty = false;			/* Note if the buffer is valid, and has storage created */			if ((bufHdr->flags & BM_VALID) && (bufHdr->flags & BM_TAG_VALID))				fctx->record[i].isvalid = true;			else				fctx->record[i].isvalid = false;			UnlockBufHdr(bufHdr);		}		/*		 * And release locks.  We do this in reverse order for two reasons:		 * (1) Anyone else who needs more than one of the locks will be trying		 * to lock them in increasing order; we don't want to release the		 * other process until it can get all the locks it needs. (2) This		 * avoids O(N^2) behavior inside LWLockRelease.		 */		for (i = NUM_BUFFER_PARTITIONS; --i >= 0;)			LWLockRelease(FirstBufMappingLock + i);	}	funcctx = SRF_PERCALL_SETUP();	/* Get the saved state */	fctx = funcctx->user_fctx;	if (funcctx->call_cntr < funcctx->max_calls)	{		uint32		i = funcctx->call_cntr;		Datum		values[NUM_BUFFERCACHE_PAGES_ELEM];		bool		nulls[NUM_BUFFERCACHE_PAGES_ELEM];		values[0] = Int32GetDatum(fctx->record[i].bufferid);		nulls[0] = false;		/*		 * Set all fields except the bufferid to null if the buffer is unused		 * or not valid.		 */		if (fctx->record[i].blocknum == InvalidBlockNumber ||			fctx->record[i].isvalid == false)		{			nulls[1] = true;			nulls[2] = true;			nulls[3] = true;			nulls[4] = true;			nulls[5] = true;			nulls[6] = true;			nulls[7] = true;		}		else		{			values[1] = ObjectIdGetDatum(fctx->record[i].relfilenode);			nulls[1] = false;			values[2] = ObjectIdGetDatum(fctx->record[i].reltablespace);			nulls[2] = false;			values[3] = ObjectIdGetDatum(fctx->record[i].reldatabase);			nulls[3] = false;			values[4] = ObjectIdGetDatum(fctx->record[i].forknum);			nulls[4] = false;			values[5] = Int64GetDatum((int64) fctx->record[i].blocknum);			nulls[5] = false;			values[6] = BoolGetDatum(fctx->record[i].isdirty);			nulls[6] = false;			values[7] = Int16GetDatum(fctx->record[i].usagecount);			nulls[7] = false;		}		/* Build and return the tuple. */		tuple = heap_form_tuple(fctx->tupdesc, values, nulls);		result = HeapTupleGetDatum(tuple);		SRF_RETURN_NEXT(funcctx, result);	}	else		SRF_RETURN_DONE(funcctx);}

/* * InsertRule - *	  takes the arguments and inserts them as a row into the system *	  relation "pg_rewrite" */static OidInsertRule(char *rulname,		   int evtype,		   Oid eventrel_oid,		   AttrNumber evslot_index,		   bool evinstead,		   Node *event_qual,		   List *action,		   bool replace,		   Oid ruleOid){	char	   *evqual = nodeToString(event_qual);	char	   *actiontree = nodeToString((Node *) action);	int			i;	Datum		values[Natts_pg_rewrite];	bool		nulls[Natts_pg_rewrite];	bool		replaces[Natts_pg_rewrite];	NameData	rname;	HeapTuple	tup,				oldtup;	Oid			rewriteObjectId;	ObjectAddress myself,				referenced;	bool		is_update = false;	cqContext  *pcqCtx;	/*	 * Set up *nulls and *values arrays	 */	MemSet(nulls, false, sizeof(nulls));	i = 0;	namestrcpy(&rname, rulname);	values[i++] = NameGetDatum(&rname); /* rulename */	values[i++] = ObjectIdGetDatum(eventrel_oid);		/* ev_class */	values[i++] = Int16GetDatum(evslot_index);	/* ev_attr */	values[i++] = CharGetDatum(evtype + '0');	/* ev_type */	values[i++] = BoolGetDatum(evinstead);		/* is_instead */	values[i++] = CStringGetTextDatum(evqual);	/* ev_qual */	values[i++] = CStringGetTextDatum(actiontree);		/* ev_action */	/*	 * Ready to store new pg_rewrite tuple	 */	/*	 * Check to see if we are replacing an existing tuple	 */	pcqCtx = caql_beginscan(			NULL,			cql("SELECT * FROM pg_rewrite "				" WHERE ev_class = :1 "				" AND rulename = :2 "				" FOR UPDATE ",				ObjectIdGetDatum(eventrel_oid),				CStringGetDatum(rulname)));		oldtup = caql_getnext(pcqCtx);	if (HeapTupleIsValid(oldtup))	{		if (!replace)			ereport(ERROR,					(errcode(ERRCODE_DUPLICATE_OBJECT),					 errmsg("rule /"%s/" for relation /"%s/" already exists",							rulname, get_rel_name(eventrel_oid))));		/*		 * When replacing, we don't need to replace every attribute		 */		MemSet(replaces, false, sizeof(replaces));		replaces[Anum_pg_rewrite_ev_attr - 1] = true;		replaces[Anum_pg_rewrite_ev_type - 1] = true;		replaces[Anum_pg_rewrite_is_instead - 1] = true;		replaces[Anum_pg_rewrite_ev_qual - 1] = true;		replaces[Anum_pg_rewrite_ev_action - 1] = true;		tup = caql_modify_current(pcqCtx,								  values, nulls, replaces);		caql_update_current(pcqCtx, tup);		/* and Update indexes (implicit) */		rewriteObjectId = HeapTupleGetOid(tup);		is_update = true;	}	else	{		tup = caql_form_tuple(pcqCtx, values, nulls);		if (OidIsValid(ruleOid))			HeapTupleSetOid(tup, ruleOid);		rewriteObjectId = caql_insert(pcqCtx, tup);		/* and Update indexes (implicit) *///.........这里部分代码省略.........

Datumquery_types(PG_FUNCTION_ARGS){	FuncCallContext *funcctx;	CmdType         MaxCmdElement = CMD_NOTHING;	if (SRF_IS_FIRSTCALL()) {		MemoryContext   oldcontext;		TupleDesc       tupdesc;		funcctx = SRF_FIRSTCALL_INIT();		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);		tupdesc = CreateTemplateTupleDesc(3, false);		TupleDescInitEntry(tupdesc, (AttrNumber) 1, "id",				   INT4OID, -1, 0);		TupleDescInitEntry(tupdesc, (AttrNumber) 2, "modify",				   BOOLOID, -1, 0);		TupleDescInitEntry(tupdesc, (AttrNumber) 3, "name",				   TEXTOID, -1, 0);		funcctx->tuple_desc = BlessTupleDesc(tupdesc);		MemoryContextSwitchTo(oldcontext);	}	funcctx = SRF_PERCALL_SETUP();	if (funcctx->call_cntr < MaxCmdElement + 1) {		Datum           values[3];		bool            nulls[3];		HeapTuple       tuple;		CmdType         current;		MemSet(values, 0, sizeof(values));		MemSet(nulls, false, sizeof(nulls));		current = (CmdType) funcctx->call_cntr;		values[0] = Int32GetDatum(funcctx->call_cntr);		if (CMD_SELECT == current) {			values[1] = BoolGetDatum(false);		} else {			values[1] = BoolGetDatum(true);		}		switch (current) {		case CMD_UNKNOWN:			values[2] = CStringGetDatum(cstring_to_text("UNKNOWN"));			break;		case CMD_SELECT:			values[2] = CStringGetDatum(cstring_to_text("SELECT"));			break;		case CMD_UPDATE:			values[2] = CStringGetDatum(cstring_to_text("UPDATE"));			break;		case CMD_INSERT:			values[2] = CStringGetDatum(cstring_to_text("INSERT"));			break;		case CMD_DELETE:			values[2] = CStringGetDatum(cstring_to_text("DELETE"));			break;		case CMD_UTILITY:			values[2] = CStringGetDatum(cstring_to_text("UTILITY"));			break;		case CMD_NOTHING:			values[2] = CStringGetDatum(cstring_to_text("NOTHING"));			break;		default:			values[2] = CStringGetDatum(cstring_to_text("UNKNOWN"));			break;		}		tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);		SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));		funcctx->call_cntr++;	} else {		SRF_RETURN_DONE(funcctx);	}}

//.........这里部分代码省略.........			nulls[4] = false;			values[4] = CStringGetTextDatum("<backend information not available>");			tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);			SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));		}		/* Values available to all callers */		values[0] = ObjectIdGetDatum(beentry->st_databaseid);		values[1] = Int32GetDatum(beentry->st_procpid);		values[2] = ObjectIdGetDatum(beentry->st_userid);		if (beentry->st_appname)			values[3] = CStringGetTextDatum(beentry->st_appname);		else			nulls[3] = true;		/* Values only available to same user or superuser */		if (superuser() || beentry->st_userid == GetUserId())		{			SockAddr	zero_clientaddr;			bool		waiting;			if (*(beentry->st_activity) == '/0')			{				values[4] = CStringGetTextDatum("<command string not enabled>");			}			else			{				values[4] = CStringGetTextDatum(beentry->st_activity);			}			waiting = beentry->st_waiting != PGBE_WAITING_NONE;			values[5] = BoolGetDatum(beentry->st_waiting);			if (beentry->st_xact_start_timestamp != 0)				values[6] = TimestampTzGetDatum(beentry->st_xact_start_timestamp);			else				nulls[6] = true;			if (beentry->st_activity_start_timestamp != 0)				values[7] = TimestampTzGetDatum(beentry->st_activity_start_timestamp);			else				nulls[7] = true;			if (beentry->st_proc_start_timestamp != 0)				values[8] = TimestampTzGetDatum(beentry->st_proc_start_timestamp);			else				nulls[8] = true;			/* A zeroed client addr means we don't know */			memset(&zero_clientaddr, 0, sizeof(zero_clientaddr));			if (memcmp(&(beentry->st_clientaddr), &zero_clientaddr,					   sizeof(zero_clientaddr)) == 0)			{				nulls[9] = true;				nulls[10] = true;			}			else			{				if (beentry->st_clientaddr.addr.ss_family == AF_INET#ifdef HAVE_IPV6					|| beentry->st_clientaddr.addr.ss_family == AF_INET6#endif					)				{

//.........这里部分代码省略.........		 * fctx->record structure.		 *		 * We don't hold the partition locks, so we don't get a consistent		 * snapshot across all buffers, but we do grab the buffer header		 * locks, so the information of each buffer is self-consistent.		 */		for (i = 0; i < NBuffers; i++)		{			BufferDesc *bufHdr;			uint32		buf_state;			bufHdr = GetBufferDescriptor(i);			/* Lock each buffer header before inspecting. */			buf_state = LockBufHdr(bufHdr);			fctx->record[i].bufferid = BufferDescriptorGetBuffer(bufHdr);			fctx->record[i].relfilenode = bufHdr->tag.rnode.relNode;			fctx->record[i].reltablespace = bufHdr->tag.rnode.spcNode;			fctx->record[i].reldatabase = bufHdr->tag.rnode.dbNode;			fctx->record[i].forknum = bufHdr->tag.forkNum;			fctx->record[i].blocknum = bufHdr->tag.blockNum;			fctx->record[i].usagecount = BUF_STATE_GET_USAGECOUNT(buf_state);			fctx->record[i].pinning_backends = BUF_STATE_GET_REFCOUNT(buf_state);			if (buf_state & BM_DIRTY)				fctx->record[i].isdirty = true;			else				fctx->record[i].isdirty = false;			/* Note if the buffer is valid, and has storage created */			if ((buf_state & BM_VALID) && (buf_state & BM_TAG_VALID))				fctx->record[i].isvalid = true;			else				fctx->record[i].isvalid = false;			UnlockBufHdr(bufHdr, buf_state);		}	}	funcctx = SRF_PERCALL_SETUP();	/* Get the saved state */	fctx = funcctx->user_fctx;	if (funcctx->call_cntr < funcctx->max_calls)	{		uint32		i = funcctx->call_cntr;		Datum		values[NUM_BUFFERCACHE_PAGES_ELEM];		bool		nulls[NUM_BUFFERCACHE_PAGES_ELEM];		values[0] = Int32GetDatum(fctx->record[i].bufferid);		nulls[0] = false;		/*		 * Set all fields except the bufferid to null if the buffer is unused		 * or not valid.		 */		if (fctx->record[i].blocknum == InvalidBlockNumber ||			fctx->record[i].isvalid == false)		{			nulls[1] = true;			nulls[2] = true;			nulls[3] = true;			nulls[4] = true;			nulls[5] = true;			nulls[6] = true;			nulls[7] = true;			/* unused for v1.0 callers, but the array is always long enough */			nulls[8] = true;		}		else		{			values[1] = ObjectIdGetDatum(fctx->record[i].relfilenode);			nulls[1] = false;			values[2] = ObjectIdGetDatum(fctx->record[i].reltablespace);			nulls[2] = false;			values[3] = ObjectIdGetDatum(fctx->record[i].reldatabase);			nulls[3] = false;			values[4] = ObjectIdGetDatum(fctx->record[i].forknum);			nulls[4] = false;			values[5] = Int64GetDatum((int64) fctx->record[i].blocknum);			nulls[5] = false;			values[6] = BoolGetDatum(fctx->record[i].isdirty);			nulls[6] = false;			values[7] = Int16GetDatum(fctx->record[i].usagecount);			nulls[7] = false;			/* unused for v1.0 callers, but the array is always long enough */			values[8] = Int32GetDatum(fctx->record[i].pinning_backends);			nulls[8] = false;		}		/* Build and return the tuple. */		tuple = heap_form_tuple(fctx->tupdesc, values, nulls);		result = HeapTupleGetDatum(tuple);		SRF_RETURN_NEXT(funcctx, result);	}	else		SRF_RETURN_DONE(funcctx);}

//.........这里部分代码省略.........	{		/* negator has same arg types */		negatorId = get_other_operator(negatorName,									   leftTypeId, rightTypeId,									   operatorName, operatorNamespace,									   leftTypeId, rightTypeId,									   false);		/* Permission check: must own other operator */		if (OidIsValid(negatorId) &&			!pg_oper_ownercheck(negatorId, GetUserId()))			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPER,						   NameListToString(negatorName));	}	else		negatorId = InvalidOid;	/*	 * set up values in the operator tuple	 */	for (i = 0; i < Natts_pg_operator; ++i)	{		values[i] = (Datum) NULL;		replaces[i] = true;		nulls[i] = false;	}	namestrcpy(&oname, operatorName);	values[Anum_pg_operator_oprname - 1] = NameGetDatum(&oname);	values[Anum_pg_operator_oprnamespace - 1] = ObjectIdGetDatum(operatorNamespace);	values[Anum_pg_operator_oprowner - 1] = ObjectIdGetDatum(GetUserId());	values[Anum_pg_operator_oprkind - 1] = CharGetDatum(leftTypeId ? (rightTypeId ? 'b' : 'r') : 'l');	values[Anum_pg_operator_oprcanmerge - 1] = BoolGetDatum(canMerge);	values[Anum_pg_operator_oprcanhash - 1] = BoolGetDatum(canHash);	values[Anum_pg_operator_oprleft - 1] = ObjectIdGetDatum(leftTypeId);	values[Anum_pg_operator_oprright - 1] = ObjectIdGetDatum(rightTypeId);	values[Anum_pg_operator_oprresult - 1] = ObjectIdGetDatum(operResultType);	values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(commutatorId);	values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(negatorId);	values[Anum_pg_operator_oprcode - 1] = ObjectIdGetDatum(procedureId);	values[Anum_pg_operator_oprrest - 1] = ObjectIdGetDatum(restrictionId);	values[Anum_pg_operator_oprjoin - 1] = ObjectIdGetDatum(joinId);	pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);	/*	 * If we are replacing an operator shell, update; else insert	 */	if (operatorObjectId)	{		tup = SearchSysCacheCopy1(OPEROID,								  ObjectIdGetDatum(operatorObjectId));		if (!HeapTupleIsValid(tup))			elog(ERROR, "cache lookup failed for operator %u",				 operatorObjectId);		tup = heap_modify_tuple(tup,								RelationGetDescr(pg_operator_desc),								values,								nulls,								replaces);		simple_heap_update(pg_operator_desc, &tup->t_self, tup);	}	else

/* * OperatorShellMake *		Make a "shell" entry for a not-yet-existing operator. */static OidOperatorShellMake(const char *operatorName,				  Oid operatorNamespace,				  Oid leftTypeId,				  Oid rightTypeId){	Relation	pg_operator_desc;	Oid			operatorObjectId;	int			i;	HeapTuple	tup;	Datum		values[Natts_pg_operator];	bool		nulls[Natts_pg_operator];	NameData	oname;	TupleDesc	tupDesc;	/*	 * validate operator name	 */	if (!validOperatorName(operatorName))		ereport(ERROR,				(errcode(ERRCODE_INVALID_NAME),				 errmsg("/"%s/" is not a valid operator name",						operatorName)));	/*	 * initialize our *nulls and *values arrays	 */	for (i = 0; i < Natts_pg_operator; ++i)	{		nulls[i] = false;		values[i] = (Datum) NULL;		/* redundant, but safe */	}	/*	 * initialize values[] with the operator name and input data types. Note	 * that oprcode is set to InvalidOid, indicating it's a shell.	 */	namestrcpy(&oname, operatorName);	values[Anum_pg_operator_oprname - 1] = NameGetDatum(&oname);	values[Anum_pg_operator_oprnamespace - 1] = ObjectIdGetDatum(operatorNamespace);	values[Anum_pg_operator_oprowner - 1] = ObjectIdGetDatum(GetUserId());	values[Anum_pg_operator_oprkind - 1] = CharGetDatum(leftTypeId ? (rightTypeId ? 'b' : 'r') : 'l');	values[Anum_pg_operator_oprcanmerge - 1] = BoolGetDatum(false);	values[Anum_pg_operator_oprcanhash - 1] = BoolGetDatum(false);	values[Anum_pg_operator_oprleft - 1] = ObjectIdGetDatum(leftTypeId);	values[Anum_pg_operator_oprright - 1] = ObjectIdGetDatum(rightTypeId);	values[Anum_pg_operator_oprresult - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_operator_oprcode - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_operator_oprrest - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_operator_oprjoin - 1] = ObjectIdGetDatum(InvalidOid);	/*	 * open pg_operator	 */	pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);	tupDesc = pg_operator_desc->rd_att;	/*	 * create a new operator tuple	 */	tup = heap_form_tuple(tupDesc, values, nulls);	/*	 * insert our "shell" operator tuple	 */	operatorObjectId = simple_heap_insert(pg_operator_desc, tup);	CatalogUpdateIndexes(pg_operator_desc, tup);	/* Add dependencies for the entry */	makeOperatorDependencies(tup);	heap_freetuple(tup);	/* Post creation hook for new shell operator */	InvokeObjectAccessHook(OAT_POST_CREATE,						   OperatorRelationId, operatorObjectId, 0);	/*	 * Make sure the tuple is visible for subsequent lookups/updates.	 */	CommandCounterIncrement();	/*	 * close the operator relation and return the oid.	 */	heap_close(pg_operator_desc, RowExclusiveLock);	return operatorObjectId;}

//.........这里部分代码省略.........		ColumnDef  *coldef = makeNode(ColumnDef);		coldef->inhcount = 0;		coldef->is_local = true;		coldef->is_not_null = true;		coldef->is_from_type = false;		coldef->storage = 0;		coldef->raw_default = NULL;		coldef->cooked_default = NULL;		coldef->collClause = NULL;		coldef->collOid = InvalidOid;		coldef->constraints = NIL;		coldef->location = -1;		null[i - 1] = false;		switch (i)		{			case SEQ_COL_NAME:				coldef->typeName = makeTypeNameFromOid(NAMEOID, -1);				coldef->colname = "sequence_name";				namestrcpy(&name, seq->sequence->relname);				value[i - 1] = NameGetDatum(&name);				break;			case SEQ_COL_LASTVAL:				coldef->typeName = makeTypeNameFromOid(INT8OID, -1);				coldef->colname = "last_value";				value[i - 1] = Int64GetDatumFast(new___.last_value);				break;			case SEQ_COL_STARTVAL:				coldef->typeName = makeTypeNameFromOid(INT8OID, -1);				coldef->colname = "start_value";				value[i - 1] = Int64GetDatumFast(new___.start_value);				break;			case SEQ_COL_INCBY:				coldef->typeName = makeTypeNameFromOid(INT8OID, -1);				coldef->colname = "increment_by";				value[i - 1] = Int64GetDatumFast(new___.increment_by);				break;			case SEQ_COL_MAXVALUE:				coldef->typeName = makeTypeNameFromOid(INT8OID, -1);				coldef->colname = "max_value";				value[i - 1] = Int64GetDatumFast(new___.max_value);				break;			case SEQ_COL_MINVALUE:				coldef->typeName = makeTypeNameFromOid(INT8OID, -1);				coldef->colname = "min_value";				value[i - 1] = Int64GetDatumFast(new___.min_value);				break;			case SEQ_COL_CACHE:				coldef->typeName = makeTypeNameFromOid(INT8OID, -1);				coldef->colname = "cache_value";				value[i - 1] = Int64GetDatumFast(new___.cache_value);				break;			case SEQ_COL_LOG:				coldef->typeName = makeTypeNameFromOid(INT8OID, -1);				coldef->colname = "log_cnt";				value[i - 1] = Int64GetDatum((int64) 0);				break;			case SEQ_COL_CYCLE:				coldef->typeName = makeTypeNameFromOid(BOOLOID, -1);				coldef->colname = "is_cycled";				value[i - 1] = BoolGetDatum(new___.is_cycled);				break;			case SEQ_COL_CALLED:				coldef->typeName = makeTypeNameFromOid(BOOLOID, -1);				coldef->colname = "is_called";				value[i - 1] = BoolGetDatum(false);				break;		}		stmt->tableElts = lappend(stmt->tableElts, coldef);	}	stmt->relation = seq->sequence;	stmt->inhRelations = NIL;	stmt->constraints = NIL;	stmt->options = NIL;	stmt->oncommit = ONCOMMIT_NOOP;	stmt->tablespacename = NULL;	stmt->if_not_exists = seq->if_not_exists;	address = DefineRelation(stmt, RELKIND_SEQUENCE, seq->ownerId, NULL);	seqoid = address.objectId;	Assert(seqoid != InvalidOid);	rel = heap_open(seqoid, AccessExclusiveLock);	tupDesc = RelationGetDescr(rel);	/* now initialize the sequence's data */	tuple = heap_form_tuple(tupDesc, value, null);	fill_seq_with_data(rel, tuple);	/* process OWNED BY if given */	if (owned_by)		process_owned_by(rel, owned_by);	heap_close(rel, NoLock);	return address;}

/* * OperatorShellMake *		Make a "shell" entry for a not-yet-existing operator. */static OidOperatorShellMake(const char *operatorName,				  Oid operatorNamespace,				  Oid leftTypeId,				  Oid rightTypeId){	Relation	pg_operator_desc;	Oid			operatorObjectId;	int			i;	HeapTuple	tup;	Datum		values[Natts_pg_operator];	char		nulls[Natts_pg_operator];	NameData	oname;	TupleDesc	tupDesc;	/*	 * validate operator name	 */	if (!validOperatorName(operatorName))		ereport(ERROR,				(errcode(ERRCODE_INVALID_NAME),				 errmsg("/"%s/" is not a valid operator name",						operatorName)));	/*	 * initialize our *nulls and *values arrays	 */	for (i = 0; i < Natts_pg_operator; ++i)	{		nulls[i] = ' ';		values[i] = (Datum) NULL;		/* redundant, but safe */	}	/*	 * initialize values[] with the operator name and input data types.	 * Note that oprcode is set to InvalidOid, indicating it's a shell.	 */	i = 0;	namestrcpy(&oname, operatorName);	values[i++] = NameGetDatum(&oname); /* oprname */	values[i++] = ObjectIdGetDatum(operatorNamespace);	/* oprnamespace */	values[i++] = Int32GetDatum(GetUserId());	/* oprowner */	values[i++] = CharGetDatum(leftTypeId ? (rightTypeId ? 'b' : 'r') : 'l');	/* oprkind */	values[i++] = BoolGetDatum(false);	/* oprcanhash */	values[i++] = ObjectIdGetDatum(leftTypeId); /* oprleft */	values[i++] = ObjectIdGetDatum(rightTypeId);		/* oprright */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprresult */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprcom */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprnegate */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprlsortop */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprrsortop */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprltcmpop */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprgtcmpop */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprcode */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprrest */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprjoin */	/*	 * open pg_operator	 */	pg_operator_desc = heap_openr(OperatorRelationName, RowExclusiveLock);	tupDesc = pg_operator_desc->rd_att;	/*	 * create a new operator tuple	 */	tup = heap_formtuple(tupDesc, values, nulls);	/*	 * insert our "shell" operator tuple	 */	operatorObjectId = simple_heap_insert(pg_operator_desc, tup);	CatalogUpdateIndexes(pg_operator_desc, tup);	/* Add dependencies for the entry */	makeOperatorDependencies(tup, RelationGetRelid(pg_operator_desc));	heap_freetuple(tup);	/*	 * close the operator relation and return the oid.	 */	heap_close(pg_operator_desc, RowExclusiveLock);	return operatorObjectId;}

//.........这里部分代码省略.........											  PageGetItemId(state->page,															state->offset));				state->dtup = brin_deform_tuple(state->bdesc, tup);				state->attno = 1;				state->unusedItem = false;			}			else				state->unusedItem = true;			MemoryContextSwitchTo(mctx);		}		else			state->attno++;		MemSet(nulls, 0, sizeof(nulls));		if (state->unusedItem)		{			values[0] = UInt16GetDatum(state->offset);			nulls[1] = true;			nulls[2] = true;			nulls[3] = true;			nulls[4] = true;			nulls[5] = true;			nulls[6] = true;		}		else		{			int		att = state->attno - 1;			values[0] = UInt16GetDatum(state->offset);			values[1] = UInt32GetDatum(state->dtup->bt_blkno);			values[2] = UInt16GetDatum(state->attno);			values[3] = BoolGetDatum(state->dtup->bt_columns[att].bv_allnulls);			values[4] = BoolGetDatum(state->dtup->bt_columns[att].bv_hasnulls);			values[5] = BoolGetDatum(state->dtup->bt_placeholder);			if (!state->dtup->bt_columns[att].bv_allnulls)			{				BrinValues   *bvalues = &state->dtup->bt_columns[att];				StringInfoData	s;				bool		first;				int			i;				initStringInfo(&s);				appendStringInfoChar(&s, '{');				first = true;				for (i = 0; i < state->columns[att]->nstored; i++)				{					char   *val;					if (!first)						appendStringInfoString(&s, " .. ");					first = false;					val = OutputFunctionCall(&state->columns[att]->outputFn[i],											 bvalues->bv_values[i]);					appendStringInfoString(&s, val);					pfree(val);				}				appendStringInfoChar(&s, '}');				values[6] = CStringGetTextDatum(s.data);				pfree(s.data);			}			else			{

//.........这里部分代码省略.........	/*	 * find join estimator	 */	if (joinName)	{		MemSet(typeId, 0, FUNC_MAX_ARGS * sizeof(Oid));		typeId[0] = INTERNALOID;	/* Query */		typeId[1] = OIDOID;		/* operator OID */		typeId[2] = INTERNALOID;	/* args list */		typeId[3] = INT2OID;	/* jointype */		joinOid = LookupFuncName(joinName, 4, typeId, false);	}	else		joinOid = InvalidOid;	/*	 * set up values in the operator tuple	 */	for (i = 0; i < Natts_pg_operator; ++i)	{		values[i] = (Datum) NULL;		replaces[i] = 'r';		nulls[i] = ' ';	}	i = 0;	namestrcpy(&oname, operatorName);	values[i++] = NameGetDatum(&oname); /* oprname */	values[i++] = ObjectIdGetDatum(operatorNamespace);	/* oprnamespace */	values[i++] = Int32GetDatum(GetUserId());	/* oprowner */	values[i++] = CharGetDatum(leftTypeId ? (rightTypeId ? 'b' : 'r') : 'l');	/* oprkind */	values[i++] = BoolGetDatum(canHash);		/* oprcanhash */	values[i++] = ObjectIdGetDatum(leftTypeId); /* oprleft */	values[i++] = ObjectIdGetDatum(rightTypeId);		/* oprright */	values[i++] = ObjectIdGetDatum(operResultType);		/* oprresult */	/*	 * Set up the other operators.	If they do not currently exist, create	 * shells in order to get ObjectId's.	 */	if (commutatorName)	{		/* commutator has reversed arg types */		commutatorId = get_other_operator(commutatorName,										  rightTypeId, leftTypeId,										  operatorName, operatorNamespace,										  leftTypeId, rightTypeId,										  true);		/*		 * self-linkage to this operator; will fix below. Note that only		 * self-linkage for commutation makes sense.		 */		if (!OidIsValid(commutatorId))			selfCommutator = true;	}	else		commutatorId = InvalidOid;	values[i++] = ObjectIdGetDatum(commutatorId);		/* oprcom */	if (negatorName)	{		/* negator has same arg types */

Datumpg_control_init(PG_FUNCTION_ARGS){	Datum		values[12];	bool		nulls[12];	TupleDesc	tupdesc;	HeapTuple	htup;	ControlFileData *ControlFile;	bool		crc_ok;	/*	 * Construct a tuple descriptor for the result row.  This must match this	 * function's pg_proc entry!	 */	tupdesc = CreateTemplateTupleDesc(12);	TupleDescInitEntry(tupdesc, (AttrNumber) 1, "max_data_alignment",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 2, "database_block_size",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 3, "blocks_per_segment",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 4, "wal_block_size",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 5, "bytes_per_wal_segment",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 6, "max_identifier_length",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 7, "max_index_columns",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 8, "max_toast_chunk_size",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 9, "large_object_chunk_size",					   INT4OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 10, "float4_pass_by_value",					   BOOLOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 11, "float8_pass_by_value",					   BOOLOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 12, "data_page_checksum_version",					   INT4OID, -1, 0);	tupdesc = BlessTupleDesc(tupdesc);	/* read the control file */	ControlFile = get_controlfile(DataDir, &crc_ok);	if (!crc_ok)		ereport(ERROR,				(errmsg("calculated CRC checksum does not match value stored in file")));	values[0] = Int32GetDatum(ControlFile->maxAlign);	nulls[0] = false;	values[1] = Int32GetDatum(ControlFile->blcksz);	nulls[1] = false;	values[2] = Int32GetDatum(ControlFile->relseg_size);	nulls[2] = false;	values[3] = Int32GetDatum(ControlFile->xlog_blcksz);	nulls[3] = false;	values[4] = Int32GetDatum(ControlFile->xlog_seg_size);	nulls[4] = false;	values[5] = Int32GetDatum(ControlFile->nameDataLen);	nulls[5] = false;	values[6] = Int32GetDatum(ControlFile->indexMaxKeys);	nulls[6] = false;	values[7] = Int32GetDatum(ControlFile->toast_max_chunk_size);	nulls[7] = false;	values[8] = Int32GetDatum(ControlFile->loblksize);	nulls[8] = false;	values[9] = BoolGetDatum(ControlFile->float4ByVal);	nulls[9] = false;	values[10] = BoolGetDatum(ControlFile->float8ByVal);	nulls[10] = false;	values[11] = Int32GetDatum(ControlFile->data_checksum_version);	nulls[11] = false;	htup = heap_form_tuple(tupdesc, values, nulls);	PG_RETURN_DATUM(HeapTupleGetDatum(htup));}

/* * InsertRule - *	  takes the arguments and inserts them as a row into the system *	  relation "pg_rewrite" */static OidInsertRule(char *rulname,		   int evtype,		   Oid eventrel_oid,		   AttrNumber evslot_index,		   bool evinstead,		   Node *event_qual,		   List *action,		   bool replace){	char	   *evqual = nodeToString(event_qual);	char	   *actiontree = nodeToString((Node *) action);	Datum		values[Natts_pg_rewrite];	bool		nulls[Natts_pg_rewrite];	bool		replaces[Natts_pg_rewrite];	NameData	rname;	Relation	pg_rewrite_desc;	HeapTuple	tup,				oldtup;	Oid			rewriteObjectId;	ObjectAddress myself,				referenced;	bool		is_update = false;	/*	 * Set up *nulls and *values arrays	 */	MemSet(nulls, false, sizeof(nulls));	namestrcpy(&rname, rulname);	values[Anum_pg_rewrite_rulename - 1] = NameGetDatum(&rname);	values[Anum_pg_rewrite_ev_class - 1] = ObjectIdGetDatum(eventrel_oid);	values[Anum_pg_rewrite_ev_attr - 1] = Int16GetDatum(evslot_index);	values[Anum_pg_rewrite_ev_type - 1] = CharGetDatum(evtype + '0');	values[Anum_pg_rewrite_ev_enabled - 1] = CharGetDatum(RULE_FIRES_ON_ORIGIN);	values[Anum_pg_rewrite_is_instead - 1] = BoolGetDatum(evinstead);	values[Anum_pg_rewrite_ev_qual - 1] = CStringGetTextDatum(evqual);	values[Anum_pg_rewrite_ev_action - 1] = CStringGetTextDatum(actiontree);	/*	 * Ready to store new pg_rewrite tuple	 */	pg_rewrite_desc = heap_open(RewriteRelationId, RowExclusiveLock);	/*	 * Check to see if we are replacing an existing tuple	 */	oldtup = SearchSysCache2(RULERELNAME,							 ObjectIdGetDatum(eventrel_oid),							 PointerGetDatum(rulname));	if (HeapTupleIsValid(oldtup))	{		if (!replace)			ereport(ERROR,					(errcode(ERRCODE_DUPLICATE_OBJECT),					 errmsg("rule /"%s/" for relation /"%s/" already exists",							rulname, get_rel_name(eventrel_oid))));		/*		 * When replacing, we don't need to replace every attribute		 */		MemSet(replaces, false, sizeof(replaces));		replaces[Anum_pg_rewrite_ev_attr - 1] = true;		replaces[Anum_pg_rewrite_ev_type - 1] = true;		replaces[Anum_pg_rewrite_is_instead - 1] = true;		replaces[Anum_pg_rewrite_ev_qual - 1] = true;		replaces[Anum_pg_rewrite_ev_action - 1] = true;		tup = heap_modify_tuple(oldtup, RelationGetDescr(pg_rewrite_desc),								values, nulls, replaces);		simple_heap_update(pg_rewrite_desc, &tup->t_self, tup);		ReleaseSysCache(oldtup);		rewriteObjectId = HeapTupleGetOid(tup);		is_update = true;	}	else	{		tup = heap_form_tuple(pg_rewrite_desc->rd_att, values, nulls);		rewriteObjectId = simple_heap_insert(pg_rewrite_desc, tup);	}	/* Need to update indexes in either case */	CatalogUpdateIndexes(pg_rewrite_desc, tup);	heap_freetuple(tup);	/* If replacing, get rid of old dependencies and make new ones */	if (is_update)		deleteDependencyRecordsFor(RewriteRelationId, rewriteObjectId, false);//.........这里部分代码省略.........

/* * Guts of language creation. */static ObjectAddresscreate_proc_lang(const char *languageName, bool replace,				 Oid languageOwner, Oid handlerOid, Oid inlineOid,				 Oid valOid, bool trusted){	Relation	rel;	TupleDesc	tupDesc;	Datum		values[Natts_pg_language];	bool		nulls[Natts_pg_language];	bool		replaces[Natts_pg_language];	NameData	langname;	HeapTuple	oldtup;	HeapTuple	tup;	bool		is_update;	ObjectAddress myself,				referenced;	rel = heap_open(LanguageRelationId, RowExclusiveLock);	tupDesc = RelationGetDescr(rel);	/* Prepare data to be inserted */	memset(values, 0, sizeof(values));	memset(nulls, false, sizeof(nulls));	memset(replaces, true, sizeof(replaces));	namestrcpy(&langname, languageName);	values[Anum_pg_language_lanname - 1] = NameGetDatum(&langname);	values[Anum_pg_language_lanowner - 1] = ObjectIdGetDatum(languageOwner);	values[Anum_pg_language_lanispl - 1] = BoolGetDatum(true);	values[Anum_pg_language_lanpltrusted - 1] = BoolGetDatum(trusted);	values[Anum_pg_language_lanplcallfoid - 1] = ObjectIdGetDatum(handlerOid);	values[Anum_pg_language_laninline - 1] = ObjectIdGetDatum(inlineOid);	values[Anum_pg_language_lanvalidator - 1] = ObjectIdGetDatum(valOid);	nulls[Anum_pg_language_lanacl - 1] = true;	/* Check for pre-existing definition */	oldtup = SearchSysCache1(LANGNAME, PointerGetDatum(languageName));	if (HeapTupleIsValid(oldtup))	{		/* There is one; okay to replace it? */		if (!replace)			ereport(ERROR,					(errcode(ERRCODE_DUPLICATE_OBJECT),					 errmsg("language /"%s/" already exists", languageName)));		if (!pg_language_ownercheck(HeapTupleGetOid(oldtup), languageOwner))			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_LANGUAGE,						   languageName);		/*		 * Do not change existing ownership or permissions.  Note		 * dependency-update code below has to agree with this decision.		 */		replaces[Anum_pg_language_lanowner - 1] = false;		replaces[Anum_pg_language_lanacl - 1] = false;		/* Okay, do it... */		tup = heap_modify_tuple(oldtup, tupDesc, values, nulls, replaces);		simple_heap_update(rel, &tup->t_self, tup);		ReleaseSysCache(oldtup);		is_update = true;	}	else	{		/* Creating a new language */		tup = heap_form_tuple(tupDesc, values, nulls);		simple_heap_insert(rel, tup);		is_update = false;	}	/* Need to update indexes for either the insert or update case */	CatalogUpdateIndexes(rel, tup);	/*	 * Create dependencies for the new language.  If we are updating an	 * existing language, first delete any existing pg_depend entries.	 * (However, since we are not changing ownership or permissions, the	 * shared dependencies do *not* need to change, and we leave them alone.)	 */	myself.classId = LanguageRelationId;	myself.objectId = HeapTupleGetOid(tup);	myself.objectSubId = 0;	if (is_update)		deleteDependencyRecordsFor(myself.classId, myself.objectId, true);	/* dependency on owner of language */	if (!is_update)		recordDependencyOnOwner(myself.classId, myself.objectId,								languageOwner);	/* dependency on extension */	recordDependencyOnCurrentExtension(&myself, is_update);	/* dependency on the PL handler function */	referenced.classId = ProcedureRelationId;//.........这里部分代码省略.........

/* * OperatorShellMake *		Make a "shell" entry for a not-yet-existing operator. */static OidOperatorShellMake(const char *operatorName,				  Oid operatorNamespace,				  Oid leftTypeId,				  Oid rightTypeId){	Oid			operatorObjectId;	int			i;	HeapTuple	tup;	Datum		values[Natts_pg_operator];	bool		nulls[Natts_pg_operator];	NameData	oname;	cqContext  *pcqCtx;	/*	 * validate operator name	 */	if (!validOperatorName(operatorName))		ereport(ERROR,				(errcode(ERRCODE_INVALID_NAME),				 errmsg("/"%s/" is not a valid operator name",						operatorName)));	/*	 * initialize our *nulls and *values arrays	 */	for (i = 0; i < Natts_pg_operator; ++i)	{		nulls[i] = false;		values[i] = (Datum) 0;		/* redundant, but safe */	}	/*	 * initialize values[] with the operator name and input data types. Note	 * that oprcode is set to InvalidOid, indicating it's a shell.	 */	i = 0;	namestrcpy(&oname, operatorName);	values[i++] = NameGetDatum(&oname); /* oprname */	values[i++] = ObjectIdGetDatum(operatorNamespace);	/* oprnamespace */	values[i++] = ObjectIdGetDatum(GetUserId());		/* oprowner */	values[i++] = CharGetDatum(leftTypeId ? (rightTypeId ? 'b' : 'r') : 'l');	/* oprkind */	values[i++] = BoolGetDatum(false);	/* oprcanmerge */	values[i++] = BoolGetDatum(false);	/* oprcanhash */	values[i++] = ObjectIdGetDatum(leftTypeId); /* oprleft */	values[i++] = ObjectIdGetDatum(rightTypeId);		/* oprright */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprresult */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprcom */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprnegate */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprcode */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprrest */	values[i++] = ObjectIdGetDatum(InvalidOid); /* oprjoin */	/*	 * open pg_operator	 */	pcqCtx = caql_beginscan(			NULL,			cql("INSERT INTO pg_operator",				NULL));		/*	 * create a new operator tuple	 */	tup = caql_form_tuple(pcqCtx, values, nulls);	/*	 * insert our "shell" operator tuple	 */	operatorObjectId = caql_insert(pcqCtx, tup); 	/* and Update indexes (implicit) */	/* Add dependencies for the entry */	makeOperatorDependencies(tup);	heap_freetuple(tup);	/*	 * close the operator relation and return the oid.	 */	caql_endscan(pcqCtx);	return operatorObjectId;}

//.........这里部分代码省略.........			case LOCKTAG_RESOURCE_QUEUE:				values[1] = ObjectIdGetDatum(proc->databaseId);				values[7] = ObjectIdGetDatum(lock->tag.locktag_field1);				nulls[2] = true;				nulls[3] = true;				nulls[4] = true;				nulls[5] = true;				nulls[6] = true;				nulls[8] = true;				break;			case LOCKTAG_OBJECT:			case LOCKTAG_USERLOCK:			case LOCKTAG_ADVISORY:			default:			/* treat unknown locktags like OBJECT */				values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);				values[6] = ObjectIdGetDatum(lock->tag.locktag_field2);				values[7] = ObjectIdGetDatum(lock->tag.locktag_field3);				values[8] = Int16GetDatum(lock->tag.locktag_field4);				nulls[2] = true;				nulls[3] = true;				nulls[4] = true;				nulls[5] = true;				break;		}		values[9] = TransactionIdGetDatum(proc->xid);		if (proc->pid != 0)			values[10] = Int32GetDatum(proc->pid);		else			nulls[10] = true;		values[11] = DirectFunctionCall1(textin,					  CStringGetDatum((char *) GetLockmodeName(LOCK_LOCKMETHOD(*lock),													  mode)));		values[12] = BoolGetDatum(granted);				values[13] = Int32GetDatum(proc->mppSessionId);				values[14] = Int32GetDatum(proc->mppIsWriter);		values[15] = Int32GetDatum(Gp_segment);		tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);		result = HeapTupleGetDatum(tuple);		SRF_RETURN_NEXT(funcctx, result);	}	/*	 * This loop only executes on the masterDB and only in dispatch mode, because that	 * is the only time we dispatched to the segDBs.	 */	while (mystatus->currIdx >= lockData->nelements && mystatus->currIdx < lockData->nelements + mystatus->numSegLocks)	{		HeapTuple	tuple;		Datum		result;		Datum		values[16];		bool		nulls[16];		int i;		int whichresultset = 0;		int whichelement = mystatus->currIdx - lockData->nelements;		int whichrow = whichelement;		Assert(Gp_role == GP_ROLE_DISPATCH);		/*		 * Because we have one result set per segDB (rather than one big result set with everything),

//.........这里部分代码省略.........	/*	 * find join estimator	 */	if (joinName)	{		typeId[0] = INTERNALOID;	/* Query */		typeId[1] = OIDOID;		/* operator OID */		typeId[2] = INTERNALOID;	/* args list */		typeId[3] = INT2OID;	/* jointype */		joinOid = LookupFuncName(joinName, 4, typeId, false);	}	else		joinOid = InvalidOid;	/*	 * set up values in the operator tuple	 */	for (i = 0; i < Natts_pg_operator; ++i)	{		values[i] = 0;		replaces[i] = true;		nulls[i] = false;	}	i = 0;	namestrcpy(&oname, operatorName);	values[i++] = NameGetDatum(&oname); /* oprname */	values[i++] = ObjectIdGetDatum(operatorNamespace);	/* oprnamespace */	values[i++] = ObjectIdGetDatum(GetUserId());		/* oprowner */	values[i++] = CharGetDatum(leftTypeId ? (rightTypeId ? 'b' : 'r') : 'l');	/* oprkind */	values[i++] = BoolGetDatum(canMerge);		/* oprcanmerge */	values[i++] = BoolGetDatum(canHash);		/* oprcanhash */	values[i++] = ObjectIdGetDatum(leftTypeId); /* oprleft */	values[i++] = ObjectIdGetDatum(rightTypeId);		/* oprright */	values[i++] = ObjectIdGetDatum(operResultType);		/* oprresult */	/*	 * Set up the other operators.	If they do not currently exist, create	 * shells in order to get ObjectId's.	 */	if (commutatorName)	{		/* commutator has reversed arg types */		commutatorId = get_other_operator(commutatorName,										  rightTypeId, leftTypeId,										  operatorName, operatorNamespace,										  leftTypeId, rightTypeId,										  true);		/*		 * self-linkage to this operator; will fix below. Note that only		 * self-linkage for commutation makes sense.		 */		if (!OidIsValid(commutatorId))			selfCommutator = true;	}	else		commutatorId = InvalidOid;	values[i++] = ObjectIdGetDatum(commutatorId);		/* oprcom */	if (negatorName)	{

/* ---------------------------------------------------------------- *		TypeShellMake * *		This procedure inserts a "shell" tuple into the pg_type relation. *		The type tuple inserted has valid but dummy values, and its *		"typisdefined" field is false indicating it's not really defined. * *		This is used so that a tuple exists in the catalogs.  The I/O *		functions for the type will link to this tuple.  When the full *		CREATE TYPE command is issued, the bogus values will be replaced *		with correct ones, and "typisdefined" will be set to true. * ---------------------------------------------------------------- */ObjectAddressTypeShellMake(const char *typeName, Oid typeNamespace, Oid ownerId){	Relation	pg_type_desc;	TupleDesc	tupDesc;	int			i;	HeapTuple	tup;	Datum		values[Natts_pg_type];	bool		nulls[Natts_pg_type];	Oid			typoid;	NameData	name;	ObjectAddress address;	Assert(PointerIsValid(typeName));	/*	 * open pg_type	 */	pg_type_desc = table_open(TypeRelationId, RowExclusiveLock);	tupDesc = pg_type_desc->rd_att;	/*	 * initialize our *nulls and *values arrays	 */	for (i = 0; i < Natts_pg_type; ++i)	{		nulls[i] = false;		values[i] = (Datum) NULL;	/* redundant, but safe */	}	/*	 * initialize *values with the type name and dummy values	 *	 * The representational details are the same as int4 ... it doesn't really	 * matter what they are so long as they are consistent.  Also note that we	 * give it typtype = TYPTYPE_PSEUDO as extra insurance that it won't be	 * mistaken for a usable type.	 */	namestrcpy(&name, typeName);	values[Anum_pg_type_typname - 1] = NameGetDatum(&name);	values[Anum_pg_type_typnamespace - 1] = ObjectIdGetDatum(typeNamespace);	values[Anum_pg_type_typowner - 1] = ObjectIdGetDatum(ownerId);	values[Anum_pg_type_typlen - 1] = Int16GetDatum(sizeof(int32));	values[Anum_pg_type_typbyval - 1] = BoolGetDatum(true);	values[Anum_pg_type_typtype - 1] = CharGetDatum(TYPTYPE_PSEUDO);	values[Anum_pg_type_typcategory - 1] = CharGetDatum(TYPCATEGORY_PSEUDOTYPE);	values[Anum_pg_type_typispreferred - 1] = BoolGetDatum(false);	values[Anum_pg_type_typisdefined - 1] = BoolGetDatum(false);	values[Anum_pg_type_typdelim - 1] = CharGetDatum(DEFAULT_TYPDELIM);	values[Anum_pg_type_typrelid - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typelem - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typarray - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typinput - 1] = ObjectIdGetDatum(F_SHELL_IN);	values[Anum_pg_type_typoutput - 1] = ObjectIdGetDatum(F_SHELL_OUT);	values[Anum_pg_type_typreceive - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typsend - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typmodin - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typmodout - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typanalyze - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typalign - 1] = CharGetDatum('i');	values[Anum_pg_type_typstorage - 1] = CharGetDatum('p');	values[Anum_pg_type_typnotnull - 1] = BoolGetDatum(false);	values[Anum_pg_type_typbasetype - 1] = ObjectIdGetDatum(InvalidOid);	values[Anum_pg_type_typtypmod - 1] = Int32GetDatum(-1);	values[Anum_pg_type_typndims - 1] = Int32GetDatum(0);	values[Anum_pg_type_typcollation - 1] = ObjectIdGetDatum(InvalidOid);	nulls[Anum_pg_type_typdefaultbin - 1] = true;	nulls[Anum_pg_type_typdefault - 1] = true;	nulls[Anum_pg_type_typacl - 1] = true;	/* Use binary-upgrade override for pg_type.oid? */	if (IsBinaryUpgrade)	{		if (!OidIsValid(binary_upgrade_next_pg_type_oid))			ereport(ERROR,					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),					 errmsg("pg_type OID value not set when in binary upgrade mode")));		typoid = binary_upgrade_next_pg_type_oid;		binary_upgrade_next_pg_type_oid = InvalidOid;	}	else	{		typoid = GetNewOidWithIndex(pg_type_desc, TypeOidIndexId,									Anum_pg_type_oid);	}//.........这里部分代码省略.........

/* * boolean primitive type. */static Datum _boolean_invoke(Type self, jclass cls, jmethodID method, jvalue* args, PG_FUNCTION_ARGS){	jboolean v = JNI_callStaticBooleanMethodA(cls, method, args);	return BoolGetDatum(v);}

/* * stat a file */Datumpg_stat_file(PG_FUNCTION_ARGS){	text	   *filename_t = PG_GETARG_TEXT_PP(0);	char	   *filename;	struct stat fst;	Datum		values[6];	bool		isnull[6];	HeapTuple	tuple;	TupleDesc	tupdesc;	bool		missing_ok = false;	/* check the optional argument */	if (PG_NARGS() == 2)		missing_ok = PG_GETARG_BOOL(1);	filename = convert_and_check_filename(filename_t);	if (stat(filename, &fst) < 0)	{		if (missing_ok && errno == ENOENT)			PG_RETURN_NULL();		else			ereport(ERROR,					(errcode_for_file_access(),					 errmsg("could not stat file /"%s/": %m", filename)));	}	/*	 * This record type had better match the output parameters declared for me	 * in pg_proc.h.	 */	tupdesc = CreateTemplateTupleDesc(6, false);	TupleDescInitEntry(tupdesc, (AttrNumber) 1,					   "size", INT8OID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 2,					   "access", TIMESTAMPTZOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 3,					   "modification", TIMESTAMPTZOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 4,					   "change", TIMESTAMPTZOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 5,					   "creation", TIMESTAMPTZOID, -1, 0);	TupleDescInitEntry(tupdesc, (AttrNumber) 6,					   "isdir", BOOLOID, -1, 0);	BlessTupleDesc(tupdesc);	memset(isnull, false, sizeof(isnull));	values[0] = Int64GetDatum((int64) fst.st_size);	values[1] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_atime));	values[2] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_mtime));	/* Unix has file status change time, while Win32 has creation time */#if !defined(WIN32) && !defined(__CYGWIN__)	values[3] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_ctime));	isnull[4] = true;#else	isnull[3] = true;	values[4] = TimestampTzGetDatum(time_t_to_timestamptz(fst.st_ctime));#endif	values[5] = BoolGetDatum(S_ISDIR(fst.st_mode));	tuple = heap_form_tuple(tupdesc, values, isnull);	pfree(filename);	PG_RETURN_DATUM(HeapTupleGetDatum(tuple));}

//.........这里部分代码省略.........					  alignment)));		/* cstring must have char alignment */		if (internalSize == -2 && !(alignment == 'c'))			ereport(ERROR,					(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),			   errmsg("alignment /"%c/" is invalid for variable-length type",					  alignment)));	}	/* Only varlena types can be toasted */	if (storage != 'p' && internalSize != -1)		ereport(ERROR,				(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),				 errmsg("fixed-size types must have storage PLAIN")));	/*	 * initialize arrays needed for heap_form_tuple or heap_modify_tuple	 */	for (i = 0; i < Natts_pg_type; ++i)	{		nulls[i] = false;		replaces[i] = true;		values[i] = (Datum) 0;	}	/*	 * insert data values	 */	namestrcpy(&name, typeName);	values[Anum_pg_type_typname - 1] = NameGetDatum(&name);	values[Anum_pg_type_typnamespace - 1] = ObjectIdGetDatum(typeNamespace);	values[Anum_pg_type_typowner - 1] = ObjectIdGetDatum(ownerId);	values[Anum_pg_type_typlen - 1] = Int16GetDatum(internalSize);	values[Anum_pg_type_typbyval - 1] = BoolGetDatum(passedByValue);	values[Anum_pg_type_typtype - 1] = CharGetDatum(typeType);	values[Anum_pg_type_typcategory - 1] = CharGetDatum(typeCategory);	values[Anum_pg_type_typispreferred - 1] = BoolGetDatum(typePreferred);	values[Anum_pg_type_typisdefined - 1] = BoolGetDatum(true);	values[Anum_pg_type_typdelim - 1] = CharGetDatum(typDelim);	values[Anum_pg_type_typrelid - 1] = ObjectIdGetDatum(relationOid);	values[Anum_pg_type_typelem - 1] = ObjectIdGetDatum(elementType);	values[Anum_pg_type_typarray - 1] = ObjectIdGetDatum(arrayType);	values[Anum_pg_type_typinput - 1] = ObjectIdGetDatum(inputProcedure);	values[Anum_pg_type_typoutput - 1] = ObjectIdGetDatum(outputProcedure);	values[Anum_pg_type_typreceive - 1] = ObjectIdGetDatum(receiveProcedure);	values[Anum_pg_type_typsend - 1] = ObjectIdGetDatum(sendProcedure);	values[Anum_pg_type_typmodin - 1] = ObjectIdGetDatum(typmodinProcedure);	values[Anum_pg_type_typmodout - 1] = ObjectIdGetDatum(typmodoutProcedure);	values[Anum_pg_type_typanalyze - 1] = ObjectIdGetDatum(analyzeProcedure);	values[Anum_pg_type_typalign - 1] = CharGetDatum(alignment);	values[Anum_pg_type_typstorage - 1] = CharGetDatum(storage);	values[Anum_pg_type_typnotnull - 1] = BoolGetDatum(typeNotNull);	values[Anum_pg_type_typbasetype - 1] = ObjectIdGetDatum(baseType);	values[Anum_pg_type_typtypmod - 1] = Int32GetDatum(typeMod);	values[Anum_pg_type_typndims - 1] = Int32GetDatum(typNDims);	values[Anum_pg_type_typcollation - 1] = ObjectIdGetDatum(typeCollation);	/*	 * initialize the default binary value for this type.  Check for nulls of	 * course.	 */	if (defaultTypeBin)		values[Anum_pg_type_typdefaultbin - 1] = CStringGetTextDatum(defaultTypeBin);	else		nulls[Anum_pg_type_typdefaultbin - 1] = true;

/* * pgdatabasev - produce a view of pgdatabase to include transient state */Datumgp_pgdatabase__(PG_FUNCTION_ARGS){	FuncCallContext *funcctx;	Working_State *mystatus;	if (SRF_IS_FIRSTCALL())	{		TupleDesc	tupdesc;		MemoryContext oldcontext;		/* create a function context for cross-call persistence */		funcctx = SRF_FIRSTCALL_INIT();		/*		 * switch to memory context appropriate for multiple function		 * calls		 */		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);		/* build tupdesc for result tuples */		/* this had better match pg_prepared_xacts view in	system_views.sql */		tupdesc = CreateTemplateTupleDesc(5, false);		TupleDescInitEntry(tupdesc, (AttrNumber) 1, "dbid",						   INT2OID, -1, 0);		TupleDescInitEntry(tupdesc, (AttrNumber) 2, "isprimary",						   BOOLOID, -1, 0);		TupleDescInitEntry(tupdesc, (AttrNumber) 3, "content",						   INT2OID, -1, 0);		TupleDescInitEntry(tupdesc, (AttrNumber) 4, "valid",						   BOOLOID, -1, 0);		TupleDescInitEntry(tupdesc, (AttrNumber) 5, "definedprimary",						   BOOLOID, -1, 0);		funcctx->tuple_desc = BlessTupleDesc(tupdesc);		/*		 * Collect all the locking information that we will format and		 * send out as a result set.		 */		mystatus = (Working_State *) palloc(sizeof(Working_State));		funcctx->user_fctx = (void *) mystatus;		mystatus->master = GetMasterSegment();		mystatus->standby = GetStandbySegment();		mystatus->segments = GetSegmentList();		mystatus->idx = 0;		MemoryContextSwitchTo(oldcontext);	}	funcctx = SRF_PERCALL_SETUP();	mystatus = (Working_State *) funcctx->user_fctx;	while (mystatus->master || mystatus->standby || (mystatus->idx < list_length(mystatus->segments)))	{		Datum		values[6];		bool		nulls[6];		HeapTuple	tuple;		Datum		result;		Segment 	*current = NULL;		if (mystatus->master)		{			current = mystatus->master;			mystatus->master = NULL;		}		else if (mystatus->standby)		{			current = mystatus->standby;			mystatus->standby = NULL;		}		else		{			current = list_nth(mystatus->segments, mystatus->idx);			mystatus->idx++;		}		/*		 * Form tuple with appropriate data.		 */		MemSet(values, 0, sizeof(values));		MemSet(nulls, false, sizeof(nulls));		//values[0] = UInt16GetDatum(current->dbid);		values[1] = current->standby ? false : true;;		values[2] = UInt16GetDatum(current->segindex);		values[3] = BoolGetDatum(true);		values[4] = values[1];		tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);		result = HeapTupleGetDatum(tuple);		SRF_RETURN_NEXT(funcctx, result);	}	SRF_RETURN_DONE(funcctx);//.........这里部分代码省略.........