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

//.........这里部分代码省略.........		 * near the front of the hashbucket's list.)		 */		DLMoveToFront(&ct->cache_elem);		/*		 * If it's a positive entry, bump its refcount and return it. If it's		 * negative, we can report failure to the caller.		 */		if (!ct->negative)		{			ResourceOwnerEnlargeCatCacheRefs(CurrentResourceOwner);			ct->refcount++;			ResourceOwnerRememberCatCacheRef(CurrentResourceOwner, &ct->tuple);			CACHE3_elog(DEBUG2, "SearchCatCache(%s): found in bucket %d",						cache->cc_relname, hashIndex);#ifdef CATCACHE_STATS			cache->cc_hits++;#endif			return &ct->tuple;		}		else		{			CACHE3_elog(DEBUG2, "SearchCatCache(%s): found neg entry in bucket %d",						cache->cc_relname, hashIndex);#ifdef CATCACHE_STATS			cache->cc_neg_hits++;#endif			return NULL;		}	}	/*	 * Tuple was not found in cache, so we have to try to retrieve it directly	 * from the relation.  If found, we will add it to the cache; if not	 * found, we will add a negative cache entry instead.	 *	 * NOTE: it is possible for recursive cache lookups to occur while reading	 * the relation --- for example, due to shared-cache-inval messages being	 * processed during heap_open().  This is OK.  It's even possible for one	 * of those lookups to find and enter the very same tuple we are trying to	 * fetch here.	If that happens, we will enter a second copy of the tuple	 * into the cache.	The first copy will never be referenced again, and	 * will eventually age out of the cache, so there's no functional problem.	 * This case is rare enough that it's not worth expending extra cycles to	 * detect.	 */	relation = heap_open(cache->cc_reloid, AccessShareLock);	scandesc = systable_beginscan(relation,								  cache->cc_indexoid,								  IndexScanOK(cache, cur_skey),								  SnapshotNow,								  cache->cc_nkeys,								  cur_skey);	ct = NULL;    while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))	{		ct = CatalogCacheCreateEntry(cache, ntp,									 hashValue, hashIndex,									 false);		if (scandesc->inmemonlyscan)		{			/* Make sure tuple is removed during ReleaseCatCache */			ct->dead = true;		}				/* immediately set the refcount to 1 */		ResourceOwnerEnlargeCatCacheRefs(CurrentResourceOwner);		ct->refcount++;		ResourceOwnerRememberCatCacheRef(CurrentResourceOwner, &ct->tuple);		break;					/* assume only one match */	}	systable_endscan(scandesc);	heap_close(relation, AccessShareLock);	if (ct == NULL)	{		return NULL;	}	CACHE4_elog(DEBUG2, "SearchCatCache(%s): Contains %d/%d tuples",				cache->cc_relname, cache->cc_ntup, CCacheHdr->ch_ntup);	CACHE3_elog(DEBUG2, "SearchCatCache(%s): put in bucket %d",				cache->cc_relname, hashIndex);#ifdef CATCACHE_STATS	cache->cc_newloads++;#endif	return &ct->tuple;}

/* *	ltreeparentsel - Selectivity of parent relationship for ltree data types. */Datumltreeparentsel(PG_FUNCTION_ARGS){	PlannerInfo *root = (PlannerInfo *) PG_GETARG_POINTER(0);	Oid			operator = PG_GETARG_OID(1);	List	   *args = (List *) PG_GETARG_POINTER(2);	int			varRelid = PG_GETARG_INT32(3);	VariableStatData vardata;	Node	   *other;	bool		varonleft;	double		selec;	/*	 * If expression is not variable <@ something or something <@ variable,	 * then punt and return a default estimate.	 */	if (!get_restriction_variable(root, args, varRelid,								  &vardata, &other, &varonleft))		PG_RETURN_FLOAT8(DEFAULT_PARENT_SEL);	/*	 * If the something is a NULL constant, assume operator is strict and	 * return zero, ie, operator will never return TRUE.	 */	if (IsA(other, Const) &&		((Const *) other)->constisnull)	{		ReleaseVariableStats(vardata);		PG_RETURN_FLOAT8(0.0);	}	if (IsA(other, Const))	{		/* Variable is being compared to a known non-null constant */		Datum		constval = ((Const *) other)->constvalue;		FmgrInfo	contproc;		double		mcvsum;		double		mcvsel;		double		nullfrac;		fmgr_info(get_opcode(operator), &contproc);		/*		 * Is the constant "<@" to any of the column's most common values?		 */		mcvsel = mcv_selectivity(&vardata, &contproc, constval, varonleft,								 &mcvsum);		/*		 * If the histogram is large enough, see what fraction of it the		 * constant is "<@" to, and assume that's representative of the		 * non-MCV population.	Otherwise use the default selectivity for the		 * non-MCV population.		 */		selec = histogram_selectivity(&vardata, &contproc,									  constval, varonleft,									  100, 1);		if (selec < 0)		{			/* Nope, fall back on default */			selec = DEFAULT_PARENT_SEL;		}		else		{			/* Yes, but don't believe extremely small or large estimates. */			if (selec < 0.0001)				selec = 0.0001;			else if (selec > 0.9999)				selec = 0.9999;		}		if (HeapTupleIsValid(vardata.statsTuple))			nullfrac = ((Form_pg_statistic) GETSTRUCT(vardata.statsTuple))->stanullfrac;		else			nullfrac = 0.0;		/*		 * Now merge the results from the MCV and histogram calculations,		 * realizing that the histogram covers only the non-null values that		 * are not listed in MCV.		 */		selec *= 1.0 - nullfrac - mcvsum;		selec += mcvsel;	}	else		selec = DEFAULT_PARENT_SEL;	ReleaseVariableStats(vardata);	/* result should be in range, but make sure... */	CLAMP_PROBABILITY(selec);	PG_RETURN_FLOAT8((float8) selec);}

