database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-30 11:03:19 +03:00
Code Activity

SQL/MED catalog manipulation facilities

Browse Source 
This doesn't do any remote or external things yet, but it gives modules
like plproxy and dblink a standardized and future-proof system for
managing their connection information.

Martin Pihlak and Peter Eisentraut
This commit is contained in:
Peter Eisentraut
2008-12-19 16:25:19 +00:00
parent 1eec10a2de
commit cae565e503
76 changed files with 8452 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
src/backend/nodes/copyfuncs.c
View File

@ -15,7 +15,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.415 2008/12/04 17:51:26 petere Exp $
* $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.416 2008/12/19 16:25:17 petere Exp $
*
*-------------------------------------------------------------------------
*/
@ -2033,6 +2033,17 @@ _copyDefElem(DefElem *from)
return newnode;
}
static OptionDefElem *
_copyOptionDefElem(OptionDefElem *from)
{
OptionDefElem *newnode = makeNode(OptionDefElem);
COPY_SCALAR_FIELD(alter_op);
COPY_NODE_FIELD(def);
return newnode;
}
static LockingClause *
_copyLockingClause(LockingClause *from)
{
@ -2869,6 +2880,117 @@ _copyDropTableSpaceStmt(DropTableSpaceStmt *from)
return newnode;
}
static CreateFdwStmt *
_copyCreateFdwStmt(CreateFdwStmt *from)
{
CreateFdwStmt *newnode = makeNode(CreateFdwStmt);
COPY_STRING_FIELD(fdwname);
COPY_STRING_FIELD(library);
COPY_NODE_FIELD(options);
return newnode;
}
static AlterFdwStmt *
_copyAlterFdwStmt(AlterFdwStmt *from)
{
AlterFdwStmt *newnode = makeNode(AlterFdwStmt);
COPY_STRING_FIELD(fdwname);
COPY_STRING_FIELD(library);
COPY_NODE_FIELD(options);
return newnode;
}
static DropFdwStmt *
_copyDropFdwStmt(DropFdwStmt *from)
{
DropFdwStmt *newnode = makeNode(DropFdwStmt);
COPY_STRING_FIELD(fdwname);
COPY_SCALAR_FIELD(missing_ok);
COPY_SCALAR_FIELD(behavior);
return newnode;
}
static CreateForeignServerStmt *
_copyCreateForeignServerStmt(CreateForeignServerStmt *from)
{
CreateForeignServerStmt *newnode = makeNode(CreateForeignServerStmt);
COPY_STRING_FIELD(servername);
COPY_STRING_FIELD(servertype);
COPY_STRING_FIELD(version);
COPY_STRING_FIELD(fdwname);
COPY_NODE_FIELD(options);
return newnode;
}
static AlterForeignServerStmt *
_copyAlterForeignServerStmt(AlterForeignServerStmt *from)
{
AlterForeignServerStmt *newnode = makeNode(AlterForeignServerStmt);
COPY_STRING_FIELD(servername);
COPY_STRING_FIELD(version);
COPY_NODE_FIELD(options);
COPY_SCALAR_FIELD(has_version);
return newnode;
}
static DropForeignServerStmt *
_copyDropForeignServerStmt(DropForeignServerStmt *from)
{
DropForeignServerStmt *newnode = makeNode(DropForeignServerStmt);
COPY_STRING_FIELD(servername);
COPY_SCALAR_FIELD(missing_ok);
COPY_SCALAR_FIELD(behavior);
return newnode;
}
static CreateUserMappingStmt *
_copyCreateUserMappingStmt(CreateUserMappingStmt *from)
{
CreateUserMappingStmt *newnode = makeNode(CreateUserMappingStmt);
COPY_STRING_FIELD(username);
COPY_STRING_FIELD(servername);
COPY_NODE_FIELD(options);
return newnode;
}
static AlterUserMappingStmt *
_copyAlterUserMappingStmt(AlterUserMappingStmt *from)
{
AlterUserMappingStmt *newnode = makeNode(AlterUserMappingStmt);
COPY_STRING_FIELD(username);
COPY_STRING_FIELD(servername);
COPY_NODE_FIELD(options);
return newnode;
}
static DropUserMappingStmt *
_copyDropUserMappingStmt(DropUserMappingStmt *from)
{
DropUserMappingStmt *newnode = makeNode(DropUserMappingStmt);
COPY_STRING_FIELD(username);
COPY_STRING_FIELD(servername);
COPY_SCALAR_FIELD(missing_ok);
return newnode;
}
static CreateTrigStmt *
_copyCreateTrigStmt(CreateTrigStmt *from)
{
@ -3696,6 +3818,33 @@ copyObject(void *from)
case T_DropTableSpaceStmt:
retval = _copyDropTableSpaceStmt(from);
break;
case T_CreateFdwStmt:
retval = _copyCreateFdwStmt(from);
break;
case T_AlterFdwStmt:
retval = _copyAlterFdwStmt(from);
break;
case T_DropFdwStmt:
retval = _copyDropFdwStmt(from);
break;
case T_CreateForeignServerStmt:
retval = _copyCreateForeignServerStmt(from);
break;
case T_AlterForeignServerStmt:
retval = _copyAlterForeignServerStmt(from);
break;
case T_DropForeignServerStmt:
retval = _copyDropForeignServerStmt(from);
break;
case T_CreateUserMappingStmt:
retval = _copyCreateUserMappingStmt(from);
break;
case T_AlterUserMappingStmt:
retval = _copyAlterUserMappingStmt(from);
break;
case T_DropUserMappingStmt:
retval = _copyDropUserMappingStmt(from);
break;
case T_CreateTrigStmt:
retval = _copyCreateTrigStmt(from);
break;
@ -3823,6 +3972,9 @@ copyObject(void *from)
case T_DefElem:
retval = _copyDefElem(from);
break;
case T_OptionDefElem:
retval = _copyOptionDefElem(from);
break;
case T_LockingClause:
retval = _copyLockingClause(from);
break;

134
src/backend/nodes/equalfuncs.c
View File

@ -22,7 +22,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.340 2008/12/04 17:51:26 petere Exp $
* $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.341 2008/12/19 16:25:17 petere Exp $
*
*-------------------------------------------------------------------------
*/
@ -1518,6 +1518,99 @@ _equalDropTableSpaceStmt(DropTableSpaceStmt *a, DropTableSpaceStmt *b)
return true;
}
static bool
_equalCreateFdwStmt(CreateFdwStmt *a, CreateFdwStmt *b)
{
COMPARE_STRING_FIELD(fdwname);
COMPARE_STRING_FIELD(library);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
_equalAlterFdwStmt(AlterFdwStmt *a, AlterFdwStmt *b)
{
COMPARE_STRING_FIELD(fdwname);
COMPARE_STRING_FIELD(library);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
_equalDropFdwStmt(DropFdwStmt *a, DropFdwStmt *b)
{
COMPARE_STRING_FIELD(fdwname);
COMPARE_SCALAR_FIELD(missing_ok);
COMPARE_SCALAR_FIELD(behavior);
return true;
}
static bool
_equalCreateForeignServerStmt(CreateForeignServerStmt *a, CreateForeignServerStmt *b)
{
COMPARE_STRING_FIELD(servername);
COMPARE_STRING_FIELD(servertype);
COMPARE_STRING_FIELD(version);
COMPARE_STRING_FIELD(fdwname);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
_equalAlterForeignServerStmt(AlterForeignServerStmt *a, AlterForeignServerStmt *b)
{
COMPARE_STRING_FIELD(servername);
COMPARE_STRING_FIELD(version);
COMPARE_NODE_FIELD(options);
COMPARE_SCALAR_FIELD(has_version);
return true;
}
static bool
_equalDropForeignServerStmt(DropForeignServerStmt *a, DropForeignServerStmt *b)
{
COMPARE_STRING_FIELD(servername);
COMPARE_SCALAR_FIELD(missing_ok);
COMPARE_SCALAR_FIELD(behavior);
return true;
}
static bool
_equalCreateUserMappingStmt(CreateUserMappingStmt *a, CreateUserMappingStmt *b)
{
COMPARE_STRING_FIELD(username);
COMPARE_STRING_FIELD(servername);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
_equalAlterUserMappingStmt(AlterUserMappingStmt *a, AlterUserMappingStmt *b)
{
COMPARE_STRING_FIELD(username);
COMPARE_STRING_FIELD(servername);
COMPARE_NODE_FIELD(options);
return true;
}
static bool
_equalDropUserMappingStmt(DropUserMappingStmt *a, DropUserMappingStmt *b)
{
COMPARE_STRING_FIELD(username);
COMPARE_STRING_FIELD(servername);
COMPARE_SCALAR_FIELD(missing_ok);
return true;
}
static bool
_equalCreateTrigStmt(CreateTrigStmt *a, CreateTrigStmt *b)
{
@ -1956,6 +2049,15 @@ _equalDefElem(DefElem *a, DefElem *b)
return true;
}
static bool
_equalOptionDefElem(OptionDefElem *a, OptionDefElem *b)
{
COMPARE_SCALAR_FIELD(alter_op);
COMPARE_NODE_FIELD(def);
return true;
}
static bool
_equalLockingClause(LockingClause *a, LockingClause *b)
{
@ -2534,6 +2636,33 @@ equal(void *a, void *b)
case T_DropTableSpaceStmt:
retval = _equalDropTableSpaceStmt(a, b);
break;
case T_CreateFdwStmt:
retval = _equalCreateFdwStmt(a, b);
break;
case T_AlterFdwStmt:
retval = _equalAlterFdwStmt(a, b);
break;
case T_DropFdwStmt:
retval = _equalDropFdwStmt(a, b);
break;
case T_CreateForeignServerStmt:
retval = _equalCreateForeignServerStmt(a, b);
break;
case T_AlterForeignServerStmt:
retval = _equalAlterForeignServerStmt(a, b);
break;
case T_DropForeignServerStmt:
retval = _equalDropForeignServerStmt(a, b);
break;
case T_CreateUserMappingStmt:
retval = _equalCreateUserMappingStmt(a, b);
break;
case T_AlterUserMappingStmt:
retval = _equalAlterUserMappingStmt(a, b);
break;
case T_DropUserMappingStmt:
retval = _equalDropUserMappingStmt(a, b);
break;
case T_CreateTrigStmt:
retval = _equalCreateTrigStmt(a, b);
break;
@ -2661,6 +2790,9 @@ equal(void *a, void *b)
case T_DefElem:
retval = _equalDefElem(a, b);
break;
case T_OptionDefElem:
retval = _equalOptionDefElem(a, b);
break;
case T_LockingClause:
retval = _equalLockingClause(a, b);
break;

15
src/backend/nodes/makefuncs.c
View File

@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/nodes/makefuncs.c,v 1.60 2008/09/01 20:42:44 tgl Exp $
* $PostgreSQL: pgsql/src/backend/nodes/makefuncs.c,v 1.61 2008/12/19 16:25:17 petere Exp $
*
*-------------------------------------------------------------------------
*/
@ -361,3 +361,16 @@ makeDefElem(char *name, Node *arg)
res->arg = arg;
return res;
}
/*
* makeOptionDefElem -
* build an OptionDefElem node
*/
OptionDefElem *
makeOptionDefElem(int op, DefElem *def)
{
OptionDefElem *res = makeNode(OptionDefElem);
res->alter_op = op;
res->def = def;
return res;
}