mirror of
https://git.postgresql.org/git/postgresql.git
synced 2025-01-24 18:55:04 +08:00
General trigger functions for referential integrity.
This commit is contained in:
Vadim B. Mikheev
parent
8ec7eef93d
commit
b6f348cd33
21
contrib/spi/Makefile
Normal file
21
contrib/spi/Makefile
Normal file
@ -0,0 +1,21 @@
|
||||
|
||||
SRCDIR= /home/postgres/current/pgsql/src
|
||||
|
||||
include $(SRCDIR)/Makefile.global
|
||||
|
||||
CFLAGS+= $(CFLAGS_SL) -I$(SRCDIR)/include -DREFINT_QUIET
|
||||
|
||||
TARGETS= refint$(DLSUFFIX) refint.sql
|
||||
|
||||
CLEANFILES+= $(TARGETS)
|
||||
|
||||
all:: $(TARGETS)
|
||||
|
||||
%.sql: %.source
|
||||
rm -f $@; \
|
||||
C=`pwd`; \
|
||||
sed -e "s:_OBJWD_:$$C:g" \
|
||||
-e "s:_DLSUFFIX_:$(DLSUFFIX):g" < $< > $@
|
||||
|
||||
clean:
|
||||
rm -f $(TARGETS)
|
||||
542
contrib/spi/refint.c
Normal file
542
contrib/spi/refint.c
Normal file
@ -0,0 +1,542 @@
|
||||
/*
|
||||
* refint.c -- set of functions to define referential integrity
|
||||
* constraints using general triggers.
|
||||
*/
|
||||
|
||||
#include "executor/spi.h" /* this is what you need to work with SPI */
|
||||
#include "commands/trigger.h" /* -"- and triggers */
|
||||
#include <ctype.h> /* tolower () */
|
||||
|
||||
HeapTuple check_primary_key(void);
|
||||
HeapTuple check_foreign_key(void);
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char *ident;
|
||||
int nplans;
|
||||
void **splan;
|
||||
} EPlan;
|
||||
|
||||
static EPlan *FPlans = NULL;
|
||||
static int nFPlans = 0;
|
||||
static EPlan *PPlans = NULL;
|
||||
static int nPPlans = 0;
|
||||
|
||||
static EPlan *find_plan(char *ident, EPlan ** eplan, int *nplans);
|
||||
|
||||
/*
|
||||
* check_primary_key () -- check that key in tuple being inserted/updated
|
||||
* references existing tuple in "primary" table.
|
||||
* Though it's called without args You have to specify referenced
|
||||
* table/keys while creating trigger: key field names in triggered table,
|
||||
* referenced table name, referenced key field names:
|
||||
* EXECUTE PROCEDURE
|
||||
* check_primary_key ('Fkey1', 'Fkey2', 'Ptable', 'Pkey1', 'Pkey2').
|
||||
*/
|
||||
|
||||
HeapTuple /* have to return HeapTuple to Executor */
|
||||
check_primary_key()
|
||||
{
|
||||
Trigger *trigger; /* to get trigger name */
|
||||
int nargs; /* # of args specified in CREATE TRIGGER */
|
||||
char **args; /* arguments: column names and table name */
|
||||
int nkeys; /* # of key columns (= nargs / 2) */
|
||||
char **kvals; /* key values */
|
||||
char *relname; /* referenced relation name */
|
||||
Relation rel; /* triggered relation */
|
||||
HeapTuple tuple = NULL; /* tuple to return */
|
||||
TupleDesc tupdesc; /* tuple description */
|
||||
EPlan *plan; /* prepared plan */
|
||||
Oid *argtypes = NULL;/* key types to prepare execution plan */
|
||||
bool isnull; /* to know is some column NULL or not */
|
||||
char ident[2 * NAMEDATALEN]; /* to identify myself */
|
||||
int ret;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Some checks first...
|
||||
*/
|
||||
|
||||
/* Called by trigger manager ? */
|
||||
if (!CurrentTriggerData)
|
||||
elog(WARN, "check_primary_key: triggers are not initialized");
|
||||
|
||||
/* Should be called for ROW trigger */
|
||||
if (TRIGGER_FIRED_FOR_STATEMENT(CurrentTriggerData->tg_event))
|
||||
elog(WARN, "check_primary_key: can't process STATEMENT events");
|
||||
|
||||
/* If INSERTion then must check Tuple to being inserted */
|
||||
if (TRIGGER_FIRED_BY_INSERT(CurrentTriggerData->tg_event))
|
||||
|
||||
tuple = CurrentTriggerData->tg_trigtuple;
|
||||
|
||||
/* Not should be called for DELETE */
|
||||
else if (TRIGGER_FIRED_BY_DELETE(CurrentTriggerData->tg_event))
|
||||
|
||||
elog(WARN, "check_primary_key: can't process DELETE events");
|
||||
|
||||
/* If UPDATion the must check new Tuple, not old one */
|
||||
else
|
||||
tuple = CurrentTriggerData->tg_newtuple;
|
||||
|
||||
trigger = CurrentTriggerData->tg_trigger;
|
||||
nargs = trigger->tgnargs;
|
||||
args = trigger->tgargs;
|
||||
|
||||
if (nargs % 2 != 1) /* odd number of arguments! */
|
||||
elog(WARN, "check_primary_key: odd number of arguments should be specified");
|
||||
|
||||
nkeys = nargs / 2;
|
||||
relname = args[nkeys];
|
||||
rel = CurrentTriggerData->tg_relation;
|
||||
tupdesc = rel->rd_att;
|
||||
|
||||
/*
|
||||
* Setting CurrentTriggerData to NULL prevents direct calls to trigger
|
||||
* functions in queries. Normally, trigger functions have to be called
|
||||
* by trigger manager code only.
|
||||
*/
|
||||
CurrentTriggerData = NULL;
|
||||
|
||||
/* Connect to SPI manager */
|
||||
if ((ret = SPI_connect()) < 0)
|
||||
elog(WARN, "check_primary_key: SPI_connect returned %d", ret);
|
||||
|
||||
/*
|
||||
* We use SPI plan preparation feature, so allocate space to place key
|
||||
* values.
|
||||
*/
|
||||
kvals = (char **) palloc(nkeys * sizeof(char *));
|
||||
|
||||
/*
|
||||
* Construct ident string as TriggerName $ TriggeredRelationId and try
|
||||
* to find prepared execution plan.
|
||||
*/
|
||||
sprintf(ident, "%s$%u", trigger->tgname, rel->rd_id);
|
||||
plan = find_plan(ident, &PPlans, &nPPlans);
|
||||
|
||||
/* if there is no plan then allocate argtypes for preparation */
|
||||
if (plan->nplans <= 0)
|
||||
argtypes = (Oid *) palloc(nkeys * sizeof(Oid));
|
||||
|
||||
/* For each column in key ... */
|
||||
for (i = 0; i < nkeys; i++)
|
||||
{
|
||||
/* get index of column in tuple */
|
||||
int fnumber = SPI_fnumber(tupdesc, args[i]);
|
||||
|
||||
/* Bad guys may give us un-existing column in CREATE TRIGGER */
|
||||
if (fnumber < 0)
|
||||
elog(WARN, "check_primary_key: there is no attribute %s in relation %s",
|
||||
args[i], SPI_getrelname(rel));
|
||||
|
||||
/* Well, get binary (in internal format) value of column */
|
||||
kvals[i] = SPI_getbinval(tuple, tupdesc, fnumber, &isnull);
|
||||
|
||||
/*
|
||||
* If it's NULL then nothing to do! DON'T FORGET call SPI_finish
|
||||
* ()! DON'T FORGET return tuple! Executor inserts tuple you're
|
||||
* returning! If you return NULL then nothing will be inserted!
|
||||
*/
|
||||
if (isnull)
|
||||
{
|
||||
SPI_finish();
|
||||
return (tuple);
|
||||
}
|
||||
|
||||
if (plan->nplans <= 0) /* Get typeId of column */
|
||||
argtypes[i] = SPI_gettypeid(tupdesc, fnumber);
|
||||
}
|
||||
|
||||
/*
|
||||
* If we have to prepare plan ...
|
||||
*/
|
||||
if (plan->nplans <= 0)
|
||||
{
|
||||
void *pplan;
|
||||
char sql[8192];
|
||||
|
||||
/*
|
||||
* Construct query: SELECT 1 FROM _referenced_relation_ WHERE
|
||||
* Pkey1 = $1 [AND Pkey2 = $2 [...]]
|
||||
*/
|
||||
sprintf(sql, "select 1 from %s where ", relname);
|
||||
for (i = 0; i < nkeys; i++)
|
||||
{
|
||||
sprintf(sql + strlen(sql), "%s = $%d %s",
|
||||
args[i + nkeys + 1], i + 1, (i < nkeys - 1) ? "and " : "");
|
||||
}
|
||||
|
||||
/* Prepare plan for query */
|
||||
pplan = SPI_prepare(sql, nkeys, argtypes);
|
||||
if (pplan == NULL)
|
||||
elog(WARN, "check_primary_key: SPI_prepare returned %d", SPI_result);
|
||||
|
||||
/*
|
||||
* Remember that SPI_prepare places plan in current memory context
|
||||
* - so, we have to save plan in Top memory context for latter
|
||||
* use.
|
||||
*/
|
||||
pplan = SPI_saveplan(pplan);
|
||||
if (pplan == NULL)
|
||||
elog(WARN, "check_primary_key: SPI_saveplan returned %d", SPI_result);
|
||||
plan->splan = (void **) malloc(sizeof(void *));
|
||||
*(plan->splan) = pplan;
|
||||
plan->nplans = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ok, execute prepared plan.
|
||||
*/
|
||||
ret = SPI_execp(*(plan->splan), kvals, NULL, 1);
|
||||
/* we have no NULLs - so we pass ^^^^ here */
|
||||
|
||||
if (ret < 0)
|
||||
elog(WARN, "check_primary_key: SPI_execp returned %d", ret);
|
||||
|
||||
/*
|
||||
* If there are no tuples returned by SELECT then ...
|
||||
*/
|
||||
if (SPI_processed == 0)
|
||||
elog(WARN, "%s: tuple references non-existing key in %s",
|
||||
trigger->tgname, relname);
|
||||
|
||||
SPI_finish();
|
||||
|
||||
return (tuple);
|
||||
}
|
||||
|
||||
/*
|
||||
* check_foreign_key () -- check that key in tuple being deleted/updated
|
||||
* is not referenced by tuples in "foreign" table(s).
|
||||
* Though it's called without args You have to specify (while creating trigger):
|
||||
* number of references, action to do if key referenced
|
||||
* ('restrict' | 'setnull' | 'cascade'), key field names in triggered
|
||||
* ("primary") table and referencing table(s)/keys:
|
||||
* EXECUTE PROCEDURE
|
||||
* check_foreign_key (2, 'restrict', 'Pkey1', 'Pkey2',
|
||||
* 'Ftable1', 'Fkey11', 'Fkey12', 'Ftable2', 'Fkey21', 'Fkey22').
|
||||
*/
|
||||
|
||||
HeapTuple /* have to return HeapTuple to Executor */
|
||||
check_foreign_key()
|
||||
{
|
||||
Trigger *trigger; /* to get trigger name */
|
||||
int nargs; /* # of args specified in CREATE TRIGGER */
|
||||
char **args; /* arguments: as described above */
|
||||
int nrefs; /* number of references (== # of plans) */
|
||||
char action; /* 'R'estrict | 'S'etnull | 'C'ascade */
|
||||
int nkeys; /* # of key columns */
|
||||
char **kvals; /* key values */
|
||||
char *relname; /* referencing relation name */
|
||||
Relation rel; /* triggered relation */
|
||||
HeapTuple trigtuple = NULL; /* tuple to being changed */
|
||||
HeapTuple newtuple = NULL;/* tuple to return */
|
||||
TupleDesc tupdesc; /* tuple description */
|
||||
EPlan *plan; /* prepared plan(s) */
|
||||
Oid *argtypes = NULL;/* key types to prepare execution plan */
|
||||
bool isnull; /* to know is some column NULL or not */
|
||||
bool isequal = true; /* are keys in both tuples equal (in
|
||||
* UPDATE) */
|
||||
char ident[2 * NAMEDATALEN]; /* to identify myself */
|
||||
int ret;
|
||||
int i,
|
||||
r;
|
||||
|
||||
/*
|
||||
* Some checks first...
|
||||
*/
|
||||
|
||||
/* Called by trigger manager ? */
|
||||
if (!CurrentTriggerData)
|
||||
elog(WARN, "check_foreign_key: triggers are not initialized");
|
||||
|
||||
/* Should be called for ROW trigger */
|
||||
if (TRIGGER_FIRED_FOR_STATEMENT(CurrentTriggerData->tg_event))
|
||||
elog(WARN, "check_foreign_key: can't process STATEMENT events");
|
||||
|
||||
/* Not should be called for INSERT */
|
||||
if (TRIGGER_FIRED_BY_INSERT(CurrentTriggerData->tg_event))
|
||||
|
||||
elog(WARN, "check_foreign_key: can't process INSERT events");
|
||||
|
||||
/* Have to check tg_trigtuple - tuple being deleted */
|
||||
trigtuple = CurrentTriggerData->tg_trigtuple;
|
||||
|
||||
/*
|
||||
* But if this is UPDATE then we have to return tg_newtuple. Also, if
|
||||
* key in tg_newtuple is the same as in tg_trigtuple then nothing to
|
||||
* do.
|
||||
*/
|
||||
if (TRIGGER_FIRED_BY_UPDATE(CurrentTriggerData->tg_event))
|
||||
newtuple = CurrentTriggerData->tg_newtuple;
|
||||
|
||||
trigger = CurrentTriggerData->tg_trigger;
|
||||
nargs = trigger->tgnargs;
|
||||
args = trigger->tgargs;
|
||||
|
||||
if (nargs < 5) /* nrefs, action, key, Relation, key - at
|
||||
* least */
|
||||
elog(WARN, "check_foreign_key: too short %d (< 5) list of arguments", nargs);
|
||||
nrefs = pg_atoi(args[0], sizeof(int), 0);
|
||||
if (nrefs < 1)
|
||||
elog(WARN, "check_foreign_key: %d (< 1) number of references specified", nrefs);
|
||||
action = tolower(*(args[1]));
|
||||
if (action != 'r' && action != 'c' && action != 's')
|
||||
elog(WARN, "check_foreign_key: invalid action %s", args[1]);
|
||||
nargs -= 2;
|
||||
args += 2;
|
||||
nkeys = (nargs - nrefs) / (nrefs + 1);
|
||||
if (nkeys <= 0 || nargs != (nrefs + nkeys * (nrefs + 1)))
|
||||
elog(WARN, "check_foreign_key: invalid number of arguments %d for %d references",
|
||||
nargs + 2, nrefs);
|
||||
|
||||
rel = CurrentTriggerData->tg_relation;
|
||||
tupdesc = rel->rd_att;
|
||||
|
||||
/*
|
||||
* Setting CurrentTriggerData to NULL prevents direct calls to trigger
|
||||
* functions in queries. Normally, trigger functions have to be called
|
||||
* by trigger manager code only.
|
||||
*/
|
||||
CurrentTriggerData = NULL;
|
||||
|
||||
/* Connect to SPI manager */
|
||||
if ((ret = SPI_connect()) < 0)
|
||||
elog(WARN, "check_foreign_key: SPI_connect returned %d", ret);
|
||||
|
||||
/*
|
||||
* We use SPI plan preparation feature, so allocate space to place key
|
||||
* values.
|
||||
*/
|
||||
kvals = (char **) palloc(nkeys * sizeof(char *));
|
||||
|
||||
/*
|
||||
* Construct ident string as TriggerName $ TriggeredRelationId and try
|
||||
* to find prepared execution plan(s).
|
||||
*/
|
||||
sprintf(ident, "%s$%u", trigger->tgname, rel->rd_id);
|
||||
plan = find_plan(ident, &FPlans, &nFPlans);
|
||||
|
||||
/* if there is no plan(s) then allocate argtypes for preparation */
|
||||
if (plan->nplans <= 0)
|
||||
argtypes = (Oid *) palloc(nkeys * sizeof(Oid));
|
||||
|
||||
/*
|
||||
* else - check that we have exactly nrefs plan(s) ready
|
||||
*/
|
||||
else if (plan->nplans != nrefs)
|
||||
elog(WARN, "%s: check_foreign_key: # of plans changed in meantime",
|
||||
trigger->tgname);
|
||||
|
||||
/* For each column in key ... */
|
||||
for (i = 0; i < nkeys; i++)
|
||||
{
|
||||
/* get index of column in tuple */
|
||||
int fnumber = SPI_fnumber(tupdesc, args[i]);
|
||||
|
||||
/* Bad guys may give us un-existing column in CREATE TRIGGER */
|
||||
if (fnumber < 0)
|
||||
elog(WARN, "check_foreign_key: there is no attribute %s in relation %s",
|
||||
args[i], SPI_getrelname(rel));
|
||||
|
||||
/* Well, get binary (in internal format) value of column */
|
||||
kvals[i] = SPI_getbinval(trigtuple, tupdesc, fnumber, &isnull);
|
||||
|
||||
/*
|
||||
* If it's NULL then nothing to do! DON'T FORGET call SPI_finish
|
||||
* ()! DON'T FORGET return tuple! Executor inserts tuple you're
|
||||
* returning! If you return NULL then nothing will be inserted!
|
||||
*/
|
||||
if (isnull)
|
||||
{
|
||||
SPI_finish();
|
||||
return ((newtuple == NULL) ? trigtuple : newtuple);
|
||||
}
|
||||
|
||||
/*
|
||||
* If UPDATE then get column value from new tuple being inserted
|
||||
* and compare is this the same as old one. For the moment we use
|
||||
* string presentation of values...
|
||||
*/
|
||||
if (newtuple != NULL)
|
||||
{
|
||||
char *oldval = SPI_getvalue(trigtuple, tupdesc, fnumber);
|
||||
char *newval;
|
||||
|
||||
/* this shouldn't happen! SPI_ERROR_NOOUTFUNC ? */
|
||||
if (oldval == NULL)
|
||||
elog(WARN, "check_foreign_key: SPI_getvalue returned %d", SPI_result);
|
||||
newval = SPI_getvalue(newtuple, tupdesc, fnumber);
|
||||
if (newval == NULL || strcmp(oldval, newval) != 0)
|
||||
isequal = false;
|
||||
}
|
||||
|
||||
if (plan->nplans <= 0) /* Get typeId of column */
|
||||
argtypes[i] = SPI_gettypeid(tupdesc, fnumber);
|
||||
}
|
||||
nargs -= nkeys;
|
||||
args += nkeys;
|
||||
|
||||
/*
|
||||
* If we have to prepare plans ...
|
||||
*/
|
||||
if (plan->nplans <= 0)
|
||||
{
|
||||
void *pplan;
|
||||
char sql[8192];
|
||||
char **args2 = args;
|
||||
|
||||
plan->splan = (void **) malloc(nrefs * sizeof(void *));
|
||||
|
||||
for (r = 0; r < nrefs; r++)
|
||||
{
|
||||
relname = args2[0];
|
||||
|
||||
/*
|
||||
* For 'R'estrict action we construct SELECT query - SELECT 1
|
||||
* FROM _referencing_relation_ WHERE Fkey1 = $1 [AND Fkey2 =
|
||||
* $2 [...]] - to check is tuple referenced or not.
|
||||
*/
|
||||
if (action == 'r')
|
||||
|
||||
sprintf(sql, "select 1 from %s where ", relname);
|
||||
|
||||
/*
|
||||
* For 'C'ascade action we construct DELETE query - DELETE
|
||||
* FROM _referencing_relation_ WHERE Fkey1 = $1 [AND Fkey2 =
|
||||
* $2 [...]] - to delete all referencing tuples.
|
||||
*/
|
||||
else if (action == 'c')
|
||||
|
||||
sprintf(sql, "delete from %s where ", relname);
|
||||
|
||||
/*
|
||||
* For 'S'etnull action we construct UPDATE query - UPDATE
|
||||
* _referencing_relation_ SET Fkey1 null [, Fkey2 null [...]]
|
||||
* WHERE Fkey1 = $1 [AND Fkey2 = $2 [...]] - to set key
|
||||
* columns in all referencing tuples to NULL.
|
||||
*/
|
||||
else if (action == 's')
|
||||
{
|
||||
sprintf(sql, "update %s set ", relname);
|
||||
for (i = 1; i <= nkeys; i++)
|
||||
{
|
||||
sprintf(sql + strlen(sql), "%s null%s",
|
||||
args2[i], (i < nkeys) ? ", " : "");
|
||||
}
|
||||
strcat(sql, " where ");
|
||||
}
|
||||
|
||||
/* Construct WHERE qual */
|
||||
for (i = 1; i <= nkeys; i++)
|
||||
{
|
||||
sprintf(sql + strlen(sql), "%s = $%d %s",
|
||||
args2[i], i, (i < nkeys) ? "and " : "");
|
||||
}
|
||||
|
||||
/* Prepare plan for query */
|
||||
pplan = SPI_prepare(sql, nkeys, argtypes);
|
||||
if (pplan == NULL)
|
||||
elog(WARN, "check_foreign_key: SPI_prepare returned %d", SPI_result);
|
||||
|
||||
/*
|
||||
* Remember that SPI_prepare places plan in current memory
|
||||
* context - so, we have to save plan in Top memory context
|
||||
* for latter use.
|
||||
*/
|
||||
pplan = SPI_saveplan(pplan);
|
||||
if (pplan == NULL)
|
||||
elog(WARN, "check_foreign_key: SPI_saveplan returned %d", SPI_result);
|
||||
|
||||
plan->splan[r] = pplan;
|
||||
|
||||
args2 += nkeys + 1; /* to the next relation */
|
||||
}
|
||||
plan->nplans = nrefs;
|
||||
}
|
||||
|
||||
/*
|
||||
* If UPDATE and key is not changed ...
|
||||
*/
|
||||
if (newtuple != NULL && isequal)
|
||||
{
|
||||
SPI_finish();
|
||||
return (newtuple);
|
||||
}
|
||||
|
||||
/*
|
||||
* Ok, execute prepared plan(s).
|
||||
*/
|
||||
for (r = 0; r < nrefs; r++)
|
||||
{
|
||||
|
||||
/*
|
||||
* For 'R'estrict we may to execute plan for one tuple only, for
|
||||
* other actions - for all tuples.
|
||||
*/
|
||||
int tcount = (action == 'r') ? 1 : 0;
|
||||
|
||||
relname = args[0];
|
||||
|
||||
ret = SPI_execp(plan->splan[r], kvals, NULL, tcount);
|
||||
/* we have no NULLs - so we pass ^^^^ here */
|
||||
|
||||
if (ret < 0)
|
||||
elog(WARN, "check_foreign_key: SPI_execp returned %d", ret);
|
||||
|
||||
/* If action is 'R'estrict ... */
|
||||
if (action == 'r')
|
||||
{
|
||||
/* If there is tuple returned by SELECT then ... */
|
||||
if (SPI_processed > 0)
|
||||
elog(WARN, "%s: tuple referenced in %s",
|
||||
trigger->tgname, relname);
|
||||
}
|
||||
#ifndef REFINT_QUIET
|
||||
else
|
||||
elog(NOTICE, "%s: %d tuple(s) of %s are %s",
|
||||
trigger->tgname, SPI_processed, relname,
|
||||
(action == 'c') ? "deleted" : "setted to null");
|
||||
#endif
|
||||
args += nkeys + 1; /* to the next relation */
|
||||
}
|
||||
|
||||
SPI_finish();
|
||||
|
||||
return ((newtuple == NULL) ? trigtuple : newtuple);
|
||||
}
|
||||
|
||||
static EPlan *
|
||||
find_plan(char *ident, EPlan ** eplan, int *nplans)
|
||||
{
|
||||
EPlan *newp;
|
||||
int i;
|
||||
|
||||
if (*nplans > 0)
|
||||
{
|
||||
for (i = 0; i < *nplans; i++)
|
||||
{
|
||||
if (strcmp((*eplan)[i].ident, ident) == 0)
|
||||
break;
|
||||
}
|
||||
if (i != *nplans)
|
||||
return (*eplan + i);
|
||||
*eplan = (EPlan *) realloc(*eplan, (i + 1) * sizeof(EPlan));
|
||||
newp = *eplan + i;
|
||||
}
|
||||
else
|
||||
{
|
||||
newp = *eplan = (EPlan *) malloc(sizeof(EPlan));
|
||||
(*nplans) = i = 0;
|
||||
}
|
||||
|
||||
newp->ident = (char *) malloc(strlen(ident) + 1);
|
||||
strcpy(newp->ident, ident);
|
||||
newp->nplans = 0;
|
||||
newp->splan = NULL;
|
||||
(*nplans)++;
|
||||
|
||||
return (newp);
|
||||
}
|
||||
14
contrib/spi/refint.source
Normal file
14
contrib/spi/refint.source
Normal file
@ -0,0 +1,14 @@
|
||||
DROP FUNCTION check_primary_key ();
|
||||
DROP FUNCTION check_foreign_key ();
|
||||
|
||||
CREATE FUNCTION check_primary_key ()
|
||||
RETURNS opaque
|
||||
AS '_OBJWD_/refint_DLSUFFIX_'
|
||||
LANGUAGE 'c'
|
||||
;
|
||||
|
||||
CREATE FUNCTION check_foreign_key ()
|
||||
RETURNS opaque
|
||||
AS '_OBJWD_/refint_DLSUFFIX_'
|
||||
LANGUAGE 'c'
|
||||
;
|
||||
Loading…
Reference in New Issue
Block a user