/* * Rebuild the event trigger cache. */static voidBuildEventTriggerCache(void){	HASHCTL         ctl;	HTAB		   *cache;	MemoryContext	oldcontext;	Relation		rel;	Relation		irel;	SysScanDesc		scan;	if (EventTriggerCacheContext != NULL)	{		/*		 * The cache has been previously built, and subsequently invalidated,		 * and now we're trying to rebuild it.  Normally, there won't be		 * anything in the context at this point, because the invalidation		 * will have already reset it.  But if the previous attempt to rebuild		 * the cache failed, then there might be some junk lying around		 * that we want to reclaim.		 */		MemoryContextReset(EventTriggerCacheContext);	}	else	{		/*		 * This is our first time attempting to build the cache, so we need		 * to set up the memory context and register a syscache callback to		 * capture future invalidation events.		 */		if (CacheMemoryContext == NULL)			CreateCacheMemoryContext();		EventTriggerCacheContext =			AllocSetContextCreate(CacheMemoryContext,								  "EventTriggerCache",								  ALLOCSET_DEFAULT_MINSIZE,								  ALLOCSET_DEFAULT_INITSIZE,								  ALLOCSET_DEFAULT_MAXSIZE);		CacheRegisterSyscacheCallback(EVENTTRIGGEROID,									  InvalidateEventCacheCallback,									  (Datum) 0);	}	/* Switch to correct memory context. */	oldcontext = MemoryContextSwitchTo(EventTriggerCacheContext);	/*	 * Create a new hash table, but don't assign it to the global variable	 * until it accurately represents the state of the catalogs, so that	 * if we fail midway through this we won't end up with incorrect cache	 * contents.	 */	MemSet(&ctl, 0, sizeof(ctl));	ctl.keysize = sizeof(EventTriggerEvent);	ctl.entrysize = sizeof(EventTriggerCacheEntry);	ctl.hash = tag_hash;	cache = hash_create("Event Trigger Cache", 32, &ctl,						HASH_ELEM | HASH_FUNCTION);	/*	 * Prepare to scan pg_event_trigger in name order.  We use an MVCC	 * snapshot to avoid getting inconsistent results if the table is	 * being concurrently updated.	 */	rel = relation_open(EventTriggerRelationId, AccessShareLock);	irel = index_open(EventTriggerNameIndexId, AccessShareLock);	scan = systable_beginscan_ordered(rel, irel, GetLatestSnapshot(), 0, NULL);	/*	 * Build a cache item for each pg_event_trigger tuple, and append each	 * one to the appropriate cache entry.	 */	for (;;)	{		HeapTuple		tup;		Form_pg_event_trigger	form;		char	   *evtevent;		EventTriggerEvent	event;		EventTriggerCacheItem *item;		Datum		evttags;		bool		evttags_isnull;		EventTriggerCacheEntry *entry;		bool		found;		/* Get next tuple. */		tup = systable_getnext_ordered(scan, ForwardScanDirection);		if (!HeapTupleIsValid(tup))			break;		/* Skip trigger if disabled. */		form = (Form_pg_event_trigger) GETSTRUCT(tup);		if (form->evtenabled == TRIGGER_DISABLED)			continue;		/* Decode event name. */		evtevent = NameStr(form->evtevent);		if (strcmp(evtevent, "ddl_command_start") == 0)			event = EVT_DDLCommandStart;//.........这里部分代码省略.........

/* * sepgsql_relation_setattr * * It checks privileges to set attribute of the supplied relation */voidsepgsql_relation_setattr(Oid relOid){	Relation		rel;	ScanKeyData		skey;	SysScanDesc		sscan;	HeapTuple		oldtup;	HeapTuple		newtup;	Form_pg_class	oldform;	Form_pg_class	newform;	ObjectAddress object;	char	   *audit_name;	uint16_t	tclass;	switch (get_rel_relkind(relOid))	{		case RELKIND_RELATION:			tclass = SEPG_CLASS_DB_TABLE;			break;		case RELKIND_SEQUENCE:			tclass = SEPG_CLASS_DB_SEQUENCE;			break;		case RELKIND_VIEW:			tclass = SEPG_CLASS_DB_VIEW;			break;		case RELKIND_INDEX:			/* deal with indexes specially */			sepgsql_index_modify(relOid);			return;		default:			/* other relkinds don't need additional work */			return;	}	/*	 * Fetch newer catalog	 */	rel = heap_open(RelationRelationId, AccessShareLock);	ScanKeyInit(&skey,				ObjectIdAttributeNumber,				BTEqualStrategyNumber, F_OIDEQ,				ObjectIdGetDatum(relOid));	sscan = systable_beginscan(rel, ClassOidIndexId, true,							   SnapshotSelf, 1, &skey);	newtup = systable_getnext(sscan);	if (!HeapTupleIsValid(newtup))		elog(ERROR, "catalog lookup failed for relation %u", relOid);	newform = (Form_pg_class) GETSTRUCT(newtup);	/*	 * Fetch older catalog	 */	oldtup = SearchSysCache1(RELOID, ObjectIdGetDatum(relOid));	if (!HeapTupleIsValid(oldtup))		elog(ERROR, "cache lookup failed for relation %u", relOid);	oldform = (Form_pg_class) GETSTRUCT(oldtup);	/*	 * Does this ALTER command takes operation to namespace?	 */	if (newform->relnamespace != oldform->relnamespace)	{		sepgsql_schema_remove_name(oldform->relnamespace);		sepgsql_schema_add_name(newform->relnamespace);	}	if (strcmp(NameStr(newform->relname), NameStr(oldform->relname)) != 0)		sepgsql_schema_rename(oldform->relnamespace);	/*	 * XXX - In the future version, db_tuple:{use} of system catalog entry	 * shall be checked, if tablespace configuration is changed.	 */	/*	 * check db_xxx:{setattr} permission	 */	object.classId = RelationRelationId;	object.objectId = relOid;	object.objectSubId = 0;	audit_name = getObjectIdentity(&object);	sepgsql_avc_check_perms(&object,							tclass,							SEPG_DB_TABLE__SETATTR,							audit_name,							true);	pfree(audit_name);	ReleaseSysCache(oldtup);	systable_endscan(sscan);	heap_close(rel, AccessShareLock);}

/* * This is a copy of swap_relation_files in cluster.c, but it also swaps * relfrozenxid. */static voidswap_heap_or_index_files(Oid r1, Oid r2){	Relation	relRelation;	HeapTuple	reltup1,				reltup2;	Form_pg_class relform1,				relform2;	Oid			swaptemp;	CatalogIndexState indstate;	/* We need writable copies of both pg_class tuples. */	relRelation = heap_open(RelationRelationId, RowExclusiveLock);	reltup1 = SearchSysCacheCopy(RELOID,								 ObjectIdGetDatum(r1),								 0, 0, 0);	if (!HeapTupleIsValid(reltup1))		elog(ERROR, "cache lookup failed for relation %u", r1);	relform1 = (Form_pg_class) GETSTRUCT(reltup1);	reltup2 = SearchSysCacheCopy(RELOID,								 ObjectIdGetDatum(r2),								 0, 0, 0);	if (!HeapTupleIsValid(reltup2))		elog(ERROR, "cache lookup failed for relation %u", r2);	relform2 = (Form_pg_class) GETSTRUCT(reltup2);	Assert(relform1->relkind == relform2->relkind);	/*	 * Actually swap the fields in the two tuples	 */	swaptemp = relform1->relfilenode;	relform1->relfilenode = relform2->relfilenode;	relform2->relfilenode = swaptemp;	swaptemp = relform1->reltablespace;	relform1->reltablespace = relform2->reltablespace;	relform2->reltablespace = swaptemp;	swaptemp = relform1->reltoastrelid;	relform1->reltoastrelid = relform2->reltoastrelid;	relform2->reltoastrelid = swaptemp;	/* set rel1's frozen Xid to larger one */	if (TransactionIdIsNormal(relform1->relfrozenxid))	{		if (TransactionIdFollows(relform1->relfrozenxid,								 relform2->relfrozenxid))			relform1->relfrozenxid = relform2->relfrozenxid;		else			relform2->relfrozenxid = relform1->relfrozenxid;	}	/* swap size statistics too, since new rel has freshly-updated stats */	{#if PG_VERSION_NUM >= 90300		int32		swap_pages;#else		int4		swap_pages;#endif		float4		swap_tuples;		swap_pages = relform1->relpages;		relform1->relpages = relform2->relpages;		relform2->relpages = swap_pages;		swap_tuples = relform1->reltuples;		relform1->reltuples = relform2->reltuples;		relform2->reltuples = swap_tuples;	}	/* Update the tuples in pg_class */	simple_heap_update(relRelation, &reltup1->t_self, reltup1);	simple_heap_update(relRelation, &reltup2->t_self, reltup2);	/* Keep system catalogs current */	indstate = CatalogOpenIndexes(relRelation);	CatalogIndexInsert(indstate, reltup1);	CatalogIndexInsert(indstate, reltup2);	CatalogCloseIndexes(indstate);	/*	 * If we have toast tables associated with the relations being swapped,	 * change their dependency links to re-associate them with their new	 * owning relations.  Otherwise the wrong one will get dropped ...	 *	 * NOTE: it is possible that only one table has a toast table; this can	 * happen in CLUSTER if there were dropped columns in the old table, and	 * in ALTER TABLE when adding or changing type of columns.	 *	 * NOTE: at present, a TOAST table's only dependency is the one on its	 * owning table.  If more are ever created, we'd need to use something	 * more selective than deleteDependencyRecordsFor() to get rid of only the	 * link we want.//.........这里部分代码省略.........

/* * Look to see if we have template information for the given language name. */static PLTemplate *find_language_template(const char *languageName){	PLTemplate *result;	Relation	rel;	SysScanDesc scan;	ScanKeyData key;	HeapTuple	tup;	rel = heap_open(PLTemplateRelationId, AccessShareLock);	ScanKeyInit(&key,				Anum_pg_pltemplate_tmplname,				BTEqualStrategyNumber, F_NAMEEQ,				CStringGetDatum(languageName));	scan = systable_beginscan(rel, PLTemplateNameIndexId, true,							  NULL, 1, &key);	tup = systable_getnext(scan);	if (HeapTupleIsValid(tup))	{		Form_pg_pltemplate tmpl = (Form_pg_pltemplate) GETSTRUCT(tup);		Datum		datum;		bool		isnull;		result = (PLTemplate *) palloc0(sizeof(PLTemplate));		result->tmpltrusted = tmpl->tmpltrusted;		result->tmpldbacreate = tmpl->tmpldbacreate;		/* Remaining fields are variable-width so we need heap_getattr */		datum = heap_getattr(tup, Anum_pg_pltemplate_tmplhandler,							 RelationGetDescr(rel), &isnull);		if (!isnull)			result->tmplhandler = TextDatumGetCString(datum);		datum = heap_getattr(tup, Anum_pg_pltemplate_tmplinline,							 RelationGetDescr(rel), &isnull);		if (!isnull)			result->tmplinline = TextDatumGetCString(datum);		datum = heap_getattr(tup, Anum_pg_pltemplate_tmplvalidator,							 RelationGetDescr(rel), &isnull);		if (!isnull)			result->tmplvalidator = TextDatumGetCString(datum);		datum = heap_getattr(tup, Anum_pg_pltemplate_tmpllibrary,							 RelationGetDescr(rel), &isnull);		if (!isnull)			result->tmpllibrary = TextDatumGetCString(datum);		/* Ignore template if handler or library info is missing */		if (!result->tmplhandler || !result->tmpllibrary)			result = NULL;	}	else		result = NULL;	systable_endscan(scan);	heap_close(rel, AccessShareLock);	return result;}

/* * sepgsql_relation_post_create * * The post creation hook of relation/attribute */voidsepgsql_relation_post_create(Oid relOid){	Relation	rel;	ScanKeyData skey;	SysScanDesc sscan;	HeapTuple	tuple;	Form_pg_class classForm;	ObjectAddress object;	uint16		tclass;	char	   *scontext;		/* subject */	char	   *tcontext;		/* schema */	char	   *rcontext;		/* relation */	char	   *ccontext;		/* column */	char	   *nsp_name;	StringInfoData audit_name;	/*	 * Fetch catalog record of the new relation. Because pg_class entry is not	 * visible right now, we need to scan the catalog using SnapshotSelf.	 */	rel = heap_open(RelationRelationId, AccessShareLock);	ScanKeyInit(&skey,				ObjectIdAttributeNumber,				BTEqualStrategyNumber, F_OIDEQ,				ObjectIdGetDatum(relOid));	sscan = systable_beginscan(rel, ClassOidIndexId, true,							   SnapshotSelf, 1, &skey);	tuple = systable_getnext(sscan);	if (!HeapTupleIsValid(tuple))		elog(ERROR, "catalog lookup failed for relation %u", relOid);	classForm = (Form_pg_class) GETSTRUCT(tuple);	/* ignore indexes on toast tables */	if (classForm->relkind == RELKIND_INDEX &&		classForm->relnamespace == PG_TOAST_NAMESPACE)		goto out;	/*	 * check db_schema:{add_name} permission of the namespace	 */	object.classId = NamespaceRelationId;	object.objectId = classForm->relnamespace;	object.objectSubId = 0;	sepgsql_avc_check_perms(&object,							SEPG_CLASS_DB_SCHEMA,							SEPG_DB_SCHEMA__ADD_NAME,							getObjectIdentity(&object),							true);	switch (classForm->relkind)	{		case RELKIND_RELATION:			tclass = SEPG_CLASS_DB_TABLE;			break;		case RELKIND_SEQUENCE:			tclass = SEPG_CLASS_DB_SEQUENCE;			break;		case RELKIND_VIEW:			tclass = SEPG_CLASS_DB_VIEW;			break;		case RELKIND_INDEX:			/* deal with indexes specially; no need for tclass */			sepgsql_index_modify(relOid);			goto out;		default:			/* ignore other relkinds */			goto out;	}	/*	 * Compute a default security label when we create a new relation object	 * under the specified namespace.	 */	scontext = sepgsql_get_client_label();	tcontext = sepgsql_get_label(NamespaceRelationId,								 classForm->relnamespace, 0);	rcontext = sepgsql_compute_create(scontext, tcontext, tclass,									  NameStr(classForm->relname));	/*	 * check db_xxx:{create} permission	 */	nsp_name = get_namespace_name(classForm->relnamespace);	initStringInfo(&audit_name);	appendStringInfo(&audit_name, "%s.%s",					 quote_identifier(nsp_name),					 quote_identifier(NameStr(classForm->relname)));	sepgsql_avc_check_perms_label(rcontext,								  tclass,								  SEPG_DB_DATABASE__CREATE,//.........这里部分代码省略.........

/* * get_attstatsslot * *		Extract the contents of a "slot" of a pg_statistic tuple. *		Returns TRUE if requested slot type was found, else FALSE. * * Unlike other routines in this file, this takes a pointer to an * already-looked-up tuple in the pg_statistic cache.  We do this since * most callers will want to extract more than one value from the cache * entry, and we don't want to repeat the cache lookup unnecessarily. * * statstuple: pg_statistics tuple to be examined. * atttype: type OID of attribute (can be InvalidOid if values == NULL). * atttypmod: typmod of attribute (can be 0 if values == NULL). * reqkind: STAKIND code for desired statistics slot kind. * reqop: STAOP value wanted, or InvalidOid if don't care. * values, nvalues: if not NULL, the slot's stavalues are extracted. * numbers, nnumbers: if not NULL, the slot's stanumbers are extracted. * * If assigned, values and numbers are set to point to palloc'd arrays. * If the attribute type is pass-by-reference, the values referenced by * the values array are themselves palloc'd.  The palloc'd stuff can be * freed by calling free_attstatsslot. */boolget_attstatsslot(HeapTuple statstuple,				 Oid atttype, int32 atttypmod,				 int reqkind, Oid reqop,				 Datum **values, int *nvalues,				 float4 **numbers, int *nnumbers){	Form_pg_statistic stats = (Form_pg_statistic) GETSTRUCT(statstuple);	int			i,				j;	Datum		val;	bool		isnull;	ArrayType  *statarray;	int			narrayelem;	HeapTuple	typeTuple;	Form_pg_type typeForm;	for (i = 0; i < STATISTIC_NUM_SLOTS; i++)	{		if ((&stats->stakind1)[i] == reqkind &&			(reqop == InvalidOid || (&stats->staop1)[i] == reqop))			break;	}	if (i >= STATISTIC_NUM_SLOTS)		return false;			/* not there */	if (values)	{		val = SysCacheGetAttr(STATRELATT, statstuple,							  Anum_pg_statistic_stavalues1 + i,							  &isnull);		if (isnull)			elog(ERROR, "stavalues is null");		statarray = DatumGetArrayTypeP(val);		/* Need to get info about the array element type */		typeTuple = SearchSysCache(TYPEOID,								   ObjectIdGetDatum(atttype),								   0, 0, 0);		if (!HeapTupleIsValid(typeTuple))			elog(ERROR, "cache lookup failed for type %u", atttype);		typeForm = (Form_pg_type) GETSTRUCT(typeTuple);		/* Deconstruct array into Datum elements; NULLs not expected */		deconstruct_array(statarray,						  atttype,						  typeForm->typlen,						  typeForm->typbyval,						  typeForm->typalign,						  values, NULL, nvalues);		/*		 * If the element type is pass-by-reference, we now have a bunch of		 * Datums that are pointers into the syscache value.  Copy them to		 * avoid problems if syscache decides to drop the entry.		 */		if (!typeForm->typbyval)		{			for (j = 0; j < *nvalues; j++)			{				(*values)[j] = datumCopy((*values)[j],										 typeForm->typbyval,										 typeForm->typlen);			}		}		ReleaseSysCache(typeTuple);		/*		 * Free statarray if it's a detoasted copy.		 */		if ((Pointer) statarray != DatumGetPointer(val))			pfree(statarray);	}	if (numbers)//.........这里部分代码省略.........

/* * Map a relation's (tablespace, filenode) to a relation's oid and cache the * result. * * Returns InvalidOid if no relation matching the criteria could be found. */OidRelidByRelfilenode(Oid reltablespace, Oid relfilenode){	RelfilenodeMapKey key;	RelfilenodeMapEntry *entry;	bool		found;	SysScanDesc scandesc;	Relation	relation;	HeapTuple	ntp;	ScanKeyData skey[2];	Oid			relid;	if (RelfilenodeMapHash == NULL)		InitializeRelfilenodeMap();	/* pg_class will show 0 when the value is actually MyDatabaseTableSpace */	if (reltablespace == MyDatabaseTableSpace)		reltablespace = 0;	MemSet(&key, 0, sizeof(key));	key.reltablespace = reltablespace;	key.relfilenode = relfilenode;	/*	 * Check cache and return entry if one is found. Even if no target	 * relation can be found later on we store the negative match and return a	 * InvalidOid from cache. That's not really necessary for performance	 * since querying invalid values isn't supposed to be a frequent thing,	 * but it's basically free.	 */	entry = hash_search(RelfilenodeMapHash, (void *) &key, HASH_FIND, &found);	if (found)		return entry->relid;	/* ok, no previous cache entry, do it the hard way */	/* initialize empty/negative cache entry before doing the actual lookups */	relid = InvalidOid;	if (reltablespace == GLOBALTABLESPACE_OID)	{		/*		 * Ok, shared table, check relmapper.		 */		relid = RelationMapFilenodeToOid(relfilenode, true);	}	else	{		/*		 * Not a shared table, could either be a plain relation or a		 * non-shared, nailed one, like e.g. pg_class.		 */		/* check for plain relations by looking in pg_class */		relation = heap_open(RelationRelationId, AccessShareLock);		/* copy scankey to local copy, it will be modified during the scan */		memcpy(skey, relfilenode_skey, sizeof(skey));		/* set scan arguments */		skey[0].sk_argument = ObjectIdGetDatum(reltablespace);		skey[1].sk_argument = ObjectIdGetDatum(relfilenode);		scandesc = systable_beginscan(relation,									  ClassTblspcRelfilenodeIndexId,									  true,									  NULL,									  2,									  skey);		found = false;		while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))		{			if (found)				elog(ERROR,					 "unexpected duplicate for tablespace %u, relfilenode %u",					 reltablespace, relfilenode);			found = true;#ifdef USE_ASSERT_CHECKING			{				bool		isnull;				Oid			check;				check = fastgetattr(ntp, Anum_pg_class_reltablespace,									RelationGetDescr(relation),									&isnull);				Assert(!isnull && check == reltablespace);				check = fastgetattr(ntp, Anum_pg_class_relfilenode,									RelationGetDescr(relation),									&isnull);//.........这里部分代码省略.........

/* * get_type_io_data * *		A six-fer:	given the type OID, return typlen, typbyval, typalign, *					typdelim, typioparam, and IO function OID. The IO function *					returned is controlled by IOFuncSelector */voidget_type_io_data(Oid typid,				 IOFuncSelector which_func,				 int16 *typlen,				 bool *typbyval,				 char *typalign,				 char *typdelim,				 Oid *typioparam,				 Oid *func){	HeapTuple	typeTuple;	Form_pg_type typeStruct;	/*	 * In bootstrap mode, pass it off to bootstrap.c.  This hack allows us to	 * use array_in and array_out during bootstrap.	 */	if (IsBootstrapProcessingMode())	{		Oid			typinput;		Oid			typoutput;		boot_get_type_io_data(typid,							  typlen,							  typbyval,							  typalign,							  typdelim,							  typioparam,							  &typinput,							  &typoutput);		switch (which_func)		{			case IOFunc_input:				*func = typinput;				break;			case IOFunc_output:				*func = typoutput;				break;			default:				elog(ERROR, "binary I/O not supported during bootstrap");				break;		}		return;	}	typeTuple = SearchSysCache(TYPEOID,							   ObjectIdGetDatum(typid),							   0, 0, 0);	if (!HeapTupleIsValid(typeTuple))		elog(ERROR, "cache lookup failed for type %u", typid);	typeStruct = (Form_pg_type) GETSTRUCT(typeTuple);	*typlen = typeStruct->typlen;	*typbyval = typeStruct->typbyval;	*typalign = typeStruct->typalign;	*typdelim = typeStruct->typdelim;	*typioparam = getTypeIOParam(typeTuple);	switch (which_func)	{		case IOFunc_input:			*func = typeStruct->typinput;			break;		case IOFunc_output:			*func = typeStruct->typoutput;			break;		case IOFunc_receive:			*func = typeStruct->typreceive;			break;		case IOFunc_send:			*func = typeStruct->typsend;			break;	}	ReleaseSysCache(typeTuple);}

/* * get_typdefault *	  Given a type OID, return the type's default value, if any. * *	  The result is a palloc'd expression node tree, or NULL if there *	  is no defined default for the datatype. * * NB: caller should be prepared to coerce result to correct datatype; * the returned expression tree might produce something of the wrong type. */Node *get_typdefault(Oid typid){	HeapTuple	typeTuple;	Form_pg_type type;	Datum		datum;	bool		isNull;	Node	   *expr;	typeTuple = SearchSysCache(TYPEOID,							   ObjectIdGetDatum(typid),							   0, 0, 0);	if (!HeapTupleIsValid(typeTuple))		elog(ERROR, "cache lookup failed for type %u", typid);	type = (Form_pg_type) GETSTRUCT(typeTuple);	/*	 * typdefault and typdefaultbin are potentially null, so don't try to	 * access 'em as struct fields. Must do it the hard way with	 * SysCacheGetAttr.	 */	datum = SysCacheGetAttr(TYPEOID,							typeTuple,							Anum_pg_type_typdefaultbin,							&isNull);	if (!isNull)	{		/* We have an expression default */		expr = stringToNode(DatumGetCString(DirectFunctionCall1(textout,																datum)));	}	else	{		/* Perhaps we have a plain literal default */		datum = SysCacheGetAttr(TYPEOID,								typeTuple,								Anum_pg_type_typdefault,								&isNull);		if (!isNull)		{			char	   *strDefaultVal;			/* Convert text datum to C string */			strDefaultVal = DatumGetCString(DirectFunctionCall1(textout,																datum));			/* Convert C string to a value of the given type */			datum = OidInputFunctionCall(type->typinput, strDefaultVal,										 getTypeIOParam(typeTuple), -1);			/* Build a Const node containing the value */			expr = (Node *) makeConst(typid,									  type->typlen,									  datum,									  false,									  type->typbyval);			pfree(strDefaultVal);		}		else		{			/* No default */			expr = NULL;		}	}	ReleaseSysCache(typeTuple);	return expr;}

/* * Create a locale_t from a collation OID.	Results are cached for the * lifetime of the backend.  Thus, do not free the result with freelocale(). * * As a special optimization, the default/database collation returns 0. * Callers should then revert to the non-locale_t-enabled code path. * In fact, they shouldn't call this function at all when they are dealing * with the default locale.  That can save quite a bit in hotspots. * Also, callers should avoid calling this before going down a C/POSIX * fastpath, because such a fastpath should work even on platforms without * locale_t support in the C library. * * For simplicity, we always generate COLLATE + CTYPE even though we * might only need one of them.  Since this is called only once per session, * it shouldn't cost much. */pg_locale_tpg_newlocale_from_collation(Oid collid){	collation_cache_entry *cache_entry;	/* Callers must pass a valid OID */	Assert(OidIsValid(collid));	/* Return 0 for "default" collation, just in case caller forgets */	if (collid == DEFAULT_COLLATION_OID)		return (pg_locale_t) 0;	cache_entry = lookup_collation_cache(collid, false);	if (cache_entry->locale == 0)	{		/* We haven't computed this yet in this session, so do it */#ifdef HAVE_LOCALE_T		HeapTuple	tp;		Form_pg_collation collform;		const char *collcollate;		const char *collctype;		locale_t	result;		tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collid));		if (!HeapTupleIsValid(tp))			elog(ERROR, "cache lookup failed for collation %u", collid);		collform = (Form_pg_collation) GETSTRUCT(tp);		collcollate = NameStr(collform->collcollate);		collctype = NameStr(collform->collctype);		if (strcmp(collcollate, collctype) == 0)		{			/* Normal case where they're the same */#ifndef WIN32			result = newlocale(LC_COLLATE_MASK | LC_CTYPE_MASK, collcollate,							   NULL);#else			result = _create_locale(LC_ALL, collcollate);#endif			if (!result)				report_newlocale_failure(collcollate);		}		else		{#ifndef WIN32			/* We need two newlocale() steps */			locale_t	loc1;			loc1 = newlocale(LC_COLLATE_MASK, collcollate, NULL);			if (!loc1)				report_newlocale_failure(collcollate);			result = newlocale(LC_CTYPE_MASK, collctype, loc1);			if (!result)				report_newlocale_failure(collctype);#else			/*			 * XXX The _create_locale() API doesn't appear to support this.			 * Could perhaps be worked around by changing pg_locale_t to			 * contain two separate fields.			 */			ereport(ERROR,					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),					 errmsg("collations with different collate and ctype values are not supported on this platform")));#endif		}		cache_entry->locale = result;		ReleaseSysCache(tp);#else							/* not HAVE_LOCALE_T */		/*		 * For platforms that don't support locale_t, we can't do anything		 * with non-default collations.		 */		ereport(ERROR,				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),		errmsg("nondefault collations are not supported on this platform")));#endif   /* not HAVE_LOCALE_T */	}//.........这里部分代码省略.........

static collation_cache_entry *lookup_collation_cache(Oid collation, bool set_flags){	collation_cache_entry *cache_entry;	bool		found;	Assert(OidIsValid(collation));	Assert(collation != DEFAULT_COLLATION_OID);	if (collation_cache == NULL)	{		/* First time through, initialize the hash table */		HASHCTL		ctl;		memset(&ctl, 0, sizeof(ctl));		ctl.keysize = sizeof(Oid);		ctl.entrysize = sizeof(collation_cache_entry);		ctl.hash = oid_hash;		collation_cache = hash_create("Collation cache", 100, &ctl,									  HASH_ELEM | HASH_FUNCTION);	}	cache_entry = hash_search(collation_cache, &collation, HASH_ENTER, &found);	if (!found)	{		/*		 * Make sure cache entry is marked invalid, in case we fail before		 * setting things.		 */		cache_entry->flags_valid = false;		cache_entry->locale = 0;	}	if (set_flags && !cache_entry->flags_valid)	{		/* Attempt to set the flags */		HeapTuple	tp;		Form_pg_collation collform;		const char *collcollate;		const char *collctype;		tp = SearchSysCache1(COLLOID, ObjectIdGetDatum(collation));		if (!HeapTupleIsValid(tp))			elog(ERROR, "cache lookup failed for collation %u", collation);		collform = (Form_pg_collation) GETSTRUCT(tp);		collcollate = NameStr(collform->collcollate);		collctype = NameStr(collform->collctype);		cache_entry->collate_is_c = ((strcmp(collcollate, "C") == 0) ||									 (strcmp(collcollate, "POSIX") == 0));		cache_entry->ctype_is_c = ((strcmp(collctype, "C") == 0) ||								   (strcmp(collctype, "POSIX") == 0));		cache_entry->flags_valid = true;		ReleaseSysCache(tp);	}	return cache_entry;}

//.........这里部分代码省略.........	}	/*	 * List was not found in cache, so we have to build it by reading the	 * relation.  For each matching tuple found in the relation, use an	 * existing cache entry if possible, else build a new one.	 *	 * We have to bump the member refcounts temporarily to ensure they won't	 * get dropped from the cache while loading other members. We use a PG_TRY	 * block to ensure we can undo those refcounts if we get an error before	 * we finish constructing the CatCList.	 */	ResourceOwnerEnlargeCatCacheListRefs(CurrentResourceOwner);	ctlist = NIL;	PG_TRY();	{		Relation	relation;		SysScanDesc scandesc;		relation = heap_open(cache->cc_reloid, AccessShareLock);		scandesc = systable_beginscan(relation,									  cache->cc_indexoid,									  IndexScanOK(cache, cur_skey),									  SnapshotNow,									  nkeys,									  cur_skey);		/* The list will be ordered iff we are doing an index scan */		ordered = (scandesc->irel != NULL);		while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))		{			uint32		hashValue;			Index		hashIndex;			/*			 * See if there's an entry for this tuple already.			 */			ct = NULL;			hashValue = CatalogCacheComputeTupleHashValue(cache, ntp);			hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);			for (elt = DLGetHead(&cache->cc_bucket[hashIndex]);				 elt;				 elt = DLGetSucc(elt))			{				ct = (CatCTup *) DLE_VAL(elt);				if (ct->dead || ct->negative)					continue;	/* ignore dead and negative entries */				if (ct->hash_value != hashValue)					continue;	/* quickly skip entry if wrong hash val */				if (!ItemPointerEquals(&(ct->tuple.t_self), &(ntp->t_self)))					continue;	/* not same tuple */				/*				 * Found a match, but can't use it if it belongs to another				 * list already				 */				if (ct->c_list)					continue;

/* * OperatorUpd * *	For a given operator, look up its negator and commutator operators. *	If they are defined, but their negator and commutator fields *	(respectively) are empty, then use the new operator for neg or comm. *	This solves a problem for users who need to insert two new operators *	which are the negator or commutator of each other. */static voidOperatorUpd(Oid baseId, Oid commId, Oid negId){	int			i;	Relation	pg_operator_desc;	HeapTuple	tup;	bool		nulls[Natts_pg_operator];	bool		replaces[Natts_pg_operator];	Datum		values[Natts_pg_operator];	for (i = 0; i < Natts_pg_operator; ++i)	{		values[i] = (Datum) 0;		replaces[i] = false;		nulls[i] = false;	}	/*	 * check and update the commutator & negator, if necessary	 *	 * We need a CommandCounterIncrement here in case of a self-commutator	 * operator: we'll need to update the tuple that we just inserted.	 */	CommandCounterIncrement();	pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);	tup = SearchSysCacheCopy1(OPEROID, ObjectIdGetDatum(commId));	/*	 * if the commutator and negator are the same operator, do one update. XXX	 * this is probably useless code --- I doubt it ever makes sense for	 * commutator and negator to be the same thing...	 */	if (commId == negId)	{		if (HeapTupleIsValid(tup))		{			Form_pg_operator t = (Form_pg_operator) GETSTRUCT(tup);			if (!OidIsValid(t->oprcom) || !OidIsValid(t->oprnegate))			{				if (!OidIsValid(t->oprnegate))				{					values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(baseId);					replaces[Anum_pg_operator_oprnegate - 1] = true;				}				if (!OidIsValid(t->oprcom))				{					values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(baseId);					replaces[Anum_pg_operator_oprcom - 1] = true;				}				tup = heap_modify_tuple(tup,										RelationGetDescr(pg_operator_desc),										values,										nulls,										replaces);				simple_heap_update(pg_operator_desc, &tup->t_self, tup);				CatalogUpdateIndexes(pg_operator_desc, tup);			}		}		heap_close(pg_operator_desc, RowExclusiveLock);		return;	}	/* if commutator and negator are different, do two updates */	if (HeapTupleIsValid(tup) &&		!(OidIsValid(((Form_pg_operator) GETSTRUCT(tup))->oprcom)))	{		values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(baseId);		replaces[Anum_pg_operator_oprcom - 1] = true;		tup = heap_modify_tuple(tup,								RelationGetDescr(pg_operator_desc),								values,								nulls,								replaces);		simple_heap_update(pg_operator_desc, &tup->t_self, tup);		CatalogUpdateIndexes(pg_operator_desc, tup);		values[Anum_pg_operator_oprcom - 1] = (Datum) NULL;		replaces[Anum_pg_operator_oprcom - 1] = false;//.........这里部分代码省略.........

//.........这里部分代码省略.........				if (aclresult != ACLCHECK_OK)					aclcheck_error(aclresult, ACL_KIND_CLASS, relrv->relname);				ErrorLogFileName(context->filename, MyDatabaseId, relid);				fp = AllocateFile(context->filename, "r");				context->fp = fp;			}		}		MemoryContextSwitchTo(oldcontext);		if (Gp_role != GP_ROLE_DISPATCH && !context->fp)		{			pfree(context);			SRF_RETURN_DONE(funcctx);		}	}	funcctx = SRF_PERCALL_SETUP();	context = (ReadErrorLogContext *) funcctx->user_fctx;	/*	 * Read error log, probably on segments.  We don't check Gp_role, however,	 * in case master also wants to read the file.	 */	if (context->fp)	{		pg_crc32	crc, written_crc;		tuple = ErrorLogRead(context->fp, &written_crc);		/*		 * CRC check.		 */		if (HeapTupleIsValid(tuple))		{			INIT_CRC32C(crc);			COMP_CRC32C(crc, tuple->t_data, tuple->t_len);			FIN_CRC32C(crc);			if (!EQ_CRC32C(crc, written_crc))			{				elog(LOG, "incorrect checksum in error log %s",						  context->filename);				tuple = NULL;			}		}		/*		 * If we found a valid tuple, return it.  Otherwise, fall through		 * in the DONE routine.		 */		if (HeapTupleIsValid(tuple))		{			/*			 * We need to set typmod for the executor to understand			 * its type we just blessed.			 */			HeapTupleHeaderSetTypMod(tuple->t_data,									 funcctx->tuple_desc->tdtypmod);			result = HeapTupleGetDatum(tuple);			SRF_RETURN_NEXT(funcctx, result);		}	}	/*

/* * Adjust dependency record(s) to point to a different object of the same type * * classId/objectId specify the referencing object. * refClassId/oldRefObjectId specify the old referenced object. * newRefObjectId is the new referenced object (must be of class refClassId). * * Note the lack of objsubid parameters.  If there are subobject references * they will all be readjusted. * * Returns the number of records updated. */longchangeDependencyFor(Oid classId, Oid objectId,					Oid refClassId, Oid oldRefObjectId,					Oid newRefObjectId){	long		count = 0;	Relation	depRel;	ScanKeyData key[2];	SysScanDesc scan;	HeapTuple	tup;	ObjectAddress objAddr;	bool		newIsPinned;	depRel = heap_open(DependRelationId, RowExclusiveLock);	/*	 * If oldRefObjectId is pinned, there won't be any dependency entries on	 * it --- we can't cope in that case.  (This isn't really worth expending	 * code to fix, in current usage; it just means you can't rename stuff out	 * of pg_catalog, which would likely be a bad move anyway.)	 */	objAddr.classId = refClassId;	objAddr.objectId = oldRefObjectId;	objAddr.objectSubId = 0;	if (isObjectPinned(&objAddr, depRel))		ereport(ERROR,				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),		errmsg("cannot remove dependency on %s because it is a system object",			   getObjectDescription(&objAddr))));	/*	 * We can handle adding a dependency on something pinned, though, since	 * that just means deleting the dependency entry.	 */	objAddr.objectId = newRefObjectId;	newIsPinned = isObjectPinned(&objAddr, depRel);	/* Now search for dependency records */	ScanKeyInit(&key[0],				Anum_pg_depend_classid,				BTEqualStrategyNumber, F_OIDEQ,				ObjectIdGetDatum(classId));	ScanKeyInit(&key[1],				Anum_pg_depend_objid,				BTEqualStrategyNumber, F_OIDEQ,				ObjectIdGetDatum(objectId));	scan = systable_beginscan(depRel, DependDependerIndexId, true,							  NULL, 2, key);	while (HeapTupleIsValid((tup = systable_getnext(scan))))	{		Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);		if (depform->refclassid == refClassId &&			depform->refobjid == oldRefObjectId)		{			if (newIsPinned)				simple_heap_delete(depRel, &tup->t_self);			else			{				/* make a modifiable copy */				tup = heap_copytuple(tup);				depform = (Form_pg_depend) GETSTRUCT(tup);				depform->refobjid = newRefObjectId;				simple_heap_update(depRel, &tup->t_self, tup);				CatalogUpdateIndexes(depRel, tup);				heap_freetuple(tup);			}			count++;		}	}	systable_endscan(scan);	heap_close(depRel, RowExclusiveLock);	return count;}

//.........这里部分代码省略.........	values[i++] = Int32GetDatum(typNDims);		/* typndims */	/*	 * initialize the default binary value for this type.  Check for nulls of	 * course.	 */	if (defaultTypeBin)		values[i] = CStringGetTextDatum(defaultTypeBin);	else		nulls[i] = true;	i++;						/* typdefaultbin */	/*	 * initialize the default value for this type.	 */	if (defaultTypeValue)		values[i] = CStringGetTextDatum(defaultTypeValue);	else		nulls[i] = true;	i++;						/* typdefault */	/*	 * open pg_type and prepare to insert or update a row.	 *	 * NOTE: updating will not work correctly in bootstrap mode; but we don't	 * expect to be overwriting any shell types in bootstrap mode.	 */	pg_type_desc = heap_open(TypeRelationId, RowExclusiveLock);	tup = SearchSysCacheCopy(TYPENAMENSP,							 CStringGetDatum(typeName),							 ObjectIdGetDatum(typeNamespace),							 0, 0);	if (HeapTupleIsValid(tup))	{		/*		 * check that the type is not already defined.	It may exist as a		 * shell type, however.		 */		if (((Form_pg_type) GETSTRUCT(tup))->typisdefined)			ereport(ERROR,					(errcode(ERRCODE_DUPLICATE_OBJECT),					 errmsg("type /"%s/" already exists", typeName)));		/*		 * shell type must have been created by same owner		 */		if (((Form_pg_type) GETSTRUCT(tup))->typowner != ownerId)			aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TYPE, typeName);		/* trouble if caller wanted to force the OID */		if (OidIsValid(newTypeOid) &&			newTypeOid != HeapTupleHeaderGetOid((tup)->t_data))			elog(ERROR, "cannot assign new OID to existing shell type %u", HeapTupleHeaderGetOid((tup)->t_data));		/*		 * Okay to update existing shell type tuple		 */		tup = heap_modify_tuple(tup,							   RelationGetDescr(pg_type_desc),							   values,							   nulls,							   replaces);		simple_heap_update(pg_type_desc, &tup->t_self, tup);		typeObjectId = HeapTupleGetOid(tup);

/* * Test whether an object exists. */static boolobject_exists(ObjectAddress address){	int			cache = -1;	Oid			indexoid = InvalidOid;	Relation	rel;	ScanKeyData	skey[1];	SysScanDesc	sd;	bool		found;	/* Sub-objects require special treatment. */	if (address.objectSubId != 0)	{		HeapTuple	atttup;		/* Currently, attributes are the only sub-objects. */		Assert(address.classId == RelationRelationId);		atttup = SearchSysCache2(ATTNUM, ObjectIdGetDatum(address.objectId),								 Int16GetDatum(address.objectSubId));		if (!HeapTupleIsValid(atttup))			found = false;		else		{			found = ((Form_pg_attribute) GETSTRUCT(atttup))->attisdropped;			ReleaseSysCache(atttup);			}		return found;	}	/*	 * For object types that have a relevant syscache, we use it; for	 * everything else, we'll have to do an index-scan.  This switch	 * sets either the cache to be used for the syscache lookup, or the	 * index to be used for the index scan.	 */	switch (address.classId)	{		case RelationRelationId:			cache = RELOID;			break;		case RewriteRelationId:			indexoid = RewriteOidIndexId;			break;		case TriggerRelationId:			indexoid = TriggerOidIndexId;			break;		case ConstraintRelationId:			cache = CONSTROID;			break;		case DatabaseRelationId:			cache = DATABASEOID;			break;		case TableSpaceRelationId:			cache = TABLESPACEOID;			break;		case AuthIdRelationId:			cache = AUTHOID;			break;		case NamespaceRelationId:			cache = NAMESPACEOID;			break;		case LanguageRelationId:			cache = LANGOID;			break;		case TypeRelationId:			cache = TYPEOID;			break;		case ProcedureRelationId:			cache = PROCOID;			break;		case OperatorRelationId:			cache = OPEROID;			break;		case ConversionRelationId:			cache = CONVOID;			break;		case OperatorClassRelationId:			cache = CLAOID;			break;		case OperatorFamilyRelationId:			cache = OPFAMILYOID;			break;		case LargeObjectRelationId:			/*			 * Weird backward compatibility hack: ObjectAddress notation uses			 * LargeObjectRelationId for large objects, but since PostgreSQL			 * 9.0, the relevant catalog is actually			 * LargeObjectMetadataRelationId.			 */			address.classId = LargeObjectMetadataRelationId;			indexoid = LargeObjectMetadataOidIndexId;			break;		case CastRelationId:			indexoid = CastOidIndexId;			break;		case TSParserRelationId:			cache = TSPARSEROID;//.........这里部分代码省略.........

/* oper() -- search for a binary operator * Given operator name, types of arg1 and arg2, return oper struct. * * IMPORTANT: the returned operator (if any) is only promised to be * coercion-compatible with the input datatypes.  Do not use this if * you need an exact- or binary-compatible match; see compatible_oper. * * If no matching operator found, return NULL if noError is true, * raise an error if it is false.  pstate and location are used only to report * the error position; pass NULL/-1 if not available. * * NOTE: on success, the returned object is a syscache entry.  The caller * must ReleaseSysCache() the entry when done with it. */Operatoroper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId,	 bool noError, int location){	Oid			operOid;	OprCacheKey key;	bool		key_ok;	FuncDetailCode fdresult = FUNCDETAIL_NOTFOUND;	HeapTuple	tup = NULL;	/*	 * Try to find the mapping in the lookaside cache.	 */	key_ok = make_oper_cache_key(&key, opname, ltypeId, rtypeId);	if (key_ok)	{		operOid = find_oper_cache_entry(&key);		if (OidIsValid(operOid))		{			tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));			if (HeapTupleIsValid(tup))				return (Operator) tup;		}	}	/*	 * First try for an "exact" match.	 */	operOid = binary_oper_exact(opname, ltypeId, rtypeId);	if (!OidIsValid(operOid))	{		/*		 * Otherwise, search for the most suitable candidate.		 */		FuncCandidateList clist;		/* Get binary operators of given name */		clist = OpernameGetCandidates(opname, 'b');		/* No operators found? Then fail... */		if (clist != NULL)		{			/*			 * Unspecified type for one of the arguments? then use the other			 * (XXX this is probably dead code?)			 */			Oid			inputOids[2];			if (rtypeId == InvalidOid)				rtypeId = ltypeId;			else if (ltypeId == InvalidOid)				ltypeId = rtypeId;			inputOids[0] = ltypeId;			inputOids[1] = rtypeId;			fdresult = oper_select_candidate(2, inputOids, clist, &operOid);		}	}	if (OidIsValid(operOid))		tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));	if (HeapTupleIsValid(tup))	{		if (key_ok)			make_oper_cache_entry(&key, operOid);	}	else if (!noError)		op_error(pstate, opname, 'b', ltypeId, rtypeId, fdresult, location);	return (Operator) tup;}

/* * sepgsql_attribute_post_create * * This routine assigns a default security label on a newly defined * column, using ALTER TABLE ... ADD COLUMN. * Note that this routine is not invoked in the case of CREATE TABLE, * although it also defines columns in addition to table. */voidsepgsql_attribute_post_create(Oid relOid, AttrNumber attnum){	Relation	rel;	ScanKeyData skey[2];	SysScanDesc sscan;	HeapTuple	tuple;	char	   *scontext;	char	   *tcontext;	char	   *ncontext;	ObjectAddress object;	Form_pg_attribute attForm;	StringInfoData audit_name;	/*	 * Only attributes within regular relation have individual security	 * labels.	 */	if (get_rel_relkind(relOid) != RELKIND_RELATION)		return;	/*	 * Compute a default security label of the new column underlying the	 * specified relation, and check permission to create it.	 */	rel = heap_open(AttributeRelationId, AccessShareLock);	ScanKeyInit(&skey[0],				Anum_pg_attribute_attrelid,				BTEqualStrategyNumber, F_OIDEQ,				ObjectIdGetDatum(relOid));	ScanKeyInit(&skey[1],				Anum_pg_attribute_attnum,				BTEqualStrategyNumber, F_INT2EQ,				Int16GetDatum(attnum));	sscan = systable_beginscan(rel, AttributeRelidNumIndexId, true,							   SnapshotSelf, 2, &skey[0]);	tuple = systable_getnext(sscan);	if (!HeapTupleIsValid(tuple))		elog(ERROR, "catalog lookup failed for column %d of relation %u",			 attnum, relOid);	attForm = (Form_pg_attribute) GETSTRUCT(tuple);	scontext = sepgsql_get_client_label();	tcontext = sepgsql_get_label(RelationRelationId, relOid, 0);	ncontext = sepgsql_compute_create(scontext, tcontext,									  SEPG_CLASS_DB_COLUMN,									  NameStr(attForm->attname));	/*	 * check db_column:{create} permission	 */	object.classId = RelationRelationId;	object.objectId = relOid;	object.objectSubId = 0;	initStringInfo(&audit_name);	appendStringInfo(&audit_name, "%s.%s",					 getObjectIdentity(&object),					 quote_identifier(NameStr(attForm->attname)));	sepgsql_avc_check_perms_label(ncontext,								  SEPG_CLASS_DB_COLUMN,								  SEPG_DB_COLUMN__CREATE,								  audit_name.data,								  true);	/*	 * Assign the default security label on a new procedure	 */	object.classId = RelationRelationId;	object.objectId = relOid;	object.objectSubId = attnum;	SetSecurityLabel(&object, SEPGSQL_LABEL_TAG, ncontext);	systable_endscan(sscan);	heap_close(rel, AccessShareLock);	pfree(tcontext);	pfree(ncontext);}

/* right_oper() -- search for a unary right operator (postfix operator) * Given operator name and type of arg, return oper struct. * * IMPORTANT: the returned operator (if any) is only promised to be * coercion-compatible with the input datatype.  Do not use this if * you need an exact- or binary-compatible match. * * If no matching operator found, return NULL if noError is true, * raise an error if it is false.  pstate and location are used only to report * the error position; pass NULL/-1 if not available. * * NOTE: on success, the returned object is a syscache entry.  The caller * must ReleaseSysCache() the entry when done with it. */Operatorright_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location){	Oid			operOid;	OprCacheKey key;	bool		key_ok;	FuncDetailCode fdresult = FUNCDETAIL_NOTFOUND;	HeapTuple	tup = NULL;	/*	 * Try to find the mapping in the lookaside cache.	 */	key_ok = make_oper_cache_key(&key, op, arg, InvalidOid);	if (key_ok)	{		operOid = find_oper_cache_entry(&key);		if (OidIsValid(operOid))		{			tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));			if (HeapTupleIsValid(tup))				return (Operator) tup;		}	}	/*	 * First try for an "exact" match.	 */	operOid = OpernameGetOprid(op, arg, InvalidOid);	if (!OidIsValid(operOid))	{		/*		 * Otherwise, search for the most suitable candidate.		 */		FuncCandidateList clist;		/* Get postfix operators of given name */		clist = OpernameGetCandidates(op, 'r');		/* No operators found? Then fail... */		if (clist != NULL)		{			/*			 * We must run oper_select_candidate even if only one candidate,			 * otherwise we may falsely return a non-type-compatible operator.			 */			fdresult = oper_select_candidate(1, &arg, clist, &operOid);		}	}	if (OidIsValid(operOid))		tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));	if (HeapTupleIsValid(tup))	{		if (key_ok)			make_oper_cache_entry(&key, operOid);	}	else if (!noError)		op_error(pstate, op, 'r', arg, InvalidOid, fdresult, location);	return (Operator) tup;}

