diff -cNr -x CVS cvs-pgsql/doc/src/sgml/catalogs.sgml pgsql/doc/src/sgml/catalogs.sgml
*** cvs-pgsql/doc/src/sgml/catalogs.sgml Mon Nov 24 09:49:51 2008
--- pgsql/doc/src/sgml/catalogs.sgml Fri Dec 12 10:44:15 2008
***************
*** 134,139 ****
--- 134,149 ----
+ pg_foreign_data_wrapper
+ foreign-data wrapper definitions
+
+
+
+ pg_foreign_server
+ foreign server definitions
+
+
+ pg_indexadditional index information
***************
*** 247,252 ****
--- 257,267 ----
pg_typedata types
+
+
+ pg_user_mapping
+ mappings of users to foreign servers
+
***************
*** 2552,2557 ****
--- 2567,2795 ----
+
+ <structname>pg_foreign_data_wrapper</structname>
+
+
+ pg_foreign_data_wrapper
+
+
+
+ The catalog pg_foreign_data_wrapper stores
+ foreign-data wrapper definitions. A foreign-data wrapper is the
+ mechanism by which external data, residing on foreign servers, is
+ accessed.
+
+
+
+ <structname>pg_foreign_data_wrapper</> Columns
+
+
+
+
+ Name
+ Type
+ References
+ Description
+
+
+
+
+
+ fdwname
+ name
+
+ Name of the foreign-data wrapper
+
+
+
+ fdwowner
+ oid
+ pg_authid.oid
+ Owner of the foreign-data wrapper
+
+
+
+ fdwlibrary
+ text
+
+ The library implementing this foreign-data wrapper
+
+
+
+ fdwacl
+ aclitem[]
+
+
+ Access privileges; see
+ and
+
+ for details
+
+
+
+
+ fdwoptions
+ text[]
+
+
+ Foreign-data wrapper specific options, as keyword=value strings
+
+
+
+
+
+
+
+
+
+ <structname>pg_foreign_server</structname>
+
+
+ pg_foreign_server
+
+
+
+ The catalog pg_foreign_server stores
+ foreign server definitions. A foreign server describes the
+ connection to a remote server, managing external data. Foreign
+ servers are accessed via foreign-data wrappers.
+
+
+
+ <structname>pg_foreign_server</> Columns
+
+
+
+
+ Name
+ Type
+ References
+ Description
+
+
+
+
+
+ srvname
+ name
+
+ Name of the foreign server
+
+
+
+ srvowner
+ oid
+ pg_authid.oid
+ Owner of the foreign server
+
+
+
+ srvfdw
+ oid
+ pg_foreign_data_wrapper.oid
+ The OID of the foreign-data wrapper of this foreign server
+
+
+
+ srvtype
+ text
+
+ Type of the server (optional)
+
+
+
+ srvversion
+ text
+
+ Version of the server (optional)
+
+
+
+ srvacl
+ aclitem[]
+
+
+ Access privileges; see
+ and
+
+ for details
+
+
+
+
+ srvoptions
+ text[]
+
+
+ Foreign server specific options, as keyword=value strings.
+
+
+
+
+
+
+
+
+
+ <structname>pg_user_mapping</structname>
+
+
+ pg_user_mapping
+
+
+
+ The catalog pg_user_mapping stores
+ the mappings from local user to remote. Access to this catalog is
+ restricted from normal users, use the view
+ pg_user_mappings
+ instead.
+
+
+
+ <structname>pg_user_mapping</> Columns
+
+
+
+
+ Name
+ Type
+ References
+ Description
+
+
+
+
+
+ umuser
+ oid
+ pg_authid.oid
+ OID of the local role to be mapped, 0 if the user mapping is public
+
+
+
+ umserver
+ oid
+ pg_foreign_server.oid
+
+ The OID of the foreign server that contains this mapping
+
+
+
+
+ umoptions
+ text[]
+
+
+ User mapping specific options, as keyword=value strings.
+
+
+
+
+
+
+
+
<structname>pg_index</structname>
***************
*** 6998,7003 ****
--- 7236,7314 ----
+
+ <structname>pg_user_mappings</structname>
+
+
+ pg_user_mappings
+
+
+
+ The view pg_user_mappings provides access
+ to information about user mappings. This is essentially a publicly
+ readable view of
+ pg_user_mapping
+ that leaves out the options field.
+
+
+
+ <structname>pg_user_mappings</> Columns
+
+
+
+
+ Name
+ Type
+ References
+ Description
+
+
+
+
+
+ umid
+ oid
+ pg_user_mapping.oid
+ OID of the user mapping
+
+
+
+ srvid
+ oid
+ pg_foreign_server.oid
+
+ The OID of the foreign server that contains this mapping
+
+
+
+
+ srvname
+ text
+
+
+ Name of the foreign server
+
+
+
+
+ umuser
+ oid
+ pg_authid.oid
+ OID of the local role to be mapped, 0 if the user mapping is public
+
+
+
+ usename
+ name
+
+ Name of the local user to be mapped
+
+
+
+
+
+
+
<structname>pg_views</structname>
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/features.sgml pgsql/doc/src/sgml/features.sgml
*** cvs-pgsql/doc/src/sgml/features.sgml Mon Dec 1 10:24:54 2008
--- pgsql/doc/src/sgml/features.sgml Fri Dec 12 10:44:15 2008
***************
*** 71,81 ****
! The PostgreSQL core covers parts 1, 2,
11, and 14. Part 3 is covered by the ODBC driver, and part 13 is
covered by the PL/Java plug-in, but exact conformance is currently
not being verified for these components. There are currently no
! implementations of parts 4, 9, and 10
for PostgreSQL.
--- 71,81 ----
! The PostgreSQL core covers parts 1, 2, 9,
11, and 14. Part 3 is covered by the ODBC driver, and part 13 is
covered by the PL/Java plug-in, but exact conformance is currently
not being verified for these components. There are currently no
! implementations of parts 4 and 10
for PostgreSQL.
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/func.sgml pgsql/doc/src/sgml/func.sgml
*** cvs-pgsql/doc/src/sgml/func.sgml Fri Dec 5 15:06:21 2008
--- pgsql/doc/src/sgml/func.sgml Fri Dec 12 13:41:36 2008
***************
*** 11336,11341 ****
--- 11336,11356 ----
does current user have privilege for database
+ has_foreign_data_wrapper_privilege(user,
+ fdw,
+ privilege)
+
+ boolean
+ does user have privilege for foreign-data wrapper
+
+
+ has_foreign_data_wrapper_privilege(fdw,
+ privilege)
+
+ boolean
+ does current user have privilege for foreign-data wrapper
+
+ has_function_privilege(user,
function,
privilege)
***************
*** 11381,11386 ****
--- 11396,11416 ----
does current user have privilege for schema
+ has_server_privilege(user,
+ server,
+ privilege)
+
+ boolean
+ does user have privilege for foreign server
+
+
+ has_server_privilege(server,
+ privilege)
+
+ boolean
+ does current user have privilege for foreign server
+
+ has_table_privilege(user,
table,
privilege)
***************
*** 11436,11447 ****
--- 11466,11483 ----
has_function_privilege
+ has_foreign_data_wrapper_privilege
+
+ has_language_privilegehas_schema_privilege
+ has_server_privilege
+
+ has_table_privilege
***************
*** 11479,11484 ****
--- 11515,11528 ----
+ has_foreign_data_wrapper_privilege checks whether a user
+ can access a foreign-data wrapper in a particular way. The possibilities for its
+ arguments are analogous to has_table_privilege.
+ The desired access privilege type must evaluate to
+ USAGE.
+
+
+ has_language_privilege checks whether a user
can access a procedural language in a particular way. The possibilities
for its arguments are analogous to has_table_privilege.
***************
*** 11496,11501 ****
--- 11540,11553 ----
+ has_server_privilege checks whether a user
+ can access a foreign server in a particular way. The possibilities for its
+ arguments are analogous to has_table_privilege.
+ The desired access privilege type must evaluate to
+ USAGE.
+
+
+ has_table_privilege checks whether a user
can access a table in a particular way. The user can be
specified by name or by OID
***************
*** 12974,12979 ****
--- 13026,13125 ----
at session end, even if the client disconnects ungracefully.)
+
+ The functions shown
+ in provide
+ information about connections to foreign databases.
+
+
+
+ Remote Connection Information Functions
+
+
+
+ Name
+ Return Type
+ Description
+
+
+
+
+
+
+ pg_get_remote_connection_info(server_name text)
+
+ setof record
+ Fetch information about connection to remote database
+
+
+
+
+ pg_get_remote_connection_info(server_name text, usernametext)
+
+ setof record
+ Fetch information about connection to remote database, use the mapping for specified username
+
+
+
+
+ pg_get_foreign_data_wrapper_options(fdwid oid)
+
+ setof record
+ Fetch options for foreign-data wrapper
+
+
+
+
+ pg_get_foreign_server_options(srvid oid)
+
+ setof record
+ Fetch options for foreign server
+
+
+
+
+ pg_get_user_mapping_options(umid oid)
+
+ setof record
+ Fetch options for user mapping
+
+
+
+
+
+
+ pg_get_remote_connection_infopg_get_remote_connection_info
+ fetches the connection information for the specified foreign
+ server. The options are processed through server's foreign-data
+ wrapper to form a valid connection string. User mapping
+ information is used to complement the server connection options.
+ In the two-parameter version, the mapping of the specified user
+ name is used, otherwise the mapping for current user is used. As
+ the output may contain information about remote user names and
+ passwords, users must explicitly be granted access to this
+ function.
+
+
+
+ pg_get_foreign_data_wrapper_optionspg_get_foreign_data_wrapper_options
+ fetches the generic options associated with the foreign-data
+ wrapper.
+
+
+
+ pg_get_foreign_server_optionspg_get_foreign_server_options
+ fetches the generic options associated with the foreign server.
+ Typically this includes the connection information to the remote
+ host and database.
+
+
+
+ pg_get_user_mapping_optionspg_get_user_mapping_options
+ fetches the generic options associated with the user mapping.
+ Typically this includes the user name and password of the remote
+ user. The calling user must be the owner of the server of the
+ mapping, otherwise an empty set is returned.
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/keywords.sgml pgsql/doc/src/sgml/keywords.sgml
*** cvs-pgsql/doc/src/sgml/keywords.sgml Fri Dec 5 15:06:21 2008
--- pgsql/doc/src/sgml/keywords.sgml Fri Dec 12 10:44:15 2008
***************
*** 2688,2693 ****
--- 2688,2701 ----
reserved
+ LIBRARY
+ non-reserved
+ non-reserved
+ non-reserved
+
+
+
+ LIKEreserved (can be function or type)reserved
***************
*** 2818,2825 ****
MAPPINGnon-reserved
!
!
--- 2826,2833 ----
MAPPINGnon-reserved
! non-reserved
! non-reserved
***************
*** 3441,3447 ****
OPTIONS
! non-reservednon-reservednon-reserved
--- 3449,3455 ----
OPTIONS
! non-reservednon-reservednon-reservednon-reserved
***************
*** 4456,4461 ****
--- 4464,4477 ----
non-reserved
+ SERVER
+ non-reserved
+ non-reserved
+ non-reserved
+
+
+
+ SERVER_NAMEnon-reserved
***************
*** 5584,5589 ****
--- 5600,5613 ----
reserved
+ WRAPPER
+ non-reserved
+ non-reserved
+ non-reserved
+
+
+
+ WRITEnon-reservednon-reserved
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/allfiles.sgml pgsql/doc/src/sgml/ref/allfiles.sgml
*** cvs-pgsql/doc/src/sgml/ref/allfiles.sgml Thu Mar 27 19:24:16 2008
--- pgsql/doc/src/sgml/ref/allfiles.sgml Fri Dec 12 10:44:15 2008
***************
*** 10,15 ****
--- 10,16 ----
+
***************
*** 19,24 ****
--- 20,26 ----
+
***************
*** 29,34 ****
--- 31,37 ----
+
***************
*** 45,50 ****
--- 48,54 ----
+
***************
*** 56,61 ****
--- 60,66 ----
+
***************
*** 66,71 ****
--- 71,77 ----
+
***************
*** 76,81 ****
--- 82,88 ----
+
***************
*** 88,93 ****
--- 95,101 ----
+
***************
*** 97,102 ****
--- 105,111 ----
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/alter_foreign_data_wrapper.sgml pgsql/doc/src/sgml/ref/alter_foreign_data_wrapper.sgml
*** cvs-pgsql/doc/src/sgml/ref/alter_foreign_data_wrapper.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/alter_foreign_data_wrapper.sgml Mon Dec 15 14:16:03 2008
***************
*** 0 ****
--- 1,132 ----
+
+
+
+
+ ALTER FOREIGN DATA WRAPPER
+ SQL - Language Statements
+
+
+
+ ALTER FOREIGN DATA WRAPPER
+ change the definition of a foreign-data wrapper
+
+
+
+ ALTER FOREIGN DATA WRAPPER
+
+
+
+
+ ALTER FOREIGN DATA WRAPPER name
+ LIBRARY 'libraryname'
+ [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ]) ]
+ ALTER FOREIGN DATA WRAPPER name OWNER TO new_owner
+
+
+
+
+ Description
+
+
+ ALTER FOREIGN DATA WRAPPER changes the
+ definition of a foreign-data wrapper. The first form of the
+ command changes the library or the generic options of the
+ foreign-data wrapper. The second form changes the owner of the
+ foreign-data wrapper.
+
+
+
+ Only superusers can alter foreign-data wrappers. Additionally,
+ only superusers can own foreign-data wrappers.
+
+
+
+
+ Parameters
+
+
+
+ name
+
+
+ The name of an existing foreign-data wrapper.
+
+
+
+
+
+ libraryname
+
+
+ New name of the foreign-data wrapper library.
+
+
+
+ Note that it is possible that after changing the library, the
+ options to the foreign-data wrapper, servers, and user mappings
+ have become invalid. It is up to the user to make sure that
+ these options are correct before using the foreign-data
+ wrapper.
+
+
+
+
+
+ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+
+
+ Change options for the foreign-data
+ wrapper. ADD, SET, and DROP
+ specify the action to be performed. ADD is assumed
+ if no operation is explicitly specified. Option names must be
+ unique; names and values are also validated using the foreign
+ data wrapper library.
+
+
+
+
+
+
+
+ Examples
+
+
+ Change a foreign-data wrapper dbi, add
+ option foo, drop bar:
+
+ ALTER FOREIGN DATA WRAPPER dbi OPTIONS (ADD foo '1', DROP 'bar');
+
+
+
+
+ Change the foreign-data wrapper dbi library
+ to /home/bob/mylibrary.so:
+
+ ALTER FOREIGN DATA WRAPPER dbi LIBRARY '/home/bob/mylibrary.so';
+
+
+
+
+
+ Compatibility
+
+
+ ALTER FOREIGN DATA WRAPPER conforms to ISO/IEC
+ 9075-9 (SQL/MED). The standard does not specify the OWNER
+ TO variant of the command.
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/alter_server.sgml pgsql/doc/src/sgml/ref/alter_server.sgml
*** cvs-pgsql/doc/src/sgml/ref/alter_server.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/alter_server.sgml Fri Dec 12 10:44:15 2008
***************
*** 0 ****
--- 1,123 ----
+
+
+
+
+ ALTER SERVER
+ SQL - Language Statements
+
+
+
+ ALTER SERVER
+ change the definition of a foreign server
+
+
+
+ ALTER SERVER
+
+
+
+
+ ALTER SERVER servername [ VERSION 'newversion' ]
+ [ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] ) ]
+ ALTER SERVER servername OWNER TO new_owner
+
+
+
+
+ Description
+
+
+ ALTER SERVER changes the definition of a foreign
+ server. The first form changes the server version string or the
+ generic options of the server. The second form changes the owner
+ of the server.
+
+
+
+ To alter the server you must be the owner of the server.
+ Additionally to alter the owner, you must own the server and also
+ be a direct or indirect member of the new owning role, and you must
+ have USAGE privilege on the server's foreign-data
+ wrapper. (Note that superusers satisfy all these criteria
+ automatically.)
+
+
+
+
+ Parameters
+
+
+
+ servername
+
+
+ The name of an existing server.
+
+
+
+
+
+ serverversion
+
+
+ New server version.
+
+
+
+
+
+ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+
+
+ Change options for the
+ server. ADD, SET, and DROP
+ specify the action to be performed. ADD is assumed
+ if no operation is explicitly specified. Option names must be
+ unique; names and values are also validated using the server's
+ foreign-data wrapper library.
+
+
+
+
+
+
+
+ Examples
+
+
+ Alter server foo, add connection options:
+
+ ALTER SERVER foo OPTIONS (host 'foo', dbname 'foodb');
+
+
+
+
+ Alter server foo, change version,
+ change host option:
+
+ ALTER SERVER foo VERSION '8.4' OPTIONS (SET host 'baz');
+
+
+
+
+
+ Compatibility
+
+
+ ALTER SERVER conforms to ISO/IEC 9075-9 (SQL/MED).
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/alter_user_mapping.sgml pgsql/doc/src/sgml/ref/alter_user_mapping.sgml
*** cvs-pgsql/doc/src/sgml/ref/alter_user_mapping.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/alter_user_mapping.sgml Fri Dec 12 11:53:02 2008
***************
*** 0 ****
--- 1,119 ----
+
+
+
+
+ ALTER USER MAPPING
+ SQL - Language Statements
+
+
+
+ ALTER USER MAPPING
+ change the definition of a user mapping
+
+
+
+ ALTER USER MAPPING
+
+
+
+
+ ALTER USER MAPPING FOR { username | USER | CURRENT_USER | PUBLIC }
+ SERVER servername
+ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+
+
+
+
+ Description
+
+
+ ALTER USER MAPPING changes the definition of a
+ user mapping. Only the owner of the server can change the user
+ mappings of that server.
+
+
+
+
+
+ Parameters
+
+
+
+ username
+
+
+ User name of the mapping. CURRENT_USER
+ and USER match the name of the current
+ user. PUBLIC is used to match all present and future
+ user names in the system.
+
+
+
+
+
+ servername
+
+
+ Server name of the user mapping.
+
+
+
+
+
+ OPTIONS ( [ ADD | SET | DROP ] option ['value'] [, ... ] )
+
+
+ Change options for the user mapping. The new options override
+ any previously specified
+ options. ADD, SET, and DROP
+ specify the action to be performed. ADD is assumed
+ if no operation is explicitly specified. Option names must be
+ unique; options are also validated by the server's foreign-data
+ wrapper.
+
+
+
+
+
+
+
+ Examples
+
+
+ Change the password for user mapping bob, server foo:
+
+ ALTER USER MAPPING FOR bob SERVER foo OPTIONS (user 'bob', password 'public');
+
+
+
+
+
+
+ Compatibility
+
+
+ ALTER USER MAPPING conforms to ISO/IEC 9075-9
+ (SQL/MED). There is a subtle syntax issue: The standard omits
+ the FOR key word. Since both CREATE
+ USER MAPPING and DROP USER MAPPING use
+ FOR in analogous positions, and IBM DB2 (being
+ the other major SQL/MED implementation) also requires it
+ for ALTER USER MAPPING, PostgreSQL diverges from
+ the standard here in the interest of consistency and
+ interoperability.
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/create_foreign_data_wrapper.sgml pgsql/doc/src/sgml/ref/create_foreign_data_wrapper.sgml
*** cvs-pgsql/doc/src/sgml/ref/create_foreign_data_wrapper.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/create_foreign_data_wrapper.sgml Mon Dec 15 14:16:02 2008
***************
*** 0 ****
--- 1,155 ----
+
+
+
+
+ CREATE FOREIGN DATA WRAPPER
+ SQL - Language Statements
+
+
+
+ CREATE FOREIGN DATA WRAPPER
+ define a new foreign-data wrapper
+
+
+
+ CREATE FOREIGN DATA WRAPPER
+
+
+
+
+ CREATE FOREIGN DATA WRAPPER name
+ LIBRARY 'libraryname'
+ LANGUAGE C
+ [ OPTIONS ( option 'value' [, ... ] ) ]
+
+
+
+
+ Description
+
+
+ CREATE FOREIGN DATA WRAPPER creates a new
+ foreign-data wrapper. The user who defines a foreign-data wrapper
+ becomes its owner.
+
+
+
+ The foreign-data wrapper name must be unique within the database.
+
+
+
+ Only superusers can create foreign-data wrappers.
+
+
+
+
+ Parameters
+
+
+
+ name
+
+
+ The name of the foreign-data wrapper to be created.
+
+
+
+
+
+ libraryname
+
+
+ The name of the shared library implementing the foreign-data wrapper.
+
+
+
+
+
+ LANGUAGE C
+
+
+ Currently, only the C programming language is supported for
+ implementing foreign-data wrappers.
+
+
+
+
+
+ OPTIONS ( option ['value'] [, ... ] )
+
+
+ This clause specifies options for the new foreign-data wrapper.
+ The allowed option names and values are specific to each foreign
+ data wrapper and are validated using the foreign-data wrapper
+ library. Option names must be unique.
+
+
+
+
+
+
+
+ Notes
+
+
+ The C language API for foreign-data wrappers is currently not
+ documented, stable, or complete. Would-be authors of functionality
+ interfacing with the SQL/MED functionality are advised to contact
+ the PostgreSQL developers.
+
+
+
+
+ Examples
+
+
+ Create a foreign-data wrapper dbi with
+ library dummy_fdw:
+
+ CREATE FOREIGN DATA WRAPPER dbi LIBRARY 'dummy_fdw' LANGUAGE C;
+
+
+
+
+ Create a foreign-data wrapper mywrapper with library
+ /home/bob/mywrapper.so and some options:
+
+ CREATE FOREIGN DATA WRAPPER mywrapper
+ LIBRARY '/home/bob/mywrapper.so'
+ LANGUAGE C
+ OPTIONS (debug 'true');
+
+
+
+
+
+ Compatibility
+
+
+ CREATE FOREIGN DATA WRAPPER conforms to ISO/IEC
+ 9075-9 (SQL/MED), with the exception that
+ the LIBRARY clause is not optional in
+ PostgreSQL.
+
+
+
+ Note, however, that the SQL/MED functionality as a whole is not yet
+ conforming.
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/create_server.sgml pgsql/doc/src/sgml/ref/create_server.sgml
*** cvs-pgsql/doc/src/sgml/ref/create_server.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/create_server.sgml Fri Dec 12 10:44:15 2008
***************
*** 0 ****
--- 1,140 ----
+
+
+
+
+ CREATE SERVER
+ SQL - Language Statements
+
+
+
+ CREATE SERVER
+ define a new foreign server
+
+
+
+ CREATE SERVER
+
+
+
+
+ CREATE SERVER servername [ TYPE 'servertype' ] [ VERSION 'serverversion' ]
+ FOREIGN DATA WRAPPER fdwname
+ [ OPTIONS ( option 'value' [, ... ] ) ]
+
+
+
+
+ Description
+
+
+ CREATE SERVER defines a new foreign server. The
+ user who defines the server becomes its owner.
+
+
+
+ The server name must be unique within database.
+
+
+
+ Creating a server requires USAGE privilege on the
+ foreign-data wrapper being used.
+
+
+
+
+ Parameters
+
+
+
+ servername
+
+
+ The name of the foreign server to be created.
+
+
+
+
+
+ servertype
+
+
+ Optional server type.
+
+
+
+
+
+ serverversion
+
+
+ Optional server version.
+
+
+
+
+
+ fdwname
+
+
+ The name of the foreign-data wrapper that manages the server.
+
+
+
+
+
+ OPTIONS ( option ['value'] [, ... ] )
+
+
+ This clause specifies the options for the server. The options
+ typically define the connection details of the server, but the
+ actual names and values are dependent on the server's
+ foreign-data wrapper.
+
+
+
+
+
+
+
+ Examples
+
+
+ Create a server foo that uses the built-in foreign-data
+ wrapper default:
+
+ CREATE SERVER foo FOREIGN DATA WRAPPER "default";
+
+
+
+
+ Create a server myserver that uses the
+ foreign-data wrapper pgsql:
+
+ CREATE SERVER myserver FOREIGN DATA WRAPPER pgsql OPTIONS (host 'foo', dbname 'foodb', port '5432');
+
+
+
+
+
+ Compatibility
+
+
+ CREATE SERVER conforms to ISO/IEC 9075-9 (SQL/MED).
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/create_user_mapping.sgml pgsql/doc/src/sgml/ref/create_user_mapping.sgml
*** cvs-pgsql/doc/src/sgml/ref/create_user_mapping.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/create_user_mapping.sgml Mon Dec 15 14:16:02 2008
***************
*** 0 ****
--- 1,111 ----
+
+
+
+
+ CREATE USER MAPPING
+ SQL - Language Statements
+
+
+
+ CREATE USER MAPPING
+ define a new mapping of a user to a foreign server
+
+
+
+ CREATE USER MAPPING
+
+
+
+
+ CREATE USER MAPPING FOR { username | USER | CURRENT_USER | PUBLIC }
+ SERVER servername
+ [ OPTIONS ( option 'value' [ , ... ] ) ]
+
+
+
+
+ Description
+
+
+ CREATE USER MAPPING defines a mapping of a user
+ to a foreign server. You must be the owner of the server to define
+ user mappings for it.
+
+
+
+
+
+ Parameters
+
+
+
+ username
+
+
+ The name of an existing user that is mapped to foreign server.
+ CURRENT_USER and USER match the name of
+ the current user. PUBLIC is used to match all
+ present and future user names in the system.
+
+
+
+
+
+ servername
+
+
+ The name of an existing server for which the user mapping is
+ to be created.
+
+
+
+
+
+ OPTIONS ( option ['value'] [, ... ] )
+
+
+ This clause specifies the options of the user mapping. The
+ options typically define the actual user name and password of
+ the mapping. Option names must be unque. The allowed option
+ names and values are specific to the server's foreign-data wrapper.
+
+
+
+
+
+
+
+ Examples
+
+
+ Create a user mapping for user bob, server foo:
+
+ CREATE USER MAPPING FOR bob SERVER foo OPTIONS (user 'bob', password 'secret');
+
+
+
+
+
+
+ Compatibility
+
+
+ CREATE USER MAPPING conforms to ISO/IEC 9075-9 (SQL/MED).
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/drop_foreign_data_wrapper.sgml pgsql/doc/src/sgml/ref/drop_foreign_data_wrapper.sgml
*** cvs-pgsql/doc/src/sgml/ref/drop_foreign_data_wrapper.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/drop_foreign_data_wrapper.sgml Mon Dec 15 14:16:01 2008
***************
*** 0 ****
--- 1,112 ----
+
+
+
+
+ DROP FOREIGN DATA WRAPPER
+ SQL - Language Statements
+
+
+
+ DROP FOREIGN DATA WRAPPER
+ remove a foreign-data wrapper
+
+
+
+ DROP FOREIGN DATA WRAPPER
+
+
+
+
+ DROP FOREIGN DATA WRAPPER [ IF EXISTS ] name [ CASCADE | RESTRICT ]
+
+
+
+
+ Description
+
+
+ DROP FOREIGN DATA WRAPPER removes an existing
+ foreign-data wrapper. To execute this command, the current user
+ must be the owner of the foreign-data wrapper.
+
+
+
+
+ Parameters
+
+
+
+ IF EXISTS
+
+
+ Do not throw an error if the foreign-data wrapper does not
+ exist. A notice is issued in this case.
+
+
+
+
+
+ name
+
+
+ The name of an existing foreign-data wrapper.
+
+
+
+
+
+ CASCADE
+
+
+ Automatically drop objects that depend on the foreign-data
+ wrapper (such as servers).
+
+
+
+
+
+ RESTRICT
+
+
+ Refuse to drop the foreign-data wrappers if any objects depend
+ on it. This is the default.
+
+
+
+
+
+
+
+ Examples
+
+
+ Drop the foreign-data wrapper dbi:
+
+ DROP FOREIGN DATA WRAPPER dbi;
+
+
+
+
+
+ Compatibility
+
+
+ DROP FOREIGN DATA WRAPPER conforms to ISO/IEC
+ 9075-9 (SQL/MED). The IF EXISTS clause is
+ a PostgreSQL extension.
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/drop_server.sgml pgsql/doc/src/sgml/ref/drop_server.sgml
*** cvs-pgsql/doc/src/sgml/ref/drop_server.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/drop_server.sgml Mon Dec 15 14:16:01 2008
***************
*** 0 ****
--- 1,112 ----
+
+
+
+
+ DROP SERVER
+ SQL - Language Statements
+
+
+
+ DROP SERVER
+ remove a foreign server descriptor
+
+
+
+ DROP SERVER
+
+
+
+
+ DROP SERVER [ IF EXISTS ] servername [ CASCADE | RESTRICT ]
+
+
+
+
+ Description
+
+
+ DROP SERVER removes an existing foreign server
+ descriptor. To execute this command, the current user must be the
+ owner of the server.
+
+
+
+
+ Parameters
+
+
+
+ IF EXISTS
+
+
+ Do not throw an error if the server does not exist. A notice is
+ issued in this case.
+
+
+
+
+
+ servername
+
+
+ The name of an existing server.
+
+
+
+
+
+ CASCADE
+
+
+ Automatically drop objects that depend on the server (such as
+ user mappings).
+
+
+
+
+
+ RESTRICT
+
+
+ Refuse to drop the server if any objects depend on it. This is
+ the default.
+
+
+
+
+
+
+
+ Examples
+
+
+ Drop a server foo if it exists:
+
+ DROP SERVER IF EXISTS foo;
+
+
+
+
+
+ Compatibility
+
+
+ DROP SERVER conforms to ISO/IEC 9075-9
+ (SQL/MED). The IF EXISTS clause is
+ a PostgreSQL extension.
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/drop_user_mapping.sgml pgsql/doc/src/sgml/ref/drop_user_mapping.sgml
*** cvs-pgsql/doc/src/sgml/ref/drop_user_mapping.sgml Thu Jan 1 02:00:00 1970
--- pgsql/doc/src/sgml/ref/drop_user_mapping.sgml Fri Dec 12 10:44:15 2008
***************
*** 0 ****
--- 1,104 ----
+
+
+
+
+ DROP USER MAPPING
+ SQL - Language Statements
+
+
+
+ DROP USER MAPPING
+ remove a user mapping for a foreign server
+
+
+
+ DROP USER MAPPING
+
+
+
+
+ DROP USER MAPPING [ IF EXISTS ] FOR { username | USER | CURRENT_USER | PUBLIC } SERVER servername
+
+
+
+
+ Description
+
+
+ DROP USER MAPPING removes an existing user
+ mapping from foreign server. To execute this command, the current
+ user must be the owner of the server containing the mapping.
+
+
+
+
+ Parameters
+
+
+
+ IF EXISTS
+
+
+ Do not throw an error if the user mapping does not exist. A
+ notice is issued in this case.
+
+
+
+
+
+ username
+
+
+ User name of the mapping. CURRENT_USER
+ and USER match the name of the current
+ user. PUBLIC is used to match all present and
+ future user names in the system.
+
+
+
+
+
+ servername
+
+
+ Server name of the user mapping.
+
+
+
+
+
+
+
+ Examples
+
+
+ Drop a user mapping bob, server foo if it exists:
+
+ DROP USER MAPPING IF EXISTS FOR bob SERVER foo;
+
+
+
+
+
+ Compatibility
+
+
+ DROP USER MAPPING conforms to ISO/IEC 9075-9
+ (SQL/MED). The IF EXISTS clause is
+ a PostgreSQL extension.
+
+
+
+
+ See Also
+
+
+
+
+
+
+
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/grant.sgml pgsql/doc/src/sgml/ref/grant.sgml
*** cvs-pgsql/doc/src/sgml/ref/grant.sgml Mon Nov 17 16:34:26 2008
--- pgsql/doc/src/sgml/ref/grant.sgml Fri Dec 12 10:44:15 2008
***************
*** 35,40 ****
--- 35,48 ----
ON DATABASE dbname [, ...]
TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+ GRANT { USAGE | ALL [ PRIVILEGES ] }
+ ON FOREIGN DATA WRAPPER fdwname [, ...]
+ TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+
+ GRANT { USAGE | ALL [ PRIVILEGES ] }
+ ON FOREIGN SERVER servername [, ...]
+ TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION funcname ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...]
TO { [ GROUP ] rolename | PUBLIC } [, ...] [ WITH GRANT OPTION ]
***************
*** 61,70 ****
The GRANT command has two basic variants: one
that grants privileges on a database object (table, view, sequence,
! database, function, procedural language, schema, or tablespace),
! and one that grants membership in a role. These variants are
! similar in many ways, but they are different enough to be described
! separately.
--- 69,78 ----
The GRANT command has two basic variants: one
that grants privileges on a database object (table, view, sequence,
! database, foreign-data wrapper, foreign server, function,
! procedural language, schema, or tablespace), and one that grants
! membership in a role. These variants are similar in many ways, but
! they are different enough to be described separately.
***************
*** 299,304 ****
--- 307,320 ----
For sequences, this privilege allows the use of the
currval and nextval functions.
+
+ For foreign-data wrappers, this privilege enables the grantee
+ to create new servers using that foreign-data wrapper.
+
+
+ For servers, this privilege enables the grantee look up
+ connection information for the server.
+
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/psql-ref.sgml pgsql/doc/src/sgml/ref/psql-ref.sgml
*** cvs-pgsql/doc/src/sgml/ref/psql-ref.sgml Fri Dec 5 15:06:21 2008
--- pgsql/doc/src/sgml/ref/psql-ref.sgml Mon Dec 15 11:00:54 2008
***************
*** 947,952 ****
--- 947,1010 ----
+ \des [ pattern ]
+ \des+ [ pattern ]
+
+
+ Lists all foreign servers (mnemonic: external
+ servers).
+ If pattern is
+ specified, only those servers whose name matches the pattern
+ are listed. If the form \des+ is used, a
+ full desription of each server is shown, including the
+ server's ACL, type, version, and connection options.
+
+
+
+
+
+
+ \deu [ pattern ]
+ \deu+ [ pattern ]
+
+
+ Lists all user mappings (mnemonic: external
+ users).
+ If pattern is
+ specified, only those mappings whose user names match the
+ pattern are listed. If the form \deu+ is
+ used, additional information about each mapping is shown.
+
+
+
+
+ \deu+ might also display the user name and
+ password of the remote user, so care should be taken not to
+ disclose them.
+
+
+
+
+
+
+
+ \dew [ pattern ]
+ \dew+ [ pattern ]
+
+
+ Lists all foreign-data wrappers (mnemonic: external
+ wrappers).
+ If pattern is
+ specified, only those foreign-data wrappers whose name matches
+ the pattern are listed. If the form \dew+
+ is used, also the ACL and options to the foreign-data wrapper
+ are shown.
+
+
+
+
+
+ \df [ pattern ]\df+ [ pattern ]
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/ref/revoke.sgml pgsql/doc/src/sgml/ref/revoke.sgml
*** cvs-pgsql/doc/src/sgml/ref/revoke.sgml Mon Nov 17 16:34:26 2008
--- pgsql/doc/src/sgml/ref/revoke.sgml Fri Dec 12 10:44:15 2008
***************
*** 42,47 ****
--- 42,59 ----
[ CASCADE | RESTRICT ]
REVOKE [ GRANT OPTION FOR ]
+ { USAGE | ALL [ PRIVILEGES ] }
+ ON FOREIGN DATA WRAPPER fdwname [, ...]
+ FROM { [ GROUP ] rolename | PUBLIC } [, ...]
+ [ CASCADE | RESTRICT ]
+
+ REVOKE [ GRANT OPTION FOR ]
+ { USAGE | ALL [ PRIVILEGES ] }
+ ON FOREIGN SERVER servername [, ...]
+ FROM { [ GROUP ] rolename | PUBLIC } [, ...]
+ [ CASCADE | RESTRICT ]
+
+ REVOKE [ GRANT OPTION FOR ]
{ EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION funcname ( [ [ argmode ] [ argname ] argtype [, ...] ] ) [, ...]
FROM { [ GROUP ] rolename | PUBLIC } [, ...]
diff -cNr -x CVS cvs-pgsql/doc/src/sgml/reference.sgml pgsql/doc/src/sgml/reference.sgml
*** cvs-pgsql/doc/src/sgml/reference.sgml Thu Mar 27 19:24:16 2008
--- pgsql/doc/src/sgml/reference.sgml Fri Dec 12 10:44:15 2008
***************
*** 38,43 ****
--- 38,44 ----
&alterConversion;
&alterDatabase;
&alterDomain;
+ &alterForeignDataWrapper;
&alterFunction;
&alterGroup;
&alterIndex;
***************
*** 48,53 ****
--- 49,55 ----
&alterRole;
&alterSchema;
&alterSequence;
+ &alterServer;
&alterTable;
&alterTableSpace;
&alterTSConfig;
***************
*** 57,62 ****
--- 59,65 ----
&alterTrigger;
&alterType;
&alterUser;
+ &alterUserMapping;
&alterView;
&analyze;
&begin;
***************
*** 73,78 ****
--- 76,82 ----
&createConversion;
&createDatabase;
&createDomain;
+ &createForeignDataWrapper;
&createFunction;
&createGroup;
&createIndex;
***************
*** 84,89 ****
--- 88,94 ----
&createRule;
&createSchema;
&createSequence;
+ &createServer;
&createTable;
&createTableAs;
&createTableSpace;
***************
*** 94,99 ****
--- 99,105 ----
&createTrigger;
&createType;
&createUser;
+ &createUserMapping;
&createView;
&deallocate;
&declare;
***************
*** 104,109 ****
--- 110,116 ----
&dropConversion;
&dropDatabase;
&dropDomain;
+ &dropForeignDataWrapper;
&dropFunction;
&dropGroup;
&dropIndex;
***************
*** 116,121 ****
--- 123,129 ----
&dropRule;
&dropSchema;
&dropSequence;
+ &dropServer;
&dropTable;
&dropTableSpace;
&dropTSConfig;
***************
*** 125,130 ****
--- 133,139 ----
&dropTrigger;
&dropType;
&dropUser;
+ &dropUserMapping;
&dropView;
&end;
&execute;
diff -cNr -x CVS cvs-pgsql/src/Makefile pgsql/src/Makefile
*** cvs-pgsql/src/Makefile Tue Mar 18 18:24:50 2008
--- pgsql/src/Makefile Mon Dec 15 12:39:14 2008
***************
*** 19,24 ****
--- 19,25 ----
$(MAKE) -C backend $@
$(MAKE) -C backend/utils/mb/conversion_procs $@
$(MAKE) -C backend/snowball $@
+ $(MAKE) -C backend/foreign $@-fdw
$(MAKE) -C include $@
$(MAKE) -C interfaces $@
$(MAKE) -C bin $@
diff -cNr -x CVS cvs-pgsql/src/backend/Makefile pgsql/src/backend/Makefile
*** cvs-pgsql/src/backend/Makefile Fri Aug 29 20:35:25 2008
--- pgsql/src/backend/Makefile Fri Dec 12 10:44:15 2008
***************
*** 14,20 ****
top_builddir = ../..
include $(top_builddir)/src/Makefile.global
! SUBDIRS = access bootstrap catalog parser commands executor lib libpq \
main nodes optimizer port postmaster regex rewrite \
storage tcop tsearch utils $(top_builddir)/src/timezone
--- 14,20 ----
top_builddir = ../..
include $(top_builddir)/src/Makefile.global
! SUBDIRS = access bootstrap catalog parser commands executor foreign lib libpq \
main nodes optimizer port postmaster regex rewrite \
storage tcop tsearch utils $(top_builddir)/src/timezone
diff -cNr -x CVS cvs-pgsql/src/backend/catalog/Makefile pgsql/src/backend/catalog/Makefile
*** cvs-pgsql/src/backend/catalog/Makefile Thu Nov 20 10:21:55 2008
--- pgsql/src/backend/catalog/Makefile Fri Dec 12 10:44:15 2008
***************
*** 36,41 ****
--- 36,42 ----
pg_authid.h pg_auth_members.h pg_shdepend.h pg_shdescription.h \
pg_ts_config.h pg_ts_config_map.h pg_ts_dict.h \
pg_ts_parser.h pg_ts_template.h \
+ pg_foreign_data_wrapper.h pg_foreign_server.h pg_user_mapping.h \
toasting.h indexing.h \
)
diff -cNr -x CVS cvs-pgsql/src/backend/catalog/aclchk.c pgsql/src/backend/catalog/aclchk.c
*** cvs-pgsql/src/backend/catalog/aclchk.c Mon Nov 3 16:31:20 2008
--- pgsql/src/backend/catalog/aclchk.c Mon Dec 15 14:16:01 2008
***************
*** 27,32 ****
--- 27,34 ----
#include "catalog/pg_authid.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_database.h"
+ #include "catalog/pg_foreign_data_wrapper.h"
+ #include "catalog/pg_foreign_server.h"
#include "catalog/pg_language.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
***************
*** 38,43 ****
--- 40,46 ----
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "commands/dbcommands.h"
+ #include "foreign/foreign.h"
#include "miscadmin.h"
#include "parser/parse_func.h"
#include "utils/acl.h"
***************
*** 50,55 ****
--- 53,60 ----
static void ExecGrant_Relation(InternalGrant *grantStmt);
static void ExecGrant_Database(InternalGrant *grantStmt);
+ static void ExecGrant_Fdw(InternalGrant *grantStmt);
+ static void ExecGrant_ForeignServer(InternalGrant *grantStmt);
static void ExecGrant_Function(InternalGrant *grantStmt);
static void ExecGrant_Language(InternalGrant *grantStmt);
static void ExecGrant_Namespace(InternalGrant *grantStmt);
***************
*** 188,193 ****
--- 193,204 ----
case ACL_KIND_TABLESPACE:
whole_mask = ACL_ALL_RIGHTS_TABLESPACE;
break;
+ case ACL_KIND_FDW:
+ whole_mask = ACL_ALL_RIGHTS_FDW;
+ break;
+ case ACL_KIND_FOREIGN_SERVER:
+ whole_mask = ACL_ALL_RIGHTS_FOREIGN_SERVER;
+ break;
default:
elog(ERROR, "unrecognized object kind: %d", objkind);
/* not reached, but keep compiler quiet */
***************
*** 323,328 ****
--- 334,347 ----
all_privileges = ACL_ALL_RIGHTS_TABLESPACE;
errormsg = gettext_noop("invalid privilege type %s for tablespace");
break;
+ case ACL_OBJECT_FDW:
+ all_privileges = ACL_ALL_RIGHTS_FDW;
+ errormsg = gettext_noop("invalid privilege type %s for foreign-data wrapper");
+ break;
+ case ACL_OBJECT_FOREIGN_SERVER:
+ all_privileges = ACL_ALL_RIGHTS_FOREIGN_SERVER;
+ errormsg = gettext_noop("invalid privilege type %s for foreign server");
+ break;
default:
/* keep compiler quiet */
all_privileges = ACL_NO_RIGHTS;
***************
*** 380,385 ****
--- 399,410 ----
case ACL_OBJECT_DATABASE:
ExecGrant_Database(istmt);
break;
+ case ACL_OBJECT_FDW:
+ ExecGrant_Fdw(istmt);
+ break;
+ case ACL_OBJECT_FOREIGN_SERVER:
+ ExecGrant_ForeignServer(istmt);
+ break;
case ACL_OBJECT_FUNCTION:
ExecGrant_Function(istmt);
break;
***************
*** 520,525 ****
--- 545,568 ----
heap_close(relation, AccessShareLock);
}
break;
+ case ACL_OBJECT_FDW:
+ foreach(cell, objnames)
+ {
+ char *fdwname = strVal(lfirst(cell));
+ Oid fdwid = GetForeignDataWrapperOidByName(fdwname, false);
+
+ objects = lappend_oid(objects, fdwid);
+ }
+ break;
+ case ACL_OBJECT_FOREIGN_SERVER:
+ foreach(cell, objnames)
+ {
+ char *srvname = strVal(lfirst(cell));
+ Oid srvid = GetForeignServerOidByName(srvname, false);
+
+ objects = lappend_oid(objects, srvid);
+ }
+ break;
default:
elog(ERROR, "unrecognized GrantStmt.objtype: %d",
(int) objtype);
***************
*** 841,846 ****
--- 884,1122 ----
}
static void
+ ExecGrant_Fdw(InternalGrant *istmt)
+ {
+ Relation relation;
+ ListCell *cell;
+
+ if (istmt->all_privs && istmt->privileges == ACL_NO_RIGHTS)
+ istmt->privileges = ACL_ALL_RIGHTS_FDW;
+
+ relation = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
+
+ foreach(cell, istmt->objects)
+ {
+ Oid fdwid = lfirst_oid(cell);
+ Form_pg_foreign_data_wrapper pg_fdw_tuple;
+ Datum aclDatum;
+ bool isNull;
+ AclMode avail_goptions;
+ AclMode this_privileges;
+ Acl *old_acl;
+ Acl *new_acl;
+ Oid grantorId;
+ Oid ownerId;
+ HeapTuple tuple;
+ HeapTuple newtuple;
+ Datum values[Natts_pg_foreign_data_wrapper];
+ bool nulls[Natts_pg_foreign_data_wrapper];
+ bool replaces[Natts_pg_foreign_data_wrapper];
+ int noldmembers;
+ int nnewmembers;
+ Oid *oldmembers;
+ Oid *newmembers;
+
+ tuple = SearchSysCache(FOREIGNDATAWRAPPEROID,
+ ObjectIdGetDatum(fdwid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tuple))
+ elog(ERROR, "cache lookup failed for foreign-data wrapper %u", fdwid);
+
+ pg_fdw_tuple = (Form_pg_foreign_data_wrapper) GETSTRUCT(tuple);
+
+ /*
+ * Get owner ID and working copy of existing ACL. If there's no ACL,
+ * substitute the proper default.
+ */
+ ownerId = pg_fdw_tuple->fdwowner;
+ aclDatum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID, tuple,
+ Anum_pg_foreign_data_wrapper_fdwacl,
+ &isNull);
+ if (isNull)
+ old_acl = acldefault(ACL_OBJECT_FDW, ownerId);
+ else
+ old_acl = DatumGetAclPCopy(aclDatum);
+
+ /* Determine ID to do the grant as, and available grant options */
+ select_best_grantor(GetUserId(), istmt->privileges,
+ old_acl, ownerId,
+ &grantorId, &avail_goptions);
+
+ /*
+ * Restrict the privileges to what we can actually grant, and emit the
+ * standards-mandated warning and error messages.
+ */
+ this_privileges =
+ restrict_and_check_grant(istmt->is_grant, avail_goptions,
+ istmt->all_privs, istmt->privileges,
+ fdwid, grantorId, ACL_KIND_FDW,
+ NameStr(pg_fdw_tuple->fdwname));
+
+ /*
+ * Generate new ACL.
+ *
+ * We need the members of both old and new ACLs so we can correct the
+ * shared dependency information.
+ */
+ noldmembers = aclmembers(old_acl, &oldmembers);
+
+ new_acl = merge_acl_with_grant(old_acl, istmt->is_grant,
+ istmt->grant_option, istmt->behavior,
+ istmt->grantees, this_privileges,
+ grantorId, ownerId);
+
+ nnewmembers = aclmembers(new_acl, &newmembers);
+
+ /* finished building new ACL value, now insert it */
+ MemSet(values, 0, sizeof(values));
+ MemSet(nulls, false, sizeof(nulls));
+ MemSet(replaces, false, sizeof(replaces));
+
+ replaces[Anum_pg_foreign_data_wrapper_fdwacl - 1] = true;
+ values[Anum_pg_foreign_data_wrapper_fdwacl - 1] = PointerGetDatum(new_acl);
+
+ newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
+ nulls, replaces);
+
+ simple_heap_update(relation, &newtuple->t_self, newtuple);
+
+ /* keep the catalog indexes up to date */
+ CatalogUpdateIndexes(relation, newtuple);
+
+ /* Update the shared dependency ACL info */
+ updateAclDependencies(ForeignDataWrapperRelationId, HeapTupleGetOid(tuple),
+ ownerId, istmt->is_grant,
+ noldmembers, oldmembers,
+ nnewmembers, newmembers);
+
+ ReleaseSysCache(tuple);
+
+ pfree(new_acl);
+
+ /* prevent error when processing duplicate objects */
+ CommandCounterIncrement();
+ }
+
+ heap_close(relation, RowExclusiveLock);
+ }
+
+ static void ExecGrant_ForeignServer(InternalGrant *istmt)
+ {
+ Relation relation;
+ ListCell *cell;
+
+ if (istmt->all_privs && istmt->privileges == ACL_NO_RIGHTS)
+ istmt->privileges = ACL_ALL_RIGHTS_FOREIGN_SERVER;
+
+ relation = heap_open(ForeignServerRelationId, RowExclusiveLock);
+
+ foreach(cell, istmt->objects)
+ {
+ Oid srvid = lfirst_oid(cell);
+ Form_pg_foreign_server pg_server_tuple;
+ Datum aclDatum;
+ bool isNull;
+ AclMode avail_goptions;
+ AclMode this_privileges;
+ Acl *old_acl;
+ Acl *new_acl;
+ Oid grantorId;
+ Oid ownerId;
+ HeapTuple tuple;
+ HeapTuple newtuple;
+ Datum values[Natts_pg_foreign_server];
+ bool nulls[Natts_pg_foreign_server];
+ bool replaces[Natts_pg_foreign_server];
+ int noldmembers;
+ int nnewmembers;
+ Oid *oldmembers;
+ Oid *newmembers;
+
+ tuple = SearchSysCache(FOREIGNSERVEROID,
+ ObjectIdGetDatum(srvid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tuple))
+ elog(ERROR, "cache lookup failed for foreign server %u", srvid);
+
+ pg_server_tuple = (Form_pg_foreign_server) GETSTRUCT(tuple);
+
+ /*
+ * Get owner ID and working copy of existing ACL. If there's no ACL,
+ * substitute the proper default.
+ */
+ ownerId = pg_server_tuple->srvowner;
+ aclDatum = SysCacheGetAttr(FOREIGNSERVEROID, tuple,
+ Anum_pg_foreign_server_srvacl,
+ &isNull);
+ if (isNull)
+ old_acl = acldefault(ACL_OBJECT_FOREIGN_SERVER, ownerId);
+ else
+ old_acl = DatumGetAclPCopy(aclDatum);
+
+ /* Determine ID to do the grant as, and available grant options */
+ select_best_grantor(GetUserId(), istmt->privileges,
+ old_acl, ownerId,
+ &grantorId, &avail_goptions);
+
+ /*
+ * Restrict the privileges to what we can actually grant, and emit the
+ * standards-mandated warning and error messages.
+ */
+ this_privileges =
+ restrict_and_check_grant(istmt->is_grant, avail_goptions,
+ istmt->all_privs, istmt->privileges,
+ srvid, grantorId, ACL_KIND_FOREIGN_SERVER,
+ NameStr(pg_server_tuple->srvname));
+
+ /*
+ * Generate new ACL.
+ *
+ * We need the members of both old and new ACLs so we can correct the
+ * shared dependency information.
+ */
+ noldmembers = aclmembers(old_acl, &oldmembers);
+
+ new_acl = merge_acl_with_grant(old_acl, istmt->is_grant,
+ istmt->grant_option, istmt->behavior,
+ istmt->grantees, this_privileges,
+ grantorId, ownerId);
+
+ nnewmembers = aclmembers(new_acl, &newmembers);
+
+ /* finished building new ACL value, now insert it */
+ MemSet(values, 0, sizeof(values));
+ MemSet(nulls, false, sizeof(nulls));
+ MemSet(replaces, false, sizeof(replaces));
+
+ replaces[Anum_pg_foreign_server_srvacl - 1] = true;
+ values[Anum_pg_foreign_server_srvacl - 1] = PointerGetDatum(new_acl);
+
+ newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
+ nulls, replaces);
+
+ simple_heap_update(relation, &newtuple->t_self, newtuple);
+
+ /* keep the catalog indexes up to date */
+ CatalogUpdateIndexes(relation, newtuple);
+
+ /* Update the shared dependency ACL info */
+ updateAclDependencies(ForeignServerRelationId, HeapTupleGetOid(tuple),
+ ownerId, istmt->is_grant,
+ noldmembers, oldmembers,
+ nnewmembers, newmembers);
+
+ ReleaseSysCache(tuple);
+
+ pfree(new_acl);
+
+ /* prevent error when processing duplicate objects */
+ CommandCounterIncrement();
+ }
+
+ heap_close(relation, RowExclusiveLock);
+ }
+
+ static void
ExecGrant_Function(InternalGrant *istmt)
{
Relation relation;
***************
*** 1428,1434 ****
/* ACL_KIND_TSDICTIONARY */
gettext_noop("permission denied for text search dictionary %s"),
/* ACL_KIND_TSCONFIGURATION */
! gettext_noop("permission denied for text search configuration %s")
};
static const char *const not_owner_msg[MAX_ACL_KIND] =
--- 1704,1714 ----
/* ACL_KIND_TSDICTIONARY */
gettext_noop("permission denied for text search dictionary %s"),
/* ACL_KIND_TSCONFIGURATION */
! gettext_noop("permission denied for text search configuration %s"),
! /* ACL_KIND_FDW */
! gettext_noop("permission denied for foreign-data wrapper %s"),
! /* ACL_KIND_FOREIGN_SERVER */
! gettext_noop("permission denied for foreign server %s")
};
static const char *const not_owner_msg[MAX_ACL_KIND] =
***************
*** 1460,1466 ****
/* ACL_KIND_TSDICTIONARY */
gettext_noop("must be owner of text search dictionary %s"),
/* ACL_KIND_TSCONFIGURATION */
! gettext_noop("must be owner of text search configuration %s")
};
--- 1740,1750 ----
/* ACL_KIND_TSDICTIONARY */
gettext_noop("must be owner of text search dictionary %s"),
/* ACL_KIND_TSCONFIGURATION */
! gettext_noop("must be owner of text search configuration %s"),
! /* ACL_KIND_FDW */
! gettext_noop("must be owner of foreign-data wrapper %s"),
! /* ACL_KIND_FOREIGN_SERVER */
! gettext_noop("must be owner of foreign server %s")
};
***************
*** 1534,1539 ****
--- 1818,1827 ----
return pg_namespace_aclmask(table_oid, roleid, mask, how);
case ACL_KIND_TABLESPACE:
return pg_tablespace_aclmask(table_oid, roleid, mask, how);
+ case ACL_KIND_FDW:
+ return pg_foreign_data_wrapper_aclmask(table_oid, roleid, mask, how);
+ case ACL_KIND_FOREIGN_SERVER:
+ return pg_foreign_server_aclmask(table_oid, roleid, mask, how);
default:
elog(ERROR, "unrecognized objkind: %d",
(int) objkind);
***************
*** 1962,1967 ****
--- 2250,2380 ----
return result;
}
+ /*
+ * Exported routine for examining a user's privileges for a foreign
+ * data wrapper
+ */
+ AclMode
+ pg_foreign_data_wrapper_aclmask(Oid fdw_oid, Oid roleid,
+ AclMode mask, AclMaskHow how)
+ {
+ AclMode result;
+ HeapTuple tuple;
+ Datum aclDatum;
+ bool isNull;
+ Acl *acl;
+ Oid ownerId;
+
+ Form_pg_foreign_data_wrapper fdwForm;
+
+ /* Bypass permission checks for superusers */
+ if (superuser_arg(roleid))
+ return mask;
+
+ /*
+ * Must get the FDW's tuple from pg_foreign_data_wrapper
+ */
+ tuple = SearchSysCache(FOREIGNDATAWRAPPEROID,
+ ObjectIdGetDatum(fdw_oid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tuple))
+ ereport(ERROR,
+ (errmsg("foreign-data wrapper with OID %u does not exist",
+ fdw_oid)));
+ fdwForm = (Form_pg_foreign_data_wrapper) GETSTRUCT(tuple);
+
+ /*
+ * Normal case: get the FDW's ACL from pg_foreign_data_wrapper
+ */
+ ownerId = fdwForm->fdwowner;
+
+ aclDatum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID, tuple,
+ Anum_pg_foreign_data_wrapper_fdwacl, &isNull);
+ if (isNull)
+ {
+ /* No ACL, so build default ACL */
+ acl = acldefault(ACL_OBJECT_FDW, ownerId);
+ aclDatum = (Datum) 0;
+ }
+ else
+ {
+ /* detoast rel's ACL if necessary */
+ acl = DatumGetAclP(aclDatum);
+ }
+
+ result = aclmask(acl, roleid, ownerId, mask, how);
+
+ /* if we have a detoasted copy, free it */
+ if (acl && (Pointer) acl != DatumGetPointer(aclDatum))
+ pfree(acl);
+
+ ReleaseSysCache(tuple);
+
+ return result;
+ }
+
+ /*
+ * Exported routine for examining a user's privileges for a foreign
+ * server.
+ */
+ AclMode
+ pg_foreign_server_aclmask(Oid srv_oid, Oid roleid,
+ AclMode mask, AclMaskHow how)
+ {
+ AclMode result;
+ HeapTuple tuple;
+ Datum aclDatum;
+ bool isNull;
+ Acl *acl;
+ Oid ownerId;
+
+ Form_pg_foreign_server srvForm;
+
+ /* Bypass permission checks for superusers */
+ if (superuser_arg(roleid))
+ return mask;
+
+ /*
+ * Must get the FDW's tuple from pg_foreign_data_wrapper
+ */
+ tuple = SearchSysCache(FOREIGNSERVEROID,
+ ObjectIdGetDatum(srv_oid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tuple))
+ ereport(ERROR,
+ (errmsg("foreign server with OID %u does not exist",
+ srv_oid)));
+ srvForm = (Form_pg_foreign_server) GETSTRUCT(tuple);
+
+ /*
+ * Normal case: get the foreign server's ACL from pg_foreign_server
+ */
+ ownerId = srvForm->srvowner;
+
+ aclDatum = SysCacheGetAttr(FOREIGNSERVEROID, tuple,
+ Anum_pg_foreign_server_srvacl, &isNull);
+ if (isNull)
+ {
+ /* No ACL, so build default ACL */
+ acl = acldefault(ACL_OBJECT_FOREIGN_SERVER, ownerId);
+ aclDatum = (Datum) 0;
+ }
+ else
+ {
+ /* detoast rel's ACL if necessary */
+ acl = DatumGetAclP(aclDatum);
+ }
+
+ result = aclmask(acl, roleid, ownerId, mask, how);
+
+ /* if we have a detoasted copy, free it */
+ if (acl && (Pointer) acl != DatumGetPointer(aclDatum))
+ pfree(acl);
+
+ ReleaseSysCache(tuple);
+
+ return result;
+ }
/*
* Exported routine for checking a user's access privileges to a table
***************
*** 2039,2044 ****
--- 2452,2482 ----
return ACLCHECK_NO_PRIV;
}
+ /*
+ * Exported routine for checking a user's access privileges to a foreign
+ * data wrapper
+ */
+ AclResult
+ pg_foreign_data_wrapper_aclcheck(Oid fdw_oid, Oid roleid, AclMode mode)
+ {
+ if (pg_foreign_data_wrapper_aclmask(fdw_oid, roleid, mode, ACLMASK_ANY) != 0)
+ return ACLCHECK_OK;
+ else
+ return ACLCHECK_NO_PRIV;
+ }
+
+ /*
+ * Exported routine for checking a user's access privileges to a foreign
+ * server
+ */
+ AclResult
+ pg_foreign_server_aclcheck(Oid srv_oid, Oid roleid, AclMode mode)
+ {
+ if (pg_foreign_server_aclmask(srv_oid, roleid, mode, ACLMASK_ANY) != 0)
+ return ACLCHECK_OK;
+ else
+ return ACLCHECK_NO_PRIV;
+ }
/*
* Ownership check for a relation (specified by OID).
***************
*** 2364,2369 ****
--- 2802,2835 ----
return has_privs_of_role(roleid, ownerId);
}
+ /*
+ * Ownership check for a foreign server (specified by OID).
+ */
+ bool
+ pg_foreign_server_ownercheck(Oid srv_oid, Oid roleid)
+ {
+ HeapTuple tuple;
+ Oid ownerId;
+
+ /* Superusers bypass all permission checking. */
+ if (superuser_arg(roleid))
+ return true;
+
+ tuple = SearchSysCache(FOREIGNSERVEROID,
+ ObjectIdGetDatum(srv_oid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tuple))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("foreign server with OID %u does not exist",
+ srv_oid)));
+
+ ownerId = ((Form_pg_foreign_server) GETSTRUCT(tuple))->srvowner;
+
+ ReleaseSysCache(tuple);
+
+ return has_privs_of_role(roleid, ownerId);
+ }
/*
* Ownership check for a database (specified by OID).
diff -cNr -x CVS cvs-pgsql/src/backend/catalog/dependency.c pgsql/src/backend/catalog/dependency.c
*** cvs-pgsql/src/backend/catalog/dependency.c Thu Nov 13 10:44:31 2008
--- pgsql/src/backend/catalog/dependency.c Fri Dec 12 10:44:15 2008
***************
*** 33,38 ****
--- 33,40 ----
#include "catalog/pg_conversion_fn.h"
#include "catalog/pg_database.h"
#include "catalog/pg_depend.h"
+ #include "catalog/pg_foreign_data_wrapper.h"
+ #include "catalog/pg_foreign_server.h"
#include "catalog/pg_language.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
***************
*** 47,52 ****
--- 49,55 ----
#include "catalog/pg_ts_parser.h"
#include "catalog/pg_ts_template.h"
#include "catalog/pg_type.h"
+ #include "catalog/pg_user_mapping.h"
#include "commands/comment.h"
#include "commands/dbcommands.h"
#include "commands/defrem.h"
***************
*** 55,60 ****
--- 58,64 ----
#include "commands/tablespace.h"
#include "commands/trigger.h"
#include "commands/typecmds.h"
+ #include "foreign/foreign.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "parser/parsetree.h"
***************
*** 1105,1110 ****
--- 1109,1126 ----
RemoveTSConfigurationById(object->objectId);
break;
+ case OCLASS_USER_MAPPING:
+ RemoveUserMappingById(object->objectId);
+ break;
+
+ case OCLASS_FOREIGN_SERVER:
+ RemoveForeignServerById(object->objectId);
+ break;
+
+ case OCLASS_FDW:
+ RemoveForeignDataWrapperById(object->objectId);
+ break;
+
/* OCLASS_ROLE, OCLASS_DATABASE, OCLASS_TBLSPACE not handled */
default:
***************
*** 2005,2010 ****
--- 2021,2038 ----
case TableSpaceRelationId:
Assert(object->objectSubId == 0);
return OCLASS_TBLSPACE;
+
+ case ForeignDataWrapperRelationId:
+ Assert(object->objectSubId == 0);
+ return OCLASS_FDW;
+
+ case ForeignServerRelationId:
+ Assert(object->objectSubId == 0);
+ return OCLASS_FOREIGN_SERVER;
+
+ case UserMappingRelationId:
+ Assert(object->objectSubId == 0);
+ return OCLASS_USER_MAPPING;
}
/* shouldn't get here */
***************
*** 2501,2506 ****
--- 2529,2578 ----
break;
}
+ case OCLASS_FDW:
+ {
+ ForeignDataWrapper *fdw;
+
+ fdw = GetForeignDataWrapper(object->objectId);
+ appendStringInfo(&buffer, _("foreign-data wrapper %s"), fdw->fdwname);
+ break;
+ }
+
+ case OCLASS_FOREIGN_SERVER:
+ {
+ ForeignServer *srv;
+
+ srv = GetForeignServer(object->objectId);
+ appendStringInfo(&buffer, _("server %s"), srv->servername);
+ break;
+ }
+
+ case OCLASS_USER_MAPPING:
+ {
+ HeapTuple tup;
+ Oid useid;
+ char *usename;
+
+ tup = SearchSysCache(USERMAPPINGOID,
+ ObjectIdGetDatum(object->objectId),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tup))
+ elog(ERROR, "cache lookup failed for user mapping %u",
+ object->objectId);
+
+ useid = ((Form_pg_user_mapping) GETSTRUCT(tup))->umuser;
+
+ ReleaseSysCache(tup);
+
+ if (OidIsValid(useid))
+ usename = GetUserNameFromId(useid);
+ else
+ usename = "public";
+
+ appendStringInfo(&buffer, _("user mapping for %s"), usename);
+ break;
+ }
+
default:
appendStringInfo(&buffer, "unrecognized object %u %u %d",
object->classId,
diff -cNr -x CVS cvs-pgsql/src/backend/catalog/information_schema.sql pgsql/src/backend/catalog/information_schema.sql
*** cvs-pgsql/src/backend/catalog/information_schema.sql Thu Sep 11 15:29:57 2008
--- pgsql/src/backend/catalog/information_schema.sql Fri Dec 12 13:36:03 2008
***************
*** 2313,2315 ****
--- 2313,2450 ----
FROM data_type_privileges );
GRANT SELECT ON element_types TO PUBLIC;
+
+
+ -- SQL/MED views; these use section numbers from part 9 of the standard.
+
+ /* Base view for foreign-data wrappers */
+ CREATE VIEW _pg_foreign_data_wrappers AS
+ SELECT w.oid,
+ w.fdwowner,
+ CAST(current_database() AS sql_identifier) AS foreign_data_wrapper_catalog,
+ CAST(fdwname AS sql_identifier) AS foreign_data_wrapper_name,
+ CAST(u.rolname AS sql_identifier) AS authorization_identifier,
+ CAST(fdwlibrary AS character_data) AS library_name,
+ CAST('c' AS character_data) AS foreign_data_wrapper_language
+ FROM pg_foreign_data_wrapper w, pg_authid u
+ WHERE u.oid = w.fdwowner;
+
+
+ /*
+ * 24.4
+ * FOREIGN_DATA_WRAPPER_OPTIONS view
+ */
+ CREATE VIEW foreign_data_wrapper_options AS
+ SELECT foreign_data_wrapper_catalog,
+ foreign_data_wrapper_name,
+ CAST((pg_get_foreign_data_wrapper_options(w.oid)).option_name AS sql_identifier) AS option_name,
+ CAST((pg_get_foreign_data_wrapper_options(w.oid)).option_value AS sql_identifier) AS option_value
+ FROM _pg_foreign_data_wrappers w
+ WHERE (pg_has_role(fdwowner, 'USAGE')
+ OR has_foreign_data_wrapper_privilege(w.oid, 'USAGE'));
+
+ GRANT SELECT ON foreign_data_wrapper_options TO PUBLIC;
+
+
+ /*
+ * 24.5
+ * FOREIGN_DATA_WRAPPERS
+ */
+ CREATE VIEW foreign_data_wrappers AS
+ SELECT foreign_data_wrapper_catalog,
+ foreign_data_wrapper_name,
+ authorization_identifier,
+ library_name,
+ foreign_data_wrapper_language
+ FROM _pg_foreign_data_wrappers w
+ WHERE (pg_has_role(fdwowner, 'USAGE')
+ OR has_foreign_data_wrapper_privilege(w.oid, 'USAGE'));
+
+ GRANT SELECT ON foreign_data_wrappers TO PUBLIC;
+
+
+ /* Base view for foreign servers */
+ CREATE VIEW _pg_foreign_servers AS
+ SELECT s.oid,
+ CAST(current_database() AS sql_identifier) AS foreign_server_catalog,
+ CAST(srvname AS sql_identifier) AS foreign_server_name,
+ w.foreign_data_wrapper_catalog,
+ w.foreign_data_wrapper_name,
+ CAST(srvtype AS character_data) AS foreign_server_type,
+ CAST(srvversion AS character_data) AS foreign_server_version,
+ CAST(u.rolname AS sql_identifier) AS authorization_identifier
+ FROM pg_foreign_server s, _pg_foreign_data_wrappers w, pg_authid u
+ WHERE w.oid = s.srvfdw
+ AND u.oid = s.srvowner
+ AND (pg_has_role(s.srvowner, 'USAGE')
+ OR has_server_privilege(s.oid, 'USAGE'));
+
+
+ /*
+ * 24.6
+ * FOREIGN_SERVER_OPTIONS view
+ */
+ CREATE VIEW foreign_server_options AS
+ SELECT foreign_server_catalog,
+ foreign_server_name,
+ CAST((pg_get_foreign_server_options(s.oid)).option_name AS character_data) AS option_name,
+ CAST((pg_get_foreign_server_options(s.oid)).option_value AS character_data) AS option_value
+ FROM _pg_foreign_servers s;
+
+ GRANT SELECT ON TABLE foreign_server_options TO PUBLIC;
+
+
+ /*
+ * 24.7
+ * FOREIGN_SERVERS view
+ */
+ CREATE VIEW foreign_servers AS
+ SELECT foreign_server_catalog,
+ foreign_server_name,
+ foreign_data_wrapper_catalog,
+ foreign_data_wrapper_name,
+ foreign_server_type,
+ foreign_server_version,
+ authorization_identifier
+ FROM _pg_foreign_servers;
+
+ GRANT SELECT ON foreign_servers TO PUBLIC;
+
+
+ /* Base view for user mappings */
+ CREATE VIEW _pg_user_mappings AS
+ SELECT um.oid,
+ CAST(COALESCE(u.rolname,'public') AS sql_identifier ) AS authorization_identifier,
+ s.foreign_server_catalog,
+ s.foreign_server_name
+ FROM pg_user_mapping um LEFT JOIN pg_authid u ON (u.oid = um.umuser),
+ _pg_foreign_servers s
+ WHERE s.oid = um.umserver;
+
+
+ /*
+ * 24.12
+ * USER_MAPPING_OPTIONS view
+ */
+ CREATE VIEW user_mapping_options AS
+ SELECT authorization_identifier,
+ foreign_server_catalog,
+ foreign_server_name,
+ CAST((pg_get_user_mapping_options(um.oid)).option_name AS character_data) AS option_name,
+ CAST((pg_get_user_mapping_options(um.oid)).option_value AS character_data) AS option_value
+ FROM _pg_user_mappings um;
+
+ GRANT SELECT ON user_mapping_options TO PUBLIC;
+
+
+ /*
+ * 24.13
+ * USER_MAPPINGS view
+ */
+ CREATE VIEW user_mappings AS
+ SELECT authorization_identifier,
+ foreign_server_catalog,
+ foreign_server_name
+ FROM _pg_user_mappings;
+
+ GRANT SELECT ON user_mappings TO PUBLIC;
diff -cNr -x CVS cvs-pgsql/src/backend/catalog/sql_features.txt pgsql/src/backend/catalog/sql_features.txt
*** cvs-pgsql/src/backend/catalog/sql_features.txt Mon Dec 1 10:24:54 2008
--- pgsql/src/backend/catalog/sql_features.txt Fri Dec 12 10:44:15 2008
***************
*** 487,492 ****
--- 487,517 ----
T653 SQL-schema statements in external routines NO
T654 SQL-dynamic statements in external routines NO
T655 Cyclically dependent routines NO
+ M001 Datalinks NO
+ M002 Datalinks via SQL/CLI NO
+ M003 Datalinks via Embedded SQL NO
+ M004 Foreign data support NO
+ M005 Foreign schema support NO
+ M006 GetSQLString routine NO
+ M007 TransmitRequest NO
+ M009 GetOpts and GetStatistics routines NO
+ M010 Foreign data wrapper support NO
+ M011 Datalinks via Ada NO
+ M012 Datalinks via C NO
+ M013 Datalinks via COBOL NO
+ M014 Datalinks via Fortran NO
+ M015 Datalinks via M NO
+ M016 Datalinks via Pascal NO
+ M017 Datalinks via PL/I NO
+ M018 Foreign data wrapper interface routines in Ada NO
+ M019 Foreign data wrapper interface routines in C NO
+ M020 Foreign data wrapper interface routines in COBOL NO
+ M021 Foreign data wrapper interface routines in Fortran NO
+ M022 Foreign data wrapper interface routines in MUMPS NO
+ M023 Foreign data wrapper interface routines in Pascal NO
+ M024 Foreign data wrapper interface routines in PL/I NO
+ M030 SQL-server foreign data support NO
+ M031 Foreign data wrapper general routines NO
X010 XML type YES
X011 Arrays of XML type YES
X012 Multisets of XML type NO
diff -cNr -x CVS cvs-pgsql/src/backend/catalog/system_views.sql pgsql/src/backend/catalog/system_views.sql
*** cvs-pgsql/src/backend/catalog/system_views.sql Thu Nov 13 10:44:31 2008
--- pgsql/src/backend/catalog/system_views.sql Mon Dec 15 14:16:00 2008
***************
*** 381,386 ****
--- 381,405 ----
pg_stat_get_buf_written_backend() AS buffers_backend,
pg_stat_get_buf_alloc() AS buffers_alloc;
+ CREATE VIEW pg_user_mappings AS
+ SELECT
+ U.oid AS umid,
+ S.oid AS srvid,
+ S.srvname AS srvname,
+ U.umuser AS umuser,
+ CASE WHEN U.umuser = 0 THEN
+ 'public'
+ ELSE
+ A.rolname
+ END AS usename
+ FROM pg_user_mapping U
+ LEFT JOIN pg_authid A ON (A.oid = U.umuser) JOIN
+ pg_foreign_server S ON (U.umserver = S.oid);
+
+ REVOKE ALL on pg_user_mapping FROM public;
+ REVOKE ALL on FUNCTION pg_get_remote_connection_info(name) FROM public;
+ REVOKE ALL on FUNCTION pg_get_remote_connection_info(name, name) FROM public;
+
-- Tsearch debug function. Defined here because it'd be pretty unwieldy
-- to put it into pg_proc.h
diff -cNr -x CVS cvs-pgsql/src/backend/commands/Makefile pgsql/src/backend/commands/Makefile
*** cvs-pgsql/src/backend/commands/Makefile Tue Feb 19 12:30:07 2008
--- pgsql/src/backend/commands/Makefile Fri Dec 12 10:44:15 2008
***************
*** 14,20 ****
OBJS = aggregatecmds.o alter.o analyze.o async.o cluster.o comment.o \
conversioncmds.o copy.o \
! dbcommands.o define.o discard.o explain.o functioncmds.o \
indexcmds.o lockcmds.o operatorcmds.o opclasscmds.o \
portalcmds.o prepare.o proclang.o \
schemacmds.o sequence.o tablecmds.o tablespace.o trigger.o \
--- 14,20 ----
OBJS = aggregatecmds.o alter.o analyze.o async.o cluster.o comment.o \
conversioncmds.o copy.o \
! dbcommands.o define.o discard.o explain.o foreigncmds.o functioncmds.o \
indexcmds.o lockcmds.o operatorcmds.o opclasscmds.o \
portalcmds.o prepare.o proclang.o \
schemacmds.o sequence.o tablecmds.o tablespace.o trigger.o \
diff -cNr -x CVS cvs-pgsql/src/backend/commands/alter.c pgsql/src/backend/commands/alter.c
*** cvs-pgsql/src/backend/commands/alter.c Sun Jun 15 04:25:53 2008
--- pgsql/src/backend/commands/alter.c Fri Dec 12 10:44:15 2008
***************
*** 270,275 ****
--- 270,284 ----
AlterTSConfigurationOwner(stmt->object, newowner);
break;
+ case OBJECT_FDW:
+ AlterForeignDataWrapperOwner(strVal(linitial(stmt->object)),
+ newowner);
+ break;
+
+ case OBJECT_FOREIGN_SERVER:
+ AlterForeignServerOwner(strVal(linitial(stmt->object)), newowner);
+ break;
+
default:
elog(ERROR, "unrecognized AlterOwnerStmt type: %d",
(int) stmt->objectType);
diff -cNr -x CVS cvs-pgsql/src/backend/commands/foreigncmds.c pgsql/src/backend/commands/foreigncmds.c
*** cvs-pgsql/src/backend/commands/foreigncmds.c Thu Jan 1 02:00:00 1970
--- pgsql/src/backend/commands/foreigncmds.c Fri Dec 12 11:06:24 2008
***************
*** 0 ****
--- 1,1103 ----
+ /*-------------------------------------------------------------------------
+ *
+ * foreigncmds.c
+ * foreign-data wrapper/server creation/manipulation commands
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ *
+ *
+ * IDENTIFICATION
+ * $PostgreSQL$
+ *
+ *-------------------------------------------------------------------------
+ */
+ #include "postgres.h"
+
+ #include "access/heapam.h"
+ #include "access/reloptions.h"
+ #include "catalog/catalog.h"
+ #include "catalog/dependency.h"
+ #include "catalog/indexing.h"
+ #include "catalog/pg_foreign_data_wrapper.h"
+ #include "catalog/pg_foreign_server.h"
+ #include "catalog/pg_type.h"
+ #include "catalog/pg_user_mapping.h"
+ #include "commands/defrem.h"
+ #include "foreign/foreign.h"
+ #include "miscadmin.h"
+ #include "utils/acl.h"
+ #include "utils/builtins.h"
+ #include "utils/lsyscache.h"
+ #include "utils/rel.h"
+ #include "utils/syscache.h"
+
+
+ /*
+ * Convert a DefElem list to the text array format that is used in
+ * pg_foreign_data_wrapper, pg_foreign_server, and pg_user_mapping.
+ *
+ * Note: The array is usually stored to database without further
+ * processing, hence any validation should be done before this
+ * conversion.
+ */
+ static Datum
+ optionListToArray(List *options)
+ {
+ ArrayBuildState *astate = NULL;
+ ListCell *cell;
+ text *t;
+
+ foreach (cell, options)
+ {
+ DefElem *def = lfirst(cell);
+ const char *value = "";
+ Size len;
+
+ value = defGetString(def);
+ len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value);
+ t = palloc(len + 1);
+ SET_VARSIZE(t, len);
+ sprintf(VARDATA(t), "%s=%s", def->defname, value);
+
+ astate = accumArrayResult(astate, PointerGetDatum(t),
+ false, TEXTOID,
+ CurrentMemoryContext);
+ }
+
+ if (astate)
+ return makeArrayResult(astate, CurrentMemoryContext);
+
+ return PointerGetDatum(NULL);
+ }
+
+
+ /*
+ * Transform the list of OptionDefElem into list of generic options.
+ * The result is converted to array of text suitable for storing in
+ * options.
+ *
+ * This is used by CREATE/ALTER of FOREIGN DATA WRAPPER/SERVER/USER
+ * MAPPING. In the ALTER cases, oldOptions is the current text array
+ * of options.
+ */
+ static Datum
+ transformGenericOptions(Datum oldOptions,
+ List *optionDefList,
+ GenericOptionFlags flags,
+ ForeignDataWrapper *fdw,
+ OptionListValidatorFunc validateOptionList)
+ {
+ List *resultOptions = untransformRelOptions(oldOptions);
+ ListCell *optcell;
+
+ foreach (optcell, optionDefList)
+ {
+ ListCell *cell;
+ ListCell *prev = NULL;
+ OptionDefElem *od = lfirst(optcell);
+
+ /*
+ * Find the element in resultOptions. We need this for
+ * validation in all cases.
+ */
+ foreach (cell, resultOptions)
+ {
+ DefElem *def = lfirst(cell);
+
+ if (strcmp(def->defname, od->def->defname) == 0)
+ break;
+ else
+ prev = cell;
+ }
+
+ /*
+ * At the moment it possible to perform multiple SET/DROP
+ * actions on the same option -- The standard permits this, as
+ * long as the options to be added are unique.
+ */
+
+ switch (od->alter_op)
+ {
+ case ALTER_OPT_DROP:
+ if (!cell)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("option \"%s\" not found",
+ od->def->defname)));
+ resultOptions = list_delete_cell(resultOptions, cell, prev);
+ break;
+
+ case ALTER_OPT_SET:
+ if (!cell)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("option \"%s\" not found",
+ od->def->defname)));
+ lfirst(cell) = od->def;
+ break;
+
+ case ALTER_OPT_ADD:
+ if (cell)
+ ereport(ERROR,
+ (errcode(ERRCODE_DUPLICATE_OBJECT),
+ errmsg("option \"%s\" provided more than once",
+ od->def->defname)));
+ resultOptions = lappend(resultOptions, od->def);
+ break;
+
+ default:
+ elog(ERROR, "unrecognized action %d on option \"%s\"",
+ od->alter_op, od->def->defname);
+ break;
+ }
+ }
+
+ if (validateOptionList)
+ validateOptionList(fdw, flags, resultOptions);
+
+ return optionListToArray(resultOptions);
+ }
+
+
+ /*
+ * Convert the user mapping user name to Oid
+ */
+ static Oid
+ GetUserOidFromMapping(const char *username, bool missing_ok)
+ {
+ if (!username)
+ /* PUBLIC user mapping */
+ return InvalidOid;
+
+ if (strcmp(username, "current_user") == 0)
+ /* map to the owner */
+ return GetUserId();
+
+ /* map to provided user */
+ return missing_ok ? get_roleid(username) : get_roleid_checked(username);
+ }
+
+
+ /*
+ * Change foreign-data wrapper owner.
+ *
+ * Allow this only for superusers; also the new owner must be a
+ * superuser.
+ */
+ void
+ AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId)
+ {
+ HeapTuple tup;
+ Relation rel;
+ Oid fdwId;
+
+ Form_pg_foreign_data_wrapper form;
+
+ /* Must be a superuser to change a FDW owner */
+ if (!superuser())
+ ereport(ERROR,
+ (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ errmsg("permission denied to change owner of foreign-data wrapper \"%s\"",
+ name),
+ errhint("Must be superuser to change owner of a foreign-data wrapper.")));
+
+ /* New owner must also be a superuser */
+ if (!superuser_arg(newOwnerId))
+ ereport(ERROR,
+ (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ errmsg("permission denied to change owner of foreign-data wrapper \"%s\"",
+ name),
+ errhint("The owner of a foreign-data wrapper must be a superuser.")));
+
+ rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
+
+ tup = SearchSysCacheCopy(FOREIGNDATAWRAPPERNAME,
+ CStringGetDatum(name),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("foreign-data wrapper \"%s\" does not exist", name)));
+
+ fdwId = HeapTupleGetOid(tup);
+ form = (Form_pg_foreign_data_wrapper) GETSTRUCT(tup);
+
+ if (form->fdwowner != newOwnerId)
+ {
+ form->fdwowner = newOwnerId;
+
+ simple_heap_update(rel, &tup->t_self, tup);
+ CatalogUpdateIndexes(rel, tup);
+
+ /* Update owner dependency reference */
+ changeDependencyOnOwner(ForeignDataWrapperRelationId,
+ fdwId,
+ newOwnerId);
+ }
+
+ heap_close(rel, NoLock);
+ heap_freetuple(tup);
+ }
+
+
+ /*
+ * Change foreign server owner
+ */
+ void
+ AlterForeignServerOwner(const char *name, Oid newOwnerId)
+ {
+ HeapTuple tup;
+ Relation rel;
+ Oid srvId;
+ AclResult aclresult;
+ Form_pg_foreign_server form;
+
+ rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
+
+ tup = SearchSysCacheCopy(FOREIGNSERVERNAME,
+ CStringGetDatum(name),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tup))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("server \"%s\" does not exist", name)));
+
+ srvId = HeapTupleGetOid(tup);
+ form = (Form_pg_foreign_server) GETSTRUCT(tup);
+
+ if (form->srvowner != newOwnerId)
+ {
+ /* Superusers can always do it */
+ if (!superuser())
+ {
+ /* Must be owner */
+ if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
+ name);
+
+ /* Must be able to become new owner */
+ check_is_member_of_role(GetUserId(), newOwnerId);
+
+ /* New owner must have USAGE privilege on foreign-data wrapper */
+ aclresult = pg_foreign_data_wrapper_aclcheck(form->srvfdw, newOwnerId, ACL_USAGE);
+ if (aclresult != ACLCHECK_OK)
+ {
+ ForeignDataWrapper *fdw = GetForeignDataWrapper(form->srvfdw);
+
+ aclcheck_error(aclresult, ACL_KIND_FDW, fdw->fdwname);
+ }
+ }
+
+ form->srvowner = newOwnerId;
+
+ simple_heap_update(rel, &tup->t_self, tup);
+ CatalogUpdateIndexes(rel, tup);
+
+ /* Update owner dependency reference */
+ changeDependencyOnOwner(ForeignServerRelationId, HeapTupleGetOid(tup),
+ newOwnerId);
+ }
+
+ heap_close(rel, NoLock);
+ heap_freetuple(tup);
+ }
+
+
+ /*
+ * Create a foreign-data wrapper
+ */
+ void
+ CreateForeignDataWrapper(CreateFdwStmt *stmt)
+ {
+ Relation rel;
+ Datum values[Natts_pg_foreign_data_wrapper];
+ bool nulls[Natts_pg_foreign_data_wrapper];
+ HeapTuple tuple;
+ Oid fdwId;
+ Datum fdwoptions = InvalidOid;
+ Oid ownerId;
+ ForeignDataWrapperLibrary *fdwlib;
+
+ /* Must be super user */
+ if (!superuser())
+ ereport(ERROR,
+ (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ errmsg("permission denied to create foreign-data wrapper \"%s\"",
+ stmt->fdwname),
+ errhint("Must be superuser to create a foreign-data wrapper.")));
+
+ /* For now the owner cannot be specified on create. Use effective user id */
+ ownerId = GetUserId();
+
+ /*
+ * Check that there is no other foreign-data wrapper by this name.
+ */
+ if (GetForeignDataWrapperByName(stmt->fdwname, true) != NULL)
+ ereport(ERROR,
+ (errcode(ERRCODE_DUPLICATE_OBJECT),
+ errmsg("foreign-data wrapper \"%s\" already exists",
+ stmt->fdwname)));
+
+ /*
+ * Insert tuple into pg_foreign_data_wrapper.
+ */
+ rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
+
+ MemSet(nulls, false, Natts_pg_foreign_data_wrapper);
+
+ values[Anum_pg_foreign_data_wrapper_fdwname - 1] =
+ DirectFunctionCall1(namein, CStringGetDatum(stmt->fdwname));
+ values[Anum_pg_foreign_data_wrapper_fdwowner - 1] = ObjectIdGetDatum(ownerId);
+ values[Anum_pg_foreign_data_wrapper_fdwlibrary - 1] = CStringGetTextDatum(stmt->library);
+ nulls[Anum_pg_foreign_data_wrapper_fdwacl - 1] = true;
+
+ /*
+ * See if the FDW library loads at all. We also might want to use it
+ * later for validating the options.
+ */
+ fdwlib = GetForeignDataWrapperLibrary(stmt->library);
+
+ fdwoptions = transformGenericOptions(0, stmt->options, FdwOpt, NULL,
+ fdwlib->validateOptionList);
+
+ if (OidIsValid(fdwoptions))
+ values[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = fdwoptions;
+ else
+ nulls[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
+
+ tuple = heap_form_tuple(rel->rd_att, values, nulls);
+
+ fdwId = simple_heap_insert(rel, tuple);
+ CatalogUpdateIndexes(rel, tuple);
+
+ heap_freetuple(tuple);
+
+ recordDependencyOnOwner(ForeignDataWrapperRelationId, fdwId, ownerId);
+
+ heap_close(rel, NoLock);
+ }
+
+
+ /*
+ * Alter foreign-data wrapper
+ */
+ void
+ AlterForeignDataWrapper(AlterFdwStmt *stmt)
+ {
+ Relation rel;
+ HeapTuple tp;
+ Datum repl_val[Natts_pg_foreign_data_wrapper];
+ bool repl_null[Natts_pg_foreign_data_wrapper];
+ bool repl_repl[Natts_pg_foreign_data_wrapper];
+ Oid fdwId;
+ bool isnull;
+ Datum datum;
+ ForeignDataWrapperLibrary *fdwlib;
+
+ /* Must be super user */
+ if (!superuser())
+ ereport(ERROR,
+ (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ errmsg("permission denied to alter foreign-data wrapper \"%s\"",
+ stmt->fdwname),
+ errhint("Must be superuser to alter a foreign-data wrapper.")));
+
+ tp = SearchSysCacheCopy(FOREIGNDATAWRAPPERNAME,
+ CStringGetDatum(stmt->fdwname),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("foreign-data wrapper \"%s\" does not exist", stmt->fdwname)));
+
+ fdwId = HeapTupleGetOid(tp);
+
+ memset(repl_val, 0, sizeof(repl_val));
+ memset(repl_null, false, sizeof(repl_null));
+ memset(repl_repl, false, sizeof(repl_repl));
+
+ if (stmt->library)
+ {
+ /*
+ * New library specified -- load to see if valid.
+ */
+ fdwlib = GetForeignDataWrapperLibrary(stmt->library);
+
+ repl_val[Anum_pg_foreign_data_wrapper_fdwlibrary - 1] = CStringGetTextDatum(stmt->library);
+ repl_repl[Anum_pg_foreign_data_wrapper_fdwlibrary - 1] = true;
+
+ /*
+ * It could be that the options for the FDW, SERVER and USER MAPPING
+ * are no longer valid with the new library. Warn about this.
+ */
+ ereport(WARNING,
+ (errmsg("changing the foreign-data wrapper library can cause "
+ "the options for dependent objects to become invalid")));
+ }
+ else
+ {
+ /*
+ * No LIBRARY clause specified, but we need to load it for validating
+ * options.
+ */
+ datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
+ tp,
+ Anum_pg_foreign_data_wrapper_fdwlibrary,
+ &isnull);
+ fdwlib = GetForeignDataWrapperLibrary(TextDatumGetCString(datum));
+ }
+
+ /*
+ * Options specified, validate and update.
+ */
+ if (stmt->options)
+ {
+ /* Extract the current options */
+ datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
+ tp,
+ Anum_pg_foreign_data_wrapper_fdwoptions,
+ &isnull);
+
+ /* Transform the options */
+ datum = transformGenericOptions(datum, stmt->options, FdwOpt,
+ NULL, fdwlib->validateOptionList);
+
+ if (OidIsValid(datum))
+ repl_val[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = ObjectIdGetDatum(datum);
+ else
+ repl_null[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
+
+ repl_repl[Anum_pg_foreign_data_wrapper_fdwoptions - 1] = true;
+ }
+
+ /* Everything looks good - update the tuple */
+
+ rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
+
+ tp = heap_modify_tuple(tp, RelationGetDescr(rel),
+ repl_val, repl_null, repl_repl);
+
+ simple_heap_update(rel, &tp->t_self, tp);
+ CatalogUpdateIndexes(rel, tp);
+
+ heap_close(rel, RowExclusiveLock);
+ heap_freetuple(tp);
+ }
+
+
+ /*
+ * Drop foreign-data wrapper
+ */
+ void
+ RemoveForeignDataWrapper(DropFdwStmt *stmt)
+ {
+ Oid fdwId;
+ ObjectAddress object;
+
+ fdwId = GetForeignDataWrapperOidByName(stmt->fdwname, true);
+
+ if (!superuser())
+ ereport(ERROR,
+ (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ errmsg("permission denied to drop foreign-data wrapper \"%s\"",
+ stmt->fdwname),
+ errhint("Must be superuser to drop a foreign-data wrapper.")));
+
+ if (!OidIsValid(fdwId))
+ {
+ if (!stmt->missing_ok)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("foreign-data wrapper \"%s\" does not exist",
+ stmt->fdwname)));
+
+ /* IF EXISTS specified, just note it */
+ ereport(NOTICE,
+ (errmsg("foreign-data wrapper \"%s\" does not exist, skipping",
+ stmt->fdwname)));
+ return;
+ }
+
+ /*
+ * Do the deletion
+ */
+ object.classId = ForeignDataWrapperRelationId;
+ object.objectId = fdwId;
+ object.objectSubId = 0;
+
+ performDeletion(&object, stmt->behavior);
+ }
+
+
+ /*
+ * Drop foreign-data wrapper by Oid.
+ */
+ void
+ RemoveForeignDataWrapperById(Oid fdwId)
+ {
+ HeapTuple tp;
+ Relation rel;
+
+ rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
+
+ tp = SearchSysCache(FOREIGNDATAWRAPPEROID,
+ ObjectIdGetDatum(fdwId),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ elog(ERROR, "cache lookup failed for foreign-data wrapper %u", fdwId);
+
+ simple_heap_delete(rel, &tp->t_self);
+
+ ReleaseSysCache(tp);
+
+ heap_close(rel, RowExclusiveLock);
+ }
+
+
+ /*
+ * Create a foreign server
+ */
+ void
+ CreateForeignServer(CreateForeignServerStmt *stmt)
+ {
+ Relation rel;
+ Datum srvoptions = InvalidOid;
+ Datum values[Natts_pg_foreign_server];
+ bool nulls[Natts_pg_foreign_server];
+ HeapTuple tuple;
+ Oid srvId;
+ Oid ownerId;
+ AclResult aclresult;
+ ObjectAddress myself;
+ ObjectAddress referenced;
+ ForeignDataWrapper *fdw;
+
+ /* For now the owner cannot be specified on create. Use effective user id */
+ ownerId = GetUserId();
+
+ /*
+ * Check that there is no other foreign server by this name.
+ */
+ if (GetForeignServerByName(stmt->servername, true) != NULL)
+ ereport(ERROR,
+ (errcode(ERRCODE_DUPLICATE_OBJECT),
+ errmsg("server \"%s\" already exists",
+ stmt->servername)));
+
+ /*
+ * Check that the FDW exists and that we have USAGE on it.
+ * Also get the actual FDW for option validation etc.
+ */
+ fdw = GetForeignDataWrapperByName(stmt->fdwname, false);
+
+ aclresult = pg_foreign_data_wrapper_aclcheck(fdw->fdwid, ownerId, ACL_USAGE);
+ if (aclresult != ACLCHECK_OK)
+ aclcheck_error(aclresult, ACL_KIND_FDW, fdw->fdwname);
+
+ /*
+ * Insert tuple into pg_foreign_server.
+ */
+ rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
+
+ MemSet(nulls, false, Natts_pg_foreign_server);
+
+ values[Anum_pg_foreign_server_srvname - 1] =
+ DirectFunctionCall1(namein, CStringGetDatum(stmt->servername));
+ values[Anum_pg_foreign_server_srvowner - 1] = ObjectIdGetDatum(ownerId);
+ values[Anum_pg_foreign_server_srvfdw - 1] = ObjectIdGetDatum(fdw->fdwid);
+
+ /* Add server type if supplied */
+ if (stmt->servertype)
+ values[Anum_pg_foreign_server_srvtype - 1] =
+ CStringGetTextDatum(stmt->servertype);
+ else
+ nulls[Anum_pg_foreign_server_srvtype - 1] = true;
+
+ /* Add server version if supplied */
+ if (stmt->version)
+ values[Anum_pg_foreign_server_srvversion - 1] =
+ CStringGetTextDatum(stmt->version);
+ else
+ nulls[Anum_pg_foreign_server_srvversion - 1] = true;
+
+ /* Start with a blank acl */
+ nulls[Anum_pg_foreign_server_srvacl - 1] = true;
+
+ /* Add server options */
+ srvoptions = transformGenericOptions(0, stmt->options, ServerOpt, fdw,
+ fdw->lib->validateOptionList);
+
+ if (OidIsValid(srvoptions))
+ values[Anum_pg_foreign_server_srvoptions - 1] = srvoptions;
+ else
+ nulls[Anum_pg_foreign_server_srvoptions - 1] = true;
+
+ tuple = heap_form_tuple(rel->rd_att, values, nulls);
+
+ srvId = simple_heap_insert(rel, tuple);
+
+ CatalogUpdateIndexes(rel, tuple);
+
+ heap_freetuple(tuple);
+
+ /* Add dependency on FDW and owner */
+ myself.classId = ForeignServerRelationId;
+ myself.objectId = srvId;
+ myself.objectSubId = 0;
+
+ referenced.classId = ForeignDataWrapperRelationId;
+ referenced.objectId = fdw->fdwid;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+
+ recordDependencyOnOwner(ForeignServerRelationId, srvId, ownerId);
+
+ heap_close(rel, NoLock);
+ }
+
+
+ /*
+ * Alter foreign server
+ */
+ void
+ AlterForeignServer(AlterForeignServerStmt *stmt)
+ {
+ Relation rel;
+ HeapTuple tp;
+ Datum repl_val[Natts_pg_foreign_server];
+ bool repl_null[Natts_pg_foreign_server];
+ bool repl_repl[Natts_pg_foreign_server];
+ Oid srvId;
+ Form_pg_foreign_server srvForm;
+
+ tp = SearchSysCacheCopy(FOREIGNSERVERNAME,
+ CStringGetDatum(stmt->servername),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("server \"%s\" does not exist", stmt->servername)));
+
+ srvId = HeapTupleGetOid(tp);
+ srvForm = (Form_pg_foreign_server) GETSTRUCT(tp);
+
+ /*
+ * Only owner or a superuser can ALTER a SERVER.
+ */
+ if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
+ stmt->servername);
+
+ memset(repl_val, 0, sizeof(repl_val));
+ memset(repl_null, false, sizeof(repl_null));
+ memset(repl_repl, false, sizeof(repl_repl));
+
+ if (stmt->has_version)
+ {
+ /*
+ * Change the server VERSION string.
+ */
+ if (stmt->version)
+ repl_val[Anum_pg_foreign_server_srvversion - 1] =
+ CStringGetTextDatum(stmt->version);
+ else
+ repl_null[Anum_pg_foreign_server_srvversion - 1] = true;
+
+ repl_repl[Anum_pg_foreign_server_srvversion - 1] = true;
+ }
+
+ if (stmt->options)
+ {
+ ForeignDataWrapper *fdw = GetForeignDataWrapper(srvForm->srvfdw);
+ Datum datum;
+ bool isnull;
+
+ /* Extract the current srvoptions */
+ datum = SysCacheGetAttr(FOREIGNSERVEROID,
+ tp,
+ Anum_pg_foreign_server_srvoptions,
+ &isnull);
+
+ /* Prepare the options array */
+ datum = transformGenericOptions(datum, stmt->options, ServerOpt,
+ fdw, fdw->lib->validateOptionList);
+
+ if (OidIsValid(datum))
+ repl_val[Anum_pg_foreign_server_srvoptions - 1] = datum;
+ else
+ repl_null[Anum_pg_foreign_server_srvoptions - 1] = true;
+
+ repl_repl[Anum_pg_foreign_server_srvoptions - 1] = true;
+ }
+
+ /* Everything looks good - update the tuple */
+
+ rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
+
+ tp = heap_modify_tuple(tp, RelationGetDescr(rel),
+ repl_val, repl_null, repl_repl);
+
+ simple_heap_update(rel, &tp->t_self, tp);
+ CatalogUpdateIndexes(rel, tp);
+
+ heap_close(rel, RowExclusiveLock);
+ heap_freetuple(tp);
+ }
+
+
+ /*
+ * Drop foreign server
+ */
+ void
+ RemoveForeignServer(DropForeignServerStmt *stmt)
+ {
+ Oid srvId;
+ ObjectAddress object;
+
+ srvId = GetForeignServerOidByName(stmt->servername, true);
+
+ if (!OidIsValid(srvId))
+ {
+ /* Server not found, complain or notice */
+ if (!stmt->missing_ok)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("server \"%s\" does not exist", stmt->servername)));
+
+ /* IF EXISTS specified, just note it */
+ ereport(NOTICE,
+ (errmsg("server \"%s\" does not exist, skipping",
+ stmt->servername)));
+ return;
+ }
+
+ /* Only allow DROP if the server is owned by the user. */
+ if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
+ stmt->servername);
+
+ object.classId = ForeignServerRelationId;
+ object.objectId = srvId;
+ object.objectSubId = 0;
+
+ performDeletion(&object, stmt->behavior);
+ }
+
+
+ /*
+ * Drop foreign server by Oid
+ */
+ void
+ RemoveForeignServerById(Oid srvId)
+ {
+ HeapTuple tp;
+ Relation rel;
+
+ rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
+
+ tp = SearchSysCache(FOREIGNSERVEROID,
+ ObjectIdGetDatum(srvId),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ elog(ERROR, "cache lookup failed for foreign server %u", srvId);
+
+ simple_heap_delete(rel, &tp->t_self);
+
+ ReleaseSysCache(tp);
+
+ heap_close(rel, RowExclusiveLock);
+ }
+
+
+ /*
+ * Create user mapping
+ */
+ void
+ CreateUserMapping(CreateUserMappingStmt *stmt)
+ {
+ Relation rel;
+ Datum useoptions = InvalidOid;
+ Datum values[Natts_pg_user_mapping];
+ bool nulls[Natts_pg_user_mapping];
+ HeapTuple tuple;
+ Oid useId;
+ Oid umId;
+ Oid ownerId;
+ ObjectAddress myself;
+ ObjectAddress referenced;
+ ForeignServer *srv;
+ ForeignDataWrapper *fdw;
+
+ ownerId = GetUserId();
+
+ useId = GetUserOidFromMapping(stmt->username, false);
+
+ /*
+ * Check that the server exists and that the we own it.
+ */
+ srv = GetForeignServerByName(stmt->servername, false);
+
+ if (!pg_foreign_server_ownercheck(srv->serverid, ownerId))
+ aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
+ stmt->servername);
+
+ /*
+ * Check that the user mapping is unique within server.
+ */
+ umId = GetSysCacheOid(USERMAPPINGUSERSERVER,
+ ObjectIdGetDatum(useId),
+ ObjectIdGetDatum(srv->serverid),
+ 0, 0);
+ if (OidIsValid(umId))
+ ereport(ERROR,
+ (errcode(ERRCODE_DUPLICATE_OBJECT),
+ errmsg("user mapping \"%s\" already exists for server %s",
+ MappingUserName(useId),
+ stmt->servername)));
+
+ fdw = GetForeignDataWrapper(srv->fdwid);
+
+ /*
+ * Insert tuple into pg_user_mapping.
+ */
+ rel = heap_open(UserMappingRelationId, RowExclusiveLock);
+
+ MemSet(nulls, false, Natts_pg_user_mapping);
+
+ values[Anum_pg_user_mapping_umuser - 1] = ObjectIdGetDatum(useId);
+ values[Anum_pg_user_mapping_umserver - 1] = ObjectIdGetDatum(srv->serverid);
+
+ /* Add user options */
+ useoptions = transformGenericOptions(0, stmt->options, UserMappingOpt,
+ fdw, fdw->lib->validateOptionList);
+
+ if (OidIsValid(useoptions))
+ values[Anum_pg_user_mapping_umoptions - 1] = useoptions;
+ else
+ nulls[Anum_pg_user_mapping_umoptions - 1] = true;
+
+ tuple = heap_form_tuple(rel->rd_att, values, nulls);
+
+ umId = simple_heap_insert(rel, tuple);
+
+ CatalogUpdateIndexes(rel, tuple);
+
+ heap_freetuple(tuple);
+
+ /* Add dependency on the server */
+ myself.classId = UserMappingRelationId;
+ myself.objectId = umId;
+ myself.objectSubId = 0;
+
+ referenced.classId = ForeignServerRelationId;
+ referenced.objectId = srv->serverid;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+
+ if (OidIsValid(useId))
+ /* Record the mapped user dependency */
+ recordDependencyOnOwner(UserMappingRelationId, umId, useId);
+
+ heap_close(rel, NoLock);
+ }
+
+
+ /*
+ * Alter user mapping
+ */
+ void
+ AlterUserMapping(AlterUserMappingStmt *stmt)
+ {
+ Relation rel;
+ HeapTuple tp;
+ Datum repl_val[Natts_pg_user_mapping];
+ bool repl_null[Natts_pg_user_mapping];
+ bool repl_repl[Natts_pg_user_mapping];
+ Oid useId;
+ Oid umId;
+ ForeignServer *srv;
+
+ useId = GetUserOidFromMapping(stmt->username, false);
+ srv = GetForeignServerByName(stmt->servername, false);
+
+ umId = GetSysCacheOid(USERMAPPINGUSERSERVER,
+ ObjectIdGetDatum(useId),
+ ObjectIdGetDatum(srv->serverid),
+ 0, 0);
+ if (!OidIsValid(umId))
+ {
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("user mapping \"%s\" does not exist for the server",
+ MappingUserName(useId))));
+ }
+
+ /*
+ * Must be owner of the server to alter user mapping.
+ */
+ if (!pg_foreign_server_ownercheck(srv->serverid, GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
+ stmt->servername);
+
+ tp = SearchSysCacheCopy(USERMAPPINGOID,
+ ObjectIdGetDatum(umId),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ elog(ERROR, "cache lookup failed for user mapping %u", umId);
+
+ memset(repl_val, 0, sizeof(repl_val));
+ memset(repl_null, false, sizeof(repl_null));
+ memset(repl_repl, false, sizeof(repl_repl));
+
+ if (stmt->options)
+ {
+ ForeignDataWrapper *fdw;
+ Datum datum;
+ bool isnull;
+
+ /*
+ * Process the options.
+ */
+
+ fdw = GetForeignDataWrapper(srv->fdwid);
+
+ datum = SysCacheGetAttr(USERMAPPINGUSERSERVER,
+ tp,
+ Anum_pg_user_mapping_umoptions,
+ &isnull);
+
+ /* Prepare the options array */
+ datum = transformGenericOptions(datum, stmt->options, UserMappingOpt,
+ fdw, fdw->lib->validateOptionList);
+
+ if (OidIsValid(datum))
+ repl_val[Anum_pg_user_mapping_umoptions - 1] = datum;
+ else
+ repl_null[Anum_pg_user_mapping_umoptions - 1] = true;
+
+ repl_repl[Anum_pg_user_mapping_umoptions - 1] = true;
+ }
+
+ /* Everything looks good - update the tuple */
+
+ rel = heap_open(UserMappingRelationId, RowExclusiveLock);
+
+ tp = heap_modify_tuple(tp, RelationGetDescr(rel),
+ repl_val, repl_null, repl_repl);
+
+ simple_heap_update(rel, &tp->t_self, tp);
+ CatalogUpdateIndexes(rel, tp);
+
+ heap_close(rel, RowExclusiveLock);
+ heap_freetuple(tp);
+ }
+
+
+ /*
+ * Drop user mapping
+ */
+ void
+ RemoveUserMapping(DropUserMappingStmt *stmt)
+ {
+ ObjectAddress object;
+ Oid useId;
+ Oid umId;
+ ForeignServer *srv;
+
+ useId = GetUserOidFromMapping(stmt->username, stmt->missing_ok);
+ srv = GetForeignServerByName(stmt->servername, true);
+
+ if (stmt->username && !OidIsValid(useId))
+ {
+ /*
+ * IF EXISTS specified, role not found and not public.
+ * Notice this and leave.
+ */
+ elog(NOTICE, "role \"%s\" does not exist, skipping", stmt->username);
+ return;
+ }
+
+ if (!srv)
+ {
+ if (!stmt->missing_ok)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("server \"%s\" does not exist",
+ stmt->servername)));
+ /* IF EXISTS, just note it */
+ ereport(NOTICE, (errmsg("server does not exist, skipping")));
+ return;
+ }
+
+ umId = GetSysCacheOid(USERMAPPINGUSERSERVER,
+ ObjectIdGetDatum(useId),
+ ObjectIdGetDatum(srv->serverid),
+ 0, 0);
+
+ if (!OidIsValid(umId))
+ {
+ if (!stmt->missing_ok)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("user mapping \"%s\" does not exist for the server",
+ MappingUserName(useId))));
+
+ /* IF EXISTS specified, just note it */
+ ereport(NOTICE,
+ (errmsg("user mapping \"%s\" does not exist for the server, skipping",
+ MappingUserName(useId))));
+ return;
+ }
+
+ /*
+ * Only allow DROP if we own the server.
+ */
+ if (!pg_foreign_server_ownercheck(srv->serverid, GetUserId()))
+ {
+ aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_FOREIGN_SERVER,
+ srv->servername);
+ }
+
+ /*
+ * Do the deletion
+ */
+ object.classId = UserMappingRelationId;
+ object.objectId = umId;
+ object.objectSubId = 0;
+
+ performDeletion(&object, DROP_CASCADE);
+ }
+
+
+ /*
+ * Drop user mapping by oid - this is called to clean up
+ * dependencies.
+ */
+ void
+ RemoveUserMappingById(Oid umId)
+ {
+ HeapTuple tp;
+ Relation rel;
+
+ rel = heap_open(UserMappingRelationId, RowExclusiveLock);
+
+ tp = SearchSysCache(USERMAPPINGOID,
+ ObjectIdGetDatum(umId),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ elog(ERROR, "cache lookup failed for user mapping %u", umId);
+
+ simple_heap_delete(rel, &tp->t_self);
+
+ ReleaseSysCache(tp);
+
+ heap_close(rel, RowExclusiveLock);
+ }
diff -cNr -x CVS cvs-pgsql/src/backend/foreign/Makefile pgsql/src/backend/foreign/Makefile
*** cvs-pgsql/src/backend/foreign/Makefile Thu Jan 1 02:00:00 1970
--- pgsql/src/backend/foreign/Makefile Mon Dec 15 13:23:47 2008
***************
*** 0 ****
--- 1,25 ----
+ #-------------------------------------------------------------------------
+ #
+ # Makefile--
+ # Makefile for foreign
+ #
+ # IDENTIFICATION
+ # $PostgreSQL$
+ #
+ #-------------------------------------------------------------------------
+
+ subdir = src/backend/foreign
+ top_builddir = ../../..
+ include $(top_builddir)/src/Makefile.global
+
+ OBJS= foreign.o
+
+ include $(top_srcdir)/src/backend/common.mk
+
+ FDW = dummy postgresql
+
+ $(addsuffix -fdw,all install installdirs uninstall distprep):
+ for dir in $(FDW); do $(MAKE) -C $$dir `echo $@ | sed 's/-fdw$$//'` || exit; done
+
+ clean distclean maintainer-clean:
+ for dir in $(FDW); do $(MAKE) -C $$dir $@ || exit; done
diff -cNr -x CVS cvs-pgsql/src/backend/foreign/dummy/Makefile pgsql/src/backend/foreign/dummy/Makefile
*** cvs-pgsql/src/backend/foreign/dummy/Makefile Thu Jan 1 02:00:00 1970
--- pgsql/src/backend/foreign/dummy/Makefile Mon Dec 15 13:23:21 2008
***************
*** 0 ****
--- 1,27 ----
+ #-------------------------------------------------------------------------
+ #
+ # Makefile--
+ # Makefile for dummy foreign-data wrapper
+ #
+ # IDENTIFICATION
+ # $PostgreSQL$
+ #
+ #-------------------------------------------------------------------------
+
+ subdir = src/backend/foreign/dummy
+ top_builddir = ../../../..
+ include $(top_builddir)/src/Makefile.global
+
+ NAME = dummy_fdw
+ OBJS = dummy_fdw.o
+
+ include $(top_srcdir)/src/Makefile.shlib
+
+ all: all-shared-lib
+
+ install: all install-lib
+
+ installdirs: installdirs-lib
+
+ clean distclean maintainer-clean: clean-lib
+ rm -f $(OBJS)
diff -cNr -x CVS cvs-pgsql/src/backend/foreign/dummy/dummy_fdw.c pgsql/src/backend/foreign/dummy/dummy_fdw.c
*** cvs-pgsql/src/backend/foreign/dummy/dummy_fdw.c Thu Jan 1 02:00:00 1970
--- pgsql/src/backend/foreign/dummy/dummy_fdw.c Tue Dec 16 16:16:53 2008
***************
*** 0 ****
--- 1,57 ----
+ /*-------------------------------------------------------------------------
+ *
+ * dummy_fdw.c
+ * "dummy" foreign-data wrapper
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ * $PostgreSQL$
+ *
+ *-------------------------------------------------------------------------
+ */
+ #include "postgres.h"
+
+ #include "fmgr.h"
+ #include "foreign/foreign.h"
+
+ PG_MODULE_MAGIC;
+
+
+ /*
+ * Validate the DefElem list given as FDW, SERVER or USER MAPPING generic
+ * options. "flag" indicates which kind of options are we interested in.
+ * Raise an ERROR if the option or its value is considered.
+ *
+ * Note: When validating new FDW the fdw parameter is NULL.
+ *
+ * No validation in the dummy wrapper.
+ */
+ void
+ _pg_validateOptionList(ForeignDataWrapper *fdw, GenericOptionFlags flags,
+ List *options)
+ {
+ }
+
+ /*
+ * Provide the connection details as DefElem list. Here, in the dummy
+ * FDW we just merge all of the server and user mapping options and
+ * hope that the client can cope with that.
+ */
+ List *
+ _pg_GetConnectionInfo(ForeignDataWrapper *fdw, ForeignServer *server,
+ UserMapping *um)
+ {
+ List *result = NIL;
+ ListCell *cell;
+
+ /* Add server options */
+ foreach (cell, server->options)
+ result = lappend(result, lfirst(cell));
+ /* Add user mapping options */
+ foreach (cell, um->options)
+ result = lappend(result, lfirst(cell));
+
+ /* And we're done */
+ return result;
+ }
diff -cNr -x CVS cvs-pgsql/src/backend/foreign/foreign.c pgsql/src/backend/foreign/foreign.c
*** cvs-pgsql/src/backend/foreign/foreign.c Thu Jan 1 02:00:00 1970
--- pgsql/src/backend/foreign/foreign.c Tue Dec 16 16:45:07 2008
***************
*** 0 ****
--- 1,536 ----
+ /*-------------------------------------------------------------------------
+ *
+ * foreign.c
+ * support for foreign-data wrappers, servers and user mappings.
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ * $PostgreSQL$
+ *
+ *-------------------------------------------------------------------------
+ */
+ #include "postgres.h"
+
+ #include "access/reloptions.h"
+ #include "catalog/namespace.h"
+ #include "catalog/pg_foreign_data_wrapper.h"
+ #include "catalog/pg_foreign_server.h"
+ #include "catalog/pg_type.h"
+ #include "catalog/pg_user_mapping.h"
+ #include "foreign/foreign.h"
+ #include "funcapi.h"
+ #include "miscadmin.h"
+ #include "nodes/parsenodes.h"
+ #include "utils/acl.h"
+ #include "utils/array.h"
+ #include "utils/builtins.h"
+ #include "utils/lsyscache.h"
+ #include "utils/memutils.h"
+ #include "utils/syscache.h"
+
+
+ extern Datum pg_get_remote_connection_info(PG_FUNCTION_ARGS);
+ extern Datum pg_get_user_mapping_options(PG_FUNCTION_ARGS);
+ extern Datum pg_get_foreign_data_wrapper_options(PG_FUNCTION_ARGS);
+ extern Datum pg_get_foreign_server_options(PG_FUNCTION_ARGS);
+
+
+ /* list of currently loaded foreign-data wrapper interfaces */
+ static List *loaded_fdw_interfaces = NIL;
+
+
+ /*
+ * GetForeignDataWrapperLibrary - return the named FDW library. If it
+ * is already loaded, use that. Otherwise allocate, initialize, and
+ * store in cache.
+ */
+ ForeignDataWrapperLibrary *
+ GetForeignDataWrapperLibrary(const char *libname)
+ {
+ MemoryContext oldcontext;
+ void *libhandle = NULL;
+ ForeignDataWrapperLibrary *fdwl = NULL;
+ ListCell *cell;
+
+ /* See if we have the FDW library is already loaded */
+ foreach (cell, loaded_fdw_interfaces)
+ {
+ fdwl = lfirst(cell);
+ if (strcmp(fdwl->libname, libname) == 0)
+ return fdwl;
+ }
+
+ /*
+ * We don't have it yet, so load and add. Attempt a load_file()
+ * first to filter out any missing or unloadable libraries.
+ */
+ load_file(libname, false);
+
+ oldcontext = MemoryContextSwitchTo(TopMemoryContext);
+
+ fdwl = palloc(sizeof(*fdwl));
+ fdwl->libname = pstrdup(libname);
+ loaded_fdw_interfaces = lappend(loaded_fdw_interfaces, fdwl);
+
+ MemoryContextSwitchTo(oldcontext);
+
+ /*
+ * Now look up the foreign data wrapper functions.
+ */
+ #define LOOKUP_FUNCTION(name) \
+ (void *)(libhandle ? \
+ lookup_external_function(libhandle, name) \
+ : load_external_function(fdwl->libname, name, false, &libhandle))
+
+ fdwl->GetConnectionInfo = LOOKUP_FUNCTION("_pg_GetConnectionInfo");
+ fdwl->validateOptionList = LOOKUP_FUNCTION("_pg_validateOptionList");
+
+ return fdwl;
+ }
+
+
+ /*
+ * GetForeignDataWrapper - look up the foreign-data wrapper by OID.
+ *
+ * Here we also deal with loading the FDW library and looking up the
+ * actual functions.
+ */
+ ForeignDataWrapper *
+ GetForeignDataWrapper(Oid fdwid)
+ {
+ Form_pg_foreign_data_wrapper fdwform;
+ ForeignDataWrapper *fdw;
+ Datum datum;
+ HeapTuple tp;
+ bool isnull;
+
+ tp = SearchSysCache(FOREIGNDATAWRAPPEROID,
+ ObjectIdGetDatum(fdwid),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ elog(ERROR, "cache lookup failed for foreign-data wrapper %u", fdwid);
+
+ fdwform = (Form_pg_foreign_data_wrapper) GETSTRUCT(tp);
+
+ fdw = palloc(sizeof(ForeignDataWrapper));
+ fdw->fdwid = fdwid;
+ fdw->owner = fdwform->fdwowner;
+ fdw->fdwname = pstrdup(NameStr(fdwform->fdwname));
+
+ /* Extract library name */
+ datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
+ tp,
+ Anum_pg_foreign_data_wrapper_fdwlibrary,
+ &isnull);
+ fdw->fdwlibrary = pstrdup(TextDatumGetCString(datum));
+
+ fdw->lib = GetForeignDataWrapperLibrary(fdw->fdwlibrary);
+
+ /* Extract the useoptions */
+ datum = SysCacheGetAttr(FOREIGNDATAWRAPPEROID,
+ tp,
+ Anum_pg_foreign_data_wrapper_fdwoptions,
+ &isnull);
+ fdw->options = untransformRelOptions(datum);
+
+ ReleaseSysCache(tp);
+
+ return fdw;
+ }
+
+
+ /*
+ * GetForeignDataWrapperOidByName - look up the foreign-data wrapper
+ * OID by name.
+ */
+ Oid
+ GetForeignDataWrapperOidByName(const char *fdwname, bool missing_ok)
+ {
+ Oid fdwId;
+
+ fdwId = GetSysCacheOid(FOREIGNDATAWRAPPERNAME,
+ CStringGetDatum(fdwname),
+ 0, 0, 0);
+
+ if (!OidIsValid(fdwId) && !missing_ok)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("foreign-data wrapper \"%s\" does not exist", fdwname)));
+
+ return fdwId;
+ }
+
+
+ /*
+ * GetForeignDataWrapperByName - look up the foreign-data wrapper
+ * definition by name.
+ */
+ ForeignDataWrapper *
+ GetForeignDataWrapperByName(const char *fdwname, bool missing_ok)
+ {
+ Oid fdwId = GetForeignDataWrapperOidByName(fdwname, missing_ok);
+
+ if (!OidIsValid(fdwId) && missing_ok)
+ return NULL;
+
+ return GetForeignDataWrapper(fdwId);
+ }
+
+
+ /*
+ * GetForeignServer - look up the foreign server definition.
+ */
+ ForeignServer *
+ GetForeignServer(Oid serverid)
+ {
+ Form_pg_foreign_server serverform;
+ ForeignServer *server;
+ HeapTuple tp;
+ Datum datum;
+ bool isnull;
+
+ tp = SearchSysCache(FOREIGNSERVEROID,
+ ObjectIdGetDatum(serverid),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ elog(ERROR, "cache lookup failed for foreign server %u", serverid);
+
+ serverform = (Form_pg_foreign_server) GETSTRUCT(tp);
+
+ server = palloc(sizeof(ForeignServer));
+ server->serverid = serverid;
+ server->servername = pstrdup(NameStr(serverform->srvname));
+ server->owner = serverform->srvowner;
+ server->fdwid = serverform->srvfdw;
+
+ /* Extract server type */
+ datum = SysCacheGetAttr(FOREIGNSERVEROID,
+ tp,
+ Anum_pg_foreign_server_srvtype,
+ &isnull);
+ server->servertype = isnull ? NULL : pstrdup(TextDatumGetCString(datum));
+
+ /* Extract server version */
+ datum = SysCacheGetAttr(FOREIGNSERVEROID,
+ tp,
+ Anum_pg_foreign_server_srvversion,
+ &isnull);
+ server->serverversion = isnull ? NULL : pstrdup(TextDatumGetCString(datum));
+
+ /* Extract the srvoptions */
+ datum = SysCacheGetAttr(FOREIGNSERVEROID,
+ tp,
+ Anum_pg_foreign_server_srvoptions,
+ &isnull);
+
+ /* untransformRelOptions does exactly what we want - avoid duplication */
+ server->options = untransformRelOptions(datum);
+
+ ReleaseSysCache(tp);
+
+ return server;
+ }
+
+
+ /*
+ * GetForeignServerByName - look up the foreign server oid by name.
+ */
+ Oid
+ GetForeignServerOidByName(const char *srvname, bool missing_ok)
+ {
+ Oid serverid;
+
+ serverid = GetSysCacheOid(FOREIGNSERVERNAME,
+ CStringGetDatum(srvname),
+ 0, 0, 0);
+
+ if (!OidIsValid(serverid) && !missing_ok)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("server \"%s\" does not exist", srvname)));
+
+ return serverid;
+ }
+
+
+ /*
+ * GetForeignServerByName - look up the foreign server definition by name.
+ */
+ ForeignServer *
+ GetForeignServerByName(const char *srvname, bool missing_ok)
+ {
+ Oid serverid = GetForeignServerOidByName(srvname, missing_ok);
+
+ if (!OidIsValid(serverid) && missing_ok)
+ return NULL;
+
+ return GetForeignServer(serverid);
+ }
+
+
+ /*
+ * GetUserMapping - look up the user mapping.
+ *
+ * If no mapping is found for the supplied user, we also look for
+ * PUBLIC mappings (userid == InvalidOid).
+ */
+ UserMapping *
+ GetUserMapping(Oid userid, Oid serverid)
+ {
+ Form_pg_user_mapping umform;
+ Datum datum;
+ HeapTuple tp;
+ bool isnull;
+ UserMapping *um;
+
+ tp = SearchSysCache(USERMAPPINGUSERSERVER,
+ ObjectIdGetDatum(userid),
+ ObjectIdGetDatum(serverid),
+ 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ {
+ /* Not found for the specific user -- try PUBLIC */
+ tp = SearchSysCache(USERMAPPINGUSERSERVER,
+ ObjectIdGetDatum(InvalidOid),
+ ObjectIdGetDatum(serverid),
+ 0, 0);
+ }
+
+ if (!HeapTupleIsValid(tp))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("user mapping not found for \"%s\"",
+ MappingUserName(userid))));
+
+ umform = (Form_pg_user_mapping) GETSTRUCT(tp);
+
+ /* Extract the umoptions */
+ datum = SysCacheGetAttr(USERMAPPINGUSERSERVER,
+ tp,
+ Anum_pg_user_mapping_umoptions,
+ &isnull);
+
+ um = palloc(sizeof(UserMapping));
+ um->userid = userid;
+ um->serverid = serverid;
+ um->options = untransformRelOptions(datum);
+
+ ReleaseSysCache(tp);
+
+ return um;
+ }
+
+
+ /*
+ * GetRemoteConnectionInfo
+ *
+ * Look up the server, FDW, and user mapping. For non-public mappings
+ * (userid != InvalidOid), first validate that the supplied user has
+ * USAGE on the server. Then call FDW to provide the connection
+ * details.
+ */
+ List *
+ GetRemoteConnectionInfo(Oid serverid, Oid userid)
+ {
+ ForeignServer *server;
+ UserMapping *um;
+ ForeignDataWrapper *fdw;
+ AclResult aclresult;
+
+ server = GetForeignServer(serverid);
+
+ /* check permissions */
+ if (OidIsValid(userid))
+ {
+ aclresult = pg_foreign_server_aclcheck(serverid, userid, ACL_USAGE);
+ if (aclresult != ACLCHECK_OK)
+ aclcheck_error(aclresult, ACL_KIND_FOREIGN_SERVER,
+ server->servername);
+ }
+
+ um = GetUserMapping(userid, serverid);
+ fdw = GetForeignDataWrapper(server->fdwid);
+
+ if (fdw->lib->GetConnectionInfo == NULL)
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("foreign-data wrapper does not provide connection lookup")));
+
+ return fdw->lib->GetConnectionInfo(fdw, server, um);
+ }
+
+
+ /*
+ * deflist_to_tuplestore - Helper function to convert DefElem list to
+ * tuplestore usable in SRF.
+ */
+ static void
+ deflist_to_tuplestore(ReturnSetInfo *rsinfo, List *options)
+ {
+ ListCell *cell;
+ TupleDesc tupdesc;
+ Tuplestorestate *tupstore;
+ Datum values[2];
+ bool nulls[2] = { 0 };
+ MemoryContext per_query_ctx;
+ MemoryContext oldcontext;
+
+ /* check to see if caller supports us returning a tuplestore */
+ if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("set-valued function called in context that cannot accept a set")));
+ if (!(rsinfo->allowedModes & SFRM_Materialize))
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("materialize mode required, but it is not " \
+ "allowed in this context")));
+
+ per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+ oldcontext = MemoryContextSwitchTo(per_query_ctx);
+
+ /*
+ * Now prepare the result set.
+ */
+ tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+ tupstore = tuplestore_begin_heap(true, false, work_mem);
+ rsinfo->returnMode = SFRM_Materialize;
+ rsinfo->setResult = tupstore;
+ rsinfo->setDesc = tupdesc;
+
+ foreach (cell, options)
+ {
+ DefElem *def = lfirst(cell);
+
+ values[0] = CStringGetTextDatum(def->defname);
+ values[1] = CStringGetTextDatum(((Value *)def->arg)->val.str);
+ tuplestore_putvalues(tupstore, tupdesc, values, nulls);
+ }
+
+ /* clean up and return the tuplestore */
+ tuplestore_donestoring(tupstore);
+
+ MemoryContextSwitchTo(oldcontext);
+ }
+
+
+ /*
+ * pg_get_remote_connection_info - provide connection details for the
+ * server/user pair.
+ *
+ * By default we use current effective user id for privilege check and
+ * user mapping lookup. Alternatively another username (or public) can
+ * be specified by second parameter.
+ *
+ */
+ Datum
+ pg_get_remote_connection_info(PG_FUNCTION_ARGS)
+ {
+ Name servername = PG_GETARG_NAME(0);
+ Oid userid;
+ ForeignServer *srv;
+
+ if (PG_NARGS() == 2)
+ {
+ /* Use the provided username for mapping and privilege check */
+ Name username = PG_GETARG_NAME(1);
+
+ if (pg_strcasecmp(NameStr(*username), "public") == 0)
+ userid = InvalidOid;
+ else
+ userid = get_roleid_checked(NameStr(*username));
+ }
+ else
+ {
+ /* Otherwise use the effective user id */
+ userid = GetUserId();
+ }
+
+ srv = GetForeignServerByName(NameStr(*servername), false);
+
+ deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo,
+ GetRemoteConnectionInfo(srv->serverid, userid));
+
+ return (Datum) 0;
+ }
+
+
+ /*
+ * pg_get_foreign_data_wrapper_options - Return the options for a
+ * foreign data wrapper.
+ *
+ * pg_get_foreign_data_wrapper_options(srvId IN text, option OUT text, value OUT text)
+ */
+ Datum
+ pg_get_foreign_data_wrapper_options(PG_FUNCTION_ARGS)
+ {
+ Oid fdwId = PG_GETARG_OID(0);
+ ForeignDataWrapper *fdw = GetForeignDataWrapper(fdwId);
+
+ deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo, fdw->options);
+
+ return (Datum) 0;
+ }
+
+
+ /*
+ * pg_get_foreign_server_options - Return the options for a foreign
+ * server.
+ *
+ * pg_get_foreign_server_options(srvId IN text, option OUT text, value OUT text)
+ */
+ Datum
+ pg_get_foreign_server_options(PG_FUNCTION_ARGS)
+ {
+ Oid srvId = PG_GETARG_OID(0);
+ ForeignServer *srv = GetForeignServer(srvId);
+
+ deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo, srv->options);
+
+ return (Datum) 0;
+ }
+
+
+ /*
+ * pg_get_user_mapping_options - Return the user mapping options for
+ * the specified mapping. The options are only visible to server
+ * owner or superuser -- return empty result set for others.
+ */
+ Datum
+ pg_get_user_mapping_options(PG_FUNCTION_ARGS)
+ {
+ Oid umId = PG_GETARG_OID(0);
+ Oid srvId;
+ Oid useId;
+ HeapTuple tp;
+ UserMapping *um;
+ List *umoptions = NIL;
+
+ tp = SearchSysCache(USERMAPPINGOID,
+ ObjectIdGetDatum(umId),
+ 0, 0, 0);
+
+ if (!HeapTupleIsValid(tp))
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("user mapping %u not found", umId)));
+
+ srvId = ((Form_pg_user_mapping) GETSTRUCT(tp))->umserver;
+ useId = ((Form_pg_user_mapping) GETSTRUCT(tp))->umuser;
+
+ ReleaseSysCache(tp);
+
+ um = GetUserMapping(useId, srvId);
+
+ /* Server owner -- OK to show user mapping options */
+ if (pg_foreign_server_ownercheck(srvId, GetUserId()))
+ umoptions = um->options;
+
+ deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo, umoptions);
+
+ return (Datum) 0;
+ }
diff -cNr -x CVS cvs-pgsql/src/backend/foreign/postgresql/Makefile pgsql/src/backend/foreign/postgresql/Makefile
*** cvs-pgsql/src/backend/foreign/postgresql/Makefile Thu Jan 1 02:00:00 1970
--- pgsql/src/backend/foreign/postgresql/Makefile Mon Dec 15 13:24:14 2008
***************
*** 0 ****
--- 1,27 ----
+ #-------------------------------------------------------------------------
+ #
+ # Makefile--
+ # Makefile for postgresql foreign-data wrapper
+ #
+ # IDENTIFICATION
+ # $PostgreSQL$
+ #
+ #-------------------------------------------------------------------------
+
+ subdir = src/backend/foreign/postgresql
+ top_builddir = ../../../..
+ include $(top_builddir)/src/Makefile.global
+
+ NAME = postgresql_fdw
+ OBJS = postgresql_fdw.o
+
+ include $(top_srcdir)/src/Makefile.shlib
+
+ all: all-shared-lib
+
+ install: all install-lib
+
+ installdirs: installdirs-lib
+
+ clean distclean maintainer-clean: clean-lib
+ rm -f $(OBJS)
diff -cNr -x CVS cvs-pgsql/src/backend/foreign/postgresql/postgresql_fdw.c pgsql/src/backend/foreign/postgresql/postgresql_fdw.c
*** cvs-pgsql/src/backend/foreign/postgresql/postgresql_fdw.c Thu Jan 1 02:00:00 1970
--- pgsql/src/backend/foreign/postgresql/postgresql_fdw.c Tue Dec 16 16:16:53 2008
***************
*** 0 ****
--- 1,172 ----
+ /*-------------------------------------------------------------------------
+ *
+ * postgresql_fdw.c
+ * foreign-data wrapper for postgresql (libpq) connections.
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ * $PostgreSQL$
+ *
+ *-------------------------------------------------------------------------
+ */
+ #include "postgres.h"
+
+ #include "fmgr.h"
+ #include "lib/stringinfo.h"
+ #include "nodes/value.h"
+ #include "nodes/parsenodes.h"
+ #include "nodes/makefuncs.h"
+ #include "foreign/foreign.h"
+
+ PG_MODULE_MAGIC;
+
+
+ /*
+ * Describes the valid options for postgresql FDW, server and user mapping.
+ */
+ typedef struct ConnectionOptions {
+ const char *optname; /* Option name */
+ GenericOptionFlags optflags; /* Option usage bitmap */
+ } ConnectionOptions;
+
+ /*
+ * Copied from fe-connect.c PQconninfoOptions.
+ *
+ * The list is small - don't bother with bsearch if it stays so.
+ */
+ static ConnectionOptions libpq_conninfo_options[] = {
+ { "authtype", ServerOpt },
+ { "service", ServerOpt },
+ { "user", UserMappingOpt },
+ { "password", UserMappingOpt },
+ { "connect_timeout", ServerOpt },
+ { "dbname", ServerOpt },
+ { "host", ServerOpt },
+ { "hostaddr", ServerOpt },
+ { "port", ServerOpt },
+ { "tty", ServerOpt },
+ { "options", ServerOpt },
+ { "requiressl", ServerOpt },
+ { "sslmode", ServerOpt },
+ { "gsslib", ServerOpt },
+ { NULL, InvalidOpt }
+ };
+
+ void _PG_fini(void);
+
+
+ /*
+ * Check if the provided option is one of libpq conninfo options.
+ * We look at only options with matching flags.
+ */
+ static bool
+ is_conninfo_option(const char *option, GenericOptionFlags flags)
+ {
+ ConnectionOptions *opt;
+
+ for (opt = libpq_conninfo_options; opt->optname != NULL; opt++)
+ if (flags & opt->optflags && strcmp(opt->optname, option) == 0)
+ return true;
+ return false;
+ }
+
+ /*
+ * Validate the generic option given to SERVER or USER MAPPING.
+ * Raise an ERROR if the option or its value is considered
+ * invalid.
+ *
+ * Valid server options are all libpq conninfo options except
+ * user and password -- these may only appear in USER MAPPING options.
+ */
+ void
+ _pg_validateOptionList(ForeignDataWrapper *fdw, GenericOptionFlags flags,
+ List *options)
+ {
+ ListCell *cell;
+
+ foreach (cell, options)
+ {
+ DefElem *def = lfirst(cell);
+
+ if (!is_conninfo_option(def->defname, flags))
+ {
+ ConnectionOptions *opt;
+ StringInfoData buf;
+ const char *objtype;
+
+ /*
+ * Unknown option specified, complain about it. Provide a hint
+ * with list of valid options for the object.
+ */
+ initStringInfo(&buf);
+ for (opt = libpq_conninfo_options; opt->optname != NULL; opt++)
+ if (flags & opt->optflags)
+ appendStringInfo(&buf, "%s%s", (buf.len > 0) ? ", " : "",
+ opt->optname);
+
+ if (flags & ServerOpt)
+ objtype = "server";
+ else if (flags & UserMappingOpt)
+ objtype = "user mapping";
+ else if (flags & FdwOpt)
+ objtype = "foreign-data wrapper";
+ else
+ objtype = "???";
+
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("invalid option \"%s\" to %s", def->defname, objtype),
+ errhint("valid %s options are: %s", objtype, buf.data)));
+ }
+ }
+ }
+
+ /*
+ * Provide the connection details as DefElem list.
+ *
+ * The known libpq conninfo parameters are merged into a single connect
+ * string and returned under the option name of "datasource". Unrecognized
+ * options are returned unmodified.
+ */
+ List *
+ _pg_GetConnectionInfo(ForeignDataWrapper *fdw, ForeignServer *server,
+ UserMapping *um)
+ {
+ List *result = NIL;
+ ListCell *cell;
+ StringInfo stringptr;
+ DefElem *datasource;
+
+ stringptr = makeStringInfo();
+
+ /* Add server options */
+ foreach (cell, server->options)
+ {
+ DefElem *def = lfirst(cell);
+
+ if (is_conninfo_option(def->defname, ServerOpt))
+ appendStringInfo(stringptr, "%s%s=%s",
+ (stringptr->len > 0) ? " " : "", def->defname, strVal(def->arg));
+ else
+ result = lappend(result, lfirst(cell));
+ }
+
+ /* And the user mapping options */
+ foreach (cell, um->options)
+ {
+ DefElem *def = lfirst(cell);
+
+ if (is_conninfo_option(def->defname, UserMappingOpt))
+ appendStringInfo(stringptr, "%s%s=%s",
+ (stringptr->len > 0) ? " " : "", def->defname, strVal(def->arg));
+ else
+ result = lappend(result, lfirst(cell));
+ }
+
+ /* Finally the compiled conninfo string */
+ datasource = makeDefElem("datasource", (Node *)makeString(stringptr->data));
+ result = lappend(result, datasource);
+
+ return result;
+ }
diff -cNr -x CVS cvs-pgsql/src/backend/nodes/copyfuncs.c pgsql/src/backend/nodes/copyfuncs.c
*** cvs-pgsql/src/backend/nodes/copyfuncs.c Fri Dec 5 15:06:23 2008
--- pgsql/src/backend/nodes/copyfuncs.c Fri Dec 12 10:44:15 2008
***************
*** 2033,2038 ****
--- 2033,2049 ----
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,2874 ****
--- 2880,2996 ----
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,3701 ****
--- 3818,3850 ----
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,3828 ****
--- 3972,3980 ----
case T_DefElem:
retval = _copyDefElem(from);
break;
+ case T_OptionDefElem:
+ retval = _copyOptionDefElem(from);
+ break;
case T_LockingClause:
retval = _copyLockingClause(from);
break;
diff -cNr -x CVS cvs-pgsql/src/backend/nodes/equalfuncs.c pgsql/src/backend/nodes/equalfuncs.c
*** cvs-pgsql/src/backend/nodes/equalfuncs.c Fri Dec 5 15:06:23 2008
--- pgsql/src/backend/nodes/equalfuncs.c Fri Dec 12 10:44:15 2008
***************
*** 1519,1524 ****
--- 1519,1617 ----
}
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)
{
COMPARE_STRING_FIELD(trigname);
***************
*** 1957,1962 ****
--- 2050,2064 ----
}
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)
{
COMPARE_NODE_FIELD(lockedRels);
***************
*** 2534,2539 ****
--- 2636,2668 ----
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,2666 ****
--- 2790,2798 ----
case T_DefElem:
retval = _equalDefElem(a, b);
break;
+ case T_OptionDefElem:
+ retval = _equalOptionDefElem(a, b);
+ break;
case T_LockingClause:
retval = _equalLockingClause(a, b);
break;
diff -cNr -x CVS cvs-pgsql/src/backend/nodes/makefuncs.c pgsql/src/backend/nodes/makefuncs.c
*** cvs-pgsql/src/backend/nodes/makefuncs.c Tue Sep 2 15:10:44 2008
--- pgsql/src/backend/nodes/makefuncs.c Fri Dec 12 10:44:15 2008
***************
*** 361,363 ****
--- 361,376 ----
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;
+ }
diff -cNr -x CVS cvs-pgsql/src/backend/parser/gram.y pgsql/src/backend/parser/gram.y
*** cvs-pgsql/src/backend/parser/gram.y Fri Dec 5 15:06:24 2008
--- pgsql/src/backend/parser/gram.y Mon Dec 15 14:11:30 2008
***************
*** 156,161 ****
--- 156,162 ----
FunctionParameterMode fun_param_mode;
FuncWithArgs *funwithargs;
DefElem *defelt;
+ OptionDefElem *optdef;
SortBy *sortby;
JoinExpr *jexpr;
IndexElem *ielem;
***************
*** 172,190 ****
}
%type stmt schema_stmt
! AlterDatabaseStmt AlterDatabaseSetStmt AlterDomainStmt AlterGroupStmt
AlterObjectSchemaStmt AlterOwnerStmt AlterSeqStmt AlterTableStmt
! AlterUserStmt AlterUserSetStmt AlterRoleStmt AlterRoleSetStmt
AnalyzeStmt ClosePortalStmt ClusterStmt CommentStmt
ConstraintsSetStmt CopyStmt CreateAsStmt CreateCastStmt
CreateDomainStmt CreateGroupStmt CreateOpClassStmt
CreateOpFamilyStmt AlterOpFamilyStmt CreatePLangStmt
CreateSchemaStmt CreateSeqStmt CreateStmt CreateTableSpaceStmt
! CreateAssertStmt CreateTrigStmt CreateUserStmt CreateRoleStmt
CreatedbStmt DeclareCursorStmt DefineStmt DeleteStmt DiscardStmt
DropGroupStmt DropOpClassStmt DropOpFamilyStmt DropPLangStmt DropStmt
DropAssertStmt DropTrigStmt DropRuleStmt DropCastStmt DropRoleStmt
! DropUserStmt DropdbStmt DropTableSpaceStmt ExplainStmt FetchStmt
GrantStmt GrantRoleStmt IndexStmt InsertStmt ListenStmt LoadStmt
LockStmt NotifyStmt ExplainableStmt PreparableStmt
CreateFunctionStmt AlterFunctionStmt ReindexStmt RemoveAggrStmt
--- 173,194 ----
}
%type stmt schema_stmt
! AlterDatabaseStmt AlterDatabaseSetStmt AlterDomainStmt AlterFdwStmt
! AlterForeignServerStmt AlterGroupStmt
AlterObjectSchemaStmt AlterOwnerStmt AlterSeqStmt AlterTableStmt
! AlterUserStmt AlterUserMappingStmt AlterUserSetStmt AlterRoleStmt AlterRoleSetStmt
AnalyzeStmt ClosePortalStmt ClusterStmt CommentStmt
ConstraintsSetStmt CopyStmt CreateAsStmt CreateCastStmt
CreateDomainStmt CreateGroupStmt CreateOpClassStmt
CreateOpFamilyStmt AlterOpFamilyStmt CreatePLangStmt
CreateSchemaStmt CreateSeqStmt CreateStmt CreateTableSpaceStmt
! CreateFdwStmt CreateForeignServerStmt CreateAssertStmt CreateTrigStmt
! CreateUserStmt CreateUserMappingStmt CreateRoleStmt
CreatedbStmt DeclareCursorStmt DefineStmt DeleteStmt DiscardStmt
DropGroupStmt DropOpClassStmt DropOpFamilyStmt DropPLangStmt DropStmt
DropAssertStmt DropTrigStmt DropRuleStmt DropCastStmt DropRoleStmt
! DropUserStmt DropdbStmt DropTableSpaceStmt DropFdwStmt
! DropForeignServerStmt DropUserMappingStmt ExplainStmt FetchStmt
GrantStmt GrantRoleStmt IndexStmt InsertStmt ListenStmt LoadStmt
LockStmt NotifyStmt ExplainableStmt PreparableStmt
CreateFunctionStmt AlterFunctionStmt ReindexStmt RemoveAggrStmt
***************
*** 222,227 ****
--- 226,235 ----
%type OptRoleList
%type OptRoleElem
+ %type opt_type
+ %type foreign_server_version opt_foreign_server_version
+ %type auth_ident
+
%type OptSchemaName
%type OptSchemaEltList
***************
*** 274,279 ****
--- 282,288 ----
prep_type_clause
execute_param_clause using_clause returning_clause
enum_val_list table_func_column_list
+ create_generic_options alter_generic_options
%type OptTempTableName
%type into_clause create_as_target
***************
*** 342,347 ****
--- 351,362 ----
%type relation_expr_opt_alias
%type target_el single_set_clause set_target insert_column_item
+ %type gopt_name
+ %type gopt_arg
+ %type gopt_elem
+ %type alter_gopt_elem
+ %type gopt_list alter_gopt_list
+
%type Typename SimpleTypename ConstTypename
GenericType Numeric opt_float
Character ConstCharacter
***************
*** 436,442 ****
KEY
LANCOMPILER LANGUAGE LARGE_P LAST_P LEADING LEAST LEFT LEVEL
! LIKE LIMIT LISTEN LOAD LOCAL LOCALTIME LOCALTIMESTAMP LOCATION
LOCK_P LOGIN_P
MAPPING MATCH MAXVALUE MINUTE_P MINVALUE MODE MONTH_P MOVE
--- 451,457 ----
KEY
LANCOMPILER LANGUAGE LARGE_P LAST_P LEADING LEAST LEFT LEVEL
! LIBRARY LIKE LIMIT LISTEN LOAD LOCAL LOCALTIME LOCALTIMESTAMP LOCATION
LOCK_P LOGIN_P
MAPPING MATCH MAXVALUE MINUTE_P MINVALUE MODE MONTH_P MOVE
***************
*** 445,451 ****
NOCREATEROLE NOCREATEUSER NOINHERIT NOLOGIN_P NONE NOSUPERUSER
NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF NULLS_P NUMERIC
! OBJECT_P OF OFF OFFSET OIDS OLD ON ONLY OPERATOR OPTION OR
ORDER OUT_P OUTER_P OVERLAPS OVERLAY OWNED OWNER
PARSER PARTIAL PASSWORD PLACING PLANS POSITION
--- 460,466 ----
NOCREATEROLE NOCREATEUSER NOINHERIT NOLOGIN_P NONE NOSUPERUSER
NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF NULLS_P NUMERIC
! OBJECT_P OF OFF OFFSET OIDS OLD ON ONLY OPERATOR OPTION OPTIONS OR
ORDER OUT_P OUTER_P OVERLAPS OVERLAY OWNED OWNER
PARSER PARTIAL PASSWORD PLACING PLANS POSITION
***************
*** 459,465 ****
REVOKE RIGHT ROLE ROLLBACK ROW ROWS RULE
SAVEPOINT SCHEMA SCROLL SEARCH SECOND_P SECURITY SELECT SEQUENCE
! SERIALIZABLE SESSION SESSION_USER SET SETOF SHARE
SHOW SIMILAR SIMPLE SMALLINT SOME STABLE STANDALONE_P START STATEMENT
STATISTICS STDIN STDOUT STORAGE STRICT_P STRIP_P SUBSTRING SUPERUSER_P
SYMMETRIC SYSID SYSTEM_P
--- 474,480 ----
REVOKE RIGHT ROLE ROLLBACK ROW ROWS RULE
SAVEPOINT SCHEMA SCROLL SEARCH SECOND_P SECURITY SELECT SEQUENCE
! SERIALIZABLE SERVER SESSION SESSION_USER SET SETOF SHARE
SHOW SIMILAR SIMPLE SMALLINT SOME STABLE STANDALONE_P START STATEMENT
STATISTICS STDIN STDOUT STORAGE STRICT_P STRIP_P SUBSTRING SUPERUSER_P
SYMMETRIC SYSID SYSTEM_P
***************
*** 474,480 ****
VACUUM VALID VALIDATOR VALUE_P VALUES VARCHAR VARIADIC VARYING
VERBOSE VERSION_P VIEW VOLATILE
! WHEN WHERE WHITESPACE_P WITH WITHOUT WORK WRITE
XML_P XMLATTRIBUTES XMLCONCAT XMLELEMENT XMLFOREST XMLPARSE
XMLPI XMLROOT XMLSERIALIZE
--- 489,495 ----
VACUUM VALID VALIDATOR VALUE_P VALUES VARCHAR VARIADIC VARYING
VERBOSE VERSION_P VIEW VOLATILE
! WHEN WHERE WHITESPACE_P WITH WITHOUT WORK WRAPPER WRITE
XML_P XMLATTRIBUTES XMLCONCAT XMLELEMENT XMLFOREST XMLPARSE
XMLPI XMLROOT XMLSERIALIZE
***************
*** 562,567 ****
--- 577,584 ----
AlterDatabaseStmt
| AlterDatabaseSetStmt
| AlterDomainStmt
+ | AlterFdwStmt
+ | AlterForeignServerStmt
| AlterFunctionStmt
| AlterGroupStmt
| AlterObjectSchemaStmt
***************
*** 572,577 ****
--- 589,595 ----
| AlterRoleStmt
| AlterTSConfigurationStmt
| AlterTSDictionaryStmt
+ | AlterUserMappingStmt
| AlterUserSetStmt
| AlterUserStmt
| AnalyzeStmt
***************
*** 586,591 ****
--- 604,611 ----
| CreateCastStmt
| CreateConversionStmt
| CreateDomainStmt
+ | CreateFdwStmt
+ | CreateForeignServerStmt
| CreateFunctionStmt
| CreateGroupStmt
| CreateOpClassStmt
***************
*** 599,604 ****
--- 619,625 ----
| CreateTrigStmt
| CreateRoleStmt
| CreateUserStmt
+ | CreateUserMappingStmt
| CreatedbStmt
| DeallocateStmt
| DeclareCursorStmt
***************
*** 607,612 ****
--- 628,635 ----
| DiscardStmt
| DropAssertStmt
| DropCastStmt
+ | DropFdwStmt
+ | DropForeignServerStmt
| DropGroupStmt
| DropOpClassStmt
| DropOpFamilyStmt
***************
*** 618,623 ****
--- 641,647 ----
| DropTrigStmt
| DropRoleStmt
| DropUserStmt
+ | DropUserMappingStmt
| DropdbStmt
| ExecuteStmt
| ExplainStmt
***************
*** 2717,2722 ****
--- 2741,3050 ----
/*****************************************************************************
*
+ * QUERY:
+ * CREATE FOREIGN DATA WRAPPER name LIBRARY 'library_name' LANGUAGE C
+ *
+ *****************************************************************************/
+
+ CreateFdwStmt: CREATE FOREIGN DATA_P WRAPPER name LIBRARY Sconst LANGUAGE ColId create_generic_options
+ {
+ CreateFdwStmt *n = makeNode(CreateFdwStmt);
+ n->fdwname = $5;
+ n->library = $7;
+ n->options = $10;
+ $$ = (Node *) n;
+
+ if (pg_strcasecmp($9, "C") != 0)
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("language for foreign-data wrapper must be C"),
+ scanner_errposition(@9)));
+ }
+ ;
+
+ /*****************************************************************************
+ *
+ * QUERY :
+ * DROP FOREIGN DATA WRAPPER name
+ *
+ ****************************************************************************/
+
+ DropFdwStmt: DROP FOREIGN DATA_P WRAPPER name opt_drop_behavior
+ {
+ DropFdwStmt *n = makeNode(DropFdwStmt);
+ n->fdwname = $5;
+ n->missing_ok = false;
+ n->behavior = $6;
+ $$ = (Node *) n;
+ }
+ | DROP FOREIGN DATA_P WRAPPER IF_P EXISTS name opt_drop_behavior
+ {
+ DropFdwStmt *n = makeNode(DropFdwStmt);
+ n->fdwname = $7;
+ n->missing_ok = true;
+ n->behavior = $8;
+ $$ = (Node *) n;
+ }
+ ;
+
+ /*****************************************************************************
+ *
+ * QUERY :
+ * ALTER FOREIGN DATA WRAPPER name
+ *
+ ****************************************************************************/
+
+ AlterFdwStmt: ALTER FOREIGN DATA_P WRAPPER name LIBRARY Sconst alter_generic_options
+ {
+ AlterFdwStmt *n = makeNode(AlterFdwStmt);
+ n->fdwname = $5;
+ n->library = $7;
+ n->options = $8;
+ $$ = (Node *) n;
+ }
+ | ALTER FOREIGN DATA_P WRAPPER name LIBRARY Sconst
+ {
+ AlterFdwStmt *n = makeNode(AlterFdwStmt);
+ n->fdwname = $5;
+ n->library = $7;
+ $$ = (Node *) n;
+ }
+ | ALTER FOREIGN DATA_P WRAPPER name alter_generic_options
+ {
+ AlterFdwStmt *n = makeNode(AlterFdwStmt);
+ n->fdwname = $5;
+ n->options = $6;
+ $$ = (Node *) n;
+ }
+ ;
+
+ /* Options definition for CREATE FDW, SERVER and USER MAPPING */
+ create_generic_options:
+ OPTIONS '(' gopt_list ')' { $$ = $3; }
+ | /*EMPTY*/ { $$ = NIL; }
+ ;
+
+ gopt_list: gopt_elem
+ {
+ $$ = list_make1(makeOptionDefElem(ALTER_OPT_ADD, $1));
+ }
+ | gopt_list ',' gopt_elem
+ {
+ $$ = lappend($1, makeOptionDefElem(ALTER_OPT_ADD, $3));
+ }
+ ;
+
+ /* Options definition for ALTER FDW, SERVER and USER MAPPING */
+ alter_generic_options:
+ OPTIONS '(' alter_gopt_list ')' { $$ = $3; }
+ ;
+
+ alter_gopt_list:
+ alter_gopt_elem
+ {
+ $$ = list_make1($1);
+ }
+ | gopt_elem
+ {
+ $$ = list_make1(makeOptionDefElem(ALTER_OPT_ADD, $1));
+ }
+ | alter_gopt_list ',' alter_gopt_elem
+ {
+ $$ = lappend($1, $3);
+ }
+ | alter_gopt_list ',' gopt_elem
+ {
+ $$ = lappend($1, makeOptionDefElem(ALTER_OPT_ADD, $3));
+ }
+ ;
+
+ alter_gopt_elem:
+ ADD_P gopt_elem
+ {
+ $$ = makeOptionDefElem(ALTER_OPT_ADD, $2);
+ }
+ | SET gopt_elem
+ {
+ $$ = makeOptionDefElem(ALTER_OPT_SET, $2);
+ }
+ | DROP gopt_name
+ {
+ $$ = makeOptionDefElem(ALTER_OPT_DROP,
+ makeDefElem($2, NULL));
+ }
+ ;
+
+ gopt_elem: gopt_name gopt_arg { $$ = makeDefElem($1, $2); }
+ ;
+
+ gopt_name: attr_name { $$ = $1; }
+ ;
+
+ gopt_arg: Sconst { $$ = (Node *)makeString($1); }
+ ;
+
+ /*****************************************************************************
+ *
+ * QUERY:
+ * CREATE SERVER name [TYPE] [VERSION] [OPTIONS]
+ *
+ *****************************************************************************/
+
+ CreateForeignServerStmt: CREATE SERVER name opt_type opt_foreign_server_version
+ FOREIGN DATA_P WRAPPER name create_generic_options
+ {
+ CreateForeignServerStmt *n = makeNode(CreateForeignServerStmt);
+ n->servername = $3;
+ n->servertype = $4;
+ n->version = $5;
+ n->fdwname = $9;
+ n->options = $10;
+ $$ = (Node *) n;
+ }
+ ;
+
+ opt_type:
+ TYPE_P Sconst { $$ = $2; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
+
+
+ foreign_server_version:
+ VERSION_P Sconst { $$ = $2; }
+ | VERSION_P NULL_P { $$ = NULL; }
+ ;
+
+ opt_foreign_server_version:
+ foreign_server_version { $$ = $1; }
+ | /*EMPTY*/ { $$ = NULL; }
+ ;
+
+ /*****************************************************************************
+ *
+ * QUERY :
+ * DROP SERVER name
+ *
+ ****************************************************************************/
+
+ DropForeignServerStmt: DROP SERVER name opt_drop_behavior
+ {
+ DropForeignServerStmt *n = makeNode(DropForeignServerStmt);
+ n->servername = $3;
+ n->missing_ok = false;
+ n->behavior = $4;
+ $$ = (Node *) n;
+ }
+ | DROP SERVER IF_P EXISTS name opt_drop_behavior
+ {
+ DropForeignServerStmt *n = makeNode(DropForeignServerStmt);
+ n->servername = $5;
+ n->missing_ok = true;
+ n->behavior = $6;
+ $$ = (Node *) n;
+ }
+ ;
+
+ /*****************************************************************************
+ *
+ * QUERY :
+ * ALTER SERVER name [VERSION] [OPTIONS]
+ *
+ ****************************************************************************/
+
+ AlterForeignServerStmt: ALTER SERVER name foreign_server_version alter_generic_options
+ {
+ AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
+ n->servername = $3;
+ n->version = $4;
+ n->options = $5;
+ n->has_version = true;
+ $$ = (Node *) n;
+ }
+ | ALTER SERVER name foreign_server_version
+ {
+ AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
+ n->servername = $3;
+ n->version = $4;
+ n->has_version = true;
+ $$ = (Node *) n;
+ }
+ | ALTER SERVER name alter_generic_options
+ {
+ AlterForeignServerStmt *n = makeNode(AlterForeignServerStmt);
+ n->servername = $3;
+ n->options = $4;
+ $$ = (Node *) n;
+ }
+ ;
+
+ /*****************************************************************************
+ *
+ * QUERY:
+ * CREATE USER MAPPING FOR auth_ident SERVER name [OPTIONS]
+ *
+ *****************************************************************************/
+
+ CreateUserMappingStmt: CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options
+ {
+ CreateUserMappingStmt *n = makeNode(CreateUserMappingStmt);
+ n->username = $5;
+ n->servername = $7;
+ n->options = $8;
+ $$ = (Node *) n;
+ }
+ ;
+
+ /* User mapping authorization identifier */
+ auth_ident:
+ CURRENT_USER { $$ = "current_user"; }
+ | USER { $$ = "current_user"; }
+ | RoleId { $$ = (strcmp($1, "public") == 0) ? NULL : $1 }
+ ;
+
+ /*****************************************************************************
+ *
+ * QUERY :
+ * DROP USER MAPPING FOR auth_ident SERVER name
+ *
+ ****************************************************************************/
+
+ DropUserMappingStmt: DROP USER MAPPING FOR auth_ident SERVER name
+ {
+ DropUserMappingStmt *n = makeNode(DropUserMappingStmt);
+ n->username = $5;
+ n->servername = $7;
+ n->missing_ok = false;
+ $$ = (Node *) n;
+ }
+ | DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name
+ {
+ DropUserMappingStmt *n = makeNode(DropUserMappingStmt);
+ n->username = $7;
+ n->servername = $9;
+ n->missing_ok = true;
+ $$ = (Node *) n;
+ }
+ ;
+
+ /*****************************************************************************
+ *
+ * QUERY :
+ * ALTER USER MAPPING FOR auth_ident SERVER name OPTIONS
+ *
+ ****************************************************************************/
+
+ AlterUserMappingStmt: ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options
+ {
+ AlterUserMappingStmt *n = makeNode(AlterUserMappingStmt);
+ n->username = $5;
+ n->servername = $7;
+ n->options = $8;
+ $$ = (Node *) n;
+ }
+ ;
+
+ /*****************************************************************************
+ *
* QUERIES :
* CREATE TRIGGER ...
* DROP TRIGGER ...
***************
*** 3912,3917 ****
--- 4240,4259 ----
n->objs = $2;
$$ = n;
}
+ | FOREIGN DATA_P WRAPPER name_list
+ {
+ PrivTarget *n = makeNode(PrivTarget);
+ n->objtype = ACL_OBJECT_FDW;
+ n->objs = $4;
+ $$ = n;
+ }
+ | FOREIGN SERVER name_list
+ {
+ PrivTarget *n = makeNode(PrivTarget);
+ n->objtype = ACL_OBJECT_FOREIGN_SERVER;
+ n->objs = $3;
+ $$ = n;
+ }
| FUNCTION function_with_argtypes_list
{
PrivTarget *n = makeNode(PrivTarget);
***************
*** 5122,5127 ****
--- 5464,5485 ----
n->newowner = $8;
$$ = (Node *)n;
}
+ | ALTER FOREIGN DATA_P WRAPPER name OWNER TO RoleId
+ {
+ AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+ n->objectType = OBJECT_FDW;
+ n->object = list_make1(makeString($5));
+ n->newowner = $8;
+ $$ = (Node *)n;
+ }
+ | ALTER SERVER name OWNER TO RoleId
+ {
+ AlterOwnerStmt *n = makeNode(AlterOwnerStmt);
+ n->objectType = OBJECT_FOREIGN_SERVER;
+ n->object = list_make1(makeString($3));
+ n->newowner = $6;
+ $$ = (Node *)n;
+ }
;
***************
*** 9555,9560 ****
--- 9913,9919 ----
| INVOKER
| ISOLATION
| KEY
+ | LIBRARY
| LANCOMPILER
| LANGUAGE
| LARGE_P
***************
*** 9593,9598 ****
--- 9952,9958 ----
| OIDS
| OPERATOR
| OPTION
+ | OPTIONS
| OWNED
| OWNER
| PARSER
***************
*** 9628,9633 ****
--- 9988,9994 ----
| ROWS
| RULE
| SAVEPOINT
+ | SERVER
| SCHEMA
| SCROLL
| SEARCH
***************
*** 9680,9685 ****
--- 10041,10047 ----
| WHITESPACE_P
| WITHOUT
| WORK
+ | WRAPPER
| WRITE
| XML_P
| YEAR_P
diff -cNr -x CVS cvs-pgsql/src/backend/parser/keywords.c pgsql/src/backend/parser/keywords.c
*** cvs-pgsql/src/backend/parser/keywords.c Tue Oct 28 14:31:25 2008
--- pgsql/src/backend/parser/keywords.c Fri Dec 12 10:44:15 2008
***************
*** 229,234 ****
--- 229,235 ----
{"least", LEAST, COL_NAME_KEYWORD},
{"left", LEFT, TYPE_FUNC_NAME_KEYWORD},
{"level", LEVEL, UNRESERVED_KEYWORD},
+ {"library", LIBRARY, UNRESERVED_KEYWORD},
{"like", LIKE, TYPE_FUNC_NAME_KEYWORD},
{"limit", LIMIT, RESERVED_KEYWORD},
{"listen", LISTEN, UNRESERVED_KEYWORD},
***************
*** 281,286 ****
--- 282,288 ----
{"only", ONLY, RESERVED_KEYWORD},
{"operator", OPERATOR, UNRESERVED_KEYWORD},
{"option", OPTION, UNRESERVED_KEYWORD},
+ {"options", OPTIONS, UNRESERVED_KEYWORD},
{"or", OR, RESERVED_KEYWORD},
{"order", ORDER, RESERVED_KEYWORD},
{"out", OUT_P, COL_NAME_KEYWORD},
***************
*** 339,344 ****
--- 341,347 ----
{"select", SELECT, RESERVED_KEYWORD},
{"sequence", SEQUENCE, UNRESERVED_KEYWORD},
{"serializable", SERIALIZABLE, UNRESERVED_KEYWORD},
+ {"server", SERVER, UNRESERVED_KEYWORD},
{"session", SESSION, UNRESERVED_KEYWORD},
{"session_user", SESSION_USER, RESERVED_KEYWORD},
{"set", SET, UNRESERVED_KEYWORD},
***************
*** 411,416 ****
--- 414,420 ----
{"with", WITH, RESERVED_KEYWORD},
{"without", WITHOUT, UNRESERVED_KEYWORD},
{"work", WORK, UNRESERVED_KEYWORD},
+ {"wrapper", WRAPPER, UNRESERVED_KEYWORD},
{"write", WRITE, UNRESERVED_KEYWORD},
{"xml", XML_P, UNRESERVED_KEYWORD},
{"xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD},
diff -cNr -x CVS cvs-pgsql/src/backend/tcop/utility.c pgsql/src/backend/tcop/utility.c
*** cvs-pgsql/src/backend/tcop/utility.c Fri Dec 5 15:06:25 2008
--- pgsql/src/backend/tcop/utility.c Fri Dec 12 10:44:15 2008
***************
*** 203,208 ****
--- 203,217 ----
case T_ReassignOwnedStmt:
case T_AlterTSDictionaryStmt:
case T_AlterTSConfigurationStmt:
+ case T_CreateFdwStmt:
+ case T_AlterFdwStmt:
+ case T_DropFdwStmt:
+ case T_CreateForeignServerStmt:
+ case T_AlterForeignServerStmt:
+ case T_DropForeignServerStmt:
+ case T_CreateUserMappingStmt:
+ case T_AlterUserMappingStmt:
+ case T_DropUserMappingStmt:
ereport(ERROR,
(errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
errmsg("transaction is read-only")));
***************
*** 452,457 ****
--- 461,502 ----
DropTableSpace((DropTableSpaceStmt *) parsetree);
break;
+ case T_CreateFdwStmt:
+ CreateForeignDataWrapper((CreateFdwStmt *) parsetree);
+ break;
+
+ case T_AlterFdwStmt:
+ AlterForeignDataWrapper((AlterFdwStmt *) parsetree);
+ break;
+
+ case T_DropFdwStmt:
+ RemoveForeignDataWrapper((DropFdwStmt *) parsetree);
+ break;
+
+ case T_CreateForeignServerStmt:
+ CreateForeignServer((CreateForeignServerStmt *) parsetree);
+ break;
+
+ case T_AlterForeignServerStmt:
+ AlterForeignServer((AlterForeignServerStmt *) parsetree);
+ break;
+
+ case T_DropForeignServerStmt:
+ RemoveForeignServer((DropForeignServerStmt *) parsetree);
+ break;
+
+ case T_CreateUserMappingStmt:
+ CreateUserMapping((CreateUserMappingStmt *) parsetree);
+ break;
+
+ case T_AlterUserMappingStmt:
+ AlterUserMapping((AlterUserMappingStmt *) parsetree);
+ break;
+
+ case T_DropUserMappingStmt:
+ RemoveUserMapping((DropUserMappingStmt *) parsetree);
+ break;
+
case T_DropStmt:
{
DropStmt *stmt = (DropStmt *) parsetree;
***************
*** 1310,1315 ****
--- 1355,1396 ----
tag = "DROP TABLESPACE";
break;
+ case T_CreateFdwStmt:
+ tag = "CREATE FOREIGN DATA WRAPPER";
+ break;
+
+ case T_AlterFdwStmt:
+ tag = "ALTER FOREIGN DATA WRAPPER";
+ break;
+
+ case T_DropFdwStmt:
+ tag = "DROP FOREIGN DATA WRAPPER";
+ break;
+
+ case T_CreateForeignServerStmt:
+ tag = "CREATE SERVER";
+ break;
+
+ case T_AlterForeignServerStmt:
+ tag = "ALTER SERVER";
+ break;
+
+ case T_DropForeignServerStmt:
+ tag = "DROP SERVER";
+ break;
+
+ case T_CreateUserMappingStmt:
+ tag = "CREATE USER MAPPING";
+ break;
+
+ case T_AlterUserMappingStmt:
+ tag = "ALTER USER MAPPING";
+ break;
+
+ case T_DropUserMappingStmt:
+ tag = "DROP USER MAPPING";
+ break;
+
case T_DropStmt:
switch (((DropStmt *) parsetree)->removeType)
{
***************
*** 1523,1528 ****
--- 1604,1615 ----
case OBJECT_TSDICTIONARY:
tag = "ALTER TEXT SEARCH DICTIONARY";
break;
+ case OBJECT_FDW:
+ tag = "ALTER FOREIGN DATA WRAPPER";
+ break;
+ case OBJECT_FOREIGN_SERVER:
+ tag = "ALTER SERVER";
+ break;
default:
tag = "???";
break;
***************
*** 2037,2042 ****
--- 2124,2141 ----
lev = LOGSTMT_DDL;
break;
+ case T_CreateFdwStmt:
+ case T_AlterFdwStmt:
+ case T_DropFdwStmt:
+ case T_CreateForeignServerStmt:
+ case T_AlterForeignServerStmt:
+ case T_DropForeignServerStmt:
+ case T_CreateUserMappingStmt:
+ case T_AlterUserMappingStmt:
+ case T_DropUserMappingStmt:
+ lev = LOGSTMT_DDL;
+ break;
+
case T_DropStmt:
lev = LOGSTMT_DDL;
break;
diff -cNr -x CVS cvs-pgsql/src/backend/utils/adt/acl.c pgsql/src/backend/utils/adt/acl.c
*** cvs-pgsql/src/backend/utils/adt/acl.c Tue Dec 16 15:58:26 2008
--- pgsql/src/backend/utils/adt/acl.c Tue Dec 16 15:59:14 2008
***************
*** 22,27 ****
--- 22,28 ----
#include "catalog/pg_type.h"
#include "commands/dbcommands.h"
#include "commands/tablespace.h"
+ #include "foreign/foreign.h"
#include "miscadmin.h"
#include "utils/acl.h"
#include "utils/builtins.h"
***************
*** 577,582 ****
--- 578,591 ----
world_default = ACL_NO_RIGHTS;
owner_default = ACL_ALL_RIGHTS_TABLESPACE;
break;
+ case ACL_OBJECT_FDW:
+ world_default = ACL_NO_RIGHTS;
+ owner_default = ACL_ALL_RIGHTS_FDW;
+ break;
+ case ACL_OBJECT_FOREIGN_SERVER:
+ world_default = ACL_NO_RIGHTS;
+ owner_default = ACL_ALL_RIGHTS_FOREIGN_SERVER;
+ break;
default:
elog(ERROR, "unrecognized objtype: %d", (int) objtype);
world_default = ACL_NO_RIGHTS; /* keep compiler quiet */
***************
*** 1824,1829 ****
--- 1833,1972 ----
/*
+ * has_foreign_data_wrapper_privilege variants
+ * These are all named "has_foreign_data_wrapper_privilege" at the SQL level.
+ * They take various combinations of foreign-data wrapper name,
+ * fdw OID, user name, user OID, or implicit user = current_user.
+ *
+ * The result is a boolean value: true if user has the indicated
+ * privilege, false if not.
+ */
+
+ /*
+ * has_foreign_data_wrapper_privilege
+ * Check user privileges on a foreign-data wrapper.
+ */
+ static Datum
+ has_foreign_data_wrapper_privilege(Oid roleid, Oid fdwid, text *priv_type_text)
+ {
+ AclResult aclresult;
+ AclMode mode = ACL_NO_RIGHTS;
+ char *priv_type = text_to_cstring(priv_type_text);
+
+ if (pg_strcasecmp(priv_type, "USAGE") == 0)
+ mode = ACL_USAGE;
+ else if (pg_strcasecmp(priv_type, "USAGE WITH GRANT OPTION") == 0)
+ mode = ACL_GRANT_OPTION_FOR(ACL_USAGE);
+ else
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("unrecognized privilege type: \"%s\"", priv_type)));
+
+ aclresult = pg_foreign_data_wrapper_aclcheck(fdwid, roleid, mode);
+
+ PG_RETURN_BOOL(aclresult == ACLCHECK_OK);
+ }
+
+ /*
+ * has_foreign_data_wrapper_privilege_name_name
+ * Check user privileges on a foreign-data wrapper given
+ * name username, text fdwname, and text priv name.
+ */
+ Datum
+ has_foreign_data_wrapper_privilege_name_name(PG_FUNCTION_ARGS)
+ {
+ Name username = PG_GETARG_NAME(0);
+ char *fdwname = text_to_cstring(PG_GETARG_TEXT_P(1));
+ text *priv_type_text = PG_GETARG_TEXT_P(2);
+
+ return has_foreign_data_wrapper_privilege(get_roleid_checked(NameStr(*username)),
+ GetForeignDataWrapperOidByName(fdwname, false),
+ priv_type_text);
+ }
+
+ /*
+ * has_foreign_data_wrapper_privilege_name
+ * Check user privileges on a foreign-data wrapper given
+ * text fdwname and text priv name.
+ * current_user is assumed
+ */
+ Datum
+ has_foreign_data_wrapper_privilege_name(PG_FUNCTION_ARGS)
+ {
+ char *fdwname = text_to_cstring(PG_GETARG_TEXT_P(0));
+ text *priv_type_text = PG_GETARG_TEXT_P(1);
+
+ return has_foreign_data_wrapper_privilege(GetUserId(),
+ GetForeignDataWrapperOidByName(fdwname, false),
+ priv_type_text);
+ }
+
+ /*
+ * has_foreign_data_wrapper_privilege_name_id
+ * Check user privileges on a foreign-data wrapper given
+ * name usename, foreign-data wrapper oid, and text priv name.
+ */
+ Datum
+ has_foreign_data_wrapper_privilege_name_id(PG_FUNCTION_ARGS)
+ {
+ Name username = PG_GETARG_NAME(0);
+ Oid fdwid = PG_GETARG_OID(1);
+ text *priv_type_text = PG_GETARG_TEXT_P(2);
+
+ return has_foreign_data_wrapper_privilege(get_roleid_checked(NameStr(*username)),
+ fdwid, priv_type_text);
+ }
+
+ /*
+ * has_foreign_data_wrapper_privilege_id
+ * Check user privileges on a foreign-data wrapper given
+ * foreign-data wrapper oid, and text priv name.
+ * current_user is assumed
+ */
+ Datum
+ has_foreign_data_wrapper_privilege_id(PG_FUNCTION_ARGS)
+ {
+ Oid fdwid = PG_GETARG_OID(0);
+ text *priv_type_text = PG_GETARG_TEXT_P(1);
+
+ return has_foreign_data_wrapper_privilege(GetUserId(), fdwid,
+ priv_type_text);
+ }
+
+ /*
+ * has_foreign_data_wrapper_privilege_id_name
+ * Check user privileges on a foreign-data wrapper given
+ * roleid, text fdwname, and text priv name.
+ */
+ Datum
+ has_foreign_data_wrapper_privilege_id_name(PG_FUNCTION_ARGS)
+ {
+ Oid roleid = PG_GETARG_OID(0);
+ char *fdwname = text_to_cstring(PG_GETARG_TEXT_P(1));
+ text *priv_type_text = PG_GETARG_TEXT_P(2);
+
+ return has_foreign_data_wrapper_privilege(roleid,
+ GetForeignDataWrapperOidByName(fdwname, false),
+ priv_type_text);
+ }
+
+ /*
+ * has_foreign_data_wrapper_privilege_id_id
+ * Check user privileges on a foreign-data wrapper given
+ * roleid, fdw oid, and text priv name.
+ */
+ Datum
+ has_foreign_data_wrapper_privilege_id_id(PG_FUNCTION_ARGS)
+ {
+ Oid roleid = PG_GETARG_OID(0);
+ Oid fdwid = PG_GETARG_OID(1);
+ text *priv_type_text = PG_GETARG_TEXT_P(2);
+
+ return has_foreign_data_wrapper_privilege(roleid, fdwid, priv_type_text);
+ }
+
+
+ /*
* has_function_privilege variants
* These are all named "has_function_privilege" at the SQL level.
* They take various combinations of function name, function OID,
***************
*** 2467,2472 ****
--- 2610,2748 ----
}
/*
+ * has_server_privilege variants
+ * These are all named "has_server_privilege" at the SQL level.
+ * They take various combinations of foreign server name,
+ * server OID, user name, user OID, or implicit user = current_user.
+ *
+ * The result is a boolean value: true if user has the indicated
+ * privilege, false if not.
+ */
+
+ /*
+ * has_server_privilege
+ * Check user privileges on a foreign server.
+ */
+ static Datum
+ has_server_privilege(Oid roleid, Oid serverid, text *priv_type_text)
+ {
+ AclResult aclresult;
+ AclMode mode = ACL_NO_RIGHTS;
+ char *priv_type = text_to_cstring(priv_type_text);
+
+ if (pg_strcasecmp(priv_type, "USAGE") == 0)
+ mode = ACL_USAGE;
+ else if (pg_strcasecmp(priv_type, "USAGE WITH GRANT OPTION") == 0)
+ mode = ACL_GRANT_OPTION_FOR(ACL_USAGE);
+ else
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("unrecognized privilege type: \"%s\"", priv_type)));
+
+ aclresult = pg_foreign_server_aclcheck(serverid, roleid, mode);
+
+ PG_RETURN_BOOL(aclresult == ACLCHECK_OK);
+ }
+
+ /*
+ * has_server_privilege_name_name
+ * Check user privileges on a foreign server given
+ * name username, text servername, and text priv name.
+ */
+ Datum
+ has_server_privilege_name_name(PG_FUNCTION_ARGS)
+ {
+ Name username = PG_GETARG_NAME(0);
+ char *servername = text_to_cstring(PG_GETARG_TEXT_P(1));
+ text *priv_type_text = PG_GETARG_TEXT_P(2);
+
+ return has_server_privilege(get_roleid_checked(NameStr(*username)),
+ GetForeignServerOidByName(servername, false),
+ priv_type_text);
+ }
+
+ /*
+ * has_server_privilege_name
+ * Check user privileges on a foreign server given
+ * text servername and text priv name.
+ * current_user is assumed
+ */
+ Datum
+ has_server_privilege_name(PG_FUNCTION_ARGS)
+ {
+ char *servername = text_to_cstring(PG_GETARG_TEXT_P(0));
+ text *priv_type_text = PG_GETARG_TEXT_P(1);
+
+ return has_server_privilege(GetUserId(),
+ GetForeignServerOidByName(servername, false),
+ priv_type_text);
+ }
+
+ /*
+ * has_server_privilege_name_id
+ * Check user privileges on a foreign server given
+ * name usename, foreign server oid, and text priv name.
+ */
+ Datum
+ has_server_privilege_name_id(PG_FUNCTION_ARGS)
+ {
+ Name username = PG_GETARG_NAME(0);
+ Oid serverid = PG_GETARG_OID(1);
+ text *priv_type_text = PG_GETARG_TEXT_P(2);
+
+ return has_server_privilege(get_roleid_checked(NameStr(*username)), serverid,
+ priv_type_text);
+ }
+
+ /*
+ * has_server_privilege_id
+ * Check user privileges on a foreign server given
+ * server oid, and text priv name.
+ * current_user is assumed
+ */
+ Datum
+ has_server_privilege_id(PG_FUNCTION_ARGS)
+ {
+ Oid serverid = PG_GETARG_OID(0);
+ text *priv_type_text = PG_GETARG_TEXT_P(1);
+
+ return has_server_privilege(GetUserId(), serverid, priv_type_text);
+ }
+
+ /*
+ * has_server_privilege_id_name
+ * Check user privileges on a foreign server given
+ * roleid, text servername, and text priv name.
+ */
+ Datum
+ has_server_privilege_id_name(PG_FUNCTION_ARGS)
+ {
+ Oid roleid = PG_GETARG_OID(0);
+ char *servername = text_to_cstring(PG_GETARG_TEXT_P(1));
+ text *priv_type_text = PG_GETARG_TEXT_P(2);
+
+ return has_server_privilege(roleid,
+ GetForeignServerOidByName(servername, false),
+ priv_type_text);
+ }
+
+ /*
+ * has_server_privilege_id_id
+ * Check user privileges on a foreign server given
+ * roleid, server oid, and text priv name.
+ */
+ Datum
+ has_server_privilege_id_id(PG_FUNCTION_ARGS)
+ {
+ Oid roleid = PG_GETARG_OID(0);
+ Oid serverid = PG_GETARG_OID(1);
+ text *priv_type_text = PG_GETARG_TEXT_P(2);
+
+ return has_server_privilege(roleid, serverid, priv_type_text);
+ }
+
+
+ /*
* has_tablespace_privilege variants
* These are all named "has_tablespace_privilege" at the SQL level.
* They take various combinations of tablespace name, tablespace OID,
diff -cNr -x CVS cvs-pgsql/src/backend/utils/cache/syscache.c pgsql/src/backend/utils/cache/syscache.c
*** cvs-pgsql/src/backend/utils/cache/syscache.c Thu Jun 19 03:46:05 2008
--- pgsql/src/backend/utils/cache/syscache.c Fri Dec 12 10:44:15 2008
***************
*** 32,37 ****
--- 32,39 ----
#include "catalog/pg_conversion.h"
#include "catalog/pg_database.h"
#include "catalog/pg_enum.h"
+ #include "catalog/pg_foreign_data_wrapper.h"
+ #include "catalog/pg_foreign_server.h"
#include "catalog/pg_language.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
***************
*** 46,51 ****
--- 48,54 ----
#include "catalog/pg_ts_parser.h"
#include "catalog/pg_ts_template.h"
#include "catalog/pg_type.h"
+ #include "catalog/pg_user_mapping.h"
#include "utils/rel.h"
#include "utils/syscache.h"
***************
*** 365,370 ****
--- 368,421 ----
},
256
},
+ {ForeignDataWrapperRelationId, /* FOREIGNDATAWRAPPERNAME */
+ ForeignDataWrapperNameIndexId,
+ 0,
+ 1,
+ {
+ Anum_pg_foreign_data_wrapper_fdwname,
+ 0,
+ 0,
+ 0
+ },
+ 8
+ },
+ {ForeignDataWrapperRelationId, /* FOREIGNDATAWRAPPEROID */
+ ForeignDataWrapperOidIndexId,
+ 0,
+ 1,
+ {
+ ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0
+ },
+ 8
+ },
+ {ForeignServerRelationId, /* FOREIGNSERVERNAME */
+ ForeignServerNameIndexId,
+ 0,
+ 1,
+ {
+ Anum_pg_foreign_server_srvname,
+ 0,
+ 0,
+ 0
+ },
+ 32
+ },
+ {ForeignServerRelationId, /* FOREIGNSERVEROID */
+ ForeignServerOidIndexId,
+ 0,
+ 1,
+ {
+ ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0
+ },
+ 32
+ },
{IndexRelationId, /* INDEXRELID */
IndexRelidIndexId,
Anum_pg_index_indrelid,
***************
*** 676,681 ****
--- 727,756 ----
0
},
1024
+ },
+ {UserMappingRelationId, /* USERMAPPINGOID */
+ UserMappingOidIndexId,
+ 0,
+ 1,
+ {
+ ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0
+ },
+ 128
+ },
+ {UserMappingRelationId, /* USERMAPPINGUSERSERVER */
+ UserMappingUserServerIndexId,
+ 0,
+ 2,
+ {
+ Anum_pg_user_mapping_umuser,
+ Anum_pg_user_mapping_umserver,
+ 0,
+ 0
+ },
+ 128
}
};
diff -cNr -x CVS cvs-pgsql/src/bin/pg_dump/common.c pgsql/src/bin/pg_dump/common.c
*** cvs-pgsql/src/bin/pg_dump/common.c Sat May 10 02:32:04 2008
--- pgsql/src/bin/pg_dump/common.c Fri Dec 12 10:44:15 2008
***************
*** 91,96 ****
--- 91,98 ----
TSTemplateInfo *tmplinfo;
TSDictInfo *dictinfo;
TSConfigInfo *cfginfo;
+ FdwInfo *fdwinfo;
+ ForeignServerInfo *srvinfo;
int numNamespaces;
int numAggregates;
int numInherits;
***************
*** 104,109 ****
--- 106,113 ----
int numTSTemplates;
int numTSDicts;
int numTSConfigs;
+ int numForeignDataWrappers;
+ int numForeignServers;
if (g_verbose)
write_msg(NULL, "reading schemas\n");
***************
*** 155,160 ****
--- 159,172 ----
cfginfo = getTSConfigurations(&numTSConfigs);
if (g_verbose)
+ write_msg(NULL, "reading user-defined foreign-data wrappers\n");
+ fdwinfo = getForeignDataWrappers(&numForeignDataWrappers);
+
+ if (g_verbose)
+ write_msg(NULL, "reading user-defined foreign servers\n");
+ srvinfo = getForeignServers(&numForeignServers);
+
+ if (g_verbose)
write_msg(NULL, "reading user-defined operator families\n");
opfinfo = getOpfamilies(&numOpfamilies);
diff -cNr -x CVS cvs-pgsql/src/bin/pg_dump/dumputils.c pgsql/src/bin/pg_dump/dumputils.c
*** cvs-pgsql/src/bin/pg_dump/dumputils.c Thu Sep 11 15:30:02 2008
--- pgsql/src/bin/pg_dump/dumputils.c Fri Dec 12 10:44:15 2008
***************
*** 687,692 ****
--- 687,696 ----
}
else if (strcmp(type, "TABLESPACE") == 0)
CONVERT_PRIV('C', "CREATE");
+ else if (strcmp(type, "FOREIGN DATA WRAPPER") == 0)
+ CONVERT_PRIV('U', "USAGE");
+ else if (strcmp(type, "SERVER") == 0)
+ CONVERT_PRIV('U', "USAGE");
else
abort();
diff -cNr -x CVS cvs-pgsql/src/bin/pg_dump/pg_backup_archiver.c pgsql/src/bin/pg_dump/pg_backup_archiver.c
*** cvs-pgsql/src/bin/pg_dump/pg_backup_archiver.c Thu Sep 11 15:30:02 2008
--- pgsql/src/bin/pg_dump/pg_backup_archiver.c Fri Dec 12 10:44:15 2008
***************
*** 2479,2485 ****
/* objects named by just a name */
if (strcmp(type, "DATABASE") == 0 ||
strcmp(type, "PROCEDURAL LANGUAGE") == 0 ||
! strcmp(type, "SCHEMA") == 0)
{
appendPQExpBuffer(buf, "%s %s", type, fmtId(te->tag));
return;
--- 2479,2488 ----
/* objects named by just a name */
if (strcmp(type, "DATABASE") == 0 ||
strcmp(type, "PROCEDURAL LANGUAGE") == 0 ||
! strcmp(type, "SCHEMA") == 0 ||
! strcmp(type, "FOREIGN DATA WRAPPER") == 0 ||
! strcmp(type, "SERVER") == 0 ||
! strcmp(type, "USER MAPPING") == 0)
{
appendPQExpBuffer(buf, "%s %s", type, fmtId(te->tag));
return;
***************
*** 2636,2642 ****
strcmp(te->desc, "VIEW") == 0 ||
strcmp(te->desc, "SEQUENCE") == 0 ||
strcmp(te->desc, "TEXT SEARCH DICTIONARY") == 0 ||
! strcmp(te->desc, "TEXT SEARCH CONFIGURATION") == 0)
{
PQExpBuffer temp = createPQExpBuffer();
--- 2639,2647 ----
strcmp(te->desc, "VIEW") == 0 ||
strcmp(te->desc, "SEQUENCE") == 0 ||
strcmp(te->desc, "TEXT SEARCH DICTIONARY") == 0 ||
! strcmp(te->desc, "TEXT SEARCH CONFIGURATION") == 0 ||
! strcmp(te->desc, "FOREIGN DATA WRAPPER") == 0 ||
! strcmp(te->desc, "SERVER") == 0)
{
PQExpBuffer temp = createPQExpBuffer();
***************
*** 2653,2659 ****
strcmp(te->desc, "FK CONSTRAINT") == 0 ||
strcmp(te->desc, "INDEX") == 0 ||
strcmp(te->desc, "RULE") == 0 ||
! strcmp(te->desc, "TRIGGER") == 0)
{
/* these object types don't have separate owners */
}
--- 2658,2665 ----
strcmp(te->desc, "FK CONSTRAINT") == 0 ||
strcmp(te->desc, "INDEX") == 0 ||
strcmp(te->desc, "RULE") == 0 ||
! strcmp(te->desc, "TRIGGER") == 0 ||
! strcmp(te->desc, "USER MAPPING") == 0)
{
/* these object types don't have separate owners */
}
diff -cNr -x CVS cvs-pgsql/src/bin/pg_dump/pg_dump.c pgsql/src/bin/pg_dump/pg_dump.c
*** cvs-pgsql/src/bin/pg_dump/pg_dump.c Fri Dec 12 10:41:32 2008
--- pgsql/src/bin/pg_dump/pg_dump.c Mon Dec 15 14:15:59 2008
***************
*** 158,163 ****
--- 158,168 ----
static void dumpTSDictionary(Archive *fout, TSDictInfo *dictinfo);
static void dumpTSTemplate(Archive *fout, TSTemplateInfo *tmplinfo);
static void dumpTSConfig(Archive *fout, TSConfigInfo *cfginfo);
+ static void dumpForeignDataWrapper(Archive *fout, FdwInfo *fdwinfo);
+ static void dumpForeignServer(Archive *fout, ForeignServerInfo *srvinfo);
+ static void dumpUserMappings(Archive *fout, const char *target,
+ const char *servername, const char *namespace,
+ const char *owner, CatalogId catalogId, DumpId dumpId);
static void dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
const char *type, const char *name,
***************
*** 5269,5274 ****
--- 5274,5442 ----
return cfginfo;
}
+ /*
+ * getForeignDataWrappers:
+ * read all foreign-data wrappers in the system catalogs and return
+ * them in the FdwInfo* structure
+ *
+ * numForeignDataWrappers is set to the number of fdws read in
+ */
+ FdwInfo *
+ getForeignDataWrappers(int *numForeignDataWrappers)
+ {
+ PGresult *res;
+ int ntups;
+ int i;
+ PQExpBuffer query = createPQExpBuffer();
+ FdwInfo *fdwinfo;
+ int i_oid;
+ int i_fdwname;
+ int i_rolname;
+ int i_fdwlibrary;
+ int i_fdwacl;
+ int i_fdwoptions;
+
+ /* Before 8.4, there are no foreign-data wrappers */
+ if (g_fout->remoteVersion < 80400)
+ {
+ *numForeignDataWrappers = 0;
+ return NULL;
+ }
+
+ /* Make sure we are in proper schema */
+ selectSourceSchema("pg_catalog");
+
+ appendPQExpBuffer(query, "SELECT oid, fdwname, "
+ "(%s fdwowner) as rolname, fdwlibrary, fdwacl,"
+ "array_to_string(ARRAY("
+ " select option_name || ' ' || quote_literal(option_value)"
+ " from pg_get_foreign_data_wrapper_options(oid)), ', ') as fdwoptions "
+ "FROM pg_foreign_data_wrapper",
+ username_subquery);
+
+ res = PQexec(g_conn, query->data);
+ check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
+
+ ntups = PQntuples(res);
+ *numForeignDataWrappers = ntups;
+
+ fdwinfo = (FdwInfo *) malloc(ntups * sizeof(FdwInfo));
+
+ i_oid = PQfnumber(res, "oid");
+ i_fdwname = PQfnumber(res, "fdwname");
+ i_rolname = PQfnumber(res, "rolname");
+ i_fdwlibrary = PQfnumber(res, "fdwlibrary");
+ i_fdwacl = PQfnumber(res, "fdwacl");
+ i_fdwoptions = PQfnumber(res, "fdwoptions");
+
+ for (i = 0; i < ntups; i++)
+ {
+ fdwinfo[i].dobj.objType = DO_FDW;
+ fdwinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
+ AssignDumpId(&fdwinfo[i].dobj);
+ fdwinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_fdwname));
+ fdwinfo[i].dobj.namespace = NULL;
+ fdwinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ fdwinfo[i].fdwlibrary = strdup(PQgetvalue(res, i, i_fdwlibrary));
+ fdwinfo[i].fdwoptions = strdup(PQgetvalue(res, i, i_fdwoptions));
+ fdwinfo[i].fdwacl = strdup(PQgetvalue(res, i, i_fdwacl));
+
+
+ /* Decide whether we want to dump it */
+ selectDumpableObject(&(fdwinfo[i].dobj));
+ }
+
+ PQclear(res);
+
+ destroyPQExpBuffer(query);
+
+ return fdwinfo;
+ }
+
+ /*
+ * getForeignServers:
+ * read all foreign servers in the system catalogs and return
+ * them in the ForeignServerInfo * structure
+ *
+ * numForeignServers is set to the number of servers read in
+ */
+ ForeignServerInfo *
+ getForeignServers(int *numForeignServers)
+ {
+ PGresult *res;
+ int ntups;
+ int i;
+ PQExpBuffer query = createPQExpBuffer();
+ ForeignServerInfo *srvinfo;
+ int i_oid;
+ int i_srvname;
+ int i_rolname;
+ int i_srvfdw;
+ int i_srvtype;
+ int i_srvversion;
+ int i_srvacl;
+ int i_srvoptions;
+
+ /* Before 8.4, there are no foreign servers */
+ if (g_fout->remoteVersion < 80400)
+ {
+ *numForeignServers = 0;
+ return NULL;
+ }
+
+ /* Make sure we are in proper schema */
+ selectSourceSchema("pg_catalog");
+
+ appendPQExpBuffer(query, "SELECT oid, srvname, "
+ "(%s srvowner) as rolname, "
+ "srvfdw, srvtype, srvversion, srvacl,"
+ "array_to_string(ARRAY("
+ " select option_name || ' ' || quote_literal(option_value)"
+ " from pg_get_foreign_server_options(oid)), ', ') as srvoptions "
+ "FROM pg_foreign_server",
+ username_subquery);
+
+ res = PQexec(g_conn, query->data);
+ check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
+
+ ntups = PQntuples(res);
+ *numForeignServers = ntups;
+
+ srvinfo = (ForeignServerInfo *) malloc(ntups * sizeof(ForeignServerInfo));
+
+ i_oid = PQfnumber(res, "oid");
+ i_srvname = PQfnumber(res, "srvname");
+ i_rolname = PQfnumber(res, "rolname");
+ i_srvfdw = PQfnumber(res, "srvfdw");
+ i_srvtype = PQfnumber(res, "srvtype");
+ i_srvversion = PQfnumber(res, "srvversion");
+ i_srvacl = PQfnumber(res, "srvacl");
+ i_srvoptions = PQfnumber(res, "srvoptions");
+
+ for (i = 0; i < ntups; i++)
+ {
+ srvinfo[i].dobj.objType = DO_FOREIGN_SERVER;
+ srvinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
+ AssignDumpId(&srvinfo[i].dobj);
+ srvinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_srvname));
+ srvinfo[i].dobj.namespace = NULL;
+ srvinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
+ srvinfo[i].srvfdw = atooid(PQgetvalue(res, i, i_srvfdw));
+ srvinfo[i].srvtype = strdup(PQgetvalue(res, i, i_srvtype));
+ srvinfo[i].srvversion = strdup(PQgetvalue(res, i, i_srvversion));
+ srvinfo[i].srvoptions = strdup(PQgetvalue(res, i, i_srvoptions));
+ srvinfo[i].srvacl = strdup(PQgetvalue(res, i, i_srvacl));
+
+ /* Decide whether we want to dump it */
+ selectDumpableObject(&(srvinfo[i].dobj));
+ }
+
+ PQclear(res);
+
+ destroyPQExpBuffer(query);
+
+ return srvinfo;
+ }
/*
* dumpComment --
***************
*** 5671,5676 ****
--- 5839,5850 ----
case DO_TSCONFIG:
dumpTSConfig(fout, (TSConfigInfo *) dobj);
break;
+ case DO_FDW:
+ dumpForeignDataWrapper(fout, (FdwInfo *) dobj);
+ break;
+ case DO_FOREIGN_SERVER:
+ dumpForeignServer(fout, (ForeignServerInfo *) dobj);
+ break;
case DO_BLOBS:
ArchiveEntry(fout, dobj->catId, dobj->dumpId,
dobj->name, NULL, NULL, "",
***************
*** 8976,8981 ****
--- 9150,9376 ----
destroyPQExpBuffer(query);
}
+ /*
+ * dumpForeignDataWrapper
+ * write out a single foreign-data wrapper definition
+ */
+ static void
+ dumpForeignDataWrapper(Archive *fout, FdwInfo *fdwinfo)
+ {
+ PQExpBuffer q;
+ PQExpBuffer delq;
+ char *namecopy;
+
+ /* Skip if not to be dumped */
+ if (!fdwinfo->dobj.dump || dataOnly)
+ return;
+
+ q = createPQExpBuffer();
+ delq = createPQExpBuffer();
+
+ appendPQExpBuffer(q, "CREATE FOREIGN DATA WRAPPER %s LIBRARY '%s' LANGUAGE C",
+ fmtId(fdwinfo->dobj.name), fdwinfo->fdwlibrary);
+ if (fdwinfo->fdwoptions && strlen(fdwinfo->fdwoptions) > 0)
+ appendPQExpBuffer(q, " OPTIONS (%s)", fdwinfo->fdwoptions);
+
+ appendPQExpBuffer(q, ";\n");
+
+ appendPQExpBuffer(delq, "DROP FOREIGN DATA WRAPPER %s;\n",
+ fmtId(fdwinfo->dobj.name));
+
+ ArchiveEntry(fout, fdwinfo->dobj.catId, fdwinfo->dobj.dumpId,
+ fdwinfo->dobj.name,
+ NULL,
+ NULL,
+ fdwinfo->rolname,
+ false, "FOREIGN DATA WRAPPER", q->data, delq->data, NULL,
+ fdwinfo->dobj.dependencies, fdwinfo->dobj.nDeps,
+ NULL, NULL);
+
+ /* Handle the ACL */
+ namecopy = strdup(fmtId(fdwinfo->dobj.name));
+ dumpACL(fout, fdwinfo->dobj.catId, fdwinfo->dobj.dumpId,
+ "FOREIGN DATA WRAPPER",
+ namecopy, fdwinfo->dobj.name,
+ NULL, fdwinfo->rolname,
+ fdwinfo->fdwacl);
+ free(namecopy);
+
+ destroyPQExpBuffer(q);
+ destroyPQExpBuffer(delq);
+ }
+
+ /*
+ * dumpForeignServer
+ * write out a foreign server definition
+ */
+ static void
+ dumpForeignServer(Archive *fout, ForeignServerInfo *srvinfo)
+ {
+ PQExpBuffer q;
+ PQExpBuffer delq;
+ PQExpBuffer query;
+ PGresult *res;
+ int ntups;
+ char *namecopy;
+ char *fdwname;
+
+ /* Skip if not to be dumped */
+ if (!srvinfo->dobj.dump || dataOnly)
+ return;
+
+ q = createPQExpBuffer();
+ delq = createPQExpBuffer();
+ query = createPQExpBuffer();
+
+ /* look up the foreign-data wrapper */
+ appendPQExpBuffer(query, "SELECT fdwname "
+ "FROM pg_foreign_data_wrapper w "
+ "WHERE w.oid = '%u'",
+ srvinfo->srvfdw);
+ res = PQexec(g_conn, query->data);
+ check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
+ ntups = PQntuples(res);
+ if (ntups != 1)
+ {
+ write_msg(NULL, "query returned %d rows instead of one: %s\n",
+ ntups, query->data);
+ exit_nicely();
+ }
+ fdwname = PQgetvalue(res, 0, 0);
+
+ appendPQExpBuffer(q, "CREATE SERVER %s", fmtId(srvinfo->dobj.name));
+ if (srvinfo->srvtype && strlen(srvinfo->srvtype) > 0)
+ appendPQExpBuffer(q, " TYPE '%s'", srvinfo->srvtype);
+ if (srvinfo->srvversion && strlen(srvinfo->srvversion) > 0)
+ appendPQExpBuffer(q, " VERSION '%s'", srvinfo->srvversion);
+
+ appendPQExpBuffer(q, " FOREIGN DATA WRAPPER ");
+ appendPQExpBuffer(q, "%s", fmtId(fdwname));
+
+ if (srvinfo->srvoptions && strlen(srvinfo->srvoptions) > 0)
+ appendPQExpBuffer(q, " OPTIONS (%s)", srvinfo->srvoptions);
+
+ appendPQExpBuffer(q, ";\n");
+
+ appendPQExpBuffer(delq, "DROP SERVER %s;\n",
+ fmtId(srvinfo->dobj.name));
+
+ ArchiveEntry(fout, srvinfo->dobj.catId, srvinfo->dobj.dumpId,
+ srvinfo->dobj.name,
+ NULL,
+ NULL,
+ srvinfo->rolname,
+ false, "SERVER", q->data, delq->data, NULL,
+ srvinfo->dobj.dependencies, srvinfo->dobj.nDeps,
+ NULL, NULL);
+
+ /* Handle the ACL */
+ namecopy = strdup(fmtId(srvinfo->dobj.name));
+ dumpACL(fout, srvinfo->dobj.catId, srvinfo->dobj.dumpId,
+ "SERVER",
+ namecopy, srvinfo->dobj.name,
+ NULL, srvinfo->rolname,
+ srvinfo->srvacl);
+ free(namecopy);
+
+ /* Dump user mappings */
+ resetPQExpBuffer(q);
+ appendPQExpBuffer(q, "SERVER %s", fmtId(srvinfo->dobj.name));
+ dumpUserMappings(fout, q->data,
+ srvinfo->dobj.name, NULL,
+ srvinfo->rolname,
+ srvinfo->dobj.catId, srvinfo->dobj.dumpId);
+
+ destroyPQExpBuffer(q);
+ destroyPQExpBuffer(delq);
+ }
+
+ /*
+ * dumpUserMappings
+ *
+ * This routine is used to dump any user mappings associated with the
+ * server handed to this routine. Should be called after ArchiveEntry()
+ * for the server.
+ */
+ static void
+ dumpUserMappings(Archive *fout, const char *target,
+ const char *servername, const char *namespace,
+ const char *owner,
+ CatalogId catalogId, DumpId dumpId)
+ {
+ PQExpBuffer q;
+ PQExpBuffer delq;
+ PQExpBuffer query;
+ PQExpBuffer tag;
+ PGresult *res;
+ int ntups;
+ int i_usename;
+ int i_umoptions;
+ int i;
+
+ q = createPQExpBuffer();
+ tag = createPQExpBuffer();
+ delq = createPQExpBuffer();
+ query = createPQExpBuffer();
+
+ appendPQExpBuffer(query, "SELECT usename, "
+ "array_to_string(ARRAY(\n"
+ " SELECT\n"
+ " option_name || ' ' || quote_literal(option_value)\n"
+ " FROM\n"
+ " pg_get_user_mapping_options(umid)\n"
+ "), ', ') as umoptions\n"
+ "FROM pg_user_mappings WHERE srvid=%u",
+ catalogId.oid);
+
+ res = PQexec(g_conn, query->data);
+ check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
+
+ ntups = PQntuples(res);
+ i_usename = PQfnumber(res, "usename");
+ i_umoptions = PQfnumber(res, "umoptions");
+
+ for (i = 0; i < ntups; i++)
+ {
+ char *usename;
+ char *umoptions;
+
+ usename = PQgetvalue(res, i, i_usename);
+ umoptions = PQgetvalue(res, i, i_umoptions);
+
+ resetPQExpBuffer(q);
+ appendPQExpBuffer(q, "CREATE USER MAPPING FOR %s", fmtId(usename));
+ appendPQExpBuffer(q, " SERVER %s", fmtId(servername));
+
+ if (umoptions && strlen(umoptions) > 0)
+ appendPQExpBuffer(q, " OPTIONS (%s)", umoptions);
+
+ appendPQExpBuffer(q, ";\n");
+
+ resetPQExpBuffer(delq);
+ appendPQExpBuffer(delq, "DROP USER MAPPING FOR %s SERVER %s;\n", fmtId(usename), fmtId(servername));
+
+ resetPQExpBuffer(tag);
+ appendPQExpBuffer(tag, "USER MAPPING %s %s", fmtId(usename), target);
+
+ ArchiveEntry(fout, nilCatalogId, createDumpId(),
+ tag->data,
+ namespace,
+ NULL,
+ owner, false,
+ "USER MAPPING", q->data,
+ delq->data, NULL,
+ &dumpId, 1,
+ NULL, NULL);
+ }
+
+ PQclear(res);
+
+ destroyPQExpBuffer(query);
+ destroyPQExpBuffer(delq);
+ destroyPQExpBuffer(q);
+ }
/*----------
* Write out grant/revoke information
diff -cNr -x CVS cvs-pgsql/src/bin/pg_dump/pg_dump.h pgsql/src/bin/pg_dump/pg_dump.h
*** cvs-pgsql/src/bin/pg_dump/pg_dump.h Thu Nov 13 10:44:41 2008
--- pgsql/src/bin/pg_dump/pg_dump.h Fri Dec 12 10:44:15 2008
***************
*** 131,136 ****
--- 131,138 ----
DO_TSDICT,
DO_TSTEMPLATE,
DO_TSCONFIG,
+ DO_FDW,
+ DO_FOREIGN_SERVER,
DO_BLOBS,
DO_BLOB_COMMENTS
} DumpableObjectType;
***************
*** 418,423 ****
--- 420,445 ----
Oid cfgparser;
} TSConfigInfo;
+ typedef struct _fdwInfo
+ {
+ DumpableObject dobj;
+ char *rolname;
+ char *fdwlibrary;
+ char *fdwoptions;
+ char *fdwacl;
+ } FdwInfo;
+
+ typedef struct _foreignServerInfo
+ {
+ DumpableObject dobj;
+ char *rolname;
+ Oid srvfdw;
+ char *srvtype;
+ char *srvversion;
+ char *srvacl;
+ char *srvoptions;
+ } ForeignServerInfo;
+
/* global decls */
extern bool force_quotes; /* double-quotes for identifiers flag */
extern bool g_verbose; /* verbose flag */
***************
*** 500,504 ****
--- 522,528 ----
extern TSDictInfo *getTSDictionaries(int *numTSDicts);
extern TSTemplateInfo *getTSTemplates(int *numTSTemplates);
extern TSConfigInfo *getTSConfigurations(int *numTSConfigs);
+ extern FdwInfo *getForeignDataWrappers(int *numForeignDataWrappers);
+ extern ForeignServerInfo *getForeignServers(int *numForeignServers);
#endif /* PG_DUMP_H */
diff -cNr -x CVS cvs-pgsql/src/bin/pg_dump/pg_dump_sort.c pgsql/src/bin/pg_dump/pg_dump_sort.c
*** cvs-pgsql/src/bin/pg_dump/pg_dump_sort.c Thu Sep 11 15:30:02 2008
--- pgsql/src/bin/pg_dump/pg_dump_sort.c Fri Dec 12 10:44:15 2008
***************
*** 50,55 ****
--- 50,57 ----
4, /* DO_TSDICT */
3, /* DO_TSTEMPLATE */
5, /* DO_TSCONFIG */
+ 3, /* DO_FDW */
+ 4, /* DO_FOREIGN_SERVER */
10, /* DO_BLOBS */
11 /* DO_BLOB_COMMENTS */
};
***************
*** 84,89 ****
--- 86,93 ----
6, /* DO_TSDICT */
5, /* DO_TSTEMPLATE */
7, /* DO_TSCONFIG */
+ 3, /* DO_FDW */
+ 4, /* DO_FOREIGN_SERVER */
14, /* DO_BLOBS */
15 /* DO_BLOB_COMMENTS */
};
***************
*** 1123,1128 ****
--- 1127,1142 ----
"TEXT SEARCH CONFIGURATION %s (ID %d OID %u)",
obj->name, obj->dumpId, obj->catId.oid);
return;
+ case DO_FDW:
+ snprintf(buf, bufsize,
+ "FOREIGN DATA WRAPPER %s (ID %d OID %u)",
+ obj->name, obj->dumpId, obj->catId.oid);
+ return;
+ case DO_FOREIGN_SERVER:
+ snprintf(buf, bufsize,
+ "FOREIGN SERVER %s (ID %d OID %u)",
+ obj->name, obj->dumpId, obj->catId.oid);
+ return;
case DO_BLOBS:
snprintf(buf, bufsize,
"BLOBS (ID %d)",
diff -cNr -x CVS cvs-pgsql/src/bin/psql/command.c pgsql/src/bin/psql/command.c
*** cvs-pgsql/src/bin/psql/command.c Mon Nov 24 09:49:53 2008
--- pgsql/src/bin/psql/command.c Mon Dec 15 11:05:44 2008
***************
*** 416,422 ****
break;
}
break;
!
default:
status = PSQL_CMD_UNKNOWN;
}
--- 416,438 ----
break;
}
break;
! case 'e': /* SQL/MED subsystem */
! switch(cmd[2])
! {
! case 's':
! success = listForeignServers(pattern, show_verbose);
! break;
! case 'u':
! success = listUserMappings(pattern, show_verbose);
! break;
! case 'w':
! success = listForeignDataWrappers(pattern, show_verbose);
! break;
! default:
! status = PSQL_CMD_UNKNOWN;
! break;
! }
! break;
default:
status = PSQL_CMD_UNKNOWN;
}
diff -cNr -x CVS cvs-pgsql/src/bin/psql/describe.c pgsql/src/bin/psql/describe.c
*** cvs-pgsql/src/bin/psql/describe.c Thu Nov 13 10:44:41 2008
--- pgsql/src/bin/psql/describe.c Mon Dec 15 11:00:27 2008
***************
*** 2766,2768 ****
--- 2766,2922 ----
PQclear(res);
return true;
}
+
+
+ /*
+ * \dew
+ *
+ * Describes foreign-data wrappers
+ */
+ bool
+ listForeignDataWrappers(const char *pattern, bool verbose)
+ {
+ PQExpBufferData buf;
+ PGresult *res;
+ printQueryOpt myopt = pset.popt;
+
+ initPQExpBuffer(&buf);
+ printfPQExpBuffer(&buf,
+ "SELECT fdwname AS \"%s\",\n"
+ " pg_catalog.pg_get_userbyid(fdwowner) AS \"%s\",\n"
+ " fdwlibrary AS \"%s\"\n",
+ gettext_noop("Name"),
+ gettext_noop("Owner"),
+ gettext_noop("Library"));
+
+ if (verbose)
+ appendPQExpBuffer(&buf,
+ ",\n fdwacl as \"%s\","
+ " fdwoptions as \"%s\"",
+ gettext_noop("Access privileges"),
+ gettext_noop("Options"));
+
+ appendPQExpBuffer(&buf, "\nFROM pg_catalog.pg_foreign_data_wrapper WHERE 1=1\n");
+
+ processSQLNamePattern(pset.db, &buf, pattern, true, false,
+ NULL, "fdwname", NULL, NULL);
+
+ appendPQExpBuffer(&buf, "ORDER BY 1;");
+
+ res = PSQLexec(buf.data, false);
+ termPQExpBuffer(&buf);
+ if (!res)
+ return false;
+
+ myopt.nullPrint = NULL;
+ myopt.title = _("List of foreign-data wrappers");
+ myopt.translate_header = true;
+
+ printQuery(res, &myopt, pset.queryFout, pset.logfile);
+
+ PQclear(res);
+ return true;
+ }
+
+ /*
+ * \des
+ *
+ * Describes servers.
+ */
+ bool
+ listForeignServers(const char *pattern, bool verbose)
+ {
+ PQExpBufferData buf;
+ PGresult *res;
+ printQueryOpt myopt = pset.popt;
+
+ initPQExpBuffer(&buf);
+ printfPQExpBuffer(&buf,
+ "SELECT s.srvname AS \"%s\",\n"
+ " pg_catalog.pg_get_userbyid(s.srvowner) AS \"%s\",\n"
+ " f.fdwname AS \"%s\"\n",
+ gettext_noop("Name"),
+ gettext_noop("Owner"),
+ gettext_noop("Foreign-data wrapper"));
+
+ if (verbose)
+ appendPQExpBuffer(&buf,
+ ",\n s.srvacl as \"%s\","
+ " s.srvtype as \"%s\","
+ " s.srvversion as \"%s\","
+ " s.srvoptions as \"%s\"",
+ gettext_noop("Access privileges"),
+ gettext_noop("Type"),
+ gettext_noop("Version"),
+ gettext_noop("Options"));
+
+ appendPQExpBuffer(&buf,
+ "\nFROM pg_foreign_server s\n"
+ "JOIN pg_catalog.pg_foreign_data_wrapper f ON f.oid=s.srvfdw\n");
+
+ processSQLNamePattern(pset.db, &buf, pattern, true, false,
+ NULL, "s.srvname", NULL, NULL);
+
+ appendPQExpBuffer(&buf, "ORDER BY 1;");
+
+ res = PSQLexec(buf.data, false);
+ termPQExpBuffer(&buf);
+ if (!res)
+ return false;
+
+ myopt.nullPrint = NULL;
+ myopt.title = _("List of foreign servers");
+ myopt.translate_header = true;
+
+ printQuery(res, &myopt, pset.queryFout, pset.logfile);
+
+ PQclear(res);
+ return true;
+ }
+
+ /*
+ * \deu
+ *
+ * Describes user mappings.
+ */
+ bool
+ listUserMappings(const char *pattern, bool verbose)
+ {
+ PQExpBufferData buf;
+ PGresult *res;
+ printQueryOpt myopt = pset.popt;
+
+ initPQExpBuffer(&buf);
+ printfPQExpBuffer(&buf,
+ "SELECT um.srvname AS \"%s\",\n"
+ " um.usename AS \"%s\"",
+ gettext_noop("Server"),
+ gettext_noop("Username"));
+
+ if (verbose)
+ appendPQExpBuffer(&buf,
+ ",\n nullif(array(select option_name||'='||option_value"
+ " from pg_get_user_mapping_options(um.umid)), '{}') \"%s\"",
+ gettext_noop("Options"));
+
+ appendPQExpBuffer(&buf, "\nFROM pg_catalog.pg_user_mappings um WHERE 1=1\n");
+
+ processSQLNamePattern(pset.db, &buf, pattern, true, false,
+ NULL, "um.srvname", "um.usename", NULL);
+
+ appendPQExpBuffer(&buf, "ORDER BY 1, 2;");
+
+ res = PSQLexec(buf.data, false);
+ termPQExpBuffer(&buf);
+ if (!res)
+ return false;
+
+ myopt.nullPrint = NULL;
+ myopt.title = _("List of user mappings");
+ myopt.translate_header = true;
+
+ printQuery(res, &myopt, pset.queryFout, pset.logfile);
+
+ PQclear(res);
+ return true;
+ }
diff -cNr -x CVS cvs-pgsql/src/bin/psql/describe.h pgsql/src/bin/psql/describe.h
*** cvs-pgsql/src/bin/psql/describe.h Tue Jan 1 21:45:56 2008
--- pgsql/src/bin/psql/describe.h Mon Dec 15 11:00:25 2008
***************
*** 66,70 ****
--- 66,79 ----
/* \dn */
extern bool listSchemas(const char *pattern, bool verbose);
+ /* \dew */
+ extern bool listForeignDataWrappers(const char *pattern, bool verbose);
+
+ /* \des */
+ extern bool listForeignServers(const char *pattern, bool verbose);
+
+ /* \deu */
+ extern bool listUserMappings(const char *pattern, bool verbose);
+
#endif /* DESCRIBE_H */
diff -cNr -x CVS cvs-pgsql/src/bin/psql/help.c pgsql/src/bin/psql/help.c
*** cvs-pgsql/src/bin/psql/help.c Thu Nov 13 10:44:41 2008
--- pgsql/src/bin/psql/help.c Mon Dec 15 11:00:26 2008
***************
*** 203,208 ****
--- 203,211 ----
fprintf(output, _(" \\dC [PATTERN] list casts\n"));
fprintf(output, _(" \\dd [PATTERN] show comment for object\n"));
fprintf(output, _(" \\dD [PATTERN] list domains\n"));
+ fprintf(output, _(" \\des [PATTERN] list foreign servers (add \"+\" for more detail)\n"));
+ fprintf(output, _(" \\deu [PATTERN] list user mappings (add \"+\" for more detail)\n"));
+ fprintf(output, _(" \\dew [PATTERN] list foreign-data wrappers (add \"+\" for more detail)\n"));
fprintf(output, _(" \\df [PATTERN] list functions (add \"+\" for more detail)\n"));
fprintf(output, _(" \\dF [PATTERN] list text search configurations (add \"+\" for more detail)\n"));
fprintf(output, _(" \\dFd [PATTERN] list text search dictionaries (add \"+\" for more detail)\n"));
diff -cNr -x CVS cvs-pgsql/src/bin/psql/tab-complete.c pgsql/src/bin/psql/tab-complete.c
*** cvs-pgsql/src/bin/psql/tab-complete.c Fri Nov 21 11:46:51 2008
--- pgsql/src/bin/psql/tab-complete.c Mon Dec 15 11:00:23 2008
***************
*** 497,502 ****
--- 497,517 ----
"SELECT pg_catalog.quote_ident(tmplname) FROM pg_catalog.pg_ts_template "\
" WHERE substring(pg_catalog.quote_ident(tmplname),1,%d)='%s'"
+ #define Query_for_list_of_fdws \
+ " SELECT pg_catalog.quote_ident(fdwname) "\
+ " FROM pg_catalog.pg_foreign_data_wrapper "\
+ " WHERE substring(pg_catalog.quote_ident(fdwname),1,%d)='%s'"
+
+ #define Query_for_list_of_servers \
+ " SELECT pg_catalog.quote_ident(srvname) "\
+ " FROM pg_catalog.pg_foreign_server "\
+ " WHERE substring(pg_catalog.quote_ident(srvname),1,%d)='%s'"
+
+ #define Query_for_list_of_user_mappings \
+ " SELECT pg_catalog.quote_ident(usename) "\
+ " FROM pg_catalog.pg_user_mappings "\
+ " WHERE substring(pg_catalog.quote_ident(usename),1,%d)='%s'"
+
/*
* This is a list of all "things" in Pgsql, which can show up after CREATE or
* DROP; and there is also a query to get a list of them.
***************
*** 525,530 ****
--- 540,546 ----
{"DATABASE", Query_for_list_of_databases},
{"DICTIONARY", Query_for_list_of_ts_dictionaries, NULL, true},
{"DOMAIN", NULL, &Query_for_list_of_domains},
+ {"FOREIGN DATA WRAPPER", Query_for_list_of_fdws},
{"FUNCTION", NULL, &Query_for_list_of_functions},
{"GROUP", Query_for_list_of_roles},
{"LANGUAGE", Query_for_list_of_languages},
***************
*** 536,541 ****
--- 552,558 ----
{"RULE", "SELECT pg_catalog.quote_ident(rulename) FROM pg_catalog.pg_rules WHERE substring(pg_catalog.quote_ident(rulename),1,%d)='%s'"},
{"SCHEMA", Query_for_list_of_schemas},
{"SEQUENCE", NULL, &Query_for_list_of_sequences},
+ {"SERVER", Query_for_list_of_servers},
{"TABLE", NULL, &Query_for_list_of_tables},
{"TABLESPACE", Query_for_list_of_tablespaces},
{"TEMP", NULL, NULL}, /* for CREATE TEMP TABLE ... */
***************
*** 545,550 ****
--- 562,568 ----
{"TYPE", NULL, &Query_for_list_of_datatypes},
{"UNIQUE", NULL, NULL}, /* for CREATE UNIQUE INDEX ... */
{"USER", Query_for_list_of_roles},
+ {"USER MAPPING", Query_for_list_of_user_mappings},
{"VIEW", NULL, &Query_for_list_of_views},
{NULL, NULL, NULL, false} /* end of list */
};
***************
*** 624,629 ****
--- 642,648 ----
"\\d", "\\da", "\\db", "\\dc", "\\dC", "\\dd", "\\dD", "\\df",
"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl",
"\\dn", "\\do", "\\dp", "\\ds", "\\dS", "\\dt", "\\dT", "\\dv", "\\du",
+ "\\des", "\\deu", "\\dew",
"\\e", "\\echo", "\\encoding",
"\\f", "\\g", "\\h", "\\help", "\\H", "\\i", "\\l",
"\\lo_import", "\\lo_export", "\\lo_list", "\\lo_unlink",
***************
*** 686,694 ****
pg_strcasecmp(prev3_wd, "TABLE") != 0)
{
static const char *const list_ALTER[] =
! {"AGGREGATE", "CONVERSION", "DATABASE", "DOMAIN", "FUNCTION",
! "GROUP", "INDEX", "LANGUAGE", "OPERATOR", "ROLE", "SCHEMA", "SEQUENCE", "TABLE",
! "TABLESPACE", "TEXT SEARCH", "TRIGGER", "TYPE", "USER", "VIEW", NULL};
COMPLETE_WITH_LIST(list_ALTER);
}
--- 705,713 ----
pg_strcasecmp(prev3_wd, "TABLE") != 0)
{
static const char *const list_ALTER[] =
! {"AGGREGATE", "CONVERSION", "DATABASE", "DOMAIN", "FOREIGN DATA WRAPPER", "FUNCTION",
! "GROUP", "INDEX", "LANGUAGE", "OPERATOR", "ROLE", "SCHEMA", "SERVER", "SEQUENCE", "TABLE",
! "TABLESPACE", "TEXT SEARCH", "TRIGGER", "TYPE", "USER", "USER MAPPING", "VIEW", NULL};
COMPLETE_WITH_LIST(list_ALTER);
}
***************
*** 746,751 ****
--- 765,771 ----
/* ALTER USER,ROLE */
else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
+ !(pg_strcasecmp(prev2_wd, "USER") == 0 && pg_strcasecmp(prev_wd, "MAPPING") == 0) &&
(pg_strcasecmp(prev2_wd, "USER") == 0 ||
pg_strcasecmp(prev2_wd, "ROLE") == 0))
{
***************
*** 1357,1362 ****
--- 1377,1383 ----
/* CREATE ROLE,USER,GROUP */
else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
+ !(pg_strcasecmp(prev2_wd, "USER") == 0 && pg_strcasecmp(prev_wd, "MAPPING") == 0) &&
(pg_strcasecmp(prev2_wd, "ROLE") == 0 ||
pg_strcasecmp(prev2_wd, "GROUP") == 0 || pg_strcasecmp(prev2_wd, "USER") == 0))
{
***************
*** 1640,1645 ****
--- 1661,1668 ----
pg_strcasecmp(prev_wd, "ON") == 0)
COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tsv,
" UNION SELECT 'DATABASE'"
+ " UNION SELECT 'FOREIGN DATA WRAPPER'"
+ " UNION SELECT 'FOREIGN SERVER'"
" UNION SELECT 'FUNCTION'"
" UNION SELECT 'LANGUAGE'"
" UNION SELECT 'SCHEMA'"
***************
*** 2075,2080 ****
--- 2098,2168 ----
pg_strcasecmp(prev3_wd, "\\copy") != 0)
COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tsv, NULL);
+ /* FOREIGN DATA WRAPPER */
+ else if (pg_strcasecmp(prev5_wd, "ALTER") == 0 &&
+ pg_strcasecmp(prev4_wd, "FOREIGN") == 0 &&
+ pg_strcasecmp(prev3_wd, "DATA") == 0 &&
+ pg_strcasecmp(prev2_wd, "WRAPPER") == 0)
+ {
+ static const char *const list_ALTER_FDW[] =
+ {"LIBRARY", "OWNER TO", NULL};
+
+ COMPLETE_WITH_LIST(list_ALTER_FDW);
+ }
+ else if (pg_strcasecmp(prev5_wd, "CREATE") == 0 &&
+ pg_strcasecmp(prev4_wd, "FOREIGN") == 0 &&
+ pg_strcasecmp(prev3_wd, "DATA") == 0 &&
+ pg_strcasecmp(prev2_wd, "WRAPPER") == 0)
+ COMPLETE_WITH_CONST("LIBRARY");
+ else if (pg_strcasecmp(prev5_wd, "DROP") == 0 &&
+ pg_strcasecmp(prev4_wd, "FOREIGN") == 0 &&
+ pg_strcasecmp(prev3_wd, "DATA") == 0 &&
+ pg_strcasecmp(prev2_wd, "WRAPPER") == 0)
+ COMPLETE_WITH_QUERY(Query_for_list_of_fdws);
+
+ /* SERVER */
+ else if (pg_strcasecmp(prev3_wd, "CREATE") == 0 &&
+ pg_strcasecmp(prev2_wd, "SERVER") == 0)
+ {
+ static const char *const list_CREATE_SERVER[] =
+ {"TYPE", "VERSION", "FOREIGN DATA WRAPPER", NULL};
+
+ COMPLETE_WITH_LIST(list_CREATE_SERVER);
+ }
+ else if (pg_strcasecmp(prev3_wd, "ALTER") == 0 &&
+ pg_strcasecmp(prev2_wd, "SERVER") == 0)
+ {
+ static const char *const list_ALTER_SERVER[] =
+ {"VERSION", "OPTIONS", NULL};
+
+ COMPLETE_WITH_LIST(list_ALTER_SERVER);
+ }
+
+ /* USER MAPPING */
+ else if ((pg_strcasecmp(prev3_wd, "ALTER") == 0 ||
+ pg_strcasecmp(prev3_wd, "CREATE") == 0 ||
+ pg_strcasecmp(prev3_wd, "DROP") == 0) &&
+ pg_strcasecmp(prev2_wd, "USER") == 0 &&
+ pg_strcasecmp(prev_wd, "MAPPING") == 0)
+ COMPLETE_WITH_CONST("FOR");
+ else if (pg_strcasecmp(prev4_wd, "CREATE") == 0 &&
+ pg_strcasecmp(prev3_wd, "USER") == 0 &&
+ pg_strcasecmp(prev2_wd, "MAPPING") == 0 &&
+ pg_strcasecmp(prev_wd, "FOR") == 0)
+ COMPLETE_WITH_QUERY(Query_for_list_of_roles);
+ else if ((pg_strcasecmp(prev4_wd, "ALTER") == 0 ||
+ pg_strcasecmp(prev4_wd, "DROP") == 0) &&
+ pg_strcasecmp(prev3_wd, "USER") == 0 &&
+ pg_strcasecmp(prev2_wd, "MAPPING") == 0 &&
+ pg_strcasecmp(prev_wd, "FOR") == 0)
+ COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings);
+ else if ((pg_strcasecmp(prev5_wd, "CREATE") == 0 ||
+ pg_strcasecmp(prev5_wd, "ALTER") == 0 ||
+ pg_strcasecmp(prev5_wd, "DROP") == 0) &&
+ pg_strcasecmp(prev4_wd, "USER") == 0 &&
+ pg_strcasecmp(prev3_wd, "MAPPING") == 0 &&
+ pg_strcasecmp(prev2_wd, "FOR") == 0)
+ COMPLETE_WITH_CONST("SERVER");
/* Backslash commands */
/* TODO: \dc \dd \dl */
***************
*** 2088,2093 ****
--- 2176,2187 ----
COMPLETE_WITH_QUERY(Query_for_list_of_tablespaces);
else if (strcmp(prev_wd, "\\dD") == 0)
COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_domains, NULL);
+ else if (strcmp(prev_wd, "\\des") == 0 || strcmp(prev_wd, "\\des+") == 0)
+ COMPLETE_WITH_QUERY(Query_for_list_of_servers);
+ else if (strcmp(prev_wd, "\\deu") == 0 || strcmp(prev_wd, "\\deu+") == 0)
+ COMPLETE_WITH_QUERY(Query_for_list_of_user_mappings);
+ else if (strcmp(prev_wd, "\\dew") == 0 || strcmp(prev_wd, "\\dew+") == 0)
+ COMPLETE_WITH_QUERY(Query_for_list_of_fdws);
else if (strcmp(prev_wd, "\\df") == 0 || strcmp(prev_wd, "\\df+") == 0)
COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_functions, NULL);
else if (strcmp(prev_wd, "\\dF") == 0 || strcmp(prev_wd, "\\dF+") == 0)
diff -cNr -x CVS cvs-pgsql/src/include/catalog/catversion.h pgsql/src/include/catalog/catversion.h
*** cvs-pgsql/src/include/catalog/catversion.h Fri Dec 5 15:06:29 2008
--- pgsql/src/include/catalog/catversion.h Mon Dec 15 11:09:21 2008
***************
*** 4,10 ****
* "Catalog version number" for PostgreSQL.
*
* The catalog version number is used to flag incompatible changes in
! * the PostgreSQL system catalogs. Whenever anyone changes the format of
* a system catalog relation, or adds, deletes, or modifies standard
* catalog entries in such a way that an updated backend wouldn't work
* with an old database (or vice versa), the catalog version number
--- 4,10 ----
* "Catalog version number" for PostgreSQL.
*
* The catalog version number is used to flag incompatible changes in
! * the PostgreSQL system catalogs. Whenever anyone changes the format of
* a system catalog relation, or adds, deletes, or modifies standard
* catalog entries in such a way that an updated backend wouldn't work
* with an old database (or vice versa), the catalog version number
***************
*** 53,58 ****
*/
/* yyyymmddN */
! #define CATALOG_VERSION_NO 200812041
#endif
--- 53,58 ----
*/
/* yyyymmddN */
! #define CATALOG_VERSION_NO 200812151
#endif
diff -cNr -x CVS cvs-pgsql/src/include/catalog/dependency.h pgsql/src/include/catalog/dependency.h
*** cvs-pgsql/src/include/catalog/dependency.h Mon Jun 9 01:41:04 2008
--- pgsql/src/include/catalog/dependency.h Fri Dec 12 10:44:16 2008
***************
*** 143,148 ****
--- 143,151 ----
OCLASS_ROLE, /* pg_authid */
OCLASS_DATABASE, /* pg_database */
OCLASS_TBLSPACE, /* pg_tablespace */
+ OCLASS_FDW, /* pg_foreign_data_wrapper */
+ OCLASS_FOREIGN_SERVER, /* pg_foreign_server */
+ OCLASS_USER_MAPPING, /* pg_user_mapping */
MAX_OCLASS /* MUST BE LAST */
} ObjectClass;
diff -cNr -x CVS cvs-pgsql/src/include/catalog/indexing.h pgsql/src/include/catalog/indexing.h
*** cvs-pgsql/src/include/catalog/indexing.h Thu Jun 19 03:46:06 2008
--- pgsql/src/include/catalog/indexing.h Fri Dec 12 10:44:16 2008
***************
*** 252,257 ****
--- 252,275 ----
DECLARE_UNIQUE_INDEX(pg_type_typname_nsp_index, 2704, on pg_type using btree(typname name_ops, typnamespace oid_ops));
#define TypeNameNspIndexId 2704
+ DECLARE_UNIQUE_INDEX(pg_foreign_data_wrapper_oid_index, 112, on pg_foreign_data_wrapper using btree(oid oid_ops));
+ #define ForeignDataWrapperOidIndexId 112
+
+ DECLARE_UNIQUE_INDEX(pg_foreign_data_wrapper_name_index, 548, on pg_foreign_data_wrapper using btree(fdwname name_ops));
+ #define ForeignDataWrapperNameIndexId 548
+
+ DECLARE_UNIQUE_INDEX(pg_foreign_server_oid_index, 113, on pg_foreign_server using btree(oid oid_ops));
+ #define ForeignServerOidIndexId 113
+
+ DECLARE_UNIQUE_INDEX(pg_foreign_server_name_index, 549, on pg_foreign_server using btree(srvname name_ops));
+ #define ForeignServerNameIndexId 549
+
+ DECLARE_UNIQUE_INDEX(pg_user_mapping_oid_index, 174, on pg_user_mapping using btree(oid oid_ops));
+ #define UserMappingOidIndexId 174
+
+ DECLARE_UNIQUE_INDEX(pg_user_mapping_user_server_index, 175, on pg_user_mapping using btree(umuser oid_ops, umserver oid_ops));
+ #define UserMappingUserServerIndexId 175
+
/* last step of initialization script: build the indexes declared above */
BUILD_INDICES
diff -cNr -x CVS cvs-pgsql/src/include/catalog/pg_foreign_data_wrapper.h pgsql/src/include/catalog/pg_foreign_data_wrapper.h
*** cvs-pgsql/src/include/catalog/pg_foreign_data_wrapper.h Thu Jan 1 02:00:00 1970
--- pgsql/src/include/catalog/pg_foreign_data_wrapper.h Mon Dec 15 13:36:49 2008
***************
*** 0 ****
--- 1,72 ----
+ /*-------------------------------------------------------------------------
+ *
+ * pg_foreign_data_wrapper.h
+ * definition of the system "foreign-data wrapper" relation (pg_foreign_data_wrapper)
+ * along with the relation's initial contents.
+ *
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $PostgreSQL$
+ *
+ * NOTES
+ * the genbki.sh script reads this file and generates .bki
+ * information from the DATA() statements.
+ *
+ *-------------------------------------------------------------------------
+ */
+ #ifndef PG_FOREIGN_DATA_WRAPPER_H
+ #define PG_FOREIGN_DATA_WRAPPER_H
+
+ #include "catalog/genbki.h"
+
+ /* ----------------
+ * pg_foreign_data_wrapper definition. cpp turns this into
+ * typedef struct FormData_pg_foreign_data_wrapper
+ * ----------------
+ */
+ #define ForeignDataWrapperRelationId 2328
+
+ CATALOG(pg_foreign_data_wrapper,2328)
+ {
+ NameData fdwname; /* foreign-data wrapper name */
+ Oid fdwowner; /* FDW owner */
+
+ /* VARIABLE LENGTH FIELDS start here. */
+
+ text fdwlibrary; /* FDW shared library location */
+ aclitem fdwacl[1]; /* access permissions */
+ text fdwoptions[1]; /* FDW options */
+ } FormData_pg_foreign_data_wrapper;
+
+ /* ----------------
+ * Form_pg_fdw corresponds to a pointer to a tuple with
+ * the format of pg_fdw relation.
+ * ----------------
+ */
+ typedef FormData_pg_foreign_data_wrapper *Form_pg_foreign_data_wrapper;
+
+ /* ----------------
+ * compiler constants for pg_fdw
+ * ----------------
+ */
+
+ #define Natts_pg_foreign_data_wrapper 5
+ #define Anum_pg_foreign_data_wrapper_fdwname 1
+ #define Anum_pg_foreign_data_wrapper_fdwowner 2
+ #define Anum_pg_foreign_data_wrapper_fdwlibrary 3
+ #define Anum_pg_foreign_data_wrapper_fdwacl 4
+ #define Anum_pg_foreign_data_wrapper_fdwoptions 5
+
+ /* ----------------
+ * initial contents of pg_fdw
+ * ----------------
+ */
+
+ DATA(insert OID = 626 ( dummy PGUID dummy_fdw _null_ _null_ ));
+ DESCR("dummy pass-through foreign-data wrapper");
+ DATA(insert OID = 627 ( postgresql PGUID postgresql_fdw _null_ _null_ ));
+ DESCR("PostgreSQL foreign-data wrapper");
+
+ #endif /* PG_FOREIGN_DATA_WRAPPER_H */
diff -cNr -x CVS cvs-pgsql/src/include/catalog/pg_foreign_server.h pgsql/src/include/catalog/pg_foreign_server.h
*** cvs-pgsql/src/include/catalog/pg_foreign_server.h Thu Jan 1 02:00:00 1970
--- pgsql/src/include/catalog/pg_foreign_server.h Fri Dec 12 10:44:16 2008
***************
*** 0 ****
--- 1,65 ----
+ /*-------------------------------------------------------------------------
+ *
+ * pg_foreign_server.h
+ * definition of the system "foreign server" relation (pg_foreign_server)
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $PostgreSQL$
+ *
+ * NOTES
+ * the genbki.sh script reads this file and generates .bki
+ * information from the DATA() statements.
+ *
+ *-------------------------------------------------------------------------
+ */
+ #ifndef PG_FOREIGN_SERVER_H
+ #define PG_FOREIGN_SERVER_H
+
+ #include "catalog/genbki.h"
+
+ /* ----------------
+ * pg_foreign_server definition. cpp turns this into
+ * typedef struct FormData_pg_foreign_server
+ * ----------------
+ */
+ #define ForeignServerRelationId 1417
+
+ CATALOG(pg_foreign_server,1417)
+ {
+ NameData srvname; /* foreign server name */
+ Oid srvowner; /* server owner */
+ Oid srvfdw; /* server FDW */
+
+ /*
+ * VARIABLE LENGTH FIELDS start here. These fields may be NULL, too.
+ */
+ text srvtype;
+ text srvversion;
+ aclitem srvacl[1]; /* access permissions */
+ text srvoptions[1]; /* FDW-specific options */
+ } FormData_pg_foreign_server;
+
+ /* ----------------
+ * Form_pg_foreign_server corresponds to a pointer to a tuple with
+ * the format of pg_foreign_server relation.
+ * ----------------
+ */
+ typedef FormData_pg_foreign_server *Form_pg_foreign_server;
+
+ /* ----------------
+ * compiler constants for pg_foreign_server
+ * ----------------
+ */
+
+ #define Natts_pg_foreign_server 7
+ #define Anum_pg_foreign_server_srvname 1
+ #define Anum_pg_foreign_server_srvowner 2
+ #define Anum_pg_foreign_server_srvfdw 3
+ #define Anum_pg_foreign_server_srvtype 4
+ #define Anum_pg_foreign_server_srvversion 5
+ #define Anum_pg_foreign_server_srvacl 6
+ #define Anum_pg_foreign_server_srvoptions 7
+
+ #endif /* PG_FOREIGN_SERVER_H */
diff -cNr -x CVS cvs-pgsql/src/include/catalog/pg_proc.h pgsql/src/include/catalog/pg_proc.h
*** cvs-pgsql/src/include/catalog/pg_proc.h Fri Dec 5 15:06:30 2008
--- pgsql/src/include/catalog/pg_proc.h Fri Dec 12 10:44:16 2008
***************
*** 3580,3585 ****
--- 3580,3611 ----
DATA(insert OID = 2395 ( has_tablespace_privilege PGNSP PGUID 12 1 0 0 f f t f s 2 0 16 "26 25" _null_ _null_ _null_ _null_ has_tablespace_privilege_id _null_ _null_ _null_ ));
DESCR("current user privilege on tablespace by tablespace oid");
+ DATA(insert OID = 3000 ( has_foreign_data_wrapper_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "19 25 25" _null_ _null_ _null_ _null_ has_foreign_data_wrapper_privilege_name_name _null_ _null_ _null_ ));
+ DESCR("user privilege on foreign data wrapper by username, foreign data wrapper name");
+ DATA(insert OID = 3001 ( has_foreign_data_wrapper_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "19 26 25" _null_ _null_ _null_ _null_ has_foreign_data_wrapper_privilege_name_id _null_ _null_ _null_ ));
+ DESCR("user privilege on foreign data wrapper by username, foreign data wrapper oid");
+ DATA(insert OID = 3002 ( has_foreign_data_wrapper_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "26 25 25" _null_ _null_ _null_ _null_ has_foreign_data_wrapper_privilege_id_name _null_ _null_ _null_ ));
+ DESCR("user privilege on foreign data wrapper by user oid, foreign data wrapper name");
+ DATA(insert OID = 3003 ( has_foreign_data_wrapper_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "26 26 25" _null_ _null_ _null_ _null_ has_foreign_data_wrapper_privilege_id_id _null_ _null_ _null_ ));
+ DESCR("user privilege on foreign data wrapper by user oid, foreign data wrapper oid");
+ DATA(insert OID = 3004 ( has_foreign_data_wrapper_privilege PGNSP PGUID 12 1 0 0 f f t f s 2 0 16 "25 25" _null_ _null_ _null_ _null_ has_foreign_data_wrapper_privilege_name _null_ _null_ _null_ ));
+ DESCR("current user privilege on foreign data wrapper by foreign data wrapper name");
+ DATA(insert OID = 3005 ( has_foreign_data_wrapper_privilege PGNSP PGUID 12 1 0 0 f f t f s 2 0 16 "26 25" _null_ _null_ _null_ _null_ has_foreign_data_wrapper_privilege_id _null_ _null_ _null_ ));
+ DESCR("current user privilege on foreign data wrapper by foreign data wrapper oid");
+
+ DATA(insert OID = 3006 ( has_server_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "19 25 25" _null_ _null_ _null_ _null_ has_server_privilege_name_name _null_ _null_ _null_ ));
+ DESCR("user privilege on server by username, server name");
+ DATA(insert OID = 3007 ( has_server_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "19 26 25" _null_ _null_ _null_ _null_ has_server_privilege_name_id _null_ _null_ _null_ ));
+ DESCR("user privilege on server by username, server oid");
+ DATA(insert OID = 3008 ( has_server_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "26 25 25" _null_ _null_ _null_ _null_ has_server_privilege_id_name _null_ _null_ _null_ ));
+ DESCR("user privilege on server by user oid, server name");
+ DATA(insert OID = 3009 ( has_server_privilege PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "26 26 25" _null_ _null_ _null_ _null_ has_server_privilege_id_id _null_ _null_ _null_ ));
+ DESCR("user privilege on server by user oid, server oid");
+ DATA(insert OID = 3010 ( has_server_privilege PGNSP PGUID 12 1 0 0 f f t f s 2 0 16 "25 25" _null_ _null_ _null_ _null_ has_server_privilege_name _null_ _null_ _null_ ));
+ DESCR("current user privilege on server by server name");
+ DATA(insert OID = 3011 ( has_server_privilege PGNSP PGUID 12 1 0 0 f f t f s 2 0 16 "26 25" _null_ _null_ _null_ _null_ has_server_privilege_id _null_ _null_ _null_ ));
+ DESCR("current user privilege on server by server oid");
+
DATA(insert OID = 2705 ( pg_has_role PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "19 19 25" _null_ _null_ _null_ _null_ pg_has_role_name_name _null_ _null_ _null_ ));
DESCR("user privilege on role by username, role name");
DATA(insert OID = 2706 ( pg_has_role PGNSP PGUID 12 1 0 0 f f t f s 3 0 16 "19 26 25" _null_ _null_ _null_ _null_ pg_has_role_name_id _null_ _null_ _null_ ));
***************
*** 4602,4607 ****
--- 4628,4644 ----
DATA(insert OID = 2987 ( btrecordcmp PGNSP PGUID 12 1 0 0 f f t f i 2 0 23 "2249 2249" _null_ _null_ _null_ _null_ btrecordcmp _null_ _null_ _null_ ));
DESCR("btree less-equal-greater");
+ /* foreign connections */
+ DATA(insert OID = 2995 ( pg_get_remote_connection_info PGNSP PGUID 12 1 3 0 f f t t s 2 0 2249 "19 19" "{19,19,25,25}" "{i,i,o,o}" "{server,username,option,value}" _null_ pg_get_remote_connection_info _null_ _null_ _null_ ));
+ DESCR("remote connection info");
+ DATA(insert OID = 2996 ( pg_get_remote_connection_info PGNSP PGUID 12 1 3 0 f f t t s 1 0 2249 "19" "{19,25,25}" "{i,o,o}" "{server,option_name,option_value}" _null_ pg_get_remote_connection_info _null_ _null_ _null_ ));
+ DESCR("remote connection info");
+ DATA(insert OID = 2997 ( pg_get_foreign_data_wrapper_options PGNSP PGUID 12 1 3 0 f f t t s 1 0 2249 "26" "{26,25,25}" "{i,o,o}" "{fdwid,option_name,option_value}" _null_ pg_get_foreign_data_wrapper_options _null_ _null_ _null_ ));
+ DESCR("user mapping options");
+ DATA(insert OID = 2998 ( pg_get_foreign_server_options PGNSP PGUID 12 1 3 0 f f t t s 1 0 2249 "26" "{26,25,25}" "{i,o,o}" "{srvid,option_name,option_value}" _null_ pg_get_foreign_server_options _null_ _null_ _null_ ));
+ DESCR("user mapping options");
+ DATA(insert OID = 2999 ( pg_get_user_mapping_options PGNSP PGUID 12 1 3 0 f f t t s 1 0 2249 "26" "{26,25,25}" "{i,o,o}" "{umid,option_name,option_value}" _null_ pg_get_user_mapping_options _null_ _null_ _null_ ));
+ DESCR("user mapping options");
/*
* Symbolic values for provolatile column: these indicate whether the result
diff -cNr -x CVS cvs-pgsql/src/include/catalog/pg_user_mapping.h pgsql/src/include/catalog/pg_user_mapping.h
*** cvs-pgsql/src/include/catalog/pg_user_mapping.h Thu Jan 1 02:00:00 1970
--- pgsql/src/include/catalog/pg_user_mapping.h Fri Dec 12 10:44:16 2008
***************
*** 0 ****
--- 1,58 ----
+ /*-------------------------------------------------------------------------
+ *
+ * pg_user_mapping.h
+ * definition of the system "user mapping" relation (pg_user_mapping)
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $PostgreSQL$
+ *
+ * NOTES
+ * the genbki.sh script reads this file and generates .bki
+ * information from the DATA() statements.
+ *
+ *-------------------------------------------------------------------------
+ */
+ #ifndef PG_USER_MAPPING_H
+ #define PG_USER_MAPPING_H
+
+ #include "catalog/genbki.h"
+
+ /* ----------------
+ * pg_user_mapping definition. cpp turns this into
+ * typedef struct FormData_pg_user_mapping
+ * ----------------
+ */
+ #define UserMappingRelationId 1418
+
+ CATALOG(pg_user_mapping,1418)
+ {
+ Oid umuser; /* Id of the user, InvalidOid if PUBLIC is wanted */
+ Oid umserver; /* server of this mapping */
+
+ /*
+ * VARIABLE LENGTH FIELDS start here. These fields may be NULL, too.
+ */
+
+ text umoptions[1]; /* user mapping options */
+ } FormData_pg_user_mapping;
+
+ /* ----------------
+ * Form_pg_user_mapping corresponds to a pointer to a tuple with
+ * the format of pg_user_mapping relation.
+ * ----------------
+ */
+ typedef FormData_pg_user_mapping *Form_pg_user_mapping;
+
+ /* ----------------
+ * compiler constants for pg_user_mapping
+ * ----------------
+ */
+
+ #define Natts_pg_user_mapping 3
+ #define Anum_pg_user_mapping_umuser 1
+ #define Anum_pg_user_mapping_umserver 2
+ #define Anum_pg_user_mapping_umoptions 3
+
+ #endif /* PG_USER_MAPPING_H */
diff -cNr -x CVS cvs-pgsql/src/include/commands/defrem.h pgsql/src/include/commands/defrem.h
*** cvs-pgsql/src/include/commands/defrem.h Fri Dec 5 15:06:30 2008
--- pgsql/src/include/commands/defrem.h Fri Dec 12 10:44:16 2008
***************
*** 118,123 ****
--- 118,139 ----
extern text *serialize_deflist(List *deflist);
extern List *deserialize_deflist(Datum txt);
+ /* commands/foreigncmds.c */
+ extern void AlterForeignServerOwner(const char *name, Oid newOwnerId);
+ extern void AlterForeignDataWrapperOwner(const char *name, Oid newOwnerId);
+ extern void CreateForeignDataWrapper(CreateFdwStmt *stmt);
+ extern void AlterForeignDataWrapper(AlterFdwStmt *stmt);
+ extern void RemoveForeignDataWrapper(DropFdwStmt *stmt);
+ extern void RemoveForeignDataWrapperById(Oid fdwId);
+ extern void CreateForeignServer(CreateForeignServerStmt *stmt);
+ extern void AlterForeignServer(AlterForeignServerStmt *stmt);
+ extern void RemoveForeignServer(DropForeignServerStmt *stmt);
+ extern void RemoveForeignServerById(Oid srvId);
+ extern void CreateUserMapping(CreateUserMappingStmt *stmt);
+ extern void AlterUserMapping(AlterUserMappingStmt *stmt);
+ extern void RemoveUserMapping(DropUserMappingStmt *stmt);
+ extern void RemoveUserMappingById(Oid umId);
+
/* support routines in commands/define.c */
extern char *case_translate_language_name(const char *input);
diff -cNr -x CVS cvs-pgsql/src/include/foreign/foreign.h pgsql/src/include/foreign/foreign.h
*** cvs-pgsql/src/include/foreign/foreign.h Thu Jan 1 02:00:00 1970
--- pgsql/src/include/foreign/foreign.h Tue Dec 16 16:46:31 2008
***************
*** 0 ****
--- 1,108 ----
+ /*-------------------------------------------------------------------------
+ *
+ * foreign.h
+ * support for foreign-data wrappers, servers and user mappings.
+ *
+ *
+ * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
+ *
+ * $PostgreSQL$
+ *
+ *-------------------------------------------------------------------------
+ */
+ #ifndef FOREIGN_H
+ #define FOREIGN_H
+
+ #include "nodes/parsenodes.h"
+ #include "nodes/pg_list.h"
+
+
+ /* Helper for obtaining username for user mapping */
+ #define MappingUserName(userid) \
+ (OidIsValid(userid) ? GetUserNameFromId(userid) : "public")
+
+
+ /*
+ * Generic option types for validation.
+ * NB! Thes are treated as flags, so use only powers of two here.
+ */
+ typedef enum {
+ InvalidOpt = 0,
+ ServerOpt = 1, /* options applicable to SERVER */
+ UserMappingOpt = 2, /* options for USER MAPPING */
+ FdwOpt = 4, /* options for FOREIGN DATA WRAPPER */
+ } GenericOptionFlags;
+
+ typedef struct ForeignDataWrapperLibrary ForeignDataWrapperLibrary;
+
+ typedef struct ForeignDataWrapper
+ {
+ Oid fdwid; /* FDW Oid */
+ Oid owner; /* FDW owner user Oid */
+ char *fdwname; /* Name of the FDW */
+ char *fdwlibrary; /* Library name */
+ List *options; /* fdwoptions as DefElem list */
+
+ ForeignDataWrapperLibrary *lib; /* interface to the FDW functions */
+ } ForeignDataWrapper;
+
+ typedef struct ForeignServer
+ {
+ Oid serverid; /* server Oid */
+ Oid fdwid; /* foreign-data wrapper */
+ Oid owner; /* server owner user Oid */
+ char *servername; /* name of the server */
+ char *servertype; /* server type, optional */
+ char *serverversion; /* server version, optional */
+ List *options; /* srvoptions as DefElem list */
+ } ForeignServer;
+
+ typedef struct UserMapping
+ {
+ Oid userid; /* local user Oid */
+ Oid serverid; /* server Oid */
+ List *options; /* useoptions as DefElem list */
+ } UserMapping;
+
+
+ /*
+ * Foreign-data wrapper library function types.
+ */
+ typedef void (*OptionListValidatorFunc)(ForeignDataWrapper *,
+ GenericOptionFlags,
+ List *);
+ typedef List * (*GetConnectionInfoFunc)(ForeignDataWrapper *,
+ ForeignServer *,
+ UserMapping *);
+
+ /*
+ * Interface functions to the foreign-data wrapper. This is decoupled
+ * from the FDW as there maybe several FDW-s accessing the same library.
+ */
+ struct ForeignDataWrapperLibrary
+ {
+ char *libname; /* name of the library file */
+
+ GetConnectionInfoFunc GetConnectionInfo;
+ OptionListValidatorFunc validateOptionList;
+ };
+
+
+ extern ForeignServer *GetForeignServer(Oid serverid);
+ extern ForeignServer *GetForeignServerByName(const char *name, bool missing_ok);
+ extern Oid GetForeignServerOidByName(const char *name, bool missing_ok);
+ extern UserMapping *GetUserMapping(Oid userid, Oid serverid);
+ extern ForeignDataWrapper *GetForeignDataWrapper(Oid fdwid);
+ extern ForeignDataWrapper *GetForeignDataWrapperByName(const char *name,
+ bool missing_ok);
+ extern Oid GetForeignDataWrapperOidByName(const char *name, bool missing_ok);
+ extern ForeignDataWrapperLibrary *GetForeignDataWrapperLibrary(const char *libname);
+ extern List *GetRemoteConnectionInfo(Oid serverid, Oid userid);
+
+ /* Foreign data wrapper interface functions */
+ extern void validateOptionList(ForeignDataWrapper *fdw,
+ GenericOptionFlags flags, List *options);
+ extern List *GetConnectionInfo(ForeignDataWrapper *fdw, ForeignServer *server,
+ UserMapping *um);
+
+ #endif /* FOREIGN_H */
diff -cNr -x CVS cvs-pgsql/src/include/nodes/makefuncs.h pgsql/src/include/nodes/makefuncs.h
*** cvs-pgsql/src/include/nodes/makefuncs.h Tue Sep 2 15:10:59 2008
--- pgsql/src/include/nodes/makefuncs.h Fri Dec 12 10:44:16 2008
***************
*** 67,70 ****
--- 67,72 ----
extern DefElem *makeDefElem(char *name, Node *arg);
+ extern OptionDefElem *makeOptionDefElem(int op, DefElem *def);
+
#endif /* MAKEFUNC_H */
diff -cNr -x CVS cvs-pgsql/src/include/nodes/nodes.h pgsql/src/include/nodes/nodes.h
*** cvs-pgsql/src/include/nodes/nodes.h Mon Nov 24 09:49:54 2008
--- pgsql/src/include/nodes/nodes.h Fri Dec 12 10:44:16 2008
***************
*** 325,330 ****
--- 325,339 ----
T_CreateEnumStmt,
T_AlterTSDictionaryStmt,
T_AlterTSConfigurationStmt,
+ T_CreateFdwStmt,
+ T_AlterFdwStmt,
+ T_DropFdwStmt,
+ T_CreateForeignServerStmt,
+ T_AlterForeignServerStmt,
+ T_DropForeignServerStmt,
+ T_CreateUserMappingStmt,
+ T_AlterUserMappingStmt,
+ T_DropUserMappingStmt,
/*
* TAGS FOR PARSE TREE NODES (parsenodes.h)
***************
*** 348,353 ****
--- 357,363 ----
T_IndexElem,
T_Constraint,
T_DefElem,
+ T_OptionDefElem,
T_RangeTblEntry,
T_SortGroupClause,
T_FkConstraint,
diff -cNr -x CVS cvs-pgsql/src/include/nodes/parsenodes.h pgsql/src/include/nodes/parsenodes.h
*** cvs-pgsql/src/include/nodes/parsenodes.h Mon Dec 8 09:11:13 2008
--- pgsql/src/include/nodes/parsenodes.h Fri Dec 12 10:44:16 2008
***************
*** 49,54 ****
--- 49,61 ----
SORTBY_NULLS_LAST
} SortByNulls;
+ /* Alter operations for generic options */
+ typedef enum AlterOptionOp
+ {
+ ALTER_OPT_DROP = -1,
+ ALTER_OPT_SET,
+ ALTER_OPT_ADD
+ } AlterOptionOp;
/*
* Grantable rights are encoded so that we can OR them together in a bitmask.
***************
*** 67,73 ****
#define ACL_REFERENCES (1<<5)
#define ACL_TRIGGER (1<<6)
#define ACL_EXECUTE (1<<7) /* for functions */
! #define ACL_USAGE (1<<8) /* for languages and namespaces */
#define ACL_CREATE (1<<9) /* for namespaces and databases */
#define ACL_CREATE_TEMP (1<<10) /* for databases */
#define ACL_CONNECT (1<<11) /* for databases */
--- 74,80 ----
#define ACL_REFERENCES (1<<5)
#define ACL_TRIGGER (1<<6)
#define ACL_EXECUTE (1<<7) /* for functions */
! #define ACL_USAGE (1<<8) /* for languages, namespaces, FDWs, and servers */
#define ACL_CREATE (1<<9) /* for namespaces and databases */
#define ACL_CREATE_TEMP (1<<10) /* for databases */
#define ACL_CONNECT (1<<11) /* for databases */
***************
*** 467,472 ****
--- 474,490 ----
} DefElem;
/*
+ * Option definition. Used in options definition lists, with optional alter
+ * operation.
+ */
+ typedef struct OptionDefElem
+ {
+ NodeTag type;
+ AlterOptionOp alter_op; /* Alter operation: ADD/SET/DROP */
+ DefElem *def; /* The actual definition */
+ } OptionDefElem;
+
+ /*
* LockingClause - raw representation of FOR UPDATE/SHARE options
*
* Note: lockedRels == NIL means "all relations in query". Otherwise it
***************
*** 930,935 ****
--- 948,955 ----
OBJECT_CONVERSION,
OBJECT_DATABASE,
OBJECT_DOMAIN,
+ OBJECT_FDW,
+ OBJECT_FOREIGN_SERVER,
OBJECT_FUNCTION,
OBJECT_INDEX,
OBJECT_LANGUAGE,
***************
*** 1076,1081 ****
--- 1096,1103 ----
ACL_OBJECT_RELATION, /* table, view */
ACL_OBJECT_SEQUENCE, /* sequence */
ACL_OBJECT_DATABASE, /* database */
+ ACL_OBJECT_FDW, /* foreign-data wrapper */
+ ACL_OBJECT_FOREIGN_SERVER, /* foreign server */
ACL_OBJECT_FUNCTION, /* function */
ACL_OBJECT_LANGUAGE, /* procedural language */
ACL_OBJECT_NAMESPACE, /* namespace */
***************
*** 1329,1334 ****
--- 1351,1446 ----
} DropTableSpaceStmt;
/* ----------------------
+ * Create/Drop FOREIGN DATA WRAPPER Statements
+ * ----------------------
+ */
+
+ typedef struct CreateFdwStmt
+ {
+ NodeTag type;
+ char *fdwname; /* foreign-data wrapper name */
+ char *library; /* libray name */
+ List *options; /* generic options to FDW */
+ } CreateFdwStmt;
+
+ typedef struct AlterFdwStmt
+ {
+ NodeTag type;
+ char *fdwname; /* foreign-data wrapper name */
+ char *library; /* libray name */
+ List *options; /* generic options to FDW */
+ } AlterFdwStmt;
+
+ typedef struct DropFdwStmt
+ {
+ NodeTag type;
+ char *fdwname; /* foreign-data wrapper name */
+ bool missing_ok; /* don't complain if missing */
+ DropBehavior behavior; /* drop behavior - cascade/restrict */
+ } DropFdwStmt;
+
+ /* ----------------------
+ * Create/Drop FOREIGN SERVER Statements
+ * ----------------------
+ */
+
+ typedef struct CreateForeignServerStmt
+ {
+ NodeTag type;
+ char *servername; /* server name */
+ char *servertype; /* optional server type */
+ char *version; /* optional server version */
+ char *fdwname; /* FDW name */
+ List *options; /* generic options to server */
+ } CreateForeignServerStmt;
+
+ typedef struct AlterForeignServerStmt
+ {
+ NodeTag type;
+ char *servername; /* server name */
+ char *version; /* optional server version */
+ List *options; /* generic options to server */
+ bool has_version; /* version specified */
+ } AlterForeignServerStmt;
+
+ typedef struct DropForeignServerStmt
+ {
+ NodeTag type;
+ char *servername; /* server name */
+ bool missing_ok; /* ignore missing servers */
+ DropBehavior behavior; /* drop behavior - cascade/restrict */
+ } DropForeignServerStmt;
+
+ /* ----------------------
+ * Create/Drop USER MAPPING Statements
+ * ----------------------
+ */
+
+ typedef struct CreateUserMappingStmt
+ {
+ NodeTag type;
+ char *username; /* username or PUBLIC/CURRENT_USER */
+ char *servername; /* server name */
+ List *options; /* generic options to server */
+ } CreateUserMappingStmt;
+
+ typedef struct AlterUserMappingStmt
+ {
+ NodeTag type;
+ char *username; /* username or PUBLIC/CURRENT_USER */
+ char *servername; /* server name */
+ List *options; /* generic options to server */
+ } AlterUserMappingStmt;
+
+ typedef struct DropUserMappingStmt
+ {
+ NodeTag type;
+ char *username; /* username or PUBLIC/CURRENT_USER */
+ char *servername; /* server name */
+ bool missing_ok; /* ignore missing mappings */
+ } DropUserMappingStmt;
+
+ /* ----------------------
* Create/Drop TRIGGER Statements
* ----------------------
*/
diff -cNr -x CVS cvs-pgsql/src/include/utils/acl.h pgsql/src/include/utils/acl.h
*** cvs-pgsql/src/include/utils/acl.h Thu Sep 11 15:30:05 2008
--- pgsql/src/include/utils/acl.h Fri Dec 12 10:44:16 2008
***************
*** 146,151 ****
--- 146,153 ----
#define ACL_ALL_RIGHTS_RELATION (ACL_INSERT|ACL_SELECT|ACL_UPDATE|ACL_DELETE|ACL_TRUNCATE|ACL_REFERENCES|ACL_TRIGGER)
#define ACL_ALL_RIGHTS_SEQUENCE (ACL_USAGE|ACL_SELECT|ACL_UPDATE)
#define ACL_ALL_RIGHTS_DATABASE (ACL_CREATE|ACL_CREATE_TEMP|ACL_CONNECT)
+ #define ACL_ALL_RIGHTS_FDW (ACL_USAGE)
+ #define ACL_ALL_RIGHTS_FOREIGN_SERVER (ACL_USAGE)
#define ACL_ALL_RIGHTS_FUNCTION (ACL_EXECUTE)
#define ACL_ALL_RIGHTS_LANGUAGE (ACL_USAGE)
#define ACL_ALL_RIGHTS_NAMESPACE (ACL_USAGE|ACL_CREATE)
***************
*** 184,189 ****
--- 186,193 ----
ACL_KIND_TABLESPACE, /* pg_tablespace */
ACL_KIND_TSDICTIONARY, /* pg_ts_dict */
ACL_KIND_TSCONFIGURATION, /* pg_ts_config */
+ ACL_KIND_FDW, /* pg_foreign_data_wrapper */
+ ACL_KIND_FOREIGN_SERVER, /* pg_foreign_server */
MAX_ACL_KIND /* MUST BE LAST */
} AclObjectKind;
***************
*** 261,266 ****
--- 265,274 ----
AclMode mask, AclMaskHow how);
extern AclMode pg_tablespace_aclmask(Oid spc_oid, Oid roleid,
AclMode mask, AclMaskHow how);
+ extern AclMode pg_foreign_data_wrapper_aclmask(Oid fdw_oid, Oid roleid,
+ AclMode mask, AclMaskHow how);
+ extern AclMode pg_foreign_server_aclmask(Oid srv_oid, Oid roleid,
+ AclMode mask, AclMaskHow how);
extern AclResult pg_class_aclcheck(Oid table_oid, Oid roleid, AclMode mode);
extern AclResult pg_database_aclcheck(Oid db_oid, Oid roleid, AclMode mode);
***************
*** 268,273 ****
--- 276,283 ----
extern AclResult pg_language_aclcheck(Oid lang_oid, Oid roleid, AclMode mode);
extern AclResult pg_namespace_aclcheck(Oid nsp_oid, Oid roleid, AclMode mode);
extern AclResult pg_tablespace_aclcheck(Oid spc_oid, Oid roleid, AclMode mode);
+ extern AclResult pg_foreign_data_wrapper_aclcheck(Oid fdw_oid, Oid roleid, AclMode mode);
+ extern AclResult pg_foreign_server_aclcheck(Oid srv_oid, Oid roleid, AclMode mode);
extern void aclcheck_error(AclResult aclerr, AclObjectKind objectkind,
const char *objectname);
***************
*** 286,290 ****
--- 296,301 ----
extern bool pg_conversion_ownercheck(Oid conv_oid, Oid roleid);
extern bool pg_ts_dict_ownercheck(Oid dict_oid, Oid roleid);
extern bool pg_ts_config_ownercheck(Oid cfg_oid, Oid roleid);
+ extern bool pg_foreign_server_ownercheck(Oid srv_oid, Oid roleid);
#endif /* ACL_H */
diff -cNr -x CVS cvs-pgsql/src/include/utils/builtins.h pgsql/src/include/utils/builtins.h
*** cvs-pgsql/src/include/utils/builtins.h Fri Dec 5 15:06:31 2008
--- pgsql/src/include/utils/builtins.h Fri Dec 12 11:22:54 2008
***************
*** 34,39 ****
--- 34,45 ----
extern Datum has_database_privilege_id_id(PG_FUNCTION_ARGS);
extern Datum has_database_privilege_name(PG_FUNCTION_ARGS);
extern Datum has_database_privilege_id(PG_FUNCTION_ARGS);
+ extern Datum has_foreign_data_wrapper_privilege_name_name(PG_FUNCTION_ARGS);
+ extern Datum has_foreign_data_wrapper_privilege_name_id(PG_FUNCTION_ARGS);
+ extern Datum has_foreign_data_wrapper_privilege_id_name(PG_FUNCTION_ARGS);
+ extern Datum has_foreign_data_wrapper_privilege_id_id(PG_FUNCTION_ARGS);
+ extern Datum has_foreign_data_wrapper_privilege_name(PG_FUNCTION_ARGS);
+ extern Datum has_foreign_data_wrapper_privilege_id(PG_FUNCTION_ARGS);
extern Datum has_function_privilege_name_name(PG_FUNCTION_ARGS);
extern Datum has_function_privilege_name_id(PG_FUNCTION_ARGS);
extern Datum has_function_privilege_id_name(PG_FUNCTION_ARGS);
***************
*** 52,57 ****
--- 58,69 ----
extern Datum has_schema_privilege_id_id(PG_FUNCTION_ARGS);
extern Datum has_schema_privilege_name(PG_FUNCTION_ARGS);
extern Datum has_schema_privilege_id(PG_FUNCTION_ARGS);
+ extern Datum has_server_privilege_name_name(PG_FUNCTION_ARGS);
+ extern Datum has_server_privilege_name_id(PG_FUNCTION_ARGS);
+ extern Datum has_server_privilege_id_name(PG_FUNCTION_ARGS);
+ extern Datum has_server_privilege_id_id(PG_FUNCTION_ARGS);
+ extern Datum has_server_privilege_name(PG_FUNCTION_ARGS);
+ extern Datum has_server_privilege_id(PG_FUNCTION_ARGS);
extern Datum has_tablespace_privilege_name_name(PG_FUNCTION_ARGS);
extern Datum has_tablespace_privilege_name_id(PG_FUNCTION_ARGS);
extern Datum has_tablespace_privilege_id_name(PG_FUNCTION_ARGS);
diff -cNr -x CVS cvs-pgsql/src/include/utils/syscache.h pgsql/src/include/utils/syscache.h
*** cvs-pgsql/src/include/utils/syscache.h Wed May 7 04:04:49 2008
--- pgsql/src/include/utils/syscache.h Fri Dec 12 10:44:16 2008
***************
*** 51,56 ****
--- 51,60 ----
DATABASEOID,
ENUMOID,
ENUMTYPOIDNAME,
+ FOREIGNDATAWRAPPERNAME,
+ FOREIGNDATAWRAPPEROID,
+ FOREIGNSERVERNAME,
+ FOREIGNSERVEROID,
INDEXRELID,
LANGNAME,
LANGOID,
***************
*** 76,82 ****
TSTEMPLATENAMENSP,
TSTEMPLATEOID,
TYPENAMENSP,
! TYPEOID
};
extern void InitCatalogCache(void);
--- 80,88 ----
TSTEMPLATENAMENSP,
TSTEMPLATEOID,
TYPENAMENSP,
! TYPEOID,
! USERMAPPINGOID,
! USERMAPPINGUSERSERVER
};
extern void InitCatalogCache(void);
diff -cNr -x CVS cvs-pgsql/src/test/regress/expected/foreign_data.out pgsql/src/test/regress/expected/foreign_data.out
*** cvs-pgsql/src/test/regress/expected/foreign_data.out Thu Jan 1 02:00:00 1970
--- pgsql/src/test/regress/expected/foreign_data.out Tue Dec 16 16:32:49 2008
***************
*** 0 ****
--- 1,1063 ----
+ --
+ -- Test foreign-data wrapper and server management.
+ --
+ CREATE USER foreign_data_user SUPERUSER;
+ \c - foreign_data_user
+ -- At this point we should have 2 built-in wrappers and no servers.
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ postgresql | postgresql_fdw |
+ (2 rows)
+
+ SELECT srvname, srvoptions FROM pg_foreign_server;
+ srvname | srvoptions
+ ---------+------------
+ (0 rows)
+
+ SELECT * FROM pg_user_mapping;
+ umuser | umserver | umoptions
+ --------+----------+-----------
+ (0 rows)
+
+ -- CREATE FOREIGN DATA WRAPPER
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY '' LANGUAGE C; -- ERROR
+ ERROR: could not access file "": No such file or directory
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'plpgsql' LANGUAGE C;
+ DROP FOREIGN DATA WRAPPER foo;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw |
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C; -- duplicate
+ ERROR: foreign-data wrapper "foo" already exists
+ CREATE FOREIGN DATA WRAPPER "Foo" LIBRARY 'dummy_fdw' LANGUAGE C;
+ DROP FOREIGN DATA WRAPPER "Foo";
+ DROP FOREIGN DATA WRAPPER foo;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C OPTIONS (testing '1');
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+-------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw | {testing=1}
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ DROP FOREIGN DATA WRAPPER foo;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C OPTIONS (testing '1', testing '2'); -- ERROR
+ ERROR: option "testing" provided more than once
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C OPTIONS (testing '1', another '2');
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+-----------------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw | {testing=1,another=2}
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ CREATE ROLE fdw_test_role;
+ CREATE ROLE fdw_test_role_super SUPERUSER;
+ DROP FOREIGN DATA WRAPPER foo;
+ SET ROLE fdw_test_role;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C; -- ERROR
+ ERROR: permission denied to create foreign-data wrapper "foo"
+ HINT: Must be superuser to create a foreign-data wrapper.
+ RESET ROLE;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'postgresql_fdw' LANGUAGE C;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ foo | postgresql_fdw |
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ -- ALTER FOREIGN DATA WRAPPER
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY ''; -- ERROR
+ ERROR: could not access file "": No such file or directory
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY 'plpgsql';
+ WARNING: changing the foreign-data wrapper library can cause the options for dependent objects to become invalid
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw';
+ WARNING: changing the foreign-data wrapper library can cause the options for dependent objects to become invalid
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw |
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (a '1', b '2');
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (SET c '4'); -- ERROR
+ ERROR: option "c" not found
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (DROP c); -- ERROR
+ ERROR: option "c" not found
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (ADD x '1', DROP x);
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw | {a=1,b=2}
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (DROP a, SET b '3', ADD c '4');
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw | {b=3,c=4}
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (a '2');
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (b '4'); -- ERROR
+ ERROR: option "b" provided more than once
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+---------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw | {b=3,c=4,a=2}
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ SET ROLE fdw_test_role;
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (ADD d '5'); -- ERROR
+ ERROR: permission denied to alter foreign-data wrapper "foo"
+ HINT: Must be superuser to alter a foreign-data wrapper.
+ SET ROLE fdw_test_role_super;
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (ADD d '5');
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+-------------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw | {b=3,c=4,a=2,d=5}
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ ALTER FOREIGN DATA WRAPPER foo OWNER to fdw_test_role; -- ERROR
+ ERROR: permission denied to change owner of foreign-data wrapper "foo"
+ HINT: The owner of a foreign-data wrapper must be a superuser.
+ ALTER FOREIGN DATA WRAPPER foo OWNER to fdw_test_role_super;
+ ALTER ROLE fdw_test_role_super NOSUPERUSER;
+ SET ROLE fdw_test_role_super;
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (ADD e '6'); -- ERROR
+ ERROR: permission denied to alter foreign-data wrapper "foo"
+ HINT: Must be superuser to alter a foreign-data wrapper.
+ RESET ROLE;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+-------------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw | {b=3,c=4,a=2,d=5}
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ -- DROP FOREIGN DATA WRAPPER
+ DROP FOREIGN DATA WRAPPER nonexistent; -- ERROR
+ ERROR: foreign-data wrapper "nonexistent" does not exist
+ DROP FOREIGN DATA WRAPPER IF EXISTS nonexistent;
+ NOTICE: foreign-data wrapper "nonexistent" does not exist, skipping
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+-------------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw | {b=3,c=4,a=2,d=5}
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ DROP ROLE fdw_test_role_super; -- ERROR
+ ERROR: role "fdw_test_role_super" cannot be dropped because some objects depend on it
+ DETAIL: owner of foreign-data wrapper foo
+ SET ROLE fdw_test_role_super;
+ DROP FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: permission denied to drop foreign-data wrapper "foo"
+ HINT: Must be superuser to drop a foreign-data wrapper.
+ RESET ROLE;
+ DROP FOREIGN DATA WRAPPER foo;
+ DROP ROLE fdw_test_role_super;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ postgresql | postgresql_fdw |
+ (2 rows)
+
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C;
+ CREATE SERVER s1 FOREIGN DATA WRAPPER foo;
+ CREATE USER MAPPING FOR current_user SERVER s1;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ foo | dummy_fdw |
+ postgresql | postgresql_fdw |
+ (3 rows)
+
+ \des+
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper | Access privileges | Type | Version | Options
+ ------+-------------------+----------------------+-------------------+------+---------+---------
+ s1 | foreign_data_user | foo | | | |
+ (1 row)
+
+ \deu+
+ List of user mappings
+ Server | Username | Options
+ --------+-------------------+---------
+ s1 | foreign_data_user |
+ (1 row)
+
+ DROP FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: cannot drop foreign-data wrapper foo because other objects depend on it
+ DETAIL: server s1 depends on foreign-data wrapper foo
+ user mapping for foreign_data_user depends on server s1
+ HINT: Use DROP ... CASCADE to drop the dependent objects too.
+ SET ROLE fdw_test_role;
+ DROP FOREIGN DATA WRAPPER foo CASCADE; -- ERROR
+ ERROR: permission denied to drop foreign-data wrapper "foo"
+ HINT: Must be superuser to drop a foreign-data wrapper.
+ RESET ROLE;
+ DROP FOREIGN DATA WRAPPER foo CASCADE;
+ NOTICE: drop cascades to 2 other objects
+ DETAIL: drop cascades to server s1
+ drop cascades to user mapping for foreign_data_user
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ postgresql | postgresql_fdw |
+ (2 rows)
+
+ \des+
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper | Access privileges | Type | Version | Options
+ ------+-------+----------------------+-------------------+------+---------+---------
+ (0 rows)
+
+ \deu+
+ List of user mappings
+ Server | Username | Options
+ --------+----------+---------
+ (0 rows)
+
+ -- exercise CREATE SERVER
+ CREATE SERVER s1 FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: foreign-data wrapper "foo" does not exist
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C OPTIONS (test_wrapper 'true');
+ CREATE SERVER s1 FOREIGN DATA WRAPPER foo;
+ CREATE SERVER s1 FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: server "s1" already exists
+ CREATE SERVER s2 FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
+ CREATE SERVER s3 TYPE 'oracle' FOREIGN DATA WRAPPER foo;
+ CREATE SERVER s4 TYPE 'oracle' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
+ CREATE SERVER s5 VERSION '15.0' FOREIGN DATA WRAPPER foo;
+ CREATE SERVER s6 VERSION '16.0' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
+ CREATE SERVER "S6" FOREIGN DATA WRAPPER foo OPTIONS (mixed_case_names 'true');
+ CREATE SERVER s7 TYPE 'oracle' VERSION '17.0' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
+ CREATE SERVER s8 FOREIGN DATA WRAPPER postgresql OPTIONS (foo '1'); -- ERROR
+ ERROR: invalid option "foo" to server
+ HINT: valid server options are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib
+ CREATE SERVER s8 FOREIGN DATA WRAPPER postgresql OPTIONS (host 'localhost', dbname 's8db');
+ \des+
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper | Access privileges | Type | Version | Options
+ ------+-------------------+----------------------+-------------------+--------+---------+------------------------------
+ S6 | foreign_data_user | foo | | | | {mixed_case_names=true}
+ s1 | foreign_data_user | foo | | | |
+ s2 | foreign_data_user | foo | | | | {host=a,dbname=b}
+ s3 | foreign_data_user | foo | | oracle | |
+ s4 | foreign_data_user | foo | | oracle | | {host=a,dbname=b}
+ s5 | foreign_data_user | foo | | | 15.0 |
+ s6 | foreign_data_user | foo | | | 16.0 | {host=a,dbname=b}
+ s7 | foreign_data_user | foo | | oracle | 17.0 | {host=a,dbname=b}
+ s8 | foreign_data_user | postgresql | | | | {host=localhost,dbname=s8db}
+ (9 rows)
+
+ CREATE ROLE server_test_role;
+ CREATE ROLE server_test_role2;
+ SET ROLE server_test_role;
+ CREATE SERVER st1 FOREIGN DATA WRAPPER foo; -- ERROR: no usage on FDW
+ ERROR: permission denied for foreign-data wrapper foo
+ RESET ROLE;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_role;
+ SET ROLE server_test_role;
+ CREATE SERVER st1 FOREIGN DATA WRAPPER foo;
+ RESET ROLE;
+ \des+
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper | Access privileges | Type | Version | Options
+ ------+-------------------+----------------------+-------------------+--------+---------+------------------------------
+ S6 | foreign_data_user | foo | | | | {mixed_case_names=true}
+ s1 | foreign_data_user | foo | | | |
+ s2 | foreign_data_user | foo | | | | {host=a,dbname=b}
+ s3 | foreign_data_user | foo | | oracle | |
+ s4 | foreign_data_user | foo | | oracle | | {host=a,dbname=b}
+ s5 | foreign_data_user | foo | | | 15.0 |
+ s6 | foreign_data_user | foo | | | 16.0 | {host=a,dbname=b}
+ s7 | foreign_data_user | foo | | oracle | 17.0 | {host=a,dbname=b}
+ s8 | foreign_data_user | postgresql | | | | {host=localhost,dbname=s8db}
+ st1 | server_test_role | foo | | | |
+ (10 rows)
+
+ CREATE ROLE server_test_indirect;
+ REVOKE USAGE ON FOREIGN DATA WRAPPER foo FROM server_test_role;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_indirect;
+ SET ROLE server_test_role;
+ CREATE SERVER st2 FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: permission denied for foreign-data wrapper foo
+ RESET ROLE;
+ GRANT server_test_indirect TO server_test_role;
+ SET ROLE server_test_role;
+ CREATE SERVER st2 FOREIGN DATA WRAPPER foo;
+ \des+
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper | Access privileges | Type | Version | Options
+ ------+-------------------+----------------------+-------------------+--------+---------+------------------------------
+ S6 | foreign_data_user | foo | | | | {mixed_case_names=true}
+ s1 | foreign_data_user | foo | | | |
+ s2 | foreign_data_user | foo | | | | {host=a,dbname=b}
+ s3 | foreign_data_user | foo | | oracle | |
+ s4 | foreign_data_user | foo | | oracle | | {host=a,dbname=b}
+ s5 | foreign_data_user | foo | | | 15.0 |
+ s6 | foreign_data_user | foo | | | 16.0 | {host=a,dbname=b}
+ s7 | foreign_data_user | foo | | oracle | 17.0 | {host=a,dbname=b}
+ s8 | foreign_data_user | postgresql | | | | {host=localhost,dbname=s8db}
+ st1 | server_test_role | foo | | | |
+ st2 | server_test_role | foo | | | |
+ (11 rows)
+
+ RESET ROLE;
+ REVOKE server_test_indirect FROM server_test_role;
+ -- ALTER SERVER
+ ALTER SERVER s0; -- ERROR
+ ERROR: syntax error at or near ";"
+ LINE 1: ALTER SERVER s0;
+ ^
+ ALTER SERVER s0 OPTIONS (a '1'); -- ERROR
+ ERROR: server "s0" does not exist
+ ALTER SERVER s1 VERSION '1.0' OPTIONS (servername 's1');
+ ALTER SERVER s2 VERSION '1.1';
+ ALTER SERVER s3 OPTIONS (tnsname 'orcl', port '1521');
+ GRANT USAGE ON FOREIGN SERVER s1 TO server_test_role;
+ \des+
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper | Access privileges | Type | Version | Options
+ ------+-------------------+----------------------+------------------------------------------------------------------------------+--------+---------+------------------------------
+ S6 | foreign_data_user | foo | | | | {mixed_case_names=true}
+ s1 | foreign_data_user | foo | {foreign_data_user=U/foreign_data_user,server_test_role=U/foreign_data_user} | | 1.0 | {servername=s1}
+ s2 | foreign_data_user | foo | | | 1.1 | {host=a,dbname=b}
+ s3 | foreign_data_user | foo | | oracle | | {tnsname=orcl,port=1521}
+ s4 | foreign_data_user | foo | | oracle | | {host=a,dbname=b}
+ s5 | foreign_data_user | foo | | | 15.0 |
+ s6 | foreign_data_user | foo | | | 16.0 | {host=a,dbname=b}
+ s7 | foreign_data_user | foo | | oracle | 17.0 | {host=a,dbname=b}
+ s8 | foreign_data_user | postgresql | | | | {host=localhost,dbname=s8db}
+ st1 | server_test_role | foo | | | |
+ st2 | server_test_role | foo | | | |
+ (11 rows)
+
+ SET ROLE server_test_role;
+ ALTER SERVER s1 VERSION '1.1'; -- ERROR
+ ERROR: must be owner of foreign server s1
+ ALTER SERVER s1 OWNER TO server_test_role; -- ERROR
+ ERROR: must be owner of foreign server s1
+ RESET ROLE;
+ ALTER SERVER s1 OWNER TO server_test_role;
+ GRANT server_test_role2 TO server_test_role;
+ SET ROLE server_test_role;
+ ALTER SERVER s1 VERSION '1.1';
+ ALTER SERVER s1 OWNER TO server_test_role2; -- ERROR
+ ERROR: permission denied for foreign-data wrapper foo
+ RESET ROLE;
+ ALTER SERVER s8 OPTIONS (foo '1'); -- ERROR option validation
+ ERROR: invalid option "foo" to server
+ HINT: valid server options are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib
+ ALTER SERVER s8 OPTIONS (connect_timeout '30', set dbname 'db1', drop host);
+ SET ROLE server_test_role;
+ ALTER SERVER s1 OWNER TO server_test_indirect; -- ERROR
+ ERROR: must be member of role "server_test_indirect"
+ RESET ROLE;
+ GRANT server_test_indirect TO server_test_role;
+ SET ROLE server_test_role;
+ ALTER SERVER s1 OWNER TO server_test_indirect;
+ RESET ROLE;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_indirect;
+ SET ROLE server_test_role;
+ ALTER SERVER s1 OWNER TO server_test_indirect;
+ RESET ROLE;
+ DROP ROLE server_test_indirect; -- ERROR
+ ERROR: role "server_test_indirect" cannot be dropped because some objects depend on it
+ DETAIL: owner of server s1
+ access to foreign-data wrapper foo
+ \des+
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper | Access privileges | Type | Version | Options
+ ------+----------------------+----------------------+------------------------------------------------------------------------------+--------+---------+---------------------------------
+ S6 | foreign_data_user | foo | | | | {mixed_case_names=true}
+ s1 | server_test_indirect | foo | {foreign_data_user=U/foreign_data_user,server_test_role=U/foreign_data_user} | | 1.1 | {servername=s1}
+ s2 | foreign_data_user | foo | | | 1.1 | {host=a,dbname=b}
+ s3 | foreign_data_user | foo | | oracle | | {tnsname=orcl,port=1521}
+ s4 | foreign_data_user | foo | | oracle | | {host=a,dbname=b}
+ s5 | foreign_data_user | foo | | | 15.0 |
+ s6 | foreign_data_user | foo | | | 16.0 | {host=a,dbname=b}
+ s7 | foreign_data_user | foo | | oracle | 17.0 | {host=a,dbname=b}
+ s8 | foreign_data_user | postgresql | | | | {dbname=db1,connect_timeout=30}
+ st1 | server_test_role | foo | | | |
+ st2 | server_test_role | foo | | | |
+ (11 rows)
+
+ -- DROP SERVER
+ DROP SERVER nonexistent; -- ERROR
+ ERROR: server "nonexistent" does not exist
+ DROP SERVER IF EXISTS nonexistent;
+ NOTICE: server "nonexistent" does not exist, skipping
+ \des
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper
+ ------+----------------------+----------------------
+ S6 | foreign_data_user | foo
+ s1 | server_test_indirect | foo
+ s2 | foreign_data_user | foo
+ s3 | foreign_data_user | foo
+ s4 | foreign_data_user | foo
+ s5 | foreign_data_user | foo
+ s6 | foreign_data_user | foo
+ s7 | foreign_data_user | foo
+ s8 | foreign_data_user | postgresql
+ st1 | server_test_role | foo
+ st2 | server_test_role | foo
+ (11 rows)
+
+ SET ROLE server_test_role;
+ DROP SERVER s2; -- ERROR
+ ERROR: must be owner of foreign server s2
+ DROP SERVER s1;
+ RESET ROLE;
+ \des
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper
+ ------+-------------------+----------------------
+ S6 | foreign_data_user | foo
+ s2 | foreign_data_user | foo
+ s3 | foreign_data_user | foo
+ s4 | foreign_data_user | foo
+ s5 | foreign_data_user | foo
+ s6 | foreign_data_user | foo
+ s7 | foreign_data_user | foo
+ s8 | foreign_data_user | postgresql
+ st1 | server_test_role | foo
+ st2 | server_test_role | foo
+ (10 rows)
+
+ ALTER SERVER s2 OWNER TO server_test_role;
+ SET ROLE server_test_role;
+ DROP SERVER s2;
+ RESET ROLE;
+ \des
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper
+ ------+-------------------+----------------------
+ S6 | foreign_data_user | foo
+ s3 | foreign_data_user | foo
+ s4 | foreign_data_user | foo
+ s5 | foreign_data_user | foo
+ s6 | foreign_data_user | foo
+ s7 | foreign_data_user | foo
+ s8 | foreign_data_user | postgresql
+ st1 | server_test_role | foo
+ st2 | server_test_role | foo
+ (9 rows)
+
+ CREATE USER MAPPING FOR current_user SERVER s3;
+ \deu
+ List of user mappings
+ Server | Username
+ --------+-------------------
+ s3 | foreign_data_user
+ (1 row)
+
+ DROP SERVER s3; -- ERROR
+ ERROR: cannot drop server s3 because other objects depend on it
+ DETAIL: user mapping for foreign_data_user depends on server s3
+ HINT: Use DROP ... CASCADE to drop the dependent objects too.
+ DROP SERVER s3 CASCADE;
+ NOTICE: drop cascades to user mapping for foreign_data_user
+ \des
+ List of foreign servers
+ Name | Owner | Foreign-data wrapper
+ ------+-------------------+----------------------
+ S6 | foreign_data_user | foo
+ s4 | foreign_data_user | foo
+ s5 | foreign_data_user | foo
+ s6 | foreign_data_user | foo
+ s7 | foreign_data_user | foo
+ s8 | foreign_data_user | postgresql
+ st1 | server_test_role | foo
+ st2 | server_test_role | foo
+ (8 rows)
+
+ \deu
+ List of user mappings
+ Server | Username
+ --------+----------
+ (0 rows)
+
+ -- CREATE USER MAPPING
+ CREATE USER MAPPING FOR baz SERVER s1; -- ERROR
+ ERROR: role "baz" does not exist
+ CREATE USER MAPPING FOR current_user SERVER s1; -- ERROR
+ ERROR: server "s1" does not exist
+ CREATE USER MAPPING FOR current_user SERVER s4;
+ CREATE USER MAPPING FOR user SERVER s4; -- ERROR duplicate
+ ERROR: user mapping "foreign_data_user" already exists for server s4
+ CREATE USER MAPPING FOR public SERVER s4 OPTIONS (mapping 'is public');
+ CREATE USER MAPPING FOR user SERVER s8 OPTIONS (username 'test', password 'secret'); -- ERROR
+ ERROR: invalid option "username" to user mapping
+ HINT: valid user mapping options are: user, password
+ CREATE USER MAPPING FOR user SERVER s8 OPTIONS (user 'test', password 'secret');
+ ALTER SERVER s5 OWNER TO server_test_role;
+ ALTER SERVER s6 OWNER TO server_test_indirect;
+ SET ROLE server_test_role;
+ CREATE USER MAPPING FOR current_user SERVER s5;
+ CREATE USER MAPPING FOR current_user SERVER s6 OPTIONS (username 'test');
+ CREATE USER MAPPING FOR current_user SERVER s7; -- ERROR
+ ERROR: must be owner of foreign server s7
+ CREATE USER MAPPING FOR public SERVER s8; -- ERROR
+ ERROR: must be owner of foreign server s8
+ RESET ROLE;
+ CREATE USER MAPPING FOR current_user SERVER "S6" OPTIONS (username 'test_mixed_case');
+ ALTER SERVER st1 OWNER TO server_test_indirect;
+ SET ROLE server_test_role;
+ CREATE USER MAPPING FOR current_user SERVER st1 OPTIONS (username 'bob', password 'boo');
+ CREATE USER MAPPING FOR public SERVER st1;
+ RESET ROLE;
+ \deu
+ List of user mappings
+ Server | Username
+ --------+-------------------
+ S6 | foreign_data_user
+ s4 | foreign_data_user
+ s4 | public
+ s5 | server_test_role
+ s6 | server_test_role
+ s8 | foreign_data_user
+ st1 | public
+ st1 | server_test_role
+ (8 rows)
+
+ -- ALTER USER MAPPING
+ ALTER USER MAPPING FOR bob SERVER s4 OPTIONS (gotcha 'true'); -- ERROR
+ ERROR: role "bob" does not exist
+ ALTER USER MAPPING FOR user SERVER ss4 OPTIONS (gotcha 'true'); -- ERROR
+ ERROR: server "ss4" does not exist
+ ALTER USER MAPPING FOR public SERVER s5 OPTIONS (gotcha 'true'); -- ERROR
+ ERROR: user mapping "public" does not exist for the server
+ ALTER USER MAPPING FOR current_user SERVER s8 OPTIONS (username 'test'); -- ERROR
+ ERROR: invalid option "username" to user mapping
+ HINT: valid user mapping options are: user, password
+ ALTER USER MAPPING FOR current_user SERVER s8 OPTIONS (DROP user, SET password 'public');
+ SET ROLE server_test_role;
+ ALTER USER MAPPING FOR current_user SERVER s5 OPTIONS (ADD modified '1');
+ ALTER USER MAPPING FOR public SERVER s4 OPTIONS (ADD modified '1'); -- ERROR
+ ERROR: must be owner of foreign server s4
+ ALTER USER MAPPING FOR public SERVER st1 OPTIONS (ADD modified '1');
+ RESET ROLE;
+ \deu+
+ List of user mappings
+ Server | Username | Options
+ --------+-------------------+-----------------------------
+ S6 | foreign_data_user | {username=test_mixed_case}
+ s4 | foreign_data_user |
+ s4 | public | {"mapping=is public"}
+ s5 | server_test_role | {modified=1}
+ s6 | server_test_role | {username=test}
+ s8 | foreign_data_user | {password=public}
+ st1 | public | {modified=1}
+ st1 | server_test_role | {username=bob,password=boo}
+ (8 rows)
+
+ -- DROP USER MAPPING
+ DROP USER MAPPING FOR bob SERVER s4; -- ERROR
+ ERROR: role "bob" does not exist
+ DROP USER MAPPING FOR user SERVER ss4;
+ ERROR: server "ss4" does not exist
+ DROP USER MAPPING FOR public SERVER s7; -- ERROR
+ ERROR: user mapping "public" does not exist for the server
+ DROP USER MAPPING IF EXISTS FOR bob SERVER s4;
+ NOTICE: role "bob" does not exist, skipping
+ DROP USER MAPPING IF EXISTS FOR user SERVER ss4;
+ NOTICE: server does not exist, skipping
+ DROP USER MAPPING IF EXISTS FOR public SERVER s7;
+ NOTICE: user mapping "public" does not exist for the server, skipping
+ CREATE USER MAPPING FOR public SERVER s8;
+ SET ROLE server_test_role;
+ DROP USER MAPPING FOR public SERVER s8; -- ERROR
+ ERROR: must be owner of foreign server s8
+ RESET ROLE;
+ DROP SERVER s7;
+ \deu
+ List of user mappings
+ Server | Username
+ --------+-------------------
+ S6 | foreign_data_user
+ s4 | foreign_data_user
+ s4 | public
+ s5 | server_test_role
+ s6 | server_test_role
+ s8 | foreign_data_user
+ s8 | public
+ st1 | public
+ st1 | server_test_role
+ (9 rows)
+
+ -- Information schema
+ -- Avoid including the superuser name in the output, as it will vary across installations.
+ SELECT * FROM information_schema.foreign_data_wrappers WHERE authorization_identifier <> (SELECT rolname FROM pg_authid WHERE oid = 10) ORDER BY 1, 2;
+ foreign_data_wrapper_catalog | foreign_data_wrapper_name | authorization_identifier | library_name | foreign_data_wrapper_language
+ ------------------------------+---------------------------+--------------------------+--------------+-------------------------------
+ regression | foo | foreign_data_user | dummy_fdw | c
+ (1 row)
+
+ SELECT * FROM information_schema.foreign_data_wrapper_options ORDER BY 1, 2, 3;
+ foreign_data_wrapper_catalog | foreign_data_wrapper_name | option_name | option_value
+ ------------------------------+---------------------------+--------------+--------------
+ regression | foo | test_wrapper | true
+ (1 row)
+
+ SELECT * FROM information_schema.foreign_servers ORDER BY 1, 2;
+ foreign_server_catalog | foreign_server_name | foreign_data_wrapper_catalog | foreign_data_wrapper_name | foreign_server_type | foreign_server_version | authorization_identifier
+ ------------------------+---------------------+------------------------------+---------------------------+---------------------+------------------------+--------------------------
+ regression | S6 | regression | foo | | | foreign_data_user
+ regression | s4 | regression | foo | oracle | | foreign_data_user
+ regression | s5 | regression | foo | | 15.0 | server_test_role
+ regression | s6 | regression | foo | | 16.0 | server_test_indirect
+ regression | s8 | regression | postgresql | | | foreign_data_user
+ regression | st1 | regression | foo | | | server_test_indirect
+ regression | st2 | regression | foo | | | server_test_role
+ (7 rows)
+
+ SELECT * FROM information_schema.foreign_server_options ORDER BY 1, 2, 3;
+ foreign_server_catalog | foreign_server_name | option_name | option_value
+ ------------------------+---------------------+------------------+--------------
+ regression | S6 | mixed_case_names | true
+ regression | s4 | dbname | b
+ regression | s4 | host | a
+ regression | s6 | dbname | b
+ regression | s6 | host | a
+ regression | s8 | connect_timeout | 30
+ regression | s8 | dbname | db1
+ (7 rows)
+
+ SELECT * FROM information_schema.user_mappings ORDER BY 1, 2, 3;
+ authorization_identifier | foreign_server_catalog | foreign_server_name
+ --------------------------+------------------------+---------------------
+ foreign_data_user | regression | S6
+ foreign_data_user | regression | s4
+ foreign_data_user | regression | s8
+ public | regression | s4
+ public | regression | s8
+ public | regression | st1
+ server_test_role | regression | s5
+ server_test_role | regression | s6
+ server_test_role | regression | st1
+ (9 rows)
+
+ SELECT * FROM information_schema.user_mapping_options ORDER BY 1, 2, 3, 4;
+ authorization_identifier | foreign_server_catalog | foreign_server_name | option_name | option_value
+ --------------------------+------------------------+---------------------+-------------+-----------------
+ foreign_data_user | regression | S6 | username | test_mixed_case
+ foreign_data_user | regression | s8 | password | public
+ public | regression | s4 | mapping | is public
+ public | regression | st1 | modified | 1
+ server_test_role | regression | s5 | modified | 1
+ server_test_role | regression | s6 | username | test
+ server_test_role | regression | st1 | password | boo
+ server_test_role | regression | st1 | username | bob
+ (8 rows)
+
+ SET ROLE server_test_role;
+ SELECT * FROM information_schema.user_mapping_options ORDER BY 1, 2, 3, 4;
+ authorization_identifier | foreign_server_catalog | foreign_server_name | option_name | option_value
+ --------------------------+------------------------+---------------------+-------------+--------------
+ public | regression | st1 | modified | 1
+ server_test_role | regression | s5 | modified | 1
+ server_test_role | regression | s6 | username | test
+ server_test_role | regression | st1 | password | boo
+ server_test_role | regression | st1 | username | bob
+ (5 rows)
+
+ DROP USER MAPPING FOR current_user SERVER st1;
+ RESET ROLE;
+ -- has_foreign_data_wrapper_privilege
+ SELECT has_foreign_data_wrapper_privilege('fdw_test_role',
+ (SELECT oid FROM pg_foreign_data_wrapper WHERE fdwname='foo'), 'USAGE');
+ has_foreign_data_wrapper_privilege
+ ------------------------------------
+ f
+ (1 row)
+
+ SELECT has_foreign_data_wrapper_privilege('fdw_test_role', 'foo', 'USAGE');
+ has_foreign_data_wrapper_privilege
+ ------------------------------------
+ f
+ (1 row)
+
+ SELECT has_foreign_data_wrapper_privilege(
+ (SELECT oid FROM pg_roles WHERE rolname='fdw_test_role'),
+ (SELECT oid FROM pg_foreign_data_wrapper WHERE fdwname='foo'), 'USAGE');
+ has_foreign_data_wrapper_privilege
+ ------------------------------------
+ f
+ (1 row)
+
+ SELECT has_foreign_data_wrapper_privilege(
+ (SELECT oid FROM pg_foreign_data_wrapper WHERE fdwname='foo'), 'USAGE');
+ has_foreign_data_wrapper_privilege
+ ------------------------------------
+ t
+ (1 row)
+
+ SELECT has_foreign_data_wrapper_privilege(
+ (SELECT oid FROM pg_roles WHERE rolname='fdw_test_role'), 'foo', 'USAGE');
+ has_foreign_data_wrapper_privilege
+ ------------------------------------
+ f
+ (1 row)
+
+ SELECT has_foreign_data_wrapper_privilege('foo', 'USAGE');
+ has_foreign_data_wrapper_privilege
+ ------------------------------------
+ t
+ (1 row)
+
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO fdw_test_role;
+ SELECT has_foreign_data_wrapper_privilege('fdw_test_role', 'foo', 'USAGE');
+ has_foreign_data_wrapper_privilege
+ ------------------------------------
+ t
+ (1 row)
+
+ -- has_server_privilege
+ SELECT has_server_privilege('server_test_role',
+ (SELECT oid FROM pg_foreign_server WHERE srvname='s8'), 'USAGE');
+ has_server_privilege
+ ----------------------
+ f
+ (1 row)
+
+ SELECT has_server_privilege('server_test_role', 's8', 'USAGE');
+ has_server_privilege
+ ----------------------
+ f
+ (1 row)
+
+ SELECT has_server_privilege(
+ (SELECT oid FROM pg_roles WHERE rolname='server_test_role'),
+ (SELECT oid FROM pg_foreign_server WHERE srvname='s8'), 'USAGE');
+ has_server_privilege
+ ----------------------
+ f
+ (1 row)
+
+ SELECT has_server_privilege(
+ (SELECT oid FROM pg_foreign_server WHERE srvname='s8'), 'USAGE');
+ has_server_privilege
+ ----------------------
+ t
+ (1 row)
+
+ SELECT has_server_privilege(
+ (SELECT oid FROM pg_roles WHERE rolname='server_test_role'), 's8', 'USAGE');
+ has_server_privilege
+ ----------------------
+ f
+ (1 row)
+
+ SELECT has_server_privilege('s8', 'USAGE');
+ has_server_privilege
+ ----------------------
+ t
+ (1 row)
+
+ GRANT USAGE ON FOREIGN SERVER s8 TO server_test_role;
+ SELECT has_server_privilege('server_test_role', 's8', 'USAGE');
+ has_server_privilege
+ ----------------------
+ t
+ (1 row)
+
+ REVOKE USAGE ON FOREIGN SERVER s8 FROM server_test_role;
+ -- pg_get_remote_connection_info
+ SELECT * FROM pg_get_remote_connection_info(NULL);
+ option_name | option_value
+ -------------+--------------
+ (0 rows)
+
+ SELECT * FROM pg_get_remote_connection_info(''); -- ERROR
+ ERROR: server "" does not exist
+ SELECT * FROM pg_get_remote_connection_info('foo'); -- ERROR
+ ERROR: server "foo" does not exist
+ SELECT * FROM pg_get_remote_connection_info('foo', 'bob'); -- ERROR
+ ERROR: role "bob" does not exist
+ SELECT * FROM pg_get_remote_connection_info('foo', 'server_test_role'); -- ERROR
+ ERROR: server "foo" does not exist
+ SELECT * FROM pg_get_remote_connection_info('foo.bar'); -- ERROR
+ ERROR: server "foo.bar" does not exist
+ SELECT * FROM pg_get_remote_connection_info('foo', current_user); -- ERROR
+ ERROR: server "foo" does not exist
+ SELECT * FROM pg_get_remote_connection_info('s4');
+ option_name | option_value
+ -------------+--------------
+ host | a
+ dbname | b
+ (2 rows)
+
+ SELECT * FROM pg_get_remote_connection_info('s4', current_user);
+ option | value
+ --------+-------
+ host | a
+ dbname | b
+ (2 rows)
+
+ SELECT * FROM pg_get_remote_connection_info('s4', 'public');
+ option | value
+ ---------+-----------
+ host | a
+ dbname | b
+ mapping | is public
+ (3 rows)
+
+ GRANT USAGE ON FOREIGN SERVER s4 TO server_test_role;
+ SELECT * FROM pg_get_remote_connection_info('s4', 'server_test_role');
+ option | value
+ ---------+-----------
+ host | a
+ dbname | b
+ mapping | is public
+ (3 rows)
+
+ DROP USER MAPPING FOR public SERVER s4;
+ SELECT * FROM pg_get_remote_connection_info('s4', 'server_test_role'); -- ERROR
+ ERROR: user mapping not found for "server_test_role"
+ SELECT * FROM pg_get_remote_connection_info('s6', 'server_test_role');
+ option | value
+ ----------+-------
+ host | a
+ dbname | b
+ username | test
+ (3 rows)
+
+ SELECT * FROM pg_get_remote_connection_info('s6', 'server_test_role');
+ option | value
+ ----------+-------
+ host | a
+ dbname | b
+ username | test
+ (3 rows)
+
+ ALTER SERVER s6 OPTIONS (DROP host, DROP dbname);
+ SELECT * FROM pg_get_remote_connection_info('s6', 'server_test_role');
+ option | value
+ ----------+-------
+ username | test
+ (1 row)
+
+ ALTER USER MAPPING FOR server_test_role SERVER s6 OPTIONS (DROP username);
+ SELECT * FROM pg_get_remote_connection_info('s6', 'server_test_role');
+ option | value
+ --------+-------
+ (0 rows)
+
+ SELECT * FROM pg_get_remote_connection_info('S6');
+ option_name | option_value
+ ------------------+-----------------
+ mixed_case_names | true
+ username | test_mixed_case
+ (2 rows)
+
+ SELECT * FROM pg_get_remote_connection_info('s8');
+ option_name | option_value
+ -------------+-----------------------------------------------
+ datasource | dbname=db1 connect_timeout=30 password=public
+ (1 row)
+
+ SELECT * FROM pg_get_remote_connection_info('s8', 'public');
+ option | value
+ ------------+-------------------------------
+ datasource | dbname=db1 connect_timeout=30
+ (1 row)
+
+ SET ROLE server_test_role;
+ SELECT * FROM pg_get_remote_connection_info('s6'); -- ERROR
+ ERROR: permission denied for function pg_get_remote_connection_info
+ RESET ROLE;
+ GRANT EXECUTE ON FUNCTION pg_get_remote_connection_info(name) TO server_test_role2;
+ SET ROLE server_test_role2;
+ SELECT * FROM pg_get_remote_connection_info('s6'); -- ERROR
+ ERROR: permission denied for foreign server s6
+ RESET ROLE;
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY 'plpgsql';
+ WARNING: changing the foreign-data wrapper library can cause the options for dependent objects to become invalid
+ SELECT * FROM pg_get_remote_connection_info('s4'); -- ERROR
+ ERROR: foreign-data wrapper does not provide connection lookup
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY 'default_fdw';
+ ERROR: could not access file "default_fdw": No such file or directory
+ -- Privileges
+ CREATE ROLE unprivileged_role;
+ SET ROLE unprivileged_role;
+ CREATE FOREIGN DATA WRAPPER foobar LIBRARY 'dummy_fdw' LANGUAGE C; -- ERROR
+ ERROR: permission denied to create foreign-data wrapper "foobar"
+ HINT: Must be superuser to create a foreign-data wrapper.
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (gotcha 'true'); -- ERROR
+ ERROR: permission denied to alter foreign-data wrapper "foo"
+ HINT: Must be superuser to alter a foreign-data wrapper.
+ ALTER FOREIGN DATA WRAPPER foo OWNER TO unprivileged_role; -- ERROR
+ ERROR: permission denied to change owner of foreign-data wrapper "foo"
+ HINT: Must be superuser to change owner of a foreign-data wrapper.
+ DROP FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: permission denied to drop foreign-data wrapper "foo"
+ HINT: Must be superuser to drop a foreign-data wrapper.
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_role; -- ERROR
+ ERROR: permission denied for foreign-data wrapper foo
+ CREATE SERVER s9 FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: permission denied for foreign-data wrapper foo
+ ALTER SERVER s4 VERSION '0.5'; -- ERROR
+ ERROR: must be owner of foreign server s4
+ ALTER SERVER s4 OWNER TO unprivileged_role; -- ERROR
+ ERROR: must be owner of foreign server s4
+ DROP SERVER s4; -- ERROR
+ ERROR: must be owner of foreign server s4
+ GRANT USAGE ON FOREIGN SERVER s4 TO server_test_role; -- ERROR
+ ERROR: permission denied for foreign server s4
+ CREATE USER MAPPING FOR public SERVER s4; -- ERROR
+ ERROR: must be owner of foreign server s4
+ ALTER USER MAPPING FOR server_test_role SERVER s6 OPTIONS (gotcha 'true'); -- ERROR
+ ERROR: must be owner of foreign server s6
+ DROP USER MAPPING FOR server_test_role SERVER s6; -- ERROR
+ ERROR: must be owner of foreign server s6
+ RESET ROLE;
+ GRANT USAGE ON FOREIGN DATA WRAPPER postgresql TO unprivileged_role;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO unprivileged_role WITH GRANT OPTION;
+ SET ROLE unprivileged_role;
+ CREATE FOREIGN DATA WRAPPER foobar LIBRARY 'dummy_fdw' LANGUAGE C; -- ERROR
+ ERROR: permission denied to create foreign-data wrapper "foobar"
+ HINT: Must be superuser to create a foreign-data wrapper.
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (gotcha 'true'); -- ERROR
+ ERROR: permission denied to alter foreign-data wrapper "foo"
+ HINT: Must be superuser to alter a foreign-data wrapper.
+ DROP FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: permission denied to drop foreign-data wrapper "foo"
+ HINT: Must be superuser to drop a foreign-data wrapper.
+ GRANT USAGE ON FOREIGN DATA WRAPPER postgresql TO server_test_role; -- WARNING
+ WARNING: no privileges were granted for "postgresql"
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_role;
+ CREATE SERVER s9 FOREIGN DATA WRAPPER postgresql;
+ ALTER SERVER s6 VERSION '0.5'; -- ERROR
+ ERROR: must be owner of foreign server s6
+ DROP SERVER s6; -- ERROR
+ ERROR: must be owner of foreign server s6
+ GRANT USAGE ON FOREIGN SERVER s6 TO server_test_role; -- ERROR
+ ERROR: permission denied for foreign server s6
+ GRANT USAGE ON FOREIGN SERVER s9 TO server_test_role;
+ CREATE USER MAPPING FOR public SERVER s6; -- ERROR
+ ERROR: must be owner of foreign server s6
+ CREATE USER MAPPING FOR public SERVER s9;
+ ALTER USER MAPPING FOR server_test_role SERVER s6 OPTIONS (gotcha 'true'); -- ERROR
+ ERROR: must be owner of foreign server s6
+ DROP USER MAPPING FOR server_test_role SERVER s6; -- ERROR
+ ERROR: must be owner of foreign server s6
+ RESET ROLE;
+ REVOKE USAGE ON FOREIGN DATA WRAPPER foo FROM unprivileged_role; -- ERROR
+ ERROR: dependent privileges exist
+ HINT: Use CASCADE to revoke them too.
+ REVOKE USAGE ON FOREIGN DATA WRAPPER foo FROM unprivileged_role CASCADE;
+ SET ROLE unprivileged_role;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_role; -- ERROR
+ ERROR: permission denied for foreign-data wrapper foo
+ CREATE SERVER s10 FOREIGN DATA WRAPPER foo; -- ERROR
+ ERROR: permission denied for foreign-data wrapper foo
+ ALTER SERVER s9 VERSION '1.1';
+ GRANT USAGE ON FOREIGN SERVER s9 TO server_test_role;
+ CREATE USER MAPPING FOR current_user SERVER s9;
+ DROP SERVER s9 CASCADE;
+ NOTICE: drop cascades to 2 other objects
+ DETAIL: drop cascades to user mapping for public
+ drop cascades to user mapping for unprivileged_role
+ RESET ROLE;
+ CREATE SERVER s9 FOREIGN DATA WRAPPER foo;
+ GRANT USAGE ON FOREIGN SERVER s9 TO unprivileged_role;
+ SET ROLE unprivileged_role;
+ ALTER SERVER s9 VERSION '1.2'; -- ERROR
+ ERROR: must be owner of foreign server s9
+ GRANT USAGE ON FOREIGN SERVER s9 TO server_test_role; -- WARNING
+ WARNING: no privileges were granted for "s9"
+ CREATE USER MAPPING FOR current_user SERVER s9; -- ERROR
+ ERROR: must be owner of foreign server s9
+ DROP SERVER s9 CASCADE; -- ERROR
+ ERROR: must be owner of foreign server s9
+ RESET ROLE;
+ -- Cleanup
+ DROP ROLE server_test_role; -- ERROR
+ ERROR: role "server_test_role" cannot be dropped because some objects depend on it
+ DETAIL: access to server s4
+ owner of user mapping for server_test_role
+ owner of user mapping for server_test_role
+ owner of server s5
+ owner of server st2
+ DROP SERVER s5 CASCADE;
+ NOTICE: drop cascades to user mapping for server_test_role
+ DROP SERVER st1 CASCADE;
+ NOTICE: drop cascades to user mapping for public
+ DROP SERVER st2;
+ DROP ROLE server_test_role; -- ERROR
+ ERROR: role "server_test_role" cannot be dropped because some objects depend on it
+ DETAIL: access to server s4
+ owner of user mapping for server_test_role
+ DROP USER MAPPING FOR server_test_role SERVER s6;
+ DROP ROLE server_test_role;
+ ERROR: role "server_test_role" cannot be dropped because some objects depend on it
+ DETAIL: access to server s4
+ DROP FOREIGN DATA WRAPPER foo CASCADE;
+ NOTICE: drop cascades to 6 other objects
+ DETAIL: drop cascades to server s4
+ drop cascades to user mapping for foreign_data_user
+ drop cascades to server s6
+ drop cascades to server S6
+ drop cascades to user mapping for foreign_data_user
+ drop cascades to server s9
+ DROP SERVER s8 CASCADE;
+ NOTICE: drop cascades to 2 other objects
+ DETAIL: drop cascades to user mapping for foreign_data_user
+ drop cascades to user mapping for public
+ DROP ROLE server_test_indirect;
+ DROP ROLE fdw_test_role;
+ DROP ROLE unprivileged_role; -- ERROR
+ ERROR: role "unprivileged_role" cannot be dropped because some objects depend on it
+ DETAIL: access to foreign-data wrapper postgresql
+ REVOKE ALL ON FOREIGN DATA WRAPPER postgresql FROM unprivileged_role;
+ DROP ROLE unprivileged_role;
+ -- At this point we should have 2 built-in wrappers and no servers or mappings.
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ fdwname | fdwlibrary | fdwoptions
+ ------------+----------------+------------
+ dummy | dummy_fdw |
+ postgresql | postgresql_fdw |
+ (2 rows)
+
+ SELECT srvname, srvoptions FROM pg_foreign_server;
+ srvname | srvoptions
+ ---------+------------
+ (0 rows)
+
+ SELECT * FROM pg_user_mapping;
+ umuser | umserver | umoptions
+ --------+----------+-----------
+ (0 rows)
+
diff -cNr -x CVS cvs-pgsql/src/test/regress/expected/opr_sanity.out pgsql/src/test/regress/expected/opr_sanity.out
*** cvs-pgsql/src/test/regress/expected/opr_sanity.out Fri Dec 5 15:06:35 2008
--- pgsql/src/test/regress/expected/opr_sanity.out Fri Dec 12 10:44:16 2008
***************
*** 117,125 ****
p1.proretset != p2.proretset OR
p1.provolatile != p2.provolatile OR
p1.pronargs != p2.pronargs);
! oid | proname | oid | proname
! -----+---------+-----+---------
! (0 rows)
-- Look for uses of different type OIDs in the argument/result type fields
-- for different aliases of the same built-in function.
--- 117,126 ----
p1.proretset != p2.proretset OR
p1.provolatile != p2.provolatile OR
p1.pronargs != p2.pronargs);
! oid | proname | oid | proname
! ------+-------------------------------+------+-------------------------------
! 2995 | pg_get_remote_connection_info | 2996 | pg_get_remote_connection_info
! (1 row)
-- Look for uses of different type OIDs in the argument/result type fields
-- for different aliases of the same built-in function.
diff -cNr -x CVS cvs-pgsql/src/test/regress/expected/rules.out pgsql/src/test/regress/expected/rules.out
*** cvs-pgsql/src/test/regress/expected/rules.out Thu Nov 13 10:44:53 2008
--- pgsql/src/test/regress/expected/rules.out Fri Dec 12 10:44:16 2008
***************
*** 1313,1318 ****
--- 1313,1319 ----
pg_timezone_abbrevs | SELECT pg_timezone_abbrevs.abbrev, pg_timezone_abbrevs.utc_offset, pg_timezone_abbrevs.is_dst FROM pg_timezone_abbrevs() pg_timezone_abbrevs(abbrev, utc_offset, is_dst);
pg_timezone_names | SELECT pg_timezone_names.name, pg_timezone_names.abbrev, pg_timezone_names.utc_offset, pg_timezone_names.is_dst FROM pg_timezone_names() pg_timezone_names(name, abbrev, utc_offset, is_dst);
pg_user | SELECT pg_shadow.usename, pg_shadow.usesysid, pg_shadow.usecreatedb, pg_shadow.usesuper, pg_shadow.usecatupd, '********'::text AS passwd, pg_shadow.valuntil, pg_shadow.useconfig FROM pg_shadow;
+ pg_user_mappings | SELECT u.oid AS umid, s.oid AS srvid, s.srvname, u.umuser, CASE WHEN (u.umuser = (0)::oid) THEN 'public'::name ELSE a.rolname END AS usename FROM ((pg_user_mapping u LEFT JOIN pg_authid a ON ((a.oid = u.umuser))) JOIN pg_foreign_server s ON ((u.umserver = s.oid)));
pg_views | SELECT n.nspname AS schemaname, c.relname AS viewname, pg_get_userbyid(c.relowner) AS viewowner, pg_get_viewdef(c.oid) AS definition FROM (pg_class c LEFT JOIN pg_namespace n ON ((n.oid = c.relnamespace))) WHERE (c.relkind = 'v'::"char");
rtest_v1 | SELECT rtest_t1.a, rtest_t1.b FROM rtest_t1;
rtest_vcomp | SELECT x.part, (x.size * y.factor) AS size_in_cm FROM rtest_comp x, rtest_unitfact y WHERE (x.unit = y.unit);
***************
*** 1328,1334 ****
shoelace_obsolete | SELECT shoelace.sl_name, shoelace.sl_avail, shoelace.sl_color, shoelace.sl_len, shoelace.sl_unit, shoelace.sl_len_cm FROM shoelace WHERE (NOT (EXISTS (SELECT shoe.shoename FROM shoe WHERE (shoe.slcolor = shoelace.sl_color))));
street | SELECT r.name, r.thepath, c.cname FROM ONLY road r, real_city c WHERE (c.outline ## r.thepath);
toyemp | SELECT emp.name, emp.age, emp.location, (12 * emp.salary) AS annualsal FROM emp;
! (50 rows)
SELECT tablename, rulename, definition FROM pg_rules
ORDER BY tablename, rulename;
--- 1329,1335 ----
shoelace_obsolete | SELECT shoelace.sl_name, shoelace.sl_avail, shoelace.sl_color, shoelace.sl_len, shoelace.sl_unit, shoelace.sl_len_cm FROM shoelace WHERE (NOT (EXISTS (SELECT shoe.shoename FROM shoe WHERE (shoe.slcolor = shoelace.sl_color))));
street | SELECT r.name, r.thepath, c.cname FROM ONLY road r, real_city c WHERE (c.outline ## r.thepath);
toyemp | SELECT emp.name, emp.age, emp.location, (12 * emp.salary) AS annualsal FROM emp;
! (51 rows)
SELECT tablename, rulename, definition FROM pg_rules
ORDER BY tablename, rulename;
diff -cNr -x CVS cvs-pgsql/src/test/regress/expected/sanity_check.out pgsql/src/test/regress/expected/sanity_check.out
*** cvs-pgsql/src/test/regress/expected/sanity_check.out Sat Nov 24 21:49:23 2007
--- pgsql/src/test/regress/expected/sanity_check.out Fri Dec 12 10:44:16 2008
***************
*** 99,104 ****
--- 99,106 ----
pg_depend | t
pg_description | t
pg_enum | t
+ pg_foreign_data_wrapper | t
+ pg_foreign_server | t
pg_index | t
pg_inherits | t
pg_language | t
***************
*** 122,127 ****
--- 124,130 ----
pg_ts_parser | t
pg_ts_template | t
pg_type | t
+ pg_user_mapping | t
point_tbl | f
polygon_tbl | t
ramp | f
***************
*** 149,155 ****
timetz_tbl | f
tinterval_tbl | f
varchar_tbl | f
! (138 rows)
--
-- another sanity check: every system catalog that has OIDs should have
--- 152,158 ----
timetz_tbl | f
tinterval_tbl | f
varchar_tbl | f
! (141 rows)
--
-- another sanity check: every system catalog that has OIDs should have
diff -cNr -x CVS cvs-pgsql/src/test/regress/parallel_schedule pgsql/src/test/regress/parallel_schedule
*** cvs-pgsql/src/test/regress/parallel_schedule Mon Nov 3 16:31:26 2008
--- pgsql/src/test/regress/parallel_schedule Fri Dec 12 10:44:16 2008
***************
*** 77,83 ****
# ----------
# Another group of parallel tests
# ----------
! test: select_views portals_p2 rules foreign_key cluster dependency guc bitmapops combocid tsearch tsdicts
# ----------
# Another group of parallel tests
--- 77,83 ----
# ----------
# Another group of parallel tests
# ----------
! test: select_views portals_p2 rules foreign_key cluster dependency guc bitmapops combocid tsearch tsdicts foreign_data
# ----------
# Another group of parallel tests
diff -cNr -x CVS cvs-pgsql/src/test/regress/serial_schedule pgsql/src/test/regress/serial_schedule
*** cvs-pgsql/src/test/regress/serial_schedule Mon Nov 3 16:31:26 2008
--- pgsql/src/test/regress/serial_schedule Fri Dec 12 10:44:16 2008
***************
*** 108,113 ****
--- 108,114 ----
test: without_oid
test: conversion
test: tsdicts
+ test: foreign_data
test: truncate
test: alter_table
test: sequence
diff -cNr -x CVS cvs-pgsql/src/test/regress/sql/foreign_data.sql pgsql/src/test/regress/sql/foreign_data.sql
*** cvs-pgsql/src/test/regress/sql/foreign_data.sql Thu Jan 1 02:00:00 1970
--- pgsql/src/test/regress/sql/foreign_data.sql Tue Dec 16 16:26:54 2008
***************
*** 0 ****
--- 1,405 ----
+ --
+ -- Test foreign-data wrapper and server management.
+ --
+
+ CREATE USER foreign_data_user SUPERUSER;
+ \c - foreign_data_user
+
+ -- At this point we should have 2 built-in wrappers and no servers.
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ SELECT srvname, srvoptions FROM pg_foreign_server;
+ SELECT * FROM pg_user_mapping;
+
+ -- CREATE FOREIGN DATA WRAPPER
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY '' LANGUAGE C; -- ERROR
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'plpgsql' LANGUAGE C;
+ DROP FOREIGN DATA WRAPPER foo;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C; -- duplicate
+ CREATE FOREIGN DATA WRAPPER "Foo" LIBRARY 'dummy_fdw' LANGUAGE C;
+ DROP FOREIGN DATA WRAPPER "Foo";
+ DROP FOREIGN DATA WRAPPER foo;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C OPTIONS (testing '1');
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ DROP FOREIGN DATA WRAPPER foo;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C OPTIONS (testing '1', testing '2'); -- ERROR
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C OPTIONS (testing '1', another '2');
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ CREATE ROLE fdw_test_role;
+ CREATE ROLE fdw_test_role_super SUPERUSER;
+
+ DROP FOREIGN DATA WRAPPER foo;
+ SET ROLE fdw_test_role;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C; -- ERROR
+ RESET ROLE;
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'postgresql_fdw' LANGUAGE C;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ -- ALTER FOREIGN DATA WRAPPER
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY ''; -- ERROR
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY 'plpgsql';
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw';
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (a '1', b '2');
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (SET c '4'); -- ERROR
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (DROP c); -- ERROR
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (ADD x '1', DROP x);
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (DROP a, SET b '3', ADD c '4');
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (a '2');
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (b '4'); -- ERROR
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ SET ROLE fdw_test_role;
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (ADD d '5'); -- ERROR
+ SET ROLE fdw_test_role_super;
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (ADD d '5');
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ ALTER FOREIGN DATA WRAPPER foo OWNER to fdw_test_role; -- ERROR
+ ALTER FOREIGN DATA WRAPPER foo OWNER to fdw_test_role_super;
+ ALTER ROLE fdw_test_role_super NOSUPERUSER;
+ SET ROLE fdw_test_role_super;
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (ADD e '6'); -- ERROR
+ RESET ROLE;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ -- DROP FOREIGN DATA WRAPPER
+ DROP FOREIGN DATA WRAPPER nonexistent; -- ERROR
+ DROP FOREIGN DATA WRAPPER IF EXISTS nonexistent;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ DROP ROLE fdw_test_role_super; -- ERROR
+ SET ROLE fdw_test_role_super;
+ DROP FOREIGN DATA WRAPPER foo; -- ERROR
+ RESET ROLE;
+ DROP FOREIGN DATA WRAPPER foo;
+ DROP ROLE fdw_test_role_super;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C;
+ CREATE SERVER s1 FOREIGN DATA WRAPPER foo;
+ CREATE USER MAPPING FOR current_user SERVER s1;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ \des+
+ \deu+
+ DROP FOREIGN DATA WRAPPER foo; -- ERROR
+ SET ROLE fdw_test_role;
+ DROP FOREIGN DATA WRAPPER foo CASCADE; -- ERROR
+ RESET ROLE;
+ DROP FOREIGN DATA WRAPPER foo CASCADE;
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ \des+
+ \deu+
+
+ -- exercise CREATE SERVER
+ CREATE SERVER s1 FOREIGN DATA WRAPPER foo; -- ERROR
+ CREATE FOREIGN DATA WRAPPER foo LIBRARY 'dummy_fdw' LANGUAGE C OPTIONS (test_wrapper 'true');
+ CREATE SERVER s1 FOREIGN DATA WRAPPER foo;
+ CREATE SERVER s1 FOREIGN DATA WRAPPER foo; -- ERROR
+ CREATE SERVER s2 FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
+ CREATE SERVER s3 TYPE 'oracle' FOREIGN DATA WRAPPER foo;
+ CREATE SERVER s4 TYPE 'oracle' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
+ CREATE SERVER s5 VERSION '15.0' FOREIGN DATA WRAPPER foo;
+ CREATE SERVER s6 VERSION '16.0' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
+ CREATE SERVER "S6" FOREIGN DATA WRAPPER foo OPTIONS (mixed_case_names 'true');
+ CREATE SERVER s7 TYPE 'oracle' VERSION '17.0' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b');
+ CREATE SERVER s8 FOREIGN DATA WRAPPER postgresql OPTIONS (foo '1'); -- ERROR
+ CREATE SERVER s8 FOREIGN DATA WRAPPER postgresql OPTIONS (host 'localhost', dbname 's8db');
+ \des+
+ CREATE ROLE server_test_role;
+ CREATE ROLE server_test_role2;
+ SET ROLE server_test_role;
+ CREATE SERVER st1 FOREIGN DATA WRAPPER foo; -- ERROR: no usage on FDW
+ RESET ROLE;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_role;
+ SET ROLE server_test_role;
+ CREATE SERVER st1 FOREIGN DATA WRAPPER foo;
+ RESET ROLE;
+ \des+
+
+ CREATE ROLE server_test_indirect;
+ REVOKE USAGE ON FOREIGN DATA WRAPPER foo FROM server_test_role;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_indirect;
+ SET ROLE server_test_role;
+ CREATE SERVER st2 FOREIGN DATA WRAPPER foo; -- ERROR
+ RESET ROLE;
+ GRANT server_test_indirect TO server_test_role;
+ SET ROLE server_test_role;
+ CREATE SERVER st2 FOREIGN DATA WRAPPER foo;
+ \des+
+ RESET ROLE;
+ REVOKE server_test_indirect FROM server_test_role;
+
+ -- ALTER SERVER
+ ALTER SERVER s0; -- ERROR
+ ALTER SERVER s0 OPTIONS (a '1'); -- ERROR
+ ALTER SERVER s1 VERSION '1.0' OPTIONS (servername 's1');
+ ALTER SERVER s2 VERSION '1.1';
+ ALTER SERVER s3 OPTIONS (tnsname 'orcl', port '1521');
+ GRANT USAGE ON FOREIGN SERVER s1 TO server_test_role;
+ \des+
+ SET ROLE server_test_role;
+ ALTER SERVER s1 VERSION '1.1'; -- ERROR
+ ALTER SERVER s1 OWNER TO server_test_role; -- ERROR
+ RESET ROLE;
+ ALTER SERVER s1 OWNER TO server_test_role;
+ GRANT server_test_role2 TO server_test_role;
+ SET ROLE server_test_role;
+ ALTER SERVER s1 VERSION '1.1';
+ ALTER SERVER s1 OWNER TO server_test_role2; -- ERROR
+ RESET ROLE;
+ ALTER SERVER s8 OPTIONS (foo '1'); -- ERROR option validation
+ ALTER SERVER s8 OPTIONS (connect_timeout '30', set dbname 'db1', drop host);
+ SET ROLE server_test_role;
+ ALTER SERVER s1 OWNER TO server_test_indirect; -- ERROR
+ RESET ROLE;
+ GRANT server_test_indirect TO server_test_role;
+ SET ROLE server_test_role;
+ ALTER SERVER s1 OWNER TO server_test_indirect;
+ RESET ROLE;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_indirect;
+ SET ROLE server_test_role;
+ ALTER SERVER s1 OWNER TO server_test_indirect;
+ RESET ROLE;
+ DROP ROLE server_test_indirect; -- ERROR
+ \des+
+
+ -- DROP SERVER
+ DROP SERVER nonexistent; -- ERROR
+ DROP SERVER IF EXISTS nonexistent;
+ \des
+ SET ROLE server_test_role;
+ DROP SERVER s2; -- ERROR
+ DROP SERVER s1;
+ RESET ROLE;
+ \des
+ ALTER SERVER s2 OWNER TO server_test_role;
+ SET ROLE server_test_role;
+ DROP SERVER s2;
+ RESET ROLE;
+ \des
+ CREATE USER MAPPING FOR current_user SERVER s3;
+ \deu
+ DROP SERVER s3; -- ERROR
+ DROP SERVER s3 CASCADE;
+ \des
+ \deu
+
+ -- CREATE USER MAPPING
+ CREATE USER MAPPING FOR baz SERVER s1; -- ERROR
+ CREATE USER MAPPING FOR current_user SERVER s1; -- ERROR
+ CREATE USER MAPPING FOR current_user SERVER s4;
+ CREATE USER MAPPING FOR user SERVER s4; -- ERROR duplicate
+ CREATE USER MAPPING FOR public SERVER s4 OPTIONS (mapping 'is public');
+ CREATE USER MAPPING FOR user SERVER s8 OPTIONS (username 'test', password 'secret'); -- ERROR
+ CREATE USER MAPPING FOR user SERVER s8 OPTIONS (user 'test', password 'secret');
+ ALTER SERVER s5 OWNER TO server_test_role;
+ ALTER SERVER s6 OWNER TO server_test_indirect;
+ SET ROLE server_test_role;
+ CREATE USER MAPPING FOR current_user SERVER s5;
+ CREATE USER MAPPING FOR current_user SERVER s6 OPTIONS (username 'test');
+ CREATE USER MAPPING FOR current_user SERVER s7; -- ERROR
+ CREATE USER MAPPING FOR public SERVER s8; -- ERROR
+ RESET ROLE;
+ CREATE USER MAPPING FOR current_user SERVER "S6" OPTIONS (username 'test_mixed_case');
+
+ ALTER SERVER st1 OWNER TO server_test_indirect;
+ SET ROLE server_test_role;
+ CREATE USER MAPPING FOR current_user SERVER st1 OPTIONS (username 'bob', password 'boo');
+ CREATE USER MAPPING FOR public SERVER st1;
+ RESET ROLE;
+ \deu
+
+ -- ALTER USER MAPPING
+ ALTER USER MAPPING FOR bob SERVER s4 OPTIONS (gotcha 'true'); -- ERROR
+ ALTER USER MAPPING FOR user SERVER ss4 OPTIONS (gotcha 'true'); -- ERROR
+ ALTER USER MAPPING FOR public SERVER s5 OPTIONS (gotcha 'true'); -- ERROR
+ ALTER USER MAPPING FOR current_user SERVER s8 OPTIONS (username 'test'); -- ERROR
+ ALTER USER MAPPING FOR current_user SERVER s8 OPTIONS (DROP user, SET password 'public');
+ SET ROLE server_test_role;
+ ALTER USER MAPPING FOR current_user SERVER s5 OPTIONS (ADD modified '1');
+ ALTER USER MAPPING FOR public SERVER s4 OPTIONS (ADD modified '1'); -- ERROR
+ ALTER USER MAPPING FOR public SERVER st1 OPTIONS (ADD modified '1');
+ RESET ROLE;
+ \deu+
+
+ -- DROP USER MAPPING
+ DROP USER MAPPING FOR bob SERVER s4; -- ERROR
+ DROP USER MAPPING FOR user SERVER ss4;
+ DROP USER MAPPING FOR public SERVER s7; -- ERROR
+ DROP USER MAPPING IF EXISTS FOR bob SERVER s4;
+ DROP USER MAPPING IF EXISTS FOR user SERVER ss4;
+ DROP USER MAPPING IF EXISTS FOR public SERVER s7;
+ CREATE USER MAPPING FOR public SERVER s8;
+ SET ROLE server_test_role;
+ DROP USER MAPPING FOR public SERVER s8; -- ERROR
+ RESET ROLE;
+ DROP SERVER s7;
+ \deu
+
+ -- Information schema
+
+ -- Avoid including the superuser name in the output, as it will vary across installations.
+ SELECT * FROM information_schema.foreign_data_wrappers WHERE authorization_identifier <> (SELECT rolname FROM pg_authid WHERE oid = 10) ORDER BY 1, 2;
+ SELECT * FROM information_schema.foreign_data_wrapper_options ORDER BY 1, 2, 3;
+ SELECT * FROM information_schema.foreign_servers ORDER BY 1, 2;
+ SELECT * FROM information_schema.foreign_server_options ORDER BY 1, 2, 3;
+ SELECT * FROM information_schema.user_mappings ORDER BY 1, 2, 3;
+ SELECT * FROM information_schema.user_mapping_options ORDER BY 1, 2, 3, 4;
+ SET ROLE server_test_role;
+ SELECT * FROM information_schema.user_mapping_options ORDER BY 1, 2, 3, 4;
+ DROP USER MAPPING FOR current_user SERVER st1;
+ RESET ROLE;
+
+
+ -- has_foreign_data_wrapper_privilege
+ SELECT has_foreign_data_wrapper_privilege('fdw_test_role',
+ (SELECT oid FROM pg_foreign_data_wrapper WHERE fdwname='foo'), 'USAGE');
+ SELECT has_foreign_data_wrapper_privilege('fdw_test_role', 'foo', 'USAGE');
+ SELECT has_foreign_data_wrapper_privilege(
+ (SELECT oid FROM pg_roles WHERE rolname='fdw_test_role'),
+ (SELECT oid FROM pg_foreign_data_wrapper WHERE fdwname='foo'), 'USAGE');
+ SELECT has_foreign_data_wrapper_privilege(
+ (SELECT oid FROM pg_foreign_data_wrapper WHERE fdwname='foo'), 'USAGE');
+ SELECT has_foreign_data_wrapper_privilege(
+ (SELECT oid FROM pg_roles WHERE rolname='fdw_test_role'), 'foo', 'USAGE');
+ SELECT has_foreign_data_wrapper_privilege('foo', 'USAGE');
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO fdw_test_role;
+ SELECT has_foreign_data_wrapper_privilege('fdw_test_role', 'foo', 'USAGE');
+
+ -- has_server_privilege
+ SELECT has_server_privilege('server_test_role',
+ (SELECT oid FROM pg_foreign_server WHERE srvname='s8'), 'USAGE');
+ SELECT has_server_privilege('server_test_role', 's8', 'USAGE');
+ SELECT has_server_privilege(
+ (SELECT oid FROM pg_roles WHERE rolname='server_test_role'),
+ (SELECT oid FROM pg_foreign_server WHERE srvname='s8'), 'USAGE');
+ SELECT has_server_privilege(
+ (SELECT oid FROM pg_foreign_server WHERE srvname='s8'), 'USAGE');
+ SELECT has_server_privilege(
+ (SELECT oid FROM pg_roles WHERE rolname='server_test_role'), 's8', 'USAGE');
+ SELECT has_server_privilege('s8', 'USAGE');
+ GRANT USAGE ON FOREIGN SERVER s8 TO server_test_role;
+ SELECT has_server_privilege('server_test_role', 's8', 'USAGE');
+ REVOKE USAGE ON FOREIGN SERVER s8 FROM server_test_role;
+
+ -- pg_get_remote_connection_info
+ SELECT * FROM pg_get_remote_connection_info(NULL);
+ SELECT * FROM pg_get_remote_connection_info(''); -- ERROR
+ SELECT * FROM pg_get_remote_connection_info('foo'); -- ERROR
+ SELECT * FROM pg_get_remote_connection_info('foo', 'bob'); -- ERROR
+ SELECT * FROM pg_get_remote_connection_info('foo', 'server_test_role'); -- ERROR
+ SELECT * FROM pg_get_remote_connection_info('foo.bar'); -- ERROR
+ SELECT * FROM pg_get_remote_connection_info('foo', current_user); -- ERROR
+ SELECT * FROM pg_get_remote_connection_info('s4');
+ SELECT * FROM pg_get_remote_connection_info('s4', current_user);
+ SELECT * FROM pg_get_remote_connection_info('s4', 'public');
+ GRANT USAGE ON FOREIGN SERVER s4 TO server_test_role;
+ SELECT * FROM pg_get_remote_connection_info('s4', 'server_test_role');
+ DROP USER MAPPING FOR public SERVER s4;
+ SELECT * FROM pg_get_remote_connection_info('s4', 'server_test_role'); -- ERROR
+ SELECT * FROM pg_get_remote_connection_info('s6', 'server_test_role');
+ SELECT * FROM pg_get_remote_connection_info('s6', 'server_test_role');
+ ALTER SERVER s6 OPTIONS (DROP host, DROP dbname);
+ SELECT * FROM pg_get_remote_connection_info('s6', 'server_test_role');
+ ALTER USER MAPPING FOR server_test_role SERVER s6 OPTIONS (DROP username);
+ SELECT * FROM pg_get_remote_connection_info('s6', 'server_test_role');
+ SELECT * FROM pg_get_remote_connection_info('S6');
+ SELECT * FROM pg_get_remote_connection_info('s8');
+ SELECT * FROM pg_get_remote_connection_info('s8', 'public');
+ SET ROLE server_test_role;
+ SELECT * FROM pg_get_remote_connection_info('s6'); -- ERROR
+ RESET ROLE;
+ GRANT EXECUTE ON FUNCTION pg_get_remote_connection_info(name) TO server_test_role2;
+ SET ROLE server_test_role2;
+ SELECT * FROM pg_get_remote_connection_info('s6'); -- ERROR
+ RESET ROLE;
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY 'plpgsql';
+ SELECT * FROM pg_get_remote_connection_info('s4'); -- ERROR
+ ALTER FOREIGN DATA WRAPPER foo LIBRARY 'default_fdw';
+
+ -- Privileges
+ CREATE ROLE unprivileged_role;
+ SET ROLE unprivileged_role;
+ CREATE FOREIGN DATA WRAPPER foobar LIBRARY 'dummy_fdw' LANGUAGE C; -- ERROR
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (gotcha 'true'); -- ERROR
+ ALTER FOREIGN DATA WRAPPER foo OWNER TO unprivileged_role; -- ERROR
+ DROP FOREIGN DATA WRAPPER foo; -- ERROR
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_role; -- ERROR
+ CREATE SERVER s9 FOREIGN DATA WRAPPER foo; -- ERROR
+ ALTER SERVER s4 VERSION '0.5'; -- ERROR
+ ALTER SERVER s4 OWNER TO unprivileged_role; -- ERROR
+ DROP SERVER s4; -- ERROR
+ GRANT USAGE ON FOREIGN SERVER s4 TO server_test_role; -- ERROR
+ CREATE USER MAPPING FOR public SERVER s4; -- ERROR
+ ALTER USER MAPPING FOR server_test_role SERVER s6 OPTIONS (gotcha 'true'); -- ERROR
+ DROP USER MAPPING FOR server_test_role SERVER s6; -- ERROR
+ RESET ROLE;
+
+ GRANT USAGE ON FOREIGN DATA WRAPPER postgresql TO unprivileged_role;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO unprivileged_role WITH GRANT OPTION;
+ SET ROLE unprivileged_role;
+ CREATE FOREIGN DATA WRAPPER foobar LIBRARY 'dummy_fdw' LANGUAGE C; -- ERROR
+ ALTER FOREIGN DATA WRAPPER foo OPTIONS (gotcha 'true'); -- ERROR
+ DROP FOREIGN DATA WRAPPER foo; -- ERROR
+ GRANT USAGE ON FOREIGN DATA WRAPPER postgresql TO server_test_role; -- WARNING
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_role;
+ CREATE SERVER s9 FOREIGN DATA WRAPPER postgresql;
+ ALTER SERVER s6 VERSION '0.5'; -- ERROR
+ DROP SERVER s6; -- ERROR
+ GRANT USAGE ON FOREIGN SERVER s6 TO server_test_role; -- ERROR
+ GRANT USAGE ON FOREIGN SERVER s9 TO server_test_role;
+ CREATE USER MAPPING FOR public SERVER s6; -- ERROR
+ CREATE USER MAPPING FOR public SERVER s9;
+ ALTER USER MAPPING FOR server_test_role SERVER s6 OPTIONS (gotcha 'true'); -- ERROR
+ DROP USER MAPPING FOR server_test_role SERVER s6; -- ERROR
+ RESET ROLE;
+
+ REVOKE USAGE ON FOREIGN DATA WRAPPER foo FROM unprivileged_role; -- ERROR
+ REVOKE USAGE ON FOREIGN DATA WRAPPER foo FROM unprivileged_role CASCADE;
+ SET ROLE unprivileged_role;
+ GRANT USAGE ON FOREIGN DATA WRAPPER foo TO server_test_role; -- ERROR
+ CREATE SERVER s10 FOREIGN DATA WRAPPER foo; -- ERROR
+ ALTER SERVER s9 VERSION '1.1';
+ GRANT USAGE ON FOREIGN SERVER s9 TO server_test_role;
+ CREATE USER MAPPING FOR current_user SERVER s9;
+ DROP SERVER s9 CASCADE;
+ RESET ROLE;
+ CREATE SERVER s9 FOREIGN DATA WRAPPER foo;
+ GRANT USAGE ON FOREIGN SERVER s9 TO unprivileged_role;
+ SET ROLE unprivileged_role;
+ ALTER SERVER s9 VERSION '1.2'; -- ERROR
+ GRANT USAGE ON FOREIGN SERVER s9 TO server_test_role; -- WARNING
+ CREATE USER MAPPING FOR current_user SERVER s9; -- ERROR
+ DROP SERVER s9 CASCADE; -- ERROR
+ RESET ROLE;
+
+ -- Cleanup
+ DROP ROLE server_test_role; -- ERROR
+ DROP SERVER s5 CASCADE;
+ DROP SERVER st1 CASCADE;
+ DROP SERVER st2;
+ DROP ROLE server_test_role; -- ERROR
+ DROP USER MAPPING FOR server_test_role SERVER s6;
+ DROP ROLE server_test_role;
+ DROP FOREIGN DATA WRAPPER foo CASCADE;
+ DROP SERVER s8 CASCADE;
+ DROP ROLE server_test_indirect;
+ DROP ROLE fdw_test_role;
+ DROP ROLE unprivileged_role; -- ERROR
+ REVOKE ALL ON FOREIGN DATA WRAPPER postgresql FROM unprivileged_role;
+ DROP ROLE unprivileged_role;
+
+ -- At this point we should have 2 built-in wrappers and no servers or mappings.
+ SELECT fdwname, fdwlibrary, fdwoptions FROM pg_foreign_data_wrapper ORDER BY 1, 2, 3;
+ SELECT srvname, srvoptions FROM pg_foreign_server;
+ SELECT * FROM pg_user_mapping;