static TupleDesc ConstructTupleDescriptor(Relation heapRelation,
const IndexInfo *indexInfo,
const List *indexColNames,
- Oid accessMethodObjectId,
- const Oid *collationObjectId,
- const Oid *classObjectId);
+ Oid accessMethodId,
+ const Oid *collationIds,
+ const Oid *opclassIds);
static void InitializeAttributeOids(Relation indexRelation,
int numatts, Oid indexoid);
static void AppendAttributeTuples(Relation indexRelation, const Datum *attopts);
Oid parentIndexId,
const IndexInfo *indexInfo,
const Oid *collationOids,
- const Oid *classOids,
+ const Oid *opclassOids,
const int16 *coloptions,
bool primary,
bool isexclusion,
ConstructTupleDescriptor(Relation heapRelation,
const IndexInfo *indexInfo,
const List *indexColNames,
- Oid accessMethodObjectId,
- const Oid *collationObjectId,
- const Oid *classObjectId)
+ Oid accessMethodId,
+ const Oid *collationIds,
+ const Oid *opclassIds)
{
int numatts = indexInfo->ii_NumIndexAttrs;
int numkeyatts = indexInfo->ii_NumIndexKeyAttrs;
int i;
/* We need access to the index AM's API struct */
- amroutine = GetIndexAmRoutineByAmId(accessMethodObjectId, false);
+ amroutine = GetIndexAmRoutineByAmId(accessMethodId, false);
/* ... and to the table's tuple descriptor */
heapTupDesc = RelationGetDescr(heapRelation);
to->attcacheoff = -1;
to->attislocal = true;
to->attcollation = (i < numkeyatts) ?
- collationObjectId[i] : InvalidOid;
+ collationIds[i] : InvalidOid;
/*
* Set the attribute name as specified by caller.
if (i < indexInfo->ii_NumIndexKeyAttrs)
{
- tuple = SearchSysCache1(CLAOID, ObjectIdGetDatum(classObjectId[i]));
+ tuple = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassIds[i]));
if (!HeapTupleIsValid(tuple))
elog(ERROR, "cache lookup failed for opclass %u",
- classObjectId[i]);
+ opclassIds[i]);
opclassTup = (Form_pg_opclass) GETSTRUCT(tuple);
if (OidIsValid(opclassTup->opckeytype))
keyType = opclassTup->opckeytype;
Oid parentIndexId,
const IndexInfo *indexInfo,
const Oid *collationOids,
- const Oid *classOids,
+ const Oid *opclassOids,
const int16 *coloptions,
bool primary,
bool isexclusion,
for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
indkey->values[i] = indexInfo->ii_IndexAttrNumbers[i];
indcollation = buildoidvector(collationOids, indexInfo->ii_NumIndexKeyAttrs);
- indclass = buildoidvector(classOids, indexInfo->ii_NumIndexKeyAttrs);
+ indclass = buildoidvector(opclassOids, indexInfo->ii_NumIndexKeyAttrs);
indoption = buildint2vector(coloptions, indexInfo->ii_NumIndexKeyAttrs);
/*
* May be nonzero to attach an existing valid build.
* indexInfo: same info executor uses to insert into the index
* indexColNames: column names to use for index (List of char *)
- * accessMethodObjectId: OID of index AM to use
+ * accessMethodId: OID of index AM to use
* tableSpaceId: OID of tablespace to use
- * collationObjectId: array of collation OIDs, one per index column
- * classObjectId: array of index opclass OIDs, one per index column
+ * collationIds: array of collation OIDs, one per index column
+ * opclassIds: array of index opclass OIDs, one per index column
* coloptions: array of per-index-column indoption settings
* reloptions: AM-specific options
* flags: bitmask that can include any combination of these bits:
RelFileNumber relFileNumber,
IndexInfo *indexInfo,
const List *indexColNames,
- Oid accessMethodObjectId,
+ Oid accessMethodId,
Oid tableSpaceId,
- const Oid *collationObjectId,
- const Oid *classObjectId,
+ const Oid *collationIds,
+ const Oid *opclassIds,
const int16 *coloptions,
Datum reloptions,
bits16 flags,
*/
for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
{
- Oid collation = collationObjectId[i];
- Oid opclass = classObjectId[i];
+ Oid collation = collationIds[i];
+ Oid opclass = opclassIds[i];
if (collation)
{
indexTupDesc = ConstructTupleDescriptor(heapRelation,
indexInfo,
indexColNames,
- accessMethodObjectId,
- collationObjectId,
- classObjectId);
+ accessMethodId,
+ collationIds,
+ opclassIds);
/*
* Allocate an OID for the index, unless we were told what to use.
tableSpaceId,
indexRelationId,
relFileNumber,
- accessMethodObjectId,
+ accessMethodId,
indexTupDesc,
relkind,
relpersistence,
* XXX should have a cleaner way to create cataloged indexes
*/
indexRelation->rd_rel->relowner = heapRelation->rd_rel->relowner;
- indexRelation->rd_rel->relam = accessMethodObjectId;
+ indexRelation->rd_rel->relam = accessMethodId;
indexRelation->rd_rel->relispartition = OidIsValid(parentIndexRelid);
/*
*/
UpdateIndexRelation(indexRelationId, heapRelationId, parentIndexRelid,
indexInfo,
- collationObjectId, classObjectId, coloptions,
+ collationIds, opclassIds, coloptions,
isprimary, is_exclusion,
(constr_flags & INDEX_CONSTR_CREATE_DEFERRABLE) == 0,
!concurrent && !invalid,
/* The default collation is pinned, so don't bother recording it */
for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
{
- if (OidIsValid(collationObjectId[i]) &&
- collationObjectId[i] != DEFAULT_COLLATION_OID)
+ if (OidIsValid(collationIds[i]) &&
+ collationIds[i] != DEFAULT_COLLATION_OID)
{
ObjectAddressSet(referenced, CollationRelationId,
- collationObjectId[i]);
+ collationIds[i]);
add_exact_object_address(&referenced, addrs);
}
}
/* Store dependency on operator classes */
for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++)
{
- ObjectAddressSet(referenced, OperatorClassRelationId, classObjectId[i]);
+ ObjectAddressSet(referenced, OperatorClassRelationId, opclassIds[i]);
add_exact_object_address(&referenced, addrs);
}
static bool CompareOpclassOptions(const Datum *opts1, const Datum *opts2, int natts);
static void CheckPredicate(Expr *predicate);
static void ComputeIndexAttrs(IndexInfo *indexInfo,
- Oid *typeOidP,
- Oid *collationOidP,
- Oid *classOidP,
- int16 *colOptionP,
+ Oid *typeOids,
+ Oid *collationOids,
+ Oid *opclassOids,
+ int16 *colOptions,
const List *attList,
const List *exclusionOpNames,
Oid relId,
const List *exclusionOpNames)
{
bool isconstraint;
- Oid *typeObjectId;
- Oid *collationObjectId;
- Oid *classObjectId;
+ Oid *typeIds;
+ Oid *collationIds;
+ Oid *opclassIds;
Oid accessMethodId;
Oid relationId;
HeapTuple tuple;
indexInfo = makeIndexInfo(numberOfAttributes, numberOfAttributes,
accessMethodId, NIL, NIL, false, false,
false, false, amsummarizing);
- typeObjectId = palloc_array(Oid, numberOfAttributes);
- collationObjectId = palloc_array(Oid, numberOfAttributes);
- classObjectId = palloc_array(Oid, numberOfAttributes);
+ typeIds = palloc_array(Oid, numberOfAttributes);
+ collationIds = palloc_array(Oid, numberOfAttributes);
+ opclassIds = palloc_array(Oid, numberOfAttributes);
coloptions = palloc_array(int16, numberOfAttributes);
ComputeIndexAttrs(indexInfo,
- typeObjectId, collationObjectId, classObjectId,
+ typeIds, collationIds, opclassIds,
coloptions, attributeList,
exclusionOpNames, relationId,
accessMethodName, accessMethodId,
d = SysCacheGetAttrNotNull(INDEXRELID, tuple, Anum_pg_index_indclass);
old_indclass = (oidvector *) DatumGetPointer(d);
- ret = (memcmp(old_indclass->values, classObjectId,
+ ret = (memcmp(old_indclass->values, opclassIds,
old_natts * sizeof(Oid)) == 0 &&
- memcmp(old_indcollation->values, collationObjectId,
+ memcmp(old_indcollation->values, collationIds,
old_natts * sizeof(Oid)) == 0);
ReleaseSysCache(tuple);
irel = index_open(oldId, AccessShareLock); /* caller probably has a lock */
for (i = 0; i < old_natts; i++)
{
- if (IsPolymorphicType(get_opclass_input_type(classObjectId[i])) &&
- TupleDescAttr(irel->rd_att, i)->atttypid != typeObjectId[i])
+ if (IsPolymorphicType(get_opclass_input_type(opclassIds[i])) &&
+ TupleDescAttr(irel->rd_att, i)->atttypid != typeIds[i])
{
ret = false;
break;
op_input_types(indexInfo->ii_ExclusionOps[i], &left, &right);
if ((IsPolymorphicType(left) || IsPolymorphicType(right)) &&
- TupleDescAttr(irel->rd_att, i)->atttypid != typeObjectId[i])
+ TupleDescAttr(irel->rd_att, i)->atttypid != typeIds[i])
{
ret = false;
break;
* consider offering one DDL command for catalog setup and a separate DDL
* command for steps that run opaque expressions.
*
- * 'relationId': the OID of the heap relation on which the index is to be
+ * 'tableId': the OID of the table relation on which the index is to be
* created
* 'stmt': IndexStmt describing the properties of the new index.
* 'indexRelationId': normally InvalidOid, but during bootstrap can be
* Returns the object address of the created index.
*/
ObjectAddress
-DefineIndex(Oid relationId,
+DefineIndex(Oid tableId,
IndexStmt *stmt,
Oid indexRelationId,
Oid parentIndexId,
bool concurrent;
char *indexRelationName;
char *accessMethodName;
- Oid *typeObjectId;
- Oid *collationObjectId;
- Oid *classObjectId;
+ Oid *typeIds;
+ Oid *collationIds;
+ Oid *opclassIds;
Oid accessMethodId;
Oid namespaceId;
Oid tablespaceId;
* is more efficient. Do this before any use of the concurrent option is
* done.
*/
- if (stmt->concurrent && get_rel_persistence(relationId) != RELPERSISTENCE_TEMP)
+ if (stmt->concurrent && get_rel_persistence(tableId) != RELPERSISTENCE_TEMP)
concurrent = true;
else
concurrent = false;
if (!OidIsValid(parentIndexId))
{
pgstat_progress_start_command(PROGRESS_COMMAND_CREATE_INDEX,
- relationId);
+ tableId);
pgstat_progress_update_param(PROGRESS_CREATEIDX_COMMAND,
concurrent ?
PROGRESS_CREATEIDX_COMMAND_CREATE_CONCURRENTLY :
* index build; but for concurrent builds we allow INSERT/UPDATE/DELETE
* (but not VACUUM).
*
- * NB: Caller is responsible for making sure that relationId refers to the
+ * NB: Caller is responsible for making sure that tableId refers to the
* relation on which the index should be built; except in bootstrap mode,
* this will typically require the caller to have already locked the
* relation. To avoid lock upgrade hazards, that lock should be at least
* functions will need to be updated, too.
*/
lockmode = concurrent ? ShareUpdateExclusiveLock : ShareLock;
- rel = table_open(relationId, lockmode);
+ rel = table_open(tableId, lockmode);
/*
* Switch to the table owner's userid, so that any index functions are run
concurrent,
amissummarizing);
- typeObjectId = palloc_array(Oid, numberOfAttributes);
- collationObjectId = palloc_array(Oid, numberOfAttributes);
- classObjectId = palloc_array(Oid, numberOfAttributes);
+ typeIds = palloc_array(Oid, numberOfAttributes);
+ collationIds = palloc_array(Oid, numberOfAttributes);
+ opclassIds = palloc_array(Oid, numberOfAttributes);
coloptions = palloc_array(int16, numberOfAttributes);
ComputeIndexAttrs(indexInfo,
- typeObjectId, collationObjectId, classObjectId,
+ typeIds, collationIds, opclassIds,
coloptions, allIndexParams,
- stmt->excludeOpNames, relationId,
+ stmt->excludeOpNames, tableId,
accessMethodName, accessMethodId,
amcanorder, stmt->isconstraint, root_save_userid,
root_save_sec_context, &root_save_nestlevel);
Oid idx_opfamily;
Oid idx_opcintype;
- if (get_opclass_opfamily_and_input_type(classObjectId[j],
+ if (get_opclass_opfamily_and_input_type(opclassIds[j],
&idx_opfamily,
&idx_opcintype))
{
parentConstraintId,
stmt->oldNumber, indexInfo, indexColNames,
accessMethodId, tablespaceId,
- collationObjectId, classObjectId,
+ collationIds, opclassIds,
coloptions, reloptions,
flags, constr_flags,
allowSystemTableMods, !check_rights,
*/
if (total_parts < 0)
{
- List *children = find_all_inheritors(relationId,
+ List *children = find_all_inheritors(tableId,
NoLock, NULL);
total_parts = list_length(children) - 1;
PushActiveSnapshot(GetTransactionSnapshot());
/* Perform concurrent build of index */
- index_concurrently_build(relationId, indexRelationId);
+ index_concurrently_build(tableId, indexRelationId);
/* we can do away with our snapshot */
PopActiveSnapshot();
/*
* Scan the index and the heap, insert any missing index entries.
*/
- validate_index(relationId, indexRelationId, snapshot);
+ validate_index(tableId, indexRelationId, snapshot);
/*
* Drop the reference snapshot. We must do this before waiting out other
*/
static void
ComputeIndexAttrs(IndexInfo *indexInfo,
- Oid *typeOidP,
- Oid *collationOidP,
- Oid *classOidP,
- int16 *colOptionP,
+ Oid *typeOids,
+ Oid *collationOids,
+ Oid *opclassOids,
+ int16 *colOptions,
const List *attList, /* list of IndexElem's */
const List *exclusionOpNames,
Oid relId,
}
}
- typeOidP[attn] = atttype;
+ typeOids[attn] = atttype;
/*
* Included columns have no collation, no opclass and no ordering
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("including column does not support NULLS FIRST/LAST options")));
- classOidP[attn] = InvalidOid;
- colOptionP[attn] = 0;
- collationOidP[attn] = InvalidOid;
+ opclassOids[attn] = InvalidOid;
+ colOptions[attn] = 0;
+ collationOids[attn] = InvalidOid;
attn++;
continue;
format_type_be(atttype))));
}
- collationOidP[attn] = attcollation;
+ collationOids[attn] = attcollation;
/*
* Identify the opclass to use. Use of ddl_userid is necessary due to
AtEOXact_GUC(false, *ddl_save_nestlevel);
SetUserIdAndSecContext(ddl_userid, ddl_sec_context);
}
- classOidP[attn] = ResolveOpClass(attribute->opclass,
- atttype,
- accessMethodName,
- accessMethodId);
+ opclassOids[attn] = ResolveOpClass(attribute->opclass,
+ atttype,
+ accessMethodName,
+ accessMethodId);
if (OidIsValid(ddl_userid))
{
SetUserIdAndSecContext(save_userid, save_sec_context);
/*
* Operator must be a member of the right opfamily, too
*/
- opfamily = get_opclass_family(classOidP[attn]);
+ opfamily = get_opclass_family(opclassOids[attn]);
strat = get_op_opfamily_strategy(opid, opfamily);
if (strat == 0)
{
* zero for any un-ordered index, while ordered indexes have DESC and
* NULLS FIRST/LAST options.
*/
- colOptionP[attn] = 0;
+ colOptions[attn] = 0;
if (amcanorder)
{
/* default ordering is ASC */
if (attribute->ordering == SORTBY_DESC)
- colOptionP[attn] |= INDOPTION_DESC;
+ colOptions[attn] |= INDOPTION_DESC;
/* default null ordering is LAST for ASC, FIRST for DESC */
if (attribute->nulls_ordering == SORTBY_NULLS_DEFAULT)
{
if (attribute->ordering == SORTBY_DESC)
- colOptionP[attn] |= INDOPTION_NULLS_FIRST;
+ colOptions[attn] |= INDOPTION_NULLS_FIRST;
}
else if (attribute->nulls_ordering == SORTBY_NULLS_FIRST)
- colOptionP[attn] |= INDOPTION_NULLS_FIRST;
+ colOptions[attn] |= INDOPTION_NULLS_FIRST;
}
else
{
projects / postgresql.git / commitdiff