/** * @fn      Datum reorg_get_index_keys(PG_FUNCTION_ARGS) * @brief   Get key definition of the index. * * reorg_get_index_keys(index, table) * * @param	index	Oid of target index. * @param	table	Oid of table of the index. * @retval			Create index DDL for temp table. * * FIXME: this function is named get_index_keys, but actually returns * an expression for ORDER BY clause. get_order_by() might be a better name. */Datumreorg_get_index_keys(PG_FUNCTION_ARGS){	Oid				index = PG_GETARG_OID(0);	Oid				table = PG_GETARG_OID(1);	IndexDef		stmt;	char		   *token;	char		   *next;	StringInfoData	str;	Relation		indexRel = NULL;	int				nattr;	parse_indexdef(&stmt, index, table);	elog(DEBUG2, "indexdef.create  = %s", stmt.create);	elog(DEBUG2, "indexdef.index   = %s", stmt.index);	elog(DEBUG2, "indexdef.table   = %s", stmt.table);	elog(DEBUG2, "indexdef.type    = %s", stmt.type);	elog(DEBUG2, "indexdef.columns = %s", stmt.columns);	elog(DEBUG2, "indexdef.options = %s", stmt.options);	/*	 * FIXME: this is very unreliable implementation but I don't want to	 * re-implement customized versions of pg_get_indexdef_string...	 */	initStringInfo(&str);	for (nattr = 0, next = stmt.columns; next; nattr++)	{		char *opcname;		token = next;		while (isspace((unsigned char) *token))			token++;		next = skip_until(index, next, ',');		opcname = skip_until(index, token, ' ');		if (opcname)		{			/* lookup default operator name from operator class */			Oid				opclass;			Oid				oprid;			int16			strategy = BTLessStrategyNumber;			Oid				opcintype;			Oid				opfamily;			HeapTuple		tp;			Form_pg_opclass	opclassTup;			opclass = OpclassnameGetOpcid(BTREE_AM_OID, opcname);			/* Retrieve operator information. */			tp = SearchSysCache(CLAOID, ObjectIdGetDatum(opclass), 0, 0, 0);			if (!HeapTupleIsValid(tp))				elog(ERROR, "cache lookup failed for opclass %u", opclass);			opclassTup = (Form_pg_opclass) GETSTRUCT(tp);			opfamily = opclassTup->opcfamily;			opcintype = opclassTup->opcintype;			ReleaseSysCache(tp);			if (!OidIsValid(opcintype))			{				if (indexRel == NULL)					indexRel = index_open(index, NoLock);				opcintype = RelationGetDescr(indexRel)->attrs[nattr]->atttypid;			}			oprid = get_opfamily_member(opfamily, opcintype, opcintype, strategy);			if (!OidIsValid(oprid))				elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",					 strategy, opcintype, opcintype, opfamily);			opcname[-1] = '/0';			appendStringInfo(&str, "%s USING %s", token, get_opname(oprid));		}		else			appendStringInfoString(&str, token);		if (next)			appendStringInfoString(&str, ", ");	}	if (indexRel != NULL)		index_close(indexRel, NoLock);	PG_RETURN_TEXT_P(cstring_to_text(str.data));}

/* left_oper() -- search for a unary left operator (prefix operator) * Given operator name and type of arg, return oper struct. * * IMPORTANT: the returned operator (if any) is only promised to be * coercion-compatible with the input datatype.  Do not use this if * you need an exact- or binary-compatible match. * * If no matching operator found, return NULL if noError is true, * raise an error if it is false.  pstate and location are used only to report * the error position; pass NULL/-1 if not available. * * NOTE: on success, the returned object is a syscache entry.  The caller * must ReleaseSysCache() the entry when done with it. */Operatorleft_oper(ParseState *pstate, List *op, Oid arg, bool noError, int location){	Oid			operOid;	OprCacheKey key;	bool		key_ok;	FuncDetailCode fdresult = FUNCDETAIL_NOTFOUND;	HeapTuple	tup = NULL;	/*	 * Try to find the mapping in the lookaside cache.	 */	key_ok = make_oper_cache_key(&key, op, InvalidOid, arg);	if (key_ok)	{		operOid = find_oper_cache_entry(&key);		if (OidIsValid(operOid))		{			tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));			if (HeapTupleIsValid(tup))				return (Operator) tup;		}	}	/*	 * First try for an "exact" match.	 */	operOid = OpernameGetOprid(op, InvalidOid, arg);	if (!OidIsValid(operOid))	{		/*		 * Otherwise, search for the most suitable candidate.		 */		FuncCandidateList clist;		/* Get prefix operators of given name */		clist = OpernameGetCandidates(op, 'l');		/* No operators found? Then fail... */		if (clist != NULL)		{			/*			 * The returned list has args in the form (0, oprright). Move the			 * useful data into args[0] to keep oper_select_candidate simple.			 * XXX we are assuming here that we may scribble on the list!			 */			FuncCandidateList clisti;			for (clisti = clist; clisti != NULL; clisti = clisti->next)			{				clisti->args[0] = clisti->args[1];			}			/*			 * We must run oper_select_candidate even if only one candidate,			 * otherwise we may falsely return a non-type-compatible operator.			 */			fdresult = oper_select_candidate(1, &arg, clist, &operOid);		}	}	if (OidIsValid(operOid))		tup = SearchSysCache1(OPEROID, ObjectIdGetDatum(operOid));	if (HeapTupleIsValid(tup))	{		if (key_ok)			make_oper_cache_entry(&key, operOid);	}	else if (!noError)		op_error(pstate, op, 'l', InvalidOid, arg, fdresult, location);	return (Operator) tup;}

/* * Write a tuple to the outputstream, in the most efficient format possible. */static voidlogicalrep_write_tuple(StringInfo out, Relation rel, HeapTuple tuple){	TupleDesc	desc;	Datum		values[MaxTupleAttributeNumber];	bool		isnull[MaxTupleAttributeNumber];	int			i;	uint16		nliveatts = 0;	desc = RelationGetDescr(rel);	for (i = 0; i < desc->natts; i++)	{		if (desc->attrs[i]->attisdropped)			continue;		nliveatts++;	}	pq_sendint(out, nliveatts, 2);	/* try to allocate enough memory from the get-go */	enlargeStringInfo(out, tuple->t_len +					  nliveatts * (1 + 4));	heap_deform_tuple(tuple, desc, values, isnull);	/* Write the values */	for (i = 0; i < desc->natts; i++)	{		HeapTuple	typtup;		Form_pg_type typclass;		Form_pg_attribute att = desc->attrs[i];		char	   *outputstr;		int			len;		/* skip dropped columns */		if (att->attisdropped)			continue;		if (isnull[i])		{			pq_sendbyte(out, 'n');	/* null column */			continue;		}		else if (att->attlen == -1 && VARATT_IS_EXTERNAL_ONDISK(values[i]))		{			pq_sendbyte(out, 'u');	/* unchanged toast column */			continue;		}		typtup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(att->atttypid));		if (!HeapTupleIsValid(typtup))			elog(ERROR, "cache lookup failed for type %u", att->atttypid);		typclass = (Form_pg_type) GETSTRUCT(typtup);		pq_sendbyte(out, 't');	/* 'text' data follows */		outputstr = OidOutputFunctionCall(typclass->typoutput, values[i]);		len = strlen(outputstr) + 1;	/* null terminated */		pq_sendint(out, len, 4);		/* length */		pq_sendstring(out, outputstr);	/* data */		pfree(outputstr);		ReleaseSysCache(typtup);	}}

