/*
* Record a type's default encoding clause in the catalog.
*/
void
add_type_encoding(Oid typid, Datum typoptions)
{
Datum values[Natts_pg_type_encoding];
bool nulls[Natts_pg_type_encoding];
HeapTuple tuple;
cqContext *pcqCtx;
pcqCtx = caql_beginscan(
NULL,
cql("INSERT INTO pg_type_encoding ",
NULL));
MemSet(nulls, false, sizeof(nulls));
values[Anum_pg_type_encoding_typid - 1] = ObjectIdGetDatum(typid);
values[Anum_pg_type_encoding_typoptions - 1] = typoptions;
tuple = caql_form_tuple(pcqCtx, values, nulls);
/* Insert tuple into the relation */
caql_insert(pcqCtx, tuple); /* implicit update of index as well */
caql_endscan(pcqCtx);
}
/*
* Add a single attribute encoding entry.
*/
static void
add_attribute_encoding_entry(Oid relid, AttrNumber attnum, Datum attoptions)
{
Datum values[Natts_pg_attribute_encoding];
bool nulls[Natts_pg_attribute_encoding];
HeapTuple tuple;
cqContext *pcqCtx;
Insist(!gp_upgrade_mode);
Insist(attnum != InvalidAttrNumber);
pcqCtx = caql_beginscan(
NULL,
cql("INSERT INTO pg_attribute_encoding",
NULL));
MemSet(nulls, 0, sizeof(nulls));
values[Anum_pg_attribute_encoding_attrelid - 1] = ObjectIdGetDatum(relid);
values[Anum_pg_attribute_encoding_attnum - 1] = Int16GetDatum(attnum);
values[Anum_pg_attribute_encoding_attoptions - 1] = attoptions;
tuple = caql_form_tuple(pcqCtx, values, nulls);
/* insert a new tuple */
caql_insert(pcqCtx, tuple); /* implicit update of index as well */
heap_freetuple(tuple);
caql_endscan(pcqCtx);
}
/*
* Add a master standby.
*
* gp_add_master_standby(hostname, address)
*
* Args:
* hostname - as above
* address - as above
*
* Returns:
* dbid of the new standby
*/
Datum
gp_add_master_standby(PG_FUNCTION_ARGS)
{
CdbComponentDatabaseInfo *master = NULL;
Relation gprel;
Datum values[Natts_gp_segment_configuration];
bool nulls[Natts_gp_segment_configuration];
HeapTuple tuple;
cqContext cqc;
cqContext *pcqCtx = NULL;
if (PG_ARGISNULL(0))
elog(ERROR, "host name cannot be NULL");
if (PG_ARGISNULL(1))
elog(ERROR, "address cannot be NULL");
mirroring_sanity_check(MASTER_ONLY | UTILITY_MODE,
"gp_add_master_standby");
if (standby_exists())
elog(ERROR, "only a single master standby may be defined");
/* master */
master = registration_order_get_dbinfo(MASTER_ORDER_ID);
/* Lock exclusively to avoid concurrent changes */
gprel = heap_open(GpSegmentConfigRelationId, AccessExclusiveLock);
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), gprel),
cql("INSERT INTO gp_segment_configuration ", NULL));
MemSet(nulls, false, sizeof(nulls));
values[Anum_gp_segment_configuration_registration_order - 1] = Int32GetDatum(STANDBY_ORDER_ID);
values[Anum_gp_segment_configuration_role - 1] = CharGetDatum(SEGMENT_ROLE_STANDBY_CONFIG);
values[Anum_gp_segment_configuration_status - 1] = CharGetDatum('u');
values[Anum_gp_segment_configuration_port - 1] = Int32GetDatum(master->port);
values[Anum_gp_segment_configuration_hostname - 1] = PG_GETARG_DATUM(0);
values[Anum_gp_segment_configuration_address - 1] = PG_GETARG_DATUM(1);
nulls[Anum_gp_segment_configuration_description - 1] = true;
tuple = caql_form_tuple(pcqCtx, values, nulls);
/* insert a new tuple */
caql_insert(pcqCtx, tuple); /* implicit update of index as well */
caql_endscan(pcqCtx);
if(master)
pfree(master);
heap_close(gprel, NoLock);
PG_RETURN_INT16(1);
}
/*
* InsertRule -
* takes the arguments and inserts them as a row into the system
* relation "pg_rewrite"
*/
static Oid
InsertRule(char *rulname,
int evtype,
Oid eventrel_oid,
AttrNumber evslot_index,
bool evinstead,
Node *event_qual,
List *action,
bool replace,
Oid ruleOid)
{
char *evqual = nodeToString(event_qual);
char *actiontree = nodeToString((Node *) action);
int i;
Datum values[Natts_pg_rewrite];
bool nulls[Natts_pg_rewrite];
bool replaces[Natts_pg_rewrite];
NameData rname;
HeapTuple tup,
oldtup;
Oid rewriteObjectId;
ObjectAddress myself,
referenced;
bool is_update = false;
cqContext *pcqCtx;
/*
* Set up *nulls and *values arrays
*/
MemSet(nulls, false, sizeof(nulls));
i = 0;
namestrcpy(&rname, rulname);
values[i++] = NameGetDatum(&rname); /* rulename */
values[i++] = ObjectIdGetDatum(eventrel_oid); /* ev_class */
values[i++] = Int16GetDatum(evslot_index); /* ev_attr */
values[i++] = CharGetDatum(evtype + '0'); /* ev_type */
values[i++] = BoolGetDatum(evinstead); /* is_instead */
values[i++] = CStringGetTextDatum(evqual); /* ev_qual */
values[i++] = CStringGetTextDatum(actiontree); /* ev_action */
/*
* Ready to store new pg_rewrite tuple
*/
/*
* Check to see if we are replacing an existing tuple
*/
pcqCtx = caql_beginscan(
NULL,
cql("SELECT * FROM pg_rewrite "
" WHERE ev_class = :1 "
" AND rulename = :2 "
" FOR UPDATE ",
ObjectIdGetDatum(eventrel_oid),
CStringGetDatum(rulname)));
oldtup = caql_getnext(pcqCtx);
if (HeapTupleIsValid(oldtup))
{
if (!replace)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("rule \"%s\" for relation \"%s\" already exists",
rulname, get_rel_name(eventrel_oid))));
/*
* When replacing, we don't need to replace every attribute
*/
MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_rewrite_ev_attr - 1] = true;
replaces[Anum_pg_rewrite_ev_type - 1] = true;
replaces[Anum_pg_rewrite_is_instead - 1] = true;
replaces[Anum_pg_rewrite_ev_qual - 1] = true;
replaces[Anum_pg_rewrite_ev_action - 1] = true;
tup = caql_modify_current(pcqCtx,
values, nulls, replaces);
caql_update_current(pcqCtx, tup);
/* and Update indexes (implicit) */
rewriteObjectId = HeapTupleGetOid(tup);
is_update = true;
}
else
{
tup = caql_form_tuple(pcqCtx, values, nulls);
if (OidIsValid(ruleOid))
HeapTupleSetOid(tup, ruleOid);
rewriteObjectId = caql_insert(pcqCtx, tup);
/* and Update indexes (implicit) */
}
heap_freetuple(tup);
/* If replacing, get rid of old dependencies and make new ones */
if (is_update)
deleteDependencyRecordsFor(RewriteRelationId, rewriteObjectId);
/*
* Install dependency on rule's relation to ensure it will go away on
* relation deletion. If the rule is ON SELECT, make the dependency
* implicit --- this prevents deleting a view's SELECT rule. Other kinds
* of rules can be AUTO.
*/
myself.classId = RewriteRelationId;
myself.objectId = rewriteObjectId;
myself.objectSubId = 0;
referenced.classId = RelationRelationId;
referenced.objectId = eventrel_oid;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced,
(evtype == CMD_SELECT) ? DEPENDENCY_INTERNAL : DEPENDENCY_AUTO);
/*
* Also install dependencies on objects referenced in action and qual.
*/
recordDependencyOnExpr(&myself, (Node *) action, NIL,
DEPENDENCY_NORMAL);
if (event_qual != NULL)
{
/* Find query containing OLD/NEW rtable entries */
Query *qry = (Query *) linitial(action);
qry = getInsertSelectQuery(qry, NULL);
recordDependencyOnExpr(&myself, event_qual, qry->rtable,
DEPENDENCY_NORMAL);
}
caql_endscan(pcqCtx);
return rewriteObjectId;
}
/*
* AggregateCreateWithOid
*/
Oid
AggregateCreateWithOid(const char *aggName,
Oid aggNamespace,
Oid *aggArgTypes,
int numArgs,
List *aggtransfnName,
List *aggprelimfnName,
List *aggfinalfnName,
List *aggsortopName,
Oid aggTransType,
const char *agginitval,
bool aggordered,
Oid procOid)
{
HeapTuple tup;
bool nulls[Natts_pg_aggregate];
Datum values[Natts_pg_aggregate];
Form_pg_proc proc;
Oid transfn;
Oid invtransfn = InvalidOid; /* MPP windowing optimization */
Oid prelimfn = InvalidOid; /* if omitted, disables MPP 2-stage for this aggregate */
Oid invprelimfn = InvalidOid; /* MPP windowing optimization */
Oid finalfn = InvalidOid; /* can be omitted */
Oid sortop = InvalidOid; /* can be omitted */
bool hasPolyArg;
bool hasInternalArg;
Oid rettype;
Oid finaltype;
Oid prelimrettype;
Oid *fnArgs;
int nargs_transfn;
int i;
ObjectAddress myself,
referenced;
cqContext *pcqCtx;
cqContext *pcqCtx2;
/* sanity checks (caller should have caught these) */
if (!aggName)
elog(ERROR, "no aggregate name supplied");
if (!aggtransfnName)
elog(ERROR, "aggregate must have a transition function");
/* check for polymorphic arguments and INTERNAL arguments */
hasPolyArg = false;
hasInternalArg = false;
for (i = 0; i < numArgs; i++)
{
if (aggArgTypes[i] == ANYARRAYOID ||
aggArgTypes[i] == ANYELEMENTOID)
hasPolyArg = true;
else if (aggArgTypes[i] == INTERNALOID)
hasInternalArg = true;
}
/*
* If transtype is polymorphic, must have polymorphic argument also; else
* we will have no way to deduce the actual transtype.
*/
if (!hasPolyArg &&
(aggTransType == ANYARRAYOID || aggTransType == ANYELEMENTOID))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("cannot determine transition data type"),
errdetail("An aggregate using \"anyarray\" or \"anyelement\" as transition type must have at least one argument of either type.")));
/* find the transfn */
nargs_transfn = numArgs + 1;
fnArgs = (Oid *) palloc(nargs_transfn * sizeof(Oid));
fnArgs[0] = aggTransType;
memcpy(fnArgs + 1, aggArgTypes, numArgs * sizeof(Oid));
transfn = lookup_agg_function(aggtransfnName, nargs_transfn, fnArgs,
&rettype);
elog(DEBUG5,"AggregateCreateWithOid: successfully located transition "
"function %s with return type %d",
func_signature_string(aggtransfnName, nargs_transfn, fnArgs),
rettype);
/*
* Return type of transfn (possibly after refinement by
* enforce_generic_type_consistency, if transtype isn't polymorphic) must
* exactly match declared transtype.
*
* In the non-polymorphic-transtype case, it might be okay to allow a
* rettype that's binary-coercible to transtype, but I'm not quite
* convinced that it's either safe or useful. When transtype is
* polymorphic we *must* demand exact equality.
*/
if (rettype != aggTransType)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("return type of transition function %s is not %s",
NameListToString(aggtransfnName),
format_type_be(aggTransType))));
pcqCtx2 = caql_beginscan(
NULL,
cql("SELECT * FROM pg_proc "
" WHERE oid = :1 ",
ObjectIdGetDatum(transfn)));
tup = caql_getnext(pcqCtx2);
if (!HeapTupleIsValid(tup))
elog(ERROR, "cache lookup failed for function %u", transfn);
proc = (Form_pg_proc) GETSTRUCT(tup);
/*
* If the transfn is strict and the initval is NULL, make sure first input
* type and transtype are the same (or at least binary-compatible), so
* that it's OK to use the first input value as the initial transValue.
*/
if (proc->proisstrict && agginitval == NULL)
{
if (numArgs < 1 ||
!IsBinaryCoercible(aggArgTypes[0], aggTransType))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("must not omit initial value when transition function is strict and transition type is not compatible with input type")));
}
caql_endscan(pcqCtx2);
/* handle prelimfn, if supplied */
if (aggprelimfnName)
{
/*
* The preliminary state function (pfunc) input arguments are the results of the
* state transition function (sfunc) and therefore must be of the same types.
*/
fnArgs[0] = rettype;
fnArgs[1] = rettype;
/*
* Check that such a function name and prototype exists in the catalog.
*/
prelimfn = lookup_agg_function(aggprelimfnName, 2, fnArgs, &prelimrettype);
elog(DEBUG5,"AggregateCreateWithOid: successfully located preliminary "
"function %s with return type %d",
func_signature_string(aggprelimfnName, 2, fnArgs),
prelimrettype);
Assert(OidIsValid(prelimrettype));
/*
* The preliminary return type must be of the same type as the internal
* state. (See similar error checking for transition types above)
*/
if (prelimrettype != rettype)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("return type of preliminary function %s is not %s",
NameListToString(aggprelimfnName),
format_type_be(rettype))));
}
/* handle finalfn, if supplied */
if (aggfinalfnName)
{
fnArgs[0] = aggTransType;
finalfn = lookup_agg_function(aggfinalfnName, 1, fnArgs,
&finaltype);
}
else
{
/*
* If no finalfn, aggregate result type is type of the state value
*/
finaltype = aggTransType;
}
Assert(OidIsValid(finaltype));
/*
* If finaltype (i.e. aggregate return type) is polymorphic, inputs must
* be polymorphic also, else parser will fail to deduce result type.
* (Note: given the previous test on transtype and inputs, this cannot
* happen, unless someone has snuck a finalfn definition into the catalogs
* that itself violates the rule against polymorphic result with no
* polymorphic input.)
*/
if (!hasPolyArg &&
(finaltype == ANYARRAYOID || finaltype == ANYELEMENTOID))
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("cannot determine result data type"),
errdetail("An aggregate returning \"anyarray\" or \"anyelement\" "
"must have at least one argument of either type.")));
/*
* Also, the return type can't be INTERNAL unless there's at least one
* INTERNAL argument. This is the same type-safety restriction we
* enforce for regular functions, but at the level of aggregates. We
* must test this explicitly because we allow INTERNAL as the transtype.
*/
if (finaltype == INTERNALOID && !hasInternalArg)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("unsafe use of pseudo-type \"internal\""),
errdetail("A function returning \"internal\" must have at least one \"internal\" argument.")));
/* handle sortop, if supplied */
if (aggsortopName)
{
if (numArgs != 1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("sort operator can only be specified for single-argument aggregates")));
sortop = LookupOperName(NULL, aggsortopName,
aggArgTypes[0], aggArgTypes[0],
false, -1);
}
/*
* Everything looks okay. Try to create the pg_proc entry for the
* aggregate. (This could fail if there's already a conflicting entry.)
*/
procOid = ProcedureCreate(aggName,
aggNamespace,
false, /* no replacement */
false, /* doesn't return a set */
finaltype, /* returnType */
INTERNALlanguageId, /* languageObjectId */
InvalidOid, /* no validator */
InvalidOid, /* no describe function */
"aggregate_dummy", /* placeholder proc */
NULL, /* probin */
true, /* isAgg */
false, /* isWin */
false, /* security invoker (currently not
* definable for agg) */
false, /* isStrict (not needed for agg) */
PROVOLATILE_IMMUTABLE, /* volatility (not
* needed for agg) */
buildoidvector(aggArgTypes,
numArgs), /* paramTypes */
PointerGetDatum(NULL), /* allParamTypes */
PointerGetDatum(NULL), /* parameterModes */
PointerGetDatum(NULL), /* parameterNames */
NIL, /* parameterDefaults */
1, /* procost */
0, /* prorows */
PRODATAACCESS_NONE, /* prodataaccess */
procOid);
/*
* Okay to create the pg_aggregate entry.
*/
/* initialize nulls and values */
for (i = 0; i < Natts_pg_aggregate; i++)
{
nulls[i] = false;
values[i] = (Datum) 0;
}
values[Anum_pg_aggregate_aggfnoid - 1] = ObjectIdGetDatum(procOid);
values[Anum_pg_aggregate_aggtransfn - 1] = ObjectIdGetDatum(transfn);
values[Anum_pg_aggregate_agginvtransfn - 1] = ObjectIdGetDatum(invtransfn);
values[Anum_pg_aggregate_aggprelimfn - 1] = ObjectIdGetDatum(prelimfn);
values[Anum_pg_aggregate_agginvprelimfn - 1] = ObjectIdGetDatum(invprelimfn);
values[Anum_pg_aggregate_aggfinalfn - 1] = ObjectIdGetDatum(finalfn);
values[Anum_pg_aggregate_aggsortop - 1] = ObjectIdGetDatum(sortop);
values[Anum_pg_aggregate_aggtranstype - 1] = ObjectIdGetDatum(aggTransType);
if (agginitval)
values[Anum_pg_aggregate_agginitval - 1] = CStringGetTextDatum(agginitval);
else
nulls[Anum_pg_aggregate_agginitval - 1] = true;
values[Anum_pg_aggregate_aggordered - 1] = BoolGetDatum(aggordered);
pcqCtx = caql_beginscan(
NULL,
cql("INSERT INTO pg_aggregate",
NULL));
tup = caql_form_tuple(pcqCtx, values, nulls);
/* insert a new tuple */
caql_insert(pcqCtx, tup); /* implicit update of index as well */
caql_endscan(pcqCtx);
/*
* Create dependencies for the aggregate (above and beyond those already
* made by ProcedureCreate). Note: we don't need an explicit dependency
* on aggTransType since we depend on it indirectly through transfn.
*/
myself.classId = ProcedureRelationId;
myself.objectId = procOid;
myself.objectSubId = 0;
/* Depends on transition function */
referenced.classId = ProcedureRelationId;
referenced.objectId = transfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
/* Depends on inverse transition function, if any */
if (OidIsValid(invtransfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = invtransfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on preliminary aggregation function, if any */
if (OidIsValid(prelimfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = prelimfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on inverse preliminary aggregation function, if any */
if (OidIsValid(invprelimfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = invprelimfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on final function, if any */
if (OidIsValid(finalfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = finalfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on sort operator, if any */
if (OidIsValid(sortop))
{
referenced.classId = OperatorRelationId;
referenced.objectId = sortop;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
return procOid;
}
/*
* Sets the policy of a table into the gp_distribution_policy table
* from a GpPolicy structure.
*
*/
void
GpPolicyReplace(Oid tbloid, const GpPolicy *policy)
{
Relation gp_policy_rel;
HeapTuple gp_policy_tuple = NULL;
cqContext cqc;
cqContext *pcqCtx;
ArrayType *attrnums;
bool nulls[2];
Datum values[2];
bool repl[2];
Insist(policy->ptype == POLICYTYPE_PARTITIONED);
/*
* Open and lock the gp_distribution_policy catalog.
*/
gp_policy_rel = heap_open(GpPolicyRelationId, RowExclusiveLock);
pcqCtx = caql_addrel(cqclr(&cqc), gp_policy_rel);
/*
* Convert C arrays into Postgres arrays.
*/
if (policy->nattrs > 0)
{
int i;
Datum *akey;
akey = (Datum *) palloc(policy->nattrs * sizeof(Datum));
for (i = 0; i < policy->nattrs; i++)
akey[i] = Int16GetDatum(policy->attrs[i]);
attrnums = construct_array(akey, policy->nattrs,
INT2OID, 2, true, 's');
}
else
{
attrnums = NULL;
}
nulls[0] = false;
nulls[1] = false;
values[0] = ObjectIdGetDatum(tbloid);
if (attrnums)
values[1] = PointerGetDatum(attrnums);
else
nulls[1] = true;
repl[0] = false;
repl[1] = true;
/*
* Select by value of the localoid field
*/
gp_policy_tuple = caql_getfirst(
pcqCtx,
cql("SELECT * FROM gp_distribution_policy "
" WHERE localoid = :1 "
" FOR UPDATE ",
ObjectIdGetDatum(tbloid)));
/*
* Read first (and only ) tuple
*/
if (HeapTupleIsValid(gp_policy_tuple))
{
HeapTuple newtuple = caql_modify_current(pcqCtx, values,
nulls, repl);
caql_update_current(pcqCtx, newtuple);
/* and Update indexes (implicit) */
heap_freetuple(newtuple);
}
else
{
gp_policy_tuple = caql_form_tuple(pcqCtx, values, nulls);
caql_insert(pcqCtx, gp_policy_tuple);
/* and Update indexes (implicit) */
}
/*
* Close the gp_distribution_policy relcache entry without unlocking.
* We have updated the catalog: consequently the lock must be held until
* end of transaction.
*/
heap_close(gp_policy_rel, NoLock);
} /* GpPolicyReplace */
/*
* Sets the policy of a table into the gp_distribution_policy table
* from a GpPolicy structure.
*
*/
void
GpPolicyStore(Oid tbloid, const GpPolicy *policy)
{
Relation gp_policy_rel;
HeapTuple gp_policy_tuple = NULL;
ArrayType *attrnums;
bool nulls[2];
Datum values[2];
cqContext cqc;
cqContext *pcqCtx;
Insist(policy->ptype == POLICYTYPE_PARTITIONED);
/*
* Open and lock the gp_distribution_policy catalog.
*/
gp_policy_rel = heap_open(GpPolicyRelationId, RowExclusiveLock);
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), gp_policy_rel),
cql("INSERT INTO gp_distribution_policy ",
NULL));
/*
* Convert C arrays into Postgres arrays.
*/
if (policy->nattrs > 0)
{
int i;
Datum *akey;
akey = (Datum *) palloc(policy->nattrs * sizeof(Datum));
for (i = 0; i < policy->nattrs; i++)
akey[i] = Int16GetDatum(policy->attrs[i]);
attrnums = construct_array(akey, policy->nattrs,
INT2OID, 2, true, 's');
}
else
{
attrnums = NULL;
}
nulls[0] = false;
nulls[1] = false;
values[0] = ObjectIdGetDatum(tbloid);
if (attrnums)
values[1] = PointerGetDatum(attrnums);
else
nulls[1] = true;
gp_policy_tuple = caql_form_tuple(pcqCtx, values, nulls);
/* Insert tuple into the relation */
caql_insert(pcqCtx, gp_policy_tuple); /* implicit update of index as well*/
/*
* Close the gp_distribution_policy relcache entry without unlocking.
* We have updated the catalog: consequently the lock must be held until
* end of transaction.
*/
caql_endscan(pcqCtx);
heap_close(gp_policy_rel, NoLock);
} /* GpPolicyStore */
/*
* Create a table space
*
* Only superusers can create a tablespace. This seems a reasonable restriction
* since we're determining the system layout and, anyway, we probably have
* root if we're doing this kind of activity
*/
void
CreateTableSpace(CreateTableSpaceStmt *stmt)
{
Relation rel;
Relation filespaceRel;
Datum values[Natts_pg_tablespace];
bool nulls[Natts_pg_tablespace];
HeapTuple tuple;
Oid tablespaceoid;
Oid filespaceoid;
Oid ownerId;
TablespaceDirNode tablespaceDirNode;
ItemPointerData persistentTid;
int64 persistentSerialNum;
cqContext cqc;
cqContext *pcqCtx;
/* Must be super user */
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("permission denied to create tablespace \"%s\"",
stmt->tablespacename),
errhint("Must be superuser to create a tablespace.")));
/* However, the eventual owner of the tablespace need not be */
if (stmt->owner)
ownerId = get_roleid_checked(stmt->owner);
else
ownerId = GetUserId();
/*
* Disallow creation of tablespaces named "pg_xxx"; we reserve this
* namespace for system purposes.
*/
if (!allowSystemTableModsDDL && IsReservedName(stmt->tablespacename))
{
ereport(ERROR,
(errcode(ERRCODE_RESERVED_NAME),
errmsg("unacceptable tablespace name \"%s\"",
stmt->tablespacename),
errdetail("The prefix \"%s\" is reserved for system tablespaces.",
GetReservedPrefix(stmt->tablespacename))));
}
/*
* Check the specified filespace
*/
filespaceRel = heap_open(FileSpaceRelationId, RowShareLock);
filespaceoid = get_filespace_oid(filespaceRel, stmt->filespacename);
heap_close(filespaceRel, NoLock); /* hold lock until commit/abort */
if (!OidIsValid(filespaceoid))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("filespace \"%s\" does not exist",
stmt->filespacename)));
/*
* Filespace pg_system is reserved for system use:
* - Used for pg_global and pg_default tablespaces only
*
* Directory layout is slightly different for the system filespace.
* Instead of having subdirectories for individual tablespaces instead
* the two system tablespaces have specific locations within it:
* pg_global : $PG_SYSTEM/global/relfilenode
* pg_default : $PG_SYSTEM/base/dboid/relfilenode
*
* In other words PG_SYSTEM points to the segments "datadir", or in
* postgres vocabulary $PGDATA.
*
*/
if (filespaceoid == SYSTEMFILESPACE_OID && !IsBootstrapProcessingMode())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("permission denied to create tablespace \"%s\"",
stmt->tablespacename),
errhint("filespace %s is reserved for system use",
stmt->filespacename)));
/*
* Check that there is no other tablespace by this name. (The unique
* index would catch this anyway, but might as well give a friendlier
* message.)
*/
if (OidIsValid(get_tablespace_oid(stmt->tablespacename)))
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("tablespace \"%s\" already exists",
stmt->tablespacename)));
/*
* Insert tuple into pg_tablespace. The purpose of doing this first is to
* lock the proposed tablename against other would-be creators. The
* insertion will roll back if we find problems below.
*/
rel = heap_open(TableSpaceRelationId, RowExclusiveLock);
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), rel),
cql("INSERT INTO pg_tablespace",
NULL));
MemSet(nulls, true, sizeof(nulls));
values[Anum_pg_tablespace_spcname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->tablespacename));
values[Anum_pg_tablespace_spcowner - 1] =
ObjectIdGetDatum(ownerId);
values[Anum_pg_tablespace_spcfsoid - 1] =
ObjectIdGetDatum(filespaceoid);
nulls[Anum_pg_tablespace_spcname - 1] = false;
nulls[Anum_pg_tablespace_spcowner - 1] = false;
nulls[Anum_pg_tablespace_spcfsoid - 1] = false;
tuple = caql_form_tuple(pcqCtx, values, nulls);
/* Keep oids synchonized between master and segments */
if (OidIsValid(stmt->tsoid))
HeapTupleSetOid(tuple, stmt->tsoid);
tablespaceoid = caql_insert(pcqCtx, tuple);
/* and Update indexes (implicit) */
heap_freetuple(tuple);
/* We keep the lock on pg_tablespace until commit */
caql_endscan(pcqCtx);
heap_close(rel, NoLock);
/* Create the persistent directory for the tablespace */
tablespaceDirNode.tablespace = tablespaceoid;
tablespaceDirNode.filespace = filespaceoid;
MirroredFileSysObj_TransactionCreateTablespaceDir(
&tablespaceDirNode,
&persistentTid,
&persistentSerialNum);
/*
* Record dependency on owner
*
* We do not record the dependency on pg_filespace because we do not track
* dependencies between shared objects. Additionally the pg_tablespace
* table itself contains the foreign key back to pg_filespace and can be
* used to fulfill the same purpose that an entry in pg_shdepend would.
*/
recordDependencyOnOwner(TableSpaceRelationId, tablespaceoid, ownerId);
/*
* Create the PG_VERSION file in the target directory. This has several
* purposes: to make sure we can write in the directory, to prevent
* someone from creating another tablespace pointing at the same directory
* (the emptiness check above will fail), and to label tablespace
* directories by PG version.
*/
// set_short_version(sublocation);
if (Gp_role == GP_ROLE_DISPATCH)
{
stmt->tsoid = tablespaceoid;
CdbDispatchUtilityStatement((Node *) stmt,
DF_CANCEL_ON_ERROR|
DF_WITH_SNAPSHOT|
DF_NEED_TWO_PHASE,
NULL);
/* MPP-6929: metadata tracking */
MetaTrackAddObject(TableSpaceRelationId,
tablespaceoid,
GetUserId(),
"CREATE", "TABLESPACE"
);
}
/*
* Force synchronous commit, to minimize the window between creating the
* symlink on-disk and marking the transaction committed. It's not great
* that there is any window at all, but definitely we don't want to make
* it larger than necessary.
*/
ForceSyncCommit();
}
/*
* shdepChangeDep
*
* Update shared dependency records to account for an updated referenced
* object. This is an internal workhorse for operations such as changing
* an object's owner.
*
* There must be no more than one existing entry for the given dependent
* object and dependency type! So in practice this can only be used for
* updating SHARED_DEPENDENCY_OWNER entries, which should have that property.
*
* If there is no previous entry, we assume it was referencing a PINned
* object, so we create a new entry. If the new referenced object is
* PINned, we don't create an entry (and drop the old one, if any).
*
* sdepRel must be the pg_shdepend relation, already opened and suitably
* locked.
*/
static void
shdepChangeDep(Relation sdepRel, Oid classid, Oid objid,
Oid refclassid, Oid refobjid,
SharedDependencyType deptype)
{
Oid dbid = classIdGetDbId(classid);
bool bGotOne = false;
HeapTuple oldtup = NULL;
HeapTuple scantup;
cqContext *pcqCtx;
cqContext cqc;
/*
* Make sure the new referenced object doesn't go away while we record the
* dependency.
*/
shdepLockAndCheckObject(refclassid, refobjid);
/*
* Look for a previous entry
*/
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), sdepRel),
cql("SELECT * FROM pg_shdepend "
" WHERE dbid = :1 "
" AND classid = :2 "
" AND objid = :3 "
" FOR UPDATE ",
ObjectIdGetDatum(dbid),
ObjectIdGetDatum(classid),
ObjectIdGetDatum(objid)));
while (HeapTupleIsValid(scantup = caql_getnext(pcqCtx)))
{
/* Ignore if not of the target dependency type */
if (((Form_pg_shdepend) GETSTRUCT(scantup))->deptype != deptype)
continue;
/* Caller screwed up if multiple matches */
if (bGotOne)
elog(ERROR,
"multiple pg_shdepend entries for object %u/%u deptype %c",
classid, objid, deptype);
bGotOne = true;
}
caql_endscan(pcqCtx);
/* XXX XXX XXX XXX XXX XXX XXX XXX XXX
* Should match this logic:
*
* if isSharedObjectpinned
* if Gotone then drop it
* else
* if Gotone
* then update it
* else insert it
*
* XXX XXX XXX XXX XXX XXX XXX XXX XXX
*/
if (!bGotOne) /* no match */
{
/* if no match and pinned, new entry not needed */
if (isSharedObjectPinned(refclassid, refobjid, sdepRel))
{
/* just return -- don't need to free anything because
* sdelRel was passed in, and pcqCtx is freed
*/
return;
}
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), sdepRel),
cql("INSERT INTO pg_shdepend ",
NULL));
/* Need to insert new entry */
Datum values[Natts_pg_shdepend];
bool nulls[Natts_pg_shdepend];
memset(nulls, 0, sizeof(nulls));
values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(dbid);
values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classid);
values[Anum_pg_shdepend_objid - 1] = ObjectIdGetDatum(objid);
values[Anum_pg_shdepend_refclassid - 1] = ObjectIdGetDatum(refclassid);
values[Anum_pg_shdepend_refobjid - 1] = ObjectIdGetDatum(refobjid);
values[Anum_pg_shdepend_deptype - 1] = CharGetDatum(deptype);
/*
* we are reusing oldtup just to avoid declaring a new variable, but
* it's certainly a new tuple
*/
oldtup = caql_form_tuple(pcqCtx, values, nulls);
caql_insert(pcqCtx, oldtup);
/* and Update indexes (implicit) */
heap_freetuple(oldtup);
caql_endscan(pcqCtx);
}
else
{
/* XXX XXX Do the scan again, but do the update/delete this time */
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), sdepRel),
cql("SELECT * FROM pg_shdepend "
" WHERE dbid = :1 "
" AND classid = :2 "
" AND objid = :3 "
" FOR UPDATE ",
ObjectIdGetDatum(dbid),
ObjectIdGetDatum(classid),
ObjectIdGetDatum(objid)));
while (HeapTupleIsValid(scantup = caql_getnext(pcqCtx)))
{
/* Ignore if not of the target dependency type */
if (((Form_pg_shdepend) GETSTRUCT(scantup))->deptype != deptype)
continue;
/*
* NOTE: already tested for multiple matches - just use
* first one
*/
if (isSharedObjectPinned(refclassid, refobjid, sdepRel))
{
/* No new entry needed, so just delete existing entry if any */
caql_delete_current(pcqCtx);
}
else
{
oldtup = heap_copytuple(scantup);
/* Need to update existing entry */
Form_pg_shdepend shForm = (Form_pg_shdepend) GETSTRUCT(oldtup);
/* Since oldtup is a copy, we can just modify it in-memory */
shForm->refclassid = refclassid;
shForm->refobjid = refobjid;
caql_update_current(pcqCtx, oldtup);
/* and Update indexes (implicit) */
heap_freetuple(oldtup);
}
break;
}
caql_endscan(pcqCtx);
}
}
/*
* ConversionCreate
*
* Add a new tuple to pg_conversion.
*/
Oid
ConversionCreate(const char *conname, Oid connamespace,
Oid conowner,
int32 conforencoding, int32 contoencoding,
Oid conproc, bool def, Oid newOid)
{
int i;
Relation rel;
HeapTuple tup;
bool nulls[Natts_pg_conversion];
Datum values[Natts_pg_conversion];
NameData cname;
Oid oid;
ObjectAddress myself,
referenced;
cqContext cqc;
cqContext *pcqCtx;
/* sanity checks */
if (!conname)
elog(ERROR, "no conversion name supplied");
/* open pg_conversion */
rel = heap_open(ConversionRelationId, RowExclusiveLock);
/* make sure there is no existing conversion of same name */
if (caql_getcount(
caql_addrel(cqclr(&cqc), rel),
cql("SELECT COUNT(*) FROM pg_conversion "
" WHERE conname = :1 "
" AND connamespace = :2 ",
CStringGetDatum((char *) conname),
ObjectIdGetDatum(connamespace))))
{
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("conversion \"%s\" already exists", conname)));
}
if (def)
{
/*
* make sure there is no existing default <for encoding><to encoding>
* pair in this name space
*/
if (FindDefaultConversion(connamespace,
conforencoding,
contoencoding))
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("default conversion for %s to %s already exists",
pg_encoding_to_char(conforencoding),
pg_encoding_to_char(contoencoding))));
}
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), rel),
cql("INSERT INTO pg_conversion",
NULL));
/* initialize nulls and values */
for (i = 0; i < Natts_pg_conversion; i++)
{
nulls[i] = false;
values[i] = (Datum) 0;
}
/* form a tuple */
namestrcpy(&cname, conname);
values[Anum_pg_conversion_conname - 1] = NameGetDatum(&cname);
values[Anum_pg_conversion_connamespace - 1] = ObjectIdGetDatum(connamespace);
values[Anum_pg_conversion_conowner - 1] = ObjectIdGetDatum(conowner);
values[Anum_pg_conversion_conforencoding - 1] = Int32GetDatum(conforencoding);
values[Anum_pg_conversion_contoencoding - 1] = Int32GetDatum(contoencoding);
values[Anum_pg_conversion_conproc - 1] = ObjectIdGetDatum(conproc);
values[Anum_pg_conversion_condefault - 1] = BoolGetDatum(def);
tup = caql_form_tuple(pcqCtx, values, nulls);
if (newOid != 0)
HeapTupleSetOid(tup, newOid);
/* insert a new tuple */
oid = caql_insert(pcqCtx, tup); /* implicit update of index as well */
Assert(OidIsValid(oid));
myself.classId = ConversionRelationId;
myself.objectId = HeapTupleGetOid(tup);
myself.objectSubId = 0;
/* create dependency on conversion procedure */
referenced.classId = ProcedureRelationId;
referenced.objectId = conproc;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
/* create dependency on namespace */
referenced.classId = NamespaceRelationId;
referenced.objectId = connamespace;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
/* create dependency on owner */
recordDependencyOnOwner(ConversionRelationId, HeapTupleGetOid(tup),
conowner);
heap_freetuple(tup);
caql_endscan(pcqCtx);
heap_close(rel, RowExclusiveLock);
return oid;
}
Oid
OperatorCreateWithOid(const char *operatorName,
Oid operatorNamespace,
Oid leftTypeId,
Oid rightTypeId,
List *procedureName,
List *commutatorName,
List *negatorName,
List *restrictionName,
List *joinName,
bool canMerge,
bool canHash,
Oid newOid)
{
Relation pg_operator_desc;
HeapTuple tup;
bool nulls[Natts_pg_operator];
bool replaces[Natts_pg_operator];
Datum values[Natts_pg_operator];
Oid operatorObjectId;
bool operatorAlreadyDefined;
Oid procOid;
Oid operResultType;
Oid commutatorId,
negatorId,
restOid,
joinOid;
bool selfCommutator = false;
Oid typeId[4]; /* only need up to 4 args here */
int nargs;
NameData oname;
int i;
cqContext cqc;
cqContext *pcqCtx;
/*
* Sanity checks
*/
if (!validOperatorName(operatorName))
ereport(ERROR,
(errcode(ERRCODE_INVALID_NAME),
errmsg("\"%s\" is not a valid operator name",
operatorName)));
if (!OidIsValid(leftTypeId) && !OidIsValid(rightTypeId))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("at least one of leftarg or rightarg must be specified")));
if (!(OidIsValid(leftTypeId) && OidIsValid(rightTypeId)))
{
/* If it's not a binary op, these things mustn't be set: */
if (commutatorName)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("only binary operators can have commutators")));
if (joinName)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("only binary operators can have join selectivity")));
if (canMerge)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("only binary operators can merge join")));
if (canHash)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("only binary operators can hash")));
}
operatorObjectId = OperatorGet(operatorName,
operatorNamespace,
leftTypeId,
rightTypeId,
&operatorAlreadyDefined);
if (operatorAlreadyDefined)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_FUNCTION),
errmsg("operator %s already exists",
operatorName)));
/*
* At this point, if operatorObjectId is not InvalidOid then we are
* filling in a previously-created shell.
*/
/*
* Look up registered procedures -- find the return type of procedureName
* to place in "result" field. Do this before shells are created so we
* don't have to worry about deleting them later.
*/
if (!OidIsValid(leftTypeId))
{
typeId[0] = rightTypeId;
nargs = 1;
}
else if (!OidIsValid(rightTypeId))
{
typeId[0] = leftTypeId;
nargs = 1;
}
else
{
typeId[0] = leftTypeId;
typeId[1] = rightTypeId;
nargs = 2;
}
procOid = LookupFuncName(procedureName, nargs, typeId, false);
operResultType = get_func_rettype(procOid);
/*
* find restriction estimator
*/
if (restrictionName)
{
typeId[0] = INTERNALOID; /* Query */
typeId[1] = OIDOID; /* operator OID */
typeId[2] = INTERNALOID; /* args list */
typeId[3] = INT4OID; /* varRelid */
restOid = LookupFuncName(restrictionName, 4, typeId, false);
}
else
restOid = InvalidOid;
/*
* find join estimator
*/
if (joinName)
{
typeId[0] = INTERNALOID; /* Query */
typeId[1] = OIDOID; /* operator OID */
typeId[2] = INTERNALOID; /* args list */
typeId[3] = INT2OID; /* jointype */
joinOid = LookupFuncName(joinName, 4, typeId, false);
}
else
joinOid = InvalidOid;
/*
* set up values in the operator tuple
*/
for (i = 0; i < Natts_pg_operator; ++i)
{
values[i] = 0;
replaces[i] = true;
nulls[i] = false;
}
i = 0;
namestrcpy(&oname, operatorName);
values[i++] = NameGetDatum(&oname); /* oprname */
values[i++] = ObjectIdGetDatum(operatorNamespace); /* oprnamespace */
values[i++] = ObjectIdGetDatum(GetUserId()); /* oprowner */
values[i++] = CharGetDatum(leftTypeId ? (rightTypeId ? 'b' : 'r') : 'l'); /* oprkind */
values[i++] = BoolGetDatum(canMerge); /* oprcanmerge */
values[i++] = BoolGetDatum(canHash); /* oprcanhash */
values[i++] = ObjectIdGetDatum(leftTypeId); /* oprleft */
values[i++] = ObjectIdGetDatum(rightTypeId); /* oprright */
values[i++] = ObjectIdGetDatum(operResultType); /* oprresult */
/*
* Set up the other operators. If they do not currently exist, create
* shells in order to get ObjectId's.
*/
if (commutatorName)
{
/* commutator has reversed arg types */
commutatorId = get_other_operator(commutatorName,
rightTypeId, leftTypeId,
operatorName, operatorNamespace,
leftTypeId, rightTypeId,
true);
/*
* self-linkage to this operator; will fix below. Note that only
* self-linkage for commutation makes sense.
*/
if (!OidIsValid(commutatorId))
selfCommutator = true;
}
else
commutatorId = InvalidOid;
values[i++] = ObjectIdGetDatum(commutatorId); /* oprcom */
if (negatorName)
{
/* negator has same arg types */
negatorId = get_other_operator(negatorName,
leftTypeId, rightTypeId,
operatorName, operatorNamespace,
leftTypeId, rightTypeId,
false);
}
else
negatorId = InvalidOid;
values[i++] = ObjectIdGetDatum(negatorId); /* oprnegate */
values[i++] = ObjectIdGetDatum(procOid); /* oprcode */
values[i++] = ObjectIdGetDatum(restOid); /* oprrest */
values[i++] = ObjectIdGetDatum(joinOid); /* oprjoin */
pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);
pcqCtx = caql_addrel(cqclr(&cqc), pg_operator_desc);
/*
* If we are replacing an operator shell, update; else insert
*/
if (operatorObjectId)
{
tup = caql_getfirst(
pcqCtx,
cql("SELECT * FROM pg_operator "
" WHERE oid = :1 "
" FOR UPDATE ",
ObjectIdGetDatum(operatorObjectId)));
if (!HeapTupleIsValid(tup))
elog(ERROR, "cache lookup failed for operator %u",
operatorObjectId);
tup = caql_modify_current(pcqCtx,
values,
nulls,
replaces);
caql_update_current(pcqCtx, tup);
/* and Update indexes (implicit) */
}
else
{
tup = caql_form_tuple(pcqCtx, values, nulls);
if (newOid != (Oid) 0)
HeapTupleSetOid(tup, newOid);
operatorObjectId = caql_insert(pcqCtx, tup);
/* and Update indexes (implicit) */
}
/* Add dependencies for the entry */
makeOperatorDependencies(tup);
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);
return operatorObjectId;
}
/*
* OperatorShellMake
* Make a "shell" entry for a not-yet-existing operator.
*/
static Oid
OperatorShellMake(const char *operatorName,
Oid operatorNamespace,
Oid leftTypeId,
Oid rightTypeId)
{
Oid operatorObjectId;
int i;
HeapTuple tup;
Datum values[Natts_pg_operator];
bool nulls[Natts_pg_operator];
NameData oname;
cqContext *pcqCtx;
/*
* validate operator name
*/
if (!validOperatorName(operatorName))
ereport(ERROR,
(errcode(ERRCODE_INVALID_NAME),
errmsg("\"%s\" is not a valid operator name",
operatorName)));
/*
* initialize our *nulls and *values arrays
*/
for (i = 0; i < Natts_pg_operator; ++i)
{
nulls[i] = false;
values[i] = (Datum) 0; /* redundant, but safe */
}
/*
* initialize values[] with the operator name and input data types. Note
* that oprcode is set to InvalidOid, indicating it's a shell.
*/
i = 0;
namestrcpy(&oname, operatorName);
values[i++] = NameGetDatum(&oname); /* oprname */
values[i++] = ObjectIdGetDatum(operatorNamespace); /* oprnamespace */
values[i++] = ObjectIdGetDatum(GetUserId()); /* oprowner */
values[i++] = CharGetDatum(leftTypeId ? (rightTypeId ? 'b' : 'r') : 'l'); /* oprkind */
values[i++] = BoolGetDatum(false); /* oprcanmerge */
values[i++] = BoolGetDatum(false); /* oprcanhash */
values[i++] = ObjectIdGetDatum(leftTypeId); /* oprleft */
values[i++] = ObjectIdGetDatum(rightTypeId); /* oprright */
values[i++] = ObjectIdGetDatum(InvalidOid); /* oprresult */
values[i++] = ObjectIdGetDatum(InvalidOid); /* oprcom */
values[i++] = ObjectIdGetDatum(InvalidOid); /* oprnegate */
values[i++] = ObjectIdGetDatum(InvalidOid); /* oprcode */
values[i++] = ObjectIdGetDatum(InvalidOid); /* oprrest */
values[i++] = ObjectIdGetDatum(InvalidOid); /* oprjoin */
/*
* open pg_operator
*/
pcqCtx = caql_beginscan(
NULL,
cql("INSERT INTO pg_operator",
NULL));
/*
* create a new operator tuple
*/
tup = caql_form_tuple(pcqCtx, values, nulls);
/*
* insert our "shell" operator tuple
*/
operatorObjectId = caql_insert(pcqCtx, tup);
/* and Update indexes (implicit) */
/* Add dependencies for the entry */
makeOperatorDependencies(tup);
heap_freetuple(tup);
/*
* close the operator relation and return the oid.
*/
caql_endscan(pcqCtx);
return operatorObjectId;
}
/* ----------------
* NamespaceCreate
* ---------------
*/
Oid
NamespaceCreate(const char *nspName, Oid ownerId, Oid forceOid)
{
Relation nspdesc;
HeapTuple tup;
Oid nspoid;
bool nulls[Natts_pg_namespace];
Datum values[Natts_pg_namespace];
NameData nname;
int i;
cqContext cqc;
cqContext cqc2;
cqContext *pcqCtx;
/* sanity checks */
if (!nspName)
elog(ERROR, "no namespace name supplied");
nspdesc = heap_open(NamespaceRelationId, RowExclusiveLock);
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), nspdesc),
cql("INSERT INTO pg_namespace",
NULL));
/* make sure there is no existing namespace of same name in the current database */
if (caql_getcount(
caql_addrel(cqclr(&cqc2), nspdesc),
cql("SELECT COUNT(*) FROM pg_namespace "
" WHERE nspname = :1 and nspdboid = :2",
PointerGetDatum((char *) nspName), ObjectIdGetDatum((Oid) NSPDBOID_CURRENT))))
{
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_SCHEMA),
errmsg("schema \"%s\" already exists", nspName)));
}
/* initialize nulls and values */
for (i = 0; i < Natts_pg_namespace; i++)
{
nulls[i] = false;
values[i] = (Datum) 0;
}
namestrcpy(&nname, nspName);
values[Anum_pg_namespace_nspname - 1] = NameGetDatum(&nname);
values[Anum_pg_namespace_nspowner - 1] = ObjectIdGetDatum(ownerId);
nulls[Anum_pg_namespace_nspacl - 1] = true;
values[Anum_pg_namespace_nspdboid - 1] = ObjectIdGetDatum((Oid) NSPDBOID_CURRENT);
tup = caql_form_tuple(pcqCtx, values, nulls);
if (forceOid != InvalidOid)
HeapTupleSetOid(tup, forceOid); /* override heap_insert's OID
* selection */
/* insert a new tuple */
nspoid = caql_insert(pcqCtx, tup); /* implicit update of index as well */
Assert(OidIsValid(nspoid));
caql_endscan(pcqCtx);
heap_close(nspdesc, RowExclusiveLock);
/* Record dependency on owner */
recordDependencyOnOwner(NamespaceRelationId, nspoid, ownerId);
return nspoid;
}
Oid
TypeShellMakeWithOid(const char *typeName, Oid typeNamespace, Oid ownerId,
Oid shelltypeOid)
{
int i;
HeapTuple tup;
Datum values[Natts_pg_type];
bool nulls[Natts_pg_type];
Oid typoid;
NameData name;
cqContext *pcqCtx;
Assert(PointerIsValid(typeName));
/*
* open pg_type
*/
pcqCtx = caql_beginscan(
NULL,
cql("INSERT INTO pg_type ",
NULL));
/*
* initialize our *nulls and *values arrays
*/
for (i = 0; i < Natts_pg_type; ++i)
{
nulls[i] = false;
values[i] = (Datum) 0; /* redundant, but safe */
}
/*
* initialize *values with the type name and dummy values
*
* The representational details are the same as int4 ... it doesn't really
* matter what they are so long as they are consistent. Also note that we
* give it typtype = 'p' (pseudotype) as extra insurance that it won't be
* mistaken for a usable type.
*/
i = 0;
namestrcpy(&name, typeName);
values[i++] = NameGetDatum(&name); /* typname */
values[i++] = ObjectIdGetDatum(typeNamespace); /* typnamespace */
values[i++] = ObjectIdGetDatum(ownerId); /* typowner */
values[i++] = Int16GetDatum(sizeof(int4)); /* typlen */
values[i++] = BoolGetDatum(true); /* typbyval */
values[i++] = CharGetDatum('p'); /* typtype */
values[i++] = BoolGetDatum(false); /* typisdefined */
values[i++] = CharGetDatum(DEFAULT_TYPDELIM); /* typdelim */
values[i++] = ObjectIdGetDatum(InvalidOid); /* typrelid */
values[i++] = ObjectIdGetDatum(InvalidOid); /* typelem */
values[i++] = ObjectIdGetDatum(F_SHELL_IN); /* typinput */
values[i++] = ObjectIdGetDatum(F_SHELL_OUT); /* typoutput */
values[i++] = ObjectIdGetDatum(InvalidOid); /* typreceive */
values[i++] = ObjectIdGetDatum(InvalidOid); /* typsend */
values[i++] = ObjectIdGetDatum(InvalidOid); /* typanalyze */
values[i++] = CharGetDatum('i'); /* typalign */
values[i++] = CharGetDatum('p'); /* typstorage */
values[i++] = BoolGetDatum(false); /* typnotnull */
values[i++] = ObjectIdGetDatum(InvalidOid); /* typbasetype */
values[i++] = Int32GetDatum(-1); /* typtypmod */
values[i++] = Int32GetDatum(0); /* typndims */
nulls[i++] = true; /* typdefaultbin */
nulls[i++] = true; /* typdefault */
/*
* create a new type tuple
*/
tup = caql_form_tuple(pcqCtx, values, nulls);
/*
* MPP: If we are on the QEs, we need to use the same Oid as the QD used
*/
if (shelltypeOid != InvalidOid)
HeapTupleSetOid(tup, shelltypeOid);
/*
* insert the tuple in the relation and get the tuple's oid.
*/
typoid = caql_insert(pcqCtx, tup); /* implicit update of index as well */
/*
* Create dependencies. We can/must skip this in bootstrap mode.
*/
if (!IsBootstrapProcessingMode())
GenerateTypeDependencies(typeNamespace,
typoid,
InvalidOid,
0,
ownerId,
F_SHELL_IN,
F_SHELL_OUT,
InvalidOid,
InvalidOid,
InvalidOid,
InvalidOid,
InvalidOid,
NULL,
false);
/*
* clean up and return the type-oid
*/
heap_freetuple(tup);
caql_endscan(pcqCtx);
return typoid;
}
/* ----------------------------------------------------------------
* TypeCreate
*
* This does all the necessary work needed to define a new type.
*
* Returns the OID assigned to the new type.
* ----------------------------------------------------------------
*/
Oid
TypeCreateWithOid(const char *typeName,
Oid typeNamespace,
Oid relationOid, /* only for 'c'atalog types */
char relationKind, /* ditto */
Oid ownerId,
int16 internalSize,
char typeType,
char typDelim,
Oid inputProcedure,
Oid outputProcedure,
Oid receiveProcedure,
Oid sendProcedure,
Oid analyzeProcedure,
Oid elementType,
Oid baseType,
const char *defaultTypeValue, /* human readable rep */
char *defaultTypeBin, /* cooked rep */
bool passedByValue,
char alignment,
char storage,
int32 typeMod,
int32 typNDims, /* Array dimensions for baseType */
bool typeNotNull,
Oid newtypeOid,
Datum typoptions)
{
Relation pg_type_desc;
Oid typeObjectId;
bool rebuildDeps = false;
HeapTuple tup;
bool nulls[Natts_pg_type];
bool replaces[Natts_pg_type];
Datum values[Natts_pg_type];
NameData name;
int i;
cqContext *pcqCtx;
cqContext cqc;
/*
* We assume that the caller validated the arguments individually, but did
* not check for bad combinations.
*
* Validate size specifications: either positive (fixed-length) or -1
* (varlena) or -2 (cstring). Pass-by-value types must have a fixed
* length not more than sizeof(Datum).
*/
if (!(internalSize > 0 ||
internalSize == -1 ||
internalSize == -2))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("invalid type internal size %d",
internalSize)));
if (passedByValue &&
(internalSize <= 0 || internalSize > (int16) sizeof(Datum)))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("internal size %d is invalid for passed-by-value type",
internalSize)));
/* Only varlena types can be toasted */
if (storage != 'p' && internalSize != -1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("fixed-size types must have storage PLAIN")));
/*
* initialize arrays needed for heap_form_tuple or heap_modify_tuple
*/
for (i = 0; i < Natts_pg_type; ++i)
{
nulls[i] = false;
replaces[i] = true;
values[i] = (Datum) 0;
}
/*
* initialize the *values information
*/
i = 0;
namestrcpy(&name, typeName);
values[i++] = NameGetDatum(&name); /* typname */
values[i++] = ObjectIdGetDatum(typeNamespace); /* typnamespace */
values[i++] = ObjectIdGetDatum(ownerId); /* typowner */
values[i++] = Int16GetDatum(internalSize); /* typlen */
values[i++] = BoolGetDatum(passedByValue); /* typbyval */
values[i++] = CharGetDatum(typeType); /* typtype */
values[i++] = BoolGetDatum(true); /* typisdefined */
values[i++] = CharGetDatum(typDelim); /* typdelim */
values[i++] = ObjectIdGetDatum(typeType == 'c' ? relationOid : InvalidOid); /* typrelid */
values[i++] = ObjectIdGetDatum(elementType); /* typelem */
values[i++] = ObjectIdGetDatum(inputProcedure); /* typinput */
values[i++] = ObjectIdGetDatum(outputProcedure); /* typoutput */
values[i++] = ObjectIdGetDatum(receiveProcedure); /* typreceive */
values[i++] = ObjectIdGetDatum(sendProcedure); /* typsend */
values[i++] = ObjectIdGetDatum(analyzeProcedure); /* typanalyze */
values[i++] = CharGetDatum(alignment); /* typalign */
values[i++] = CharGetDatum(storage); /* typstorage */
values[i++] = BoolGetDatum(typeNotNull); /* typnotnull */
values[i++] = ObjectIdGetDatum(baseType); /* typbasetype */
values[i++] = Int32GetDatum(typeMod); /* typtypmod */
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);
pcqCtx = caql_addrel(cqclr(&cqc), pg_type_desc);
tup = caql_getfirst(
pcqCtx,
cql("SELECT * FROM pg_type "
" WHERE typname = :1 "
" AND typnamespace = :2 "
" FOR UPDATE ",
CStringGetDatum((char *) typeName),
ObjectIdGetDatum(typeNamespace)));
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);
/*
* Okay to update existing shell type tuple
*/
tup = caql_modify_current(pcqCtx,
values,
nulls,
replaces);
caql_update_current(pcqCtx, tup);
/* and Update indexes (implicit) */
typeObjectId = HeapTupleGetOid(tup);
rebuildDeps = true; /* get rid of shell type's dependencies */
}
else
{
tup = caql_form_tuple(pcqCtx, values, nulls);
if (newtypeOid != InvalidOid)
{
elog(DEBUG5," Setting Oid in new pg_type tuple");
HeapTupleSetOid(tup, newtypeOid);
}
else if (Gp_role == GP_ROLE_EXECUTE) elog(ERROR," newtypeOid NULL");
/* Insert tuple into the relation */
typeObjectId = caql_insert(pcqCtx, tup);
/* and Update indexes (implicit) */
}
/*
* Create dependencies. We can/must skip this in bootstrap mode.
*/
if (!IsBootstrapProcessingMode())
GenerateTypeDependencies(typeNamespace,
typeObjectId,
relationOid,
relationKind,
ownerId,
inputProcedure,
outputProcedure,
receiveProcedure,
sendProcedure,
analyzeProcedure,
elementType,
baseType,
(defaultTypeBin ?
stringToNode(defaultTypeBin) :
NULL),
rebuildDeps);
/*
* finish up with pg_type
*/
heap_close(pg_type_desc, RowExclusiveLock);
/* now pg_type_encoding */
if (DatumGetPointer(typoptions) != NULL)
add_type_encoding(typeObjectId, typoptions);
return typeObjectId;
}
/*
* ExtProtocolCreateWithOid
*/
Oid
ExtProtocolCreateWithOid(const char *protocolName,
List *readfuncName,
List *writefuncName,
List *validatorfuncName,
Oid protOid,
bool trusted)
{
Relation rel;
HeapTuple tup;
bool nulls[Natts_pg_extprotocol];
Datum values[Natts_pg_extprotocol];
Oid readfn = InvalidOid;
Oid writefn = InvalidOid;
Oid validatorfn = InvalidOid;
NameData prtname;
int i;
ObjectAddress myself,
referenced;
Oid ownerId = GetUserId();
cqContext cqc;
cqContext cqc2;
cqContext *pcqCtx;
/* sanity checks (caller should have caught these) */
if (!protocolName)
elog(ERROR, "no protocol name supplied");
if (!readfuncName && !writefuncName)
elog(ERROR, "protocol must have at least one of readfunc or writefunc");
/*
* Until we add system protocols to pg_extprotocol, make sure no
* protocols with the same name are created.
*/
if (strcasecmp(protocolName, "file") == 0 ||
strcasecmp(protocolName, "http") == 0 ||
strcasecmp(protocolName, "gpfdist") == 0 ||
strcasecmp(protocolName, "gpfdists") == 0)
{
ereport(ERROR,
(errcode(ERRCODE_RESERVED_NAME),
errmsg("protocol \"%s\" already exists",
protocolName),
errhint("pick a different protocol name")));
}
rel = heap_open(ExtprotocolRelationId, RowExclusiveLock);
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), rel),
cql("INSERT INTO pg_extprotocol",
NULL));
/* make sure there is no existing protocol of same name */
if (caql_getcount(
caql_addrel(cqclr(&cqc2), rel),
cql("SELECT COUNT(*) FROM pg_extprotocol "
" WHERE ptcname = :1 ",
CStringGetDatum((char *) protocolName))))
{
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("protocol \"%s\" already exists",
protocolName)));
}
/*
* function checks: if supplied, check existence and correct signature in the catalog
*/
if (readfuncName)
readfn = ValidateProtocolFunction(readfuncName, EXTPTC_FUNC_READER);
if (writefuncName)
writefn = ValidateProtocolFunction(writefuncName, EXTPTC_FUNC_WRITER);
if (validatorfuncName)
validatorfn = ValidateProtocolFunction(validatorfuncName, EXTPTC_FUNC_VALIDATOR);
/*
* Everything looks okay. Try to create the pg_extprotocol entry for the
* protocol. (This could fail if there's already a conflicting entry.)
*/
/* initialize nulls and values */
for (i = 0; i < Natts_pg_extprotocol; i++)
{
nulls[i] = false;
values[i] = (Datum) 0;
}
namestrcpy(&prtname, protocolName);
values[Anum_pg_extprotocol_ptcname - 1] = NameGetDatum(&prtname);
values[Anum_pg_extprotocol_ptcreadfn - 1] = ObjectIdGetDatum(readfn);
values[Anum_pg_extprotocol_ptcwritefn - 1] = ObjectIdGetDatum(writefn);
values[Anum_pg_extprotocol_ptcvalidatorfn - 1] = ObjectIdGetDatum(validatorfn);
values[Anum_pg_extprotocol_ptcowner - 1] = ObjectIdGetDatum(ownerId);
values[Anum_pg_extprotocol_ptctrusted - 1] = BoolGetDatum(trusted);
nulls[Anum_pg_extprotocol_ptcacl - 1] = true;
tup = caql_form_tuple(pcqCtx, values, nulls);
if (protOid != (Oid) 0)
HeapTupleSetOid(tup, protOid);
/* insert a new tuple */
protOid = caql_insert(pcqCtx, tup); /* implicit update of index as well */
caql_endscan(pcqCtx);
heap_close(rel, RowExclusiveLock);
/*
* Create dependencies for the protocol
*/
myself.classId = ExtprotocolRelationId;
myself.objectId = protOid;
myself.objectSubId = 0;
/* Depends on read function, if any */
if (OidIsValid(readfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = readfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on write function, if any */
if (OidIsValid(writefn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = writefn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* dependency on owner */
recordDependencyOnOwner(ExtprotocolRelationId, protOid, GetUserId());
return protOid;
}
/* AddUpdResqueueCapabilityEntryInternal:
*
* Internal function to add a new entry to pg_resqueuecapability, or
* update an existing one. Key cols are queueid, restypint. If
* old_tuple is set (ie not InvalidOid), the update the ressetting column,
* else insert a new row.
*
*/
static
List *
AddUpdResqueueCapabilityEntryInternal(
cqContext *pcqCtx,
List *stmtOptIdList,
Oid queueid,
int resTypeInt,
char *pResSetting,
Relation rel,
HeapTuple old_tuple)
{
HeapTuple new_tuple;
Datum values[Natts_pg_resqueuecapability];
bool isnull[Natts_pg_resqueuecapability];
bool new_record_repl[Natts_pg_resqueuecapability];
MemSet(isnull, 0, sizeof(bool) * Natts_pg_resqueuecapability);
MemSet(new_record_repl, 0, sizeof(bool) * Natts_pg_resqueuecapability);
values[Anum_pg_resqueuecapability_resqueueid - 1] =
ObjectIdGetDatum(queueid);
values[Anum_pg_resqueuecapability_restypid - 1] = resTypeInt;
Assert(pResSetting);
values[Anum_pg_resqueuecapability_ressetting - 1] =
CStringGetTextDatum(pResSetting);
/* set this column to update */
new_record_repl[Anum_pg_resqueuecapability_ressetting - 1] = true;
ValidateResqueueCapabilityEntry(resTypeInt, pResSetting);
if (HeapTupleIsValid(old_tuple))
{
new_tuple = caql_modify_current(pcqCtx, values,
isnull, new_record_repl);
caql_update_current(pcqCtx, new_tuple);
/* and Update indexes (implicit) */
}
else
{
Oid s1;
new_tuple = caql_form_tuple(pcqCtx, values, isnull);
/* MPP-11858: synchronize the oids for CREATE/ALTER options... */
if ((Gp_role != GP_ROLE_DISPATCH) && list_length(stmtOptIdList))
{
Oid s2 = list_nth_oid(stmtOptIdList, 0);
stmtOptIdList = list_delete_first(stmtOptIdList);
if (OidIsValid(s2))
HeapTupleSetOid(new_tuple, s2);
}
s1 = caql_insert(pcqCtx, new_tuple);
/* and Update indexes (implicit) */
if (Gp_role == GP_ROLE_DISPATCH)
{
stmtOptIdList = lappend_oid(stmtOptIdList, s1);
}
}
if (HeapTupleIsValid(old_tuple))
heap_freetuple(new_tuple);
return stmtOptIdList;
} /* end AddUpdResqueueCapabilityEntryInternal */
/*
* CreateConstraintEntry
* Create a constraint table entry.
*
* Subsidiary records (such as triggers or indexes to implement the
* constraint) are *not* created here. But we do make dependency links
* from the constraint to the things it depends on.
*/
Oid
CreateConstraintEntry(const char *constraintName,
Oid conOid,
Oid constraintNamespace,
char constraintType,
bool isDeferrable,
bool isDeferred,
Oid relId,
const int16 *constraintKey,
int constraintNKeys,
Oid domainId,
Oid foreignRelId,
const int16 *foreignKey,
int foreignNKeys,
char foreignUpdateType,
char foreignDeleteType,
char foreignMatchType,
Oid indexRelId,
Node *conExpr,
const char *conBin,
const char *conSrc)
{
HeapTuple tup;
bool nulls[Natts_pg_constraint];
Datum values[Natts_pg_constraint];
ArrayType *conkeyArray;
ArrayType *confkeyArray;
NameData cname;
int i;
ObjectAddress conobject;
cqContext *pcqCtx;
pcqCtx = caql_beginscan(
NULL,
cql("INSERT INTO pg_constraint",
NULL));
Assert(constraintName);
namestrcpy(&cname, constraintName);
/*
* Convert C arrays into Postgres arrays.
*/
if (constraintNKeys > 0)
{
Datum *conkey;
conkey = (Datum *) palloc(constraintNKeys * sizeof(Datum));
for (i = 0; i < constraintNKeys; i++)
conkey[i] = Int16GetDatum(constraintKey[i]);
conkeyArray = construct_array(conkey, constraintNKeys,
INT2OID, 2, true, 's');
}
else
conkeyArray = NULL;
if (foreignNKeys > 0)
{
Datum *confkey;
confkey = (Datum *) palloc(foreignNKeys * sizeof(Datum));
for (i = 0; i < foreignNKeys; i++)
confkey[i] = Int16GetDatum(foreignKey[i]);
confkeyArray = construct_array(confkey, foreignNKeys,
INT2OID, 2, true, 's');
}
else
confkeyArray = NULL;
/* initialize nulls and values */
for (i = 0; i < Natts_pg_constraint; i++)
{
nulls[i] = false;
values[i] = (Datum) 0;
}
values[Anum_pg_constraint_conname - 1] = NameGetDatum(&cname);
values[Anum_pg_constraint_connamespace - 1] = ObjectIdGetDatum(constraintNamespace);
values[Anum_pg_constraint_contype - 1] = CharGetDatum(constraintType);
values[Anum_pg_constraint_condeferrable - 1] = BoolGetDatum(isDeferrable);
values[Anum_pg_constraint_condeferred - 1] = BoolGetDatum(isDeferred);
values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(relId);
values[Anum_pg_constraint_contypid - 1] = ObjectIdGetDatum(domainId);
values[Anum_pg_constraint_confrelid - 1] = ObjectIdGetDatum(foreignRelId);
values[Anum_pg_constraint_confupdtype - 1] = CharGetDatum(foreignUpdateType);
values[Anum_pg_constraint_confdeltype - 1] = CharGetDatum(foreignDeleteType);
values[Anum_pg_constraint_confmatchtype - 1] = CharGetDatum(foreignMatchType);
if (conkeyArray)
values[Anum_pg_constraint_conkey - 1] = PointerGetDatum(conkeyArray);
else
nulls[Anum_pg_constraint_conkey - 1] = true;
if (confkeyArray)
values[Anum_pg_constraint_confkey - 1] = PointerGetDatum(confkeyArray);
else
nulls[Anum_pg_constraint_confkey - 1] = true;
/*
* initialize the binary form of the check constraint.
*/
if (conBin)
values[Anum_pg_constraint_conbin - 1] = DirectFunctionCall1(textin,
CStringGetDatum((char *) conBin));
else
nulls[Anum_pg_constraint_conbin - 1] = true;
/*
* initialize the text form of the check constraint
*/
if (conSrc)
values[Anum_pg_constraint_consrc - 1] = DirectFunctionCall1(textin,
CStringGetDatum((char *) conSrc));
else
nulls[Anum_pg_constraint_consrc - 1] = true;
tup = caql_form_tuple(pcqCtx, values, nulls);
/* force tuple to have the desired OID */
if (OidIsValid(conOid))
HeapTupleSetOid(tup, conOid);
conOid = caql_insert(pcqCtx, tup); /* implicit update of index as well */
conobject.classId = ConstraintRelationId;
conobject.objectId = conOid;
conobject.objectSubId = 0;
caql_endscan(pcqCtx);
if (OidIsValid(relId))
{
/*
* Register auto dependency from constraint to owning relation, or to
* specific column(s) if any are mentioned.
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = relId;
if (constraintNKeys > 0)
{
for (i = 0; i < constraintNKeys; i++)
{
relobject.objectSubId = constraintKey[i];
recordDependencyOn(&conobject, &relobject, DEPENDENCY_AUTO);
}
}
else
{
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_AUTO);
}
}
if (OidIsValid(domainId))
{
/*
* Register auto dependency from constraint to owning domain
*/
ObjectAddress domobject;
domobject.classId = TypeRelationId;
domobject.objectId = domainId;
domobject.objectSubId = 0;
recordDependencyOn(&conobject, &domobject, DEPENDENCY_AUTO);
}
if (OidIsValid(foreignRelId))
{
/*
* Register normal dependency from constraint to foreign relation, or
* to specific column(s) if any are mentioned.
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = foreignRelId;
if (foreignNKeys > 0)
{
for (i = 0; i < foreignNKeys; i++)
{
relobject.objectSubId = foreignKey[i];
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
}
else
{
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
}
if (OidIsValid(indexRelId))
{
/*
* Register normal dependency on the unique index that supports a
* foreign-key constraint.
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = indexRelId;
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
if (conExpr != NULL)
{
/*
* Register dependencies from constraint to objects mentioned in CHECK
* expression.
*/
recordDependencyOnSingleRelExpr(&conobject, conExpr, relId,
DEPENDENCY_NORMAL,
DEPENDENCY_NORMAL);
}
return conOid;
}