/*
* Copied from src/backend/utils/adt/ruleutils.c, not exported.
*
* get_opclass_name - fetch name of an index operator class
*
* The opclass name is appended (after a space) to buf.
*
* Output is suppressed if the opclass is the default for the given
* actual_datatype. (If you don't want this behavior, just pass
* InvalidOid for actual_datatype.)
*/
void
get_opclass_name(Oid opclass, Oid actual_datatype,
StringInfo buf)
{
HeapTuple ht_opc;
Form_pg_opclass opcrec;
char *opcname;
char *nspname;
ht_opc = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));
if (!HeapTupleIsValid(ht_opc))
elog(ERROR, "cache lookup failed for opclass %u", opclass);
opcrec = (Form_pg_opclass) GETSTRUCT(ht_opc);
if (!OidIsValid(actual_datatype) ||
GetDefaultOpClass(actual_datatype, opcrec->opcmethod) != opclass)
{
/* Okay, we need the opclass name. Do we need to qualify it? */
opcname = NameStr(opcrec->opcname);
if (OpclassIsVisible(opclass))
appendStringInfo(buf, " %s", quote_identifier(opcname));
else
{
nspname = get_namespace_name(opcrec->opcnamespace);
appendStringInfo(buf, " %s.%s",
quote_identifier(nspname),
quote_identifier(opcname));
}
}
ReleaseSysCache(ht_opc);
}
/*
* Copied from src/backend/commands/indexcmds.c, not exported.
* Resolve possibly-defaulted operator class specification
*/
Oid
GetIndexOpClass(List *opclass, Oid attrType,
char *accessMethodName, Oid accessMethodId)
{
char *schemaname;
char *opcname;
HeapTuple tuple;
Oid opClassId,
opInputType;
/*
* Release 7.0 removed network_ops, timespan_ops, and datetime_ops, so we
* ignore those opclass names so the default *_ops is used. This can be
* removed in some later release. bjm 2000/02/07
*
* Release 7.1 removes lztext_ops, so suppress that too for a while. tgl
* 2000/07/30
*
* Release 7.2 renames timestamp_ops to timestamptz_ops, so suppress that
* too for awhile. I'm starting to think we need a better approach. tgl
* 2000/10/01
*
* Release 8.0 removes bigbox_ops (which was dead code for a long while
* anyway). tgl 2003/11/11
*/
if (list_length(opclass) == 1)
{
char *claname = strVal(linitial(opclass));
if (strcmp(claname, "network_ops") == 0 ||
strcmp(claname, "timespan_ops") == 0 ||
strcmp(claname, "datetime_ops") == 0 ||
strcmp(claname, "lztext_ops") == 0 ||
strcmp(claname, "timestamp_ops") == 0 ||
strcmp(claname, "bigbox_ops") == 0)
opclass = NIL;
}
if (opclass == NIL)
{
/* no operator class specified, so find the default */
opClassId = GetDefaultOpClass(attrType, accessMethodId);
if (!OidIsValid(opClassId))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("data type %s has no default operator class for access method \"%s\"",
format_type_be(attrType), accessMethodName),
errhint("You must specify an operator class for the index or define a default operator class for the data type.")));
return opClassId;
}
/*
* Specific opclass name given, so look up the opclass.
*/
/* deconstruct the name list */
DeconstructQualifiedName(opclass, &schemaname, &opcname);
if (schemaname)
{
/* Look in specific schema only */
Oid namespaceId;
#if PG_VERSION_NUM >= 90300
namespaceId = LookupExplicitNamespace(schemaname, false);
#else
namespaceId = LookupExplicitNamespace(schemaname);
#endif
tuple = SearchSysCache3(CLAAMNAMENSP,
ObjectIdGetDatum(accessMethodId),
PointerGetDatum(opcname),
ObjectIdGetDatum(namespaceId));
}
else
{
/* Unqualified opclass name, so search the search path */
opClassId = OpclassnameGetOpcid(accessMethodId, opcname);
if (!OidIsValid(opClassId))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("operator class \"%s\" does not exist for access method \"%s\"",
opcname, accessMethodName)));
tuple = SearchSysCache1(CLAOID, ObjectIdGetDatum(opClassId));
}
if (!HeapTupleIsValid(tuple))
{
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("operator class \"%s\" does not exist for access method \"%s\"",
NameListToString(opclass), accessMethodName)));
}
/*
* Verify that the index operator class accepts this datatype. Note we
* will accept binary compatibility.
*/
opClassId = HeapTupleGetOid(tuple);
opInputType = ((Form_pg_opclass) GETSTRUCT(tuple))->opcintype;
if (!IsBinaryCoercible(attrType, opInputType))
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("operator class \"%s\" does not accept data type %s",
NameListToString(opclass), format_type_be(attrType))));
ReleaseSysCache(tuple);
return opClassId;
}
void
_bitmap_create_lov_heapandindex(Relation rel,
Oid lovComptypeOid,
Oid *lovHeapOid,
Oid *lovIndexOid,
Oid lovHeapRelfilenode,
Oid lovIndexRelfilenode)
{
char lovHeapName[NAMEDATALEN];
char lovIndexName[NAMEDATALEN];
TupleDesc tupDesc;
IndexInfo *indexInfo;
ObjectAddress objAddr, referenced;
Oid *classObjectId;
int16 *coloptions;
Oid heapid;
Oid idxid;
int indattrs;
int i;
Oid unusedArrayOid = InvalidOid;
Assert(rel != NULL);
/* create the new names for the new lov heap and index */
snprintf(lovHeapName, sizeof(lovHeapName),
"pg_bm_%u", RelationGetRelid(rel));
snprintf(lovIndexName, sizeof(lovIndexName),
"pg_bm_%u_index", RelationGetRelid(rel));
heapid = get_relname_relid(lovHeapName, PG_BITMAPINDEX_NAMESPACE);
/*
* If heapid exists, then this is happening during re-indexing.
* We allocate new relfilenodes for lov heap and lov index.
*
* XXX Each segment db may have different relfilenodes for lov heap and
* lov index, which should not be an issue now. Ideally, we would like each
* segment db use the same oids.
*/
if (OidIsValid(heapid))
{
Relation lovHeap;
Relation lovIndex;
Buffer btree_metabuf;
Page btree_metapage;
*lovHeapOid = heapid;
idxid = get_relname_relid(lovIndexName, PG_BITMAPINDEX_NAMESPACE);
Assert(OidIsValid(idxid));
*lovIndexOid = idxid;
lovComptypeOid = get_rel_type_id(heapid);
Assert(OidIsValid(lovComptypeOid));
lovHeap = heap_open(heapid, AccessExclusiveLock);
lovIndex = index_open(idxid, AccessExclusiveLock);
if (OidIsValid(lovHeapRelfilenode))
setNewRelfilenodeToOid(lovHeap, lovHeapRelfilenode);
else
setNewRelfilenode(lovHeap);
if (OidIsValid(lovIndexRelfilenode))
setNewRelfilenodeToOid(lovIndex, lovIndexRelfilenode);
else
setNewRelfilenode(lovIndex);
/*
* After creating the new relfilenode for a btee index, this is not
* a btree anymore. We create the new metapage for this btree.
*/
btree_metabuf = _bt_getbuf(lovIndex, P_NEW, BT_WRITE);
Assert (BTREE_METAPAGE == BufferGetBlockNumber(btree_metabuf));
btree_metapage = BufferGetPage(btree_metabuf);
_bt_initmetapage(btree_metapage, P_NONE, 0);
/* XLOG the metapage */
if (!XLog_UnconvertedCanBypassWal() && !lovIndex->rd_istemp)
{
// Fetch gp_persistent_relation_node information that will be added to XLOG record.
RelationFetchGpRelationNodeForXLog(lovIndex);
_bt_lognewpage(lovIndex,
btree_metapage,
BufferGetBlockNumber(btree_metabuf));
}
/* This cache value is not valid anymore. */
if (lovIndex->rd_amcache)
{
pfree(lovIndex->rd_amcache);
lovIndex->rd_amcache = NULL;
}
MarkBufferDirty(btree_metabuf);
_bt_relbuf(lovIndex, btree_metabuf);
index_close(lovIndex, NoLock);
heap_close(lovHeap, NoLock);
return;
}
/*
* create a new empty heap to store all attribute values with their
* corresponding block number and offset in LOV.
*/
tupDesc = _bitmap_create_lov_heapTupleDesc(rel);
Assert(rel->rd_rel != NULL);
heapid =
heap_create_with_catalog(lovHeapName, PG_BITMAPINDEX_NAMESPACE,
rel->rd_rel->reltablespace,
*lovHeapOid, rel->rd_rel->relowner,
tupDesc,
/* relam */ InvalidOid, RELKIND_RELATION, RELSTORAGE_HEAP,
rel->rd_rel->relisshared, false, /* bufferPoolBulkLoad */ false, 0,
ONCOMMIT_NOOP, NULL /* GP Policy */,
(Datum)0, true,
/* valid_opts */ true,
&lovComptypeOid,
&unusedArrayOid,
/* persistentTid */ NULL,
/* persistentSerialNum */ NULL);
Assert(heapid == *lovHeapOid);
/*
* We must bump the command counter to make the newly-created relation
* tuple visible for opening.
*/
CommandCounterIncrement();
objAddr.classId = RelationRelationId;
objAddr.objectId = *lovHeapOid;
objAddr.objectSubId = 0 ;
referenced.classId = RelationRelationId;
referenced.objectId = RelationGetRelid(rel);
referenced.objectSubId = 0;
recordDependencyOn(&objAddr, &referenced, DEPENDENCY_INTERNAL);
/*
* create a btree index on the newly-created heap.
* The key includes all attributes to be indexed in this bitmap index.
*/
indattrs = tupDesc->natts - 2;
indexInfo = makeNode(IndexInfo);
indexInfo->ii_NumIndexAttrs = indattrs;
indexInfo->ii_Expressions = NIL;
indexInfo->ii_ExpressionsState = NIL;
indexInfo->ii_Predicate = make_ands_implicit(NULL);
indexInfo->ii_PredicateState = NIL;
indexInfo->ii_Unique = true;
indexInfo->opaque = NULL;
classObjectId = (Oid *) palloc(indattrs * sizeof(Oid));
coloptions = (int16 *) palloc(indattrs * sizeof(int16));
for (i = 0; i < indattrs; i++)
{
Oid typid = tupDesc->attrs[i]->atttypid;
indexInfo->ii_KeyAttrNumbers[i] = i + 1;
classObjectId[i] = GetDefaultOpClass(typid, BTREE_AM_OID);
coloptions[i] = 0;
}
idxid = index_create(*lovHeapOid, lovIndexName, *lovIndexOid,
indexInfo, BTREE_AM_OID,
rel->rd_rel->reltablespace,
classObjectId, coloptions, 0, false, false, (Oid *) NULL, true,
false, false, NULL);
Assert(idxid == *lovIndexOid);
}