//.........这里部分代码省略.........	 *	 * NOTE: the normal TOAST access routines could actually function with a	 * single-column index on chunk_id only. However, the slice access	 * routines use both columns for faster access to an individual chunk. In	 * addition, we want it to be unique as a check against the possibility of	 * duplicate TOAST chunk OIDs. The index might also be a little more	 * efficient this way, since btree isn't all that happy with large numbers	 * of equal keys.	 */	indexInfo = makeNode(IndexInfo);	indexInfo->ii_NumIndexAttrs = 2;	indexInfo->ii_KeyAttrNumbers[0] = 1;	indexInfo->ii_KeyAttrNumbers[1] = 2;	indexInfo->ii_Expressions = NIL;	indexInfo->ii_ExpressionsState = NIL;	indexInfo->ii_Predicate = NIL;	indexInfo->ii_PredicateState = NULL;	indexInfo->ii_ExclusionOps = NULL;	indexInfo->ii_ExclusionProcs = NULL;	indexInfo->ii_ExclusionStrats = NULL;	indexInfo->ii_Unique = true;	indexInfo->ii_ReadyForInserts = true;	indexInfo->ii_Concurrent = false;	indexInfo->ii_BrokenHotChain = false;	indexInfo->ii_ParallelWorkers = 0;	indexInfo->ii_Am = BTREE_AM_OID;	indexInfo->ii_AmCache = NULL;	indexInfo->ii_Context = CurrentMemoryContext;	collationObjectId[0] = InvalidOid;	collationObjectId[1] = InvalidOid;	classObjectId[0] = OID_BTREE_OPS_OID;	classObjectId[1] = INT4_BTREE_OPS_OID;	coloptions[0] = 0;	coloptions[1] = 0;	index_create(toast_rel, toast_idxname, toastIndexOid, InvalidOid,				 InvalidOid, InvalidOid,				 indexInfo,				 list_make2("chunk_id", "chunk_seq"),				 BTREE_AM_OID,				 rel->rd_rel->reltablespace,				 collationObjectId, classObjectId, coloptions, (Datum) 0,				 INDEX_CREATE_IS_PRIMARY, 0, true, true, NULL);	heap_close(toast_rel, NoLock);	/*	 * Store the toast table's OID in the parent relation's pg_class row	 */	class_rel = heap_open(RelationRelationId, RowExclusiveLock);	reltup = SearchSysCacheCopy1(RELOID, ObjectIdGetDatum(relOid));	if (!HeapTupleIsValid(reltup))		elog(ERROR, "cache lookup failed for relation %u", relOid);	((Form_pg_class) GETSTRUCT(reltup))->reltoastrelid = toast_relid;	if (!IsBootstrapProcessingMode())	{		/* normal case, use a transactional update */		CatalogTupleUpdate(class_rel, &reltup->t_self, reltup);	}	else	{		/* While bootstrapping, we cannot UPDATE, so overwrite in-place */		heap_inplace_update(class_rel, reltup);	}	heap_freetuple(reltup);	heap_close(class_rel, RowExclusiveLock);	/*	 * Register dependency from the toast table to the master, so that the	 * toast table will be deleted if the master is.  Skip this in bootstrap	 * mode.	 */	if (!IsBootstrapProcessingMode())	{		baseobject.classId = RelationRelationId;		baseobject.objectId = relOid;		baseobject.objectSubId = 0;		toastobject.classId = RelationRelationId;		toastobject.objectId = toast_relid;		toastobject.objectSubId = 0;		recordDependencyOn(&toastobject, &baseobject, DEPENDENCY_INTERNAL);	}	/*	 * Make changes visible	 */	CommandCounterIncrement();	return true;}

