/*
* Check whether the user is allowed to comment on the specified cast.
*/
static void
CheckCastComment(List *qualname, List *arguments)
{
TypeName *sourcetype;
TypeName *targettype;
Oid sourcetypeid;
Oid targettypeid;
Assert(list_length(qualname) == 1);
sourcetype = (TypeName *) linitial(qualname);
Assert(IsA(sourcetype, TypeName));
Assert(list_length(arguments) == 1);
targettype = (TypeName *) linitial(arguments);
Assert(IsA(targettype, TypeName));
sourcetypeid = typenameTypeId(NULL, sourcetype);
targettypeid = typenameTypeId(NULL, targettype);
/* Permission check */
if (!pg_type_ownercheck(sourcetypeid, GetUserId())
&& !pg_type_ownercheck(targettypeid, GetUserId()))
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must be owner of type %s or type %s",
format_type_be(sourcetypeid),
format_type_be(targettypeid))));
}
/*
* BuildDescForRelation
*
* Given a relation schema (list of ColumnDef nodes), build a TupleDesc.
*
* Note: the default assumption is no OIDs; caller may modify the returned
* TupleDesc if it wants OIDs. Also, tdtypeid will need to be filled in
* later on.
*/
TupleDesc
BuildDescForRelation(List *schema)
{
int natts;
AttrNumber attnum;
ListCell *l;
TupleDesc desc;
bool has_not_null;
char *attname;
Oid atttypid;
int32 atttypmod;
int attdim;
/*
* allocate a new tuple descriptor
*/
natts = list_length(schema);
desc = CreateTemplateTupleDesc(natts, false);
has_not_null = false;
attnum = 0;
foreach(l, schema)
{
ColumnDef *entry = lfirst(l);
/*
* for each entry in the list, get the name and type information from
* the list and have TupleDescInitEntry fill in the attribute
* information we need.
*/
attnum++;
attname = entry->colname;
atttypid = typenameTypeId(NULL, entry->typeName, &atttypmod);
attdim = list_length(entry->typeName->arrayBounds);
if (entry->typeName->setof)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
errmsg("column \"%s\" cannot be declared SETOF",
attname)));
TupleDescInitEntry(desc, attnum, attname,
atttypid, atttypmod, attdim);
/* Override TupleDescInitEntry's settings as requested */
if (entry->storage)
desc->attrs[attnum - 1]->attstorage = entry->storage;
/* Fill in additional stuff not handled by TupleDescInitEntry */
desc->attrs[attnum - 1]->attnotnull = entry->is_not_null;
has_not_null |= entry->is_not_null;
desc->attrs[attnum - 1]->attislocal = entry->is_local;
desc->attrs[attnum - 1]->attinhcount = entry->inhcount;
}
/*
* LookupOperNameTypeNames
* Like LookupOperName, but the argument types are specified by
* TypeName nodes.
*
* Pass oprleft = NULL for a prefix op, oprright = NULL for a postfix op.
*/
Oid
LookupOperNameTypeNames(ParseState *pstate, List *opername,
TypeName *oprleft, TypeName *oprright,
bool noError, int location)
{
Oid leftoid,
rightoid;
if (oprleft == NULL)
leftoid = InvalidOid;
else
leftoid = typenameTypeId(pstate, oprleft);
if (oprright == NULL)
rightoid = InvalidOid;
else
rightoid = typenameTypeId(pstate, oprright);
return LookupOperName(pstate, opername, leftoid, rightoid,
noError, location);
}
/*
* BuildDescForRelation
*
* Given a relation schema (list of ColumnDef nodes), build a TupleDesc.
*
* Note: the default assumption is no OIDs; caller may modify the returned
* TupleDesc if it wants OIDs. Also, tdtypeid will need to be filled in
* later on.
*/
TupleDesc
BuildDescForRelation(List *schema)
{
int natts;
AttrNumber attnum;
ListCell *l;
TupleDesc desc;
AttrDefault *attrdef = NULL;
TupleConstr *constr = (TupleConstr *) palloc0(sizeof(TupleConstr));
char *attname;
int32 atttypmod;
int attdim;
int ndef = 0;
/*
* allocate a new tuple descriptor
*/
natts = list_length(schema);
desc = CreateTemplateTupleDesc(natts, false);
constr->has_not_null = false;
attnum = 0;
foreach(l, schema)
{
ColumnDef *entry = lfirst(l);
/*
* for each entry in the list, get the name and type information from
* the list and have TupleDescInitEntry fill in the attribute
* information we need.
*/
attnum++;
attname = entry->colname;
atttypmod = entry->typname->typmod;
attdim = list_length(entry->typname->arrayBounds);
if (entry->typname->setof)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
errmsg("column \"%s\" cannot be declared SETOF",
attname)));
TupleDescInitEntry(desc, attnum, attname,
typenameTypeId(NULL, entry->typname),
atttypmod, attdim);
/* Fill in additional stuff not handled by TupleDescInitEntry */
if (entry->is_not_null)
constr->has_not_null = true;
desc->attrs[attnum - 1]->attnotnull = entry->is_not_null;
/*
* Note we copy only pre-cooked default expressions. Digestion of raw
* ones is someone else's problem.
*/
if (entry->cooked_default != NULL)
{
if (attrdef == NULL)
attrdef = (AttrDefault *) palloc(natts * sizeof(AttrDefault));
attrdef[ndef].adnum = attnum;
attrdef[ndef].adbin = pstrdup(entry->cooked_default);
ndef++;
desc->attrs[attnum - 1]->atthasdef = true;
}
desc->attrs[attnum - 1]->attislocal = entry->is_local;
desc->attrs[attnum - 1]->attinhcount = entry->inhcount;
}
/*
* Check ownership of an object previously identified by get_object_address.
*/
void
check_object_ownership(Oid roleid, ObjectType objtype, ObjectAddress address,
List *objname, List *objargs, Relation relation)
{
switch (objtype)
{
case OBJECT_INDEX:
case OBJECT_SEQUENCE:
case OBJECT_TABLE:
case OBJECT_VIEW:
case OBJECT_FOREIGN_TABLE:
case OBJECT_COLUMN:
case OBJECT_RULE:
case OBJECT_TRIGGER:
case OBJECT_CONSTRAINT:
if (!pg_class_ownercheck(RelationGetRelid(relation), roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CLASS,
RelationGetRelationName(relation));
break;
case OBJECT_DATABASE:
if (!pg_database_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_DATABASE,
NameListToString(objname));
break;
case OBJECT_TYPE:
case OBJECT_DOMAIN:
case OBJECT_ATTRIBUTE:
if (!pg_type_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TYPE,
format_type_be(address.objectId));
break;
case OBJECT_AGGREGATE:
case OBJECT_FUNCTION:
if (!pg_proc_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_PROC,
NameListToString(objname));
break;
case OBJECT_OPERATOR:
if (!pg_oper_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPER,
NameListToString(objname));
break;
case OBJECT_SCHEMA:
if (!pg_namespace_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_NAMESPACE,
NameListToString(objname));
break;
case OBJECT_COLLATION:
if (!pg_collation_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_COLLATION,
NameListToString(objname));
break;
case OBJECT_CONVERSION:
if (!pg_conversion_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CONVERSION,
NameListToString(objname));
break;
case OBJECT_EXTENSION:
if (!pg_extension_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_EXTENSION,
NameListToString(objname));
break;
case OBJECT_FDW:
if (!pg_foreign_data_wrapper_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FDW,
NameListToString(objname));
break;
case OBJECT_FOREIGN_SERVER:
if (!pg_foreign_server_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
NameListToString(objname));
break;
case OBJECT_LANGUAGE:
if (!pg_language_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_LANGUAGE,
NameListToString(objname));
break;
case OBJECT_OPCLASS:
if (!pg_opclass_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPCLASS,
NameListToString(objname));
break;
case OBJECT_OPFAMILY:
if (!pg_opfamily_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPFAMILY,
NameListToString(objname));
break;
case OBJECT_LARGEOBJECT:
if (!lo_compat_privileges &&
!pg_largeobject_ownercheck(address.objectId, roleid))
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must be owner of large object %u",
address.objectId)));
break;
case OBJECT_CAST:
{
/* We can only check permissions on the source/target types */
TypeName *sourcetype = (TypeName *) linitial(objname);
TypeName *targettype = (TypeName *) linitial(objargs);
Oid sourcetypeid = typenameTypeId(NULL, sourcetype);
Oid targettypeid = typenameTypeId(NULL, targettype);
if (!pg_type_ownercheck(sourcetypeid, roleid)
&& !pg_type_ownercheck(targettypeid, roleid))
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must be owner of type %s or type %s",
format_type_be(sourcetypeid),
format_type_be(targettypeid))));
}
break;
case OBJECT_TABLESPACE:
if (!pg_tablespace_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TABLESPACE,
NameListToString(objname));
break;
case OBJECT_TSDICTIONARY:
if (!pg_ts_dict_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSDICTIONARY,
NameListToString(objname));
break;
case OBJECT_TSCONFIGURATION:
if (!pg_ts_config_ownercheck(address.objectId, roleid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TSCONFIGURATION,
NameListToString(objname));
break;
case OBJECT_ROLE:
/*
* We treat roles as being "owned" by those with CREATEROLE priv,
* except that superusers are only owned by superusers.
*/
if (superuser_arg(address.objectId))
{
if (!superuser_arg(roleid))
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must be superuser")));
}
else
{
if (!has_createrole_privilege(roleid))
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must have CREATEROLE privilege")));
}
break;
case OBJECT_TSPARSER:
case OBJECT_TSTEMPLATE:
/* We treat these object types as being owned by superusers */
if (!superuser_arg(roleid))
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must be superuser")));
break;
default:
elog(ERROR, "unrecognized object type: %d",
(int) objtype);
}
}
/*
* Translate an object name and arguments (as passed by the parser) to an
* ObjectAddress.
*
* The returned object will be locked using the specified lockmode. If a
* sub-object is looked up, the parent object will be locked instead.
*
* If the object is a relation or a child object of a relation (e.g. an
* attribute or contraint), the relation is also opened and *relp receives
* the open relcache entry pointer; otherwise, *relp is set to NULL. This
* is a bit grotty but it makes life simpler, since the caller will
* typically need the relcache entry too. Caller must close the relcache
* entry when done with it. The relation is locked with the specified lockmode
* if the target object is the relation itself or an attribute, but for other
* child objects, only AccessShareLock is acquired on the relation.
*
* We don't currently provide a function to release the locks acquired here;
* typically, the lock must be held until commit to guard against a concurrent
* drop operation.
*/
ObjectAddress
get_object_address(ObjectType objtype, List *objname, List *objargs,
Relation *relp, LOCKMODE lockmode)
{
ObjectAddress address;
Relation relation = NULL;
/* Some kind of lock must be taken. */
Assert(lockmode != NoLock);
switch (objtype)
{
case OBJECT_INDEX:
case OBJECT_SEQUENCE:
case OBJECT_TABLE:
case OBJECT_VIEW:
case OBJECT_FOREIGN_TABLE:
relation =
get_relation_by_qualified_name(objtype, objname, lockmode);
address.classId = RelationRelationId;
address.objectId = RelationGetRelid(relation);
address.objectSubId = 0;
break;
case OBJECT_COLUMN:
address =
get_object_address_attribute(objtype, objname, &relation,
lockmode);
break;
case OBJECT_RULE:
case OBJECT_TRIGGER:
case OBJECT_CONSTRAINT:
address = get_object_address_relobject(objtype, objname, &relation);
break;
case OBJECT_DATABASE:
case OBJECT_EXTENSION:
case OBJECT_TABLESPACE:
case OBJECT_ROLE:
case OBJECT_SCHEMA:
case OBJECT_LANGUAGE:
case OBJECT_FDW:
case OBJECT_FOREIGN_SERVER:
address = get_object_address_unqualified(objtype, objname);
break;
case OBJECT_TYPE:
case OBJECT_DOMAIN:
address.classId = TypeRelationId;
address.objectId =
typenameTypeId(NULL, makeTypeNameFromNameList(objname));
address.objectSubId = 0;
break;
case OBJECT_AGGREGATE:
address.classId = ProcedureRelationId;
address.objectId = LookupAggNameTypeNames(objname, objargs, false);
address.objectSubId = 0;
break;
case OBJECT_FUNCTION:
address.classId = ProcedureRelationId;
address.objectId = LookupFuncNameTypeNames(objname, objargs, false);
address.objectSubId = 0;
break;
case OBJECT_OPERATOR:
Assert(list_length(objargs) == 2);
address.classId = OperatorRelationId;
address.objectId =
LookupOperNameTypeNames(NULL, objname,
(TypeName *) linitial(objargs),
(TypeName *) lsecond(objargs),
false, -1);
address.objectSubId = 0;
break;
case OBJECT_COLLATION:
address.classId = CollationRelationId;
address.objectId = get_collation_oid(objname, false);
address.objectSubId = 0;
break;
case OBJECT_CONVERSION:
address.classId = ConversionRelationId;
address.objectId = get_conversion_oid(objname, false);
address.objectSubId = 0;
break;
case OBJECT_OPCLASS:
case OBJECT_OPFAMILY:
address = get_object_address_opcf(objtype, objname, objargs);
break;
case OBJECT_LARGEOBJECT:
Assert(list_length(objname) == 1);
address.classId = LargeObjectRelationId;
address.objectId = oidparse(linitial(objname));
address.objectSubId = 0;
if (!LargeObjectExists(address.objectId))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("large object %u does not exist",
address.objectId)));
break;
case OBJECT_CAST:
{
TypeName *sourcetype = (TypeName *) linitial(objname);
TypeName *targettype = (TypeName *) linitial(objargs);
Oid sourcetypeid = typenameTypeId(NULL, sourcetype);
Oid targettypeid = typenameTypeId(NULL, targettype);
address.classId = CastRelationId;
address.objectId =
get_cast_oid(sourcetypeid, targettypeid, false);
address.objectSubId = 0;
}
break;
case OBJECT_TSPARSER:
address.classId = TSParserRelationId;
address.objectId = get_ts_parser_oid(objname, false);
address.objectSubId = 0;
break;
case OBJECT_TSDICTIONARY:
address.classId = TSDictionaryRelationId;
address.objectId = get_ts_dict_oid(objname, false);
address.objectSubId = 0;
break;
case OBJECT_TSTEMPLATE:
address.classId = TSTemplateRelationId;
address.objectId = get_ts_template_oid(objname, false);
address.objectSubId = 0;
break;
case OBJECT_TSCONFIGURATION:
address.classId = TSConfigRelationId;
address.objectId = get_ts_config_oid(objname, false);
address.objectSubId = 0;
break;
default:
elog(ERROR, "unrecognized objtype: %d", (int) objtype);
/* placate compiler, in case it thinks elog might return */
address.classId = InvalidOid;
address.objectId = InvalidOid;
address.objectSubId = 0;
}
/*
* If we're dealing with a relation or attribute, then the relation is
* already locked. If we're dealing with any other type of object, we need
* to lock it and then verify that it still exists.
*/
if (address.classId != RelationRelationId)
{
if (IsSharedRelation(address.classId))
LockSharedObject(address.classId, address.objectId, 0, lockmode);
else
LockDatabaseObject(address.classId, address.objectId, 0, lockmode);
/* Did it go away while we were waiting for the lock? */
if (!object_exists(address))
elog(ERROR, "cache lookup failed for class %u object %u subobj %d",
address.classId, address.objectId, address.objectSubId);
}
/* Return the object address and the relation. */
*relp = relation;
return address;
}
static Slony_I_ClusterStatus *
getClusterStatus(Name cluster_name, int need_plan_mask)
{
Slony_I_ClusterStatus *cs;
int rc;
char query[1024];
bool isnull;
Oid plan_types[9];
Oid txid_snapshot_typid;
TypeName *txid_snapshot_typname;
/*
* Find an existing cs row for this cluster
*/
for (cs = clusterStatusList; cs; cs = cs->next)
{
if ((bool) DirectFunctionCall2(nameeq,
NameGetDatum(&(cs->clustername)),
NameGetDatum(cluster_name)) == true)
{
/*
* Return it if all the requested SPI plans are prepared already.
*/
if ((cs->have_plan & need_plan_mask) == need_plan_mask)
return cs;
/*
* Create more SPI plans below.
*/
break;
}
}
if (cs == NULL)
{
/*
* No existing cs found ... create a new one
*/
cs = (Slony_I_ClusterStatus *) malloc(sizeof(Slony_I_ClusterStatus));
memset(cs, 0, sizeof(Slony_I_ClusterStatus));
/*
* We remember the plain cluster name for fast lookup
*/
strncpy(NameStr(cs->clustername), NameStr(*cluster_name), NAMEDATALEN);
/*
* ... and the quoted identifier of it for building queries
*/
cs->clusterident = strdup(DatumGetCString(DirectFunctionCall1(textout,
DirectFunctionCall1(quote_ident,
DirectFunctionCall1(textin, CStringGetDatum(NameStr(*cluster_name)))))));
/*
* Get our local node ID
*/
snprintf(query, 1024, "select last_value::int4 from %s.sl_local_node_id",
cs->clusterident);
rc = SPI_exec(query, 0);
if (rc < 0 || SPI_processed != 1)
elog(ERROR, "Slony-I: failed to read sl_local_node_id");
cs->localNodeId = DatumGetInt32(
SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1, &isnull));
SPI_freetuptable(SPI_tuptable);
if (cs->localNodeId < 0)
elog(ERROR, "Slony-I: Node is uninitialized - cluster %s", DatumGetCString(cluster_name));
/*
* Initialize the currentXid to invalid
*/
cs->currentXid = InvalidTransactionId;
/*
* Insert the new control block into the list
*/
cs->next = clusterStatusList;
clusterStatusList = cs;
}
/*
* Prepare and save the PLAN_INSERT_EVENT
*/
if ((need_plan_mask & PLAN_INSERT_EVENT) != 0 &&
(cs->have_plan & PLAN_INSERT_EVENT) == 0)
{
/*
* Lookup the oid of the txid_snapshot type
*/
txid_snapshot_typname = makeNode(TypeName);
txid_snapshot_typname->names =
lappend(lappend(NIL, makeString("pg_catalog")),
makeString("txid_snapshot"));
#ifdef HAVE_TYPENAMETYPEID_3
txid_snapshot_typid = typenameTypeId(NULL, txid_snapshot_typname, NULL);
#elif HAVE_TYPENAMETYPEID_2
txid_snapshot_typid = typenameTypeId(NULL, txid_snapshot_typname);
#elif HAVE_TYPENAMETYPEID_1
txid_snapshot_typid = typenameTypeId(txid_snapshot_typname);
#endif
/*
* Create the saved plan. We lock the sl_event table in exclusive mode
* in order to ensure that all events are really assigned sequence
* numbers in the order they get committed.
*/
sprintf(query,
"LOCK TABLE %s.sl_event IN EXCLUSIVE MODE; "
"INSERT INTO %s.sl_event "
"(ev_origin, ev_seqno, "
"ev_timestamp, ev_snapshot, "
"ev_type, ev_data1, ev_data2, ev_data3, ev_data4, "
"ev_data5, ev_data6, ev_data7, ev_data8) "
"VALUES ('%d', nextval('%s.sl_event_seq'), "
"now(), \"pg_catalog\".txid_current_snapshot(), $1, $2, "
"$3, $4, $5, $6, $7, $8, $9); "
"SELECT currval('%s.sl_event_seq');",
cs->clusterident,
cs->clusterident, cs->localNodeId, cs->clusterident,
cs->clusterident);
plan_types[0] = TEXTOID;
plan_types[1] = TEXTOID;
plan_types[2] = TEXTOID;
plan_types[3] = TEXTOID;
plan_types[4] = TEXTOID;
plan_types[5] = TEXTOID;
plan_types[6] = TEXTOID;
plan_types[7] = TEXTOID;
plan_types[8] = TEXTOID;
cs->plan_insert_event = SPI_saveplan(SPI_prepare(query, 9, plan_types));
if (cs->plan_insert_event == NULL)
elog(ERROR, "Slony-I: SPI_prepare() failed");
/*
* Also prepare the plan to remember sequence numbers on certain
* events.
*/
sprintf(query,
"insert into %s.sl_seqlog "
"(seql_seqid, seql_origin, seql_ev_seqno, seql_last_value) "
"select * from ("
"select seq_id, %d, currval('%s.sl_event_seq'), seq_last_value "
"from %s.sl_seqlastvalue "
"where seq_origin = '%d') as FOO "
"where NOT %s.seqtrack(seq_id, seq_last_value) IS NULL; ",
cs->clusterident,
cs->localNodeId, cs->clusterident,
cs->clusterident, cs->localNodeId,
cs->clusterident);
cs->plan_record_sequences = SPI_saveplan(SPI_prepare(query, 0, NULL));
if (cs->plan_record_sequences == NULL)
elog(ERROR, "Slony-I: SPI_prepare() failed");
cs->have_plan |= PLAN_INSERT_EVENT;
}
/*
* Prepare and save the PLAN_INSERT_LOG
*/
if ((need_plan_mask & PLAN_INSERT_LOG) != 0 &&
(cs->have_plan & PLAN_INSERT_LOG) == 0)
{
/*
* Create the saved plan's
*/
sprintf(query, "INSERT INTO %s.sl_log_1 "
"(log_origin, log_txid, log_tableid, log_actionseq,"
" log_cmdtype, log_cmddata) "
"VALUES (%d, \"pg_catalog\".txid_current(), $1, "
"nextval('%s.sl_action_seq'), $2, $3); ",
cs->clusterident, cs->localNodeId, cs->clusterident);
plan_types[0] = INT4OID;
plan_types[1] = TEXTOID;
plan_types[2] = TEXTOID;
cs->plan_insert_log_1 = SPI_saveplan(SPI_prepare(query, 3, plan_types));
if (cs->plan_insert_log_1 == NULL)
elog(ERROR, "Slony-I: SPI_prepare() failed");
sprintf(query, "INSERT INTO %s.sl_log_2 "
"(log_origin, log_txid, log_tableid, log_actionseq,"
" log_cmdtype, log_cmddata) "
"VALUES (%d, \"pg_catalog\".txid_current(), $1, "
"nextval('%s.sl_action_seq'), $2, $3); ",
cs->clusterident, cs->localNodeId, cs->clusterident);
plan_types[0] = INT4OID;
plan_types[1] = TEXTOID;
plan_types[2] = TEXTOID;
cs->plan_insert_log_2 = SPI_saveplan(SPI_prepare(query, 3, plan_types));
if (cs->plan_insert_log_2 == NULL)
elog(ERROR, "Slony-I: SPI_prepare() failed");
/* @-nullderef@ */
/*
* Also create the 3 rather static text values for the log_cmdtype
* parameter and initialize the cmddata_buf.
*/
cs->cmdtype_I = malloc(VARHDRSZ + 1);
SET_VARSIZE(cs->cmdtype_I, VARHDRSZ + 1);
*VARDATA(cs->cmdtype_I) = 'I';
cs->cmdtype_U = malloc(VARHDRSZ + 1);
SET_VARSIZE(cs->cmdtype_U, VARHDRSZ + 1);
*VARDATA(cs->cmdtype_U) = 'U';
cs->cmdtype_D = malloc(VARHDRSZ + 1);
SET_VARSIZE(cs->cmdtype_D, VARHDRSZ + 1);
*VARDATA(cs->cmdtype_D) = 'D';
/*
* And the plan to read the current log_status.
*/
sprintf(query, "SELECT last_value::int4 FROM %s.sl_log_status",
cs->clusterident);
cs->plan_get_logstatus = SPI_saveplan(SPI_prepare(query, 0, NULL));
cs->cmddata_size = 8192;
cs->cmddata_buf = (text *) malloc(8192);
cs->have_plan |= PLAN_INSERT_LOG;
}
return cs;
/* @+nullderef@ */
}