/* * scram_utils_verifier * * Generate a verifier for SCRAM-SHA-256 authentication and update the * related user's pg_authid entry as per RFC 7677. */Datumscram_utils_verifier(PG_FUNCTION_ARGS){	pg_saslprep_rc rc;	char	   *username = text_to_cstring(PG_GETARG_TEXT_PP(0));	const char *password = text_to_cstring(PG_GETARG_TEXT_PP(1));	int			iterations = PG_GETARG_INT32(2);	int			saltlen = PG_GETARG_INT32(3);	char	   *prep_password = NULL;	char	   *saltbuf;	char	   *verifier;	HeapTuple	oldtuple, newtuple;	TupleDesc	dsc;	Relation	rel;	Datum		repl_val[Natts_pg_authid];	bool		repl_null[Natts_pg_authid];	bool		repl_repl[Natts_pg_authid];	if (!superuser())		ereport(ERROR,				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),				 (errmsg("must be superuser to update one's SCRAM verifier"))));	/* Control iteration number and salt length */	if (iterations <= 0)	{		ereport(WARNING,				(errmsg("Incorrect iteration number, defaulting to %d",						SCRAM_DEFAULT_ITERATIONS)));		iterations = SCRAM_DEFAULT_ITERATIONS;	}	if (saltlen <= 0)	{		ereport(WARNING,				(errmsg("Incorrect salt length number, defaulting to %d",						SCRAM_DEFAULT_SALT_LEN)));		saltlen = SCRAM_DEFAULT_SALT_LEN;	}	/*	 * Normalize the password with SASLprep.  If that doesn't work, because	 * the password isn't valid UTF-8 or contains prohibited characters, just	 * proceed with the original password.  (See comments at top of file.)	 */	rc = pg_saslprep(password, &prep_password);	if (rc == SASLPREP_OOM)		elog(ERROR, "out of memory");	if (rc == SASLPREP_SUCCESS)		password = (const char *) prep_password;	/* Generate a random salt */	saltbuf = palloc(sizeof(char) * saltlen);	if (!pg_strong_random(saltbuf, saltlen))		elog(ERROR, "Failed to generate random salt");	/* Build verifier */	verifier = scram_build_verifier(saltbuf, saltlen, iterations, password);	if (prep_password)		pfree(prep_password);	/* Verifier is built, so update pg_authid with it */	rel = heap_open(AuthIdRelationId, RowExclusiveLock);	oldtuple = SearchSysCache1(AUTHNAME, CStringGetDatum(username));	if (!HeapTupleIsValid(oldtuple))		ereport(ERROR,				(errcode(ERRCODE_UNDEFINED_OBJECT),				 errmsg("role /"%s/" does not exist", username)));	/* OK, construct the modified tuple with new password */	memset(repl_repl, false, sizeof(repl_repl));	memset(repl_null, false, sizeof(repl_null));	repl_repl[Anum_pg_authid_rolpassword - 1] = true;	repl_val[Anum_pg_authid_rolpassword - 1] = CStringGetTextDatum(verifier);	repl_null[Anum_pg_authid_rolpassword - 1] = false;	dsc = RelationGetDescr(rel);	newtuple = heap_modify_tuple(oldtuple, dsc, repl_val, repl_null, repl_repl);	CatalogTupleUpdate(rel, &oldtuple->t_self, newtuple);	ReleaseSysCache(oldtuple);	/*	 * Close pg_authid, but keep lock till commit.	 */	heap_close(rel, NoLock);	PG_RETURN_NULL();}

//.........这里部分代码省略.........		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	{		tupDesc = pg_operator_desc->rd_att;		tup = heap_form_tuple(tupDesc, values, nulls);		operatorObjectId = simple_heap_insert(pg_operator_desc, tup);	}	/* Must update the indexes in either case */	CatalogUpdateIndexes(pg_operator_desc, tup);	/* Add dependencies for the entry */	makeOperatorDependencies(tup);	/* Post creation hook for new operator */	InvokeObjectAccessHook(OAT_POST_CREATE,						   OperatorRelationId, operatorObjectId, 0);	heap_close(pg_operator_desc, RowExclusiveLock);	/*	 * If a commutator and/or negator link is provided, update the other	 * operator(s) to point at this one, if they don't already have a link.	 * This supports an alternative style of operator definition wherein the	 * user first defines one operator without giving negator or commutator,	 * then defines the other operator of the pair with the proper commutator	 * or negator attribute.  That style doesn't require creation of a shell,	 * and it's the only style that worked right before Postgres version 6.5.	 * This code also takes care of the situation where the new operator is	 * its own commutator.	 */	if (selfCommutator)		commutatorId = operatorObjectId;	if (OidIsValid(commutatorId) || OidIsValid(negatorId))		OperatorUpd(operatorObjectId, commutatorId, negatorId);}

/* * Guts of language creation. */static Oidcreate_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;//.........这里部分代码省略.........

static char *format_type_internal(Oid type_oid, int32 typemod,					 bool typemod_given, bool allow_invalid){	bool		with_typemod = typemod_given && (typemod >= 0);	HeapTuple	tuple;	Form_pg_type typeform;	Oid			array_base_type;	bool		is_array;	char	   *buf;	if (type_oid == InvalidOid && allow_invalid)		return pstrdup("-");	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));	if (!HeapTupleIsValid(tuple))	{		if (allow_invalid)			return pstrdup("???");		else			elog(ERROR, "cache lookup failed for type %u", type_oid);	}	typeform = (Form_pg_type) GETSTRUCT(tuple);	/*	 * Check if it's a regular (variable length) array type.  Fixed-length	 * array types such as "name" shouldn't get deconstructed.  As of Postgres	 * 8.1, rather than checking typlen we check the toast property, and don't	 * deconstruct "plain storage" array types --- this is because we don't	 * want to show oidvector as oid[].	 */	array_base_type = typeform->typelem;	if (array_base_type != InvalidOid &&		typeform->typstorage != 'p')	{		/* Switch our attention to the array element type */		ReleaseSysCache(tuple);		tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));		if (!HeapTupleIsValid(tuple))		{			if (allow_invalid)				return pstrdup("???[]");			else				elog(ERROR, "cache lookup failed for type %u", type_oid);		}		typeform = (Form_pg_type) GETSTRUCT(tuple);		type_oid = array_base_type;		is_array = true;	}	else		is_array = false;	/*	 * See if we want to special-case the output for certain built-in types.	 * Note that these special cases should all correspond to special	 * productions in gram.y, to ensure that the type name will be taken as a	 * system type, not a user type of the same name.	 *	 * If we do not provide a special-case output here, the type name will be	 * handled the same way as a user type name --- in particular, it will be	 * double-quoted if it matches any lexer keyword.  This behavior is	 * essential for some cases, such as types "bit" and "char".	 */	buf = NULL;					/* flag for no special case */	switch (type_oid)	{		case BITOID:			if (with_typemod)				buf = printTypmod("bit", typemod, typeform->typmodout);			else if (typemod_given)			{				/*				 * bit with typmod -1 is not the same as BIT, which means				 * BIT(1) per SQL spec.  Report it as the quoted typename so				 * that parser will not assign a bogus typmod.				 */			}			else				buf = pstrdup("bit");			break;		case BOOLOID:			buf = pstrdup("boolean");			break;		case BPCHAROID:			if (with_typemod)				buf = printTypmod("character", typemod, typeform->typmodout);			else if (typemod_given)			{				/*				 * bpchar with typmod -1 is not the same as CHARACTER, which				 * means CHARACTER(1) per SQL spec.  Report it as bpchar so				 * that parser will not assign a bogus typmod.				 */			}			else				buf = pstrdup("character");//.........这里部分代码省略.........