char todo[1024];
/* get the oid and database name from the system pg_database table */
- snprintf(todo, 1024, "SELECT d.oid AS \"Oid\", datname AS \"Database Name\", "
+ snprintf(todo, sizeof(todo),
+ "SELECT d.oid AS \"Oid\", datname AS \"Database Name\", "
"spcname AS \"Tablespace\" FROM pg_database d JOIN pg_tablespace t ON "
"(dattablespace = t.oid) ORDER BY 2");
char todo[1024];
char *addfields = ",c.oid AS \"Oid\", nspname AS \"Schema\", spcname as \"Tablespace\" ";
- snprintf(todo, 1024,
+ snprintf(todo, sizeof(todo),
"SELECT relfilenode as \"Filenode\", relname as \"Table Name\" %s "
"FROM pg_class c "
" LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace "
" %s"
" t.oid = CASE"
" WHEN reltablespace <> 0 THEN reltablespace"
- " WHEN n.nsptablespace <> 0 THEN nsptablespace"
- " WHEN d.dattablespace <> 0 THEN dattablespace"
+ " ELSE dattablespace"
" END "
"ORDER BY relname",
opts->extended ? addfields : "",
/* now build the query */
todo = (char *) myalloc(650 + strlen(qualifiers));
- snprintf(todo, 1024,
+ snprintf(todo, 650 + strlen(qualifiers),
"SELECT relfilenode as \"Filenode\", relname as \"Table Name\" %s\n"
"FROM pg_class c \n"
" LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \n"
"WHERE relkind IN ('r', 'i', 'S', 't') AND \n"
" t.oid = CASE\n"
" WHEN reltablespace <> 0 THEN reltablespace\n"
- " WHEN n.nsptablespace <> 0 THEN nsptablespace\n"
- " WHEN d.dattablespace <> 0 THEN dattablespace\n"
+ " ELSE dattablespace\n"
" END AND \n"
" (%s) \n"
"ORDER BY relname\n",
{
char todo[1024];
- snprintf(todo, 1024, "SELECT oid AS \"Oid\", spcname as \"Tablespace Name\"\n"
+ snprintf(todo, sizeof(todo),
+ "SELECT oid AS \"Oid\", spcname as \"Tablespace Name\"\n"
"FROM pg_tablespace");
sql_exec(conn, todo, opts->quiet);
Owner of the namespace
- |
- nsptablespace
- oid
- pg_tablespace.oid
-
- The default tablespace in which to place relations created in this
- namespace. If zero, the database's default tablespace is implied.
- (Changing this does not affect pre-existing relations.)
-
-
-
|
nspacl
aclitem[]
- Databases, schemas, tables, and indexes can all be assigned to
+ Tables, indexes, and entire databases can be assigned to
particular tablespaces. To do so, a user with the CREATE
privilege on a given tablespace must pass the tablespace name as a
parameter to the relevant command. For example, the following creates
- The tablespace associated with a database is used to store the system
- catalogs of that database, as well as any temporary files created by
- server processes using that database. Furthermore, it is the default
- tablespace selected for any objects created within the database, if
- no specific TABLESPACE clause is given when those objects
- are created. If a database is created without specifying a tablespace
- for it, it uses the same tablespace as the template database it is copied
- from.
-
-
- A schema does not in itself occupy any storage (other than a
- system catalog entry), so assigning a schema to a tablespace does
- not in itself do anything. What this actually does is to set a
- default tablespace for tables later created within the schema. If
- no tablespace is mentioned when creating a schema, it inherits its
- default tablespace from the current database.
-
-
- The default tablespace for an index is the tablespace associated
- with the table the index is on.
+ Alternatively, use the parameter:
+SET default_tablespace = space1;
+CREATE TABLE foo(i int);
+
+ When default_tablespace is set to anything but an empty
+ string, it supplies an implicit TABLESPACE clause for
+ CREATE TABLE and CREATE INDEX commands that
+ do not have an explicit one.
- Another way to state the above rules is that when a schema, table, or index
- is created without specifying a tablespace, the object
- inherits its logical parent's tablespace. A schema will be created in the
- current database's tablespace; a table will be created in the
- tablespace of the schema it is being created in; an index will be created
- in the tablespace of the table underlying the index.
+ The tablespace associated with a database is used to store the system
+ catalogs of that database, as well as any temporary files created by
+ server processes using that database. Furthermore, it is the default
+ tablespace selected for tables and indexes created within the database,
+ if no TABLESPACE clause is given (either explicitly or via
+ default_tablespace) when the objects are created.
+ If a database is created without specifying a tablespace for it,
+ it uses the same tablespace as the template database it is copied from.
pg_global tablespace is used for shared system catalogs. The
pg_default tablespace is the default tablespace of the
template1 and template0 databases (and, therefore,
- will be the default tablespace for everything else as well, unless
- explicit TABLESPACE clauses are used somewhere along the
- line).
+ will be the default tablespace for other databases as well, unless
+ overridden by a TABLESPACE clause in CREATE
+ DATABASE).
The tablespace in which to create the index. If not specified,
- the tablespace of the parent table is used.
+ is used, or the database's
+ default tablespace if default_tablespace is an empty
+ string.
-CREATE SCHEMA schemaname [ AUTHORIZATION username ] [ TABLESPACE tablespace ] [ schema_element [ ... ] ]
-CREATE SCHEMA AUTHORIZATION username [ TABLESPACE tablespace ] [ schema_element [ ... ] ]
+CREATE SCHEMA schemaname [ AUTHORIZATION username ] [ schema_element [ ... ] ]
+CREATE SCHEMA AUTHORIZATION username [ schema_element [ ... ] ]
-
- tablespace
-
- The name of the tablespace that is to be the default tablespace
- for all new objects created in the schema. If not supplied, the schema
- will inherit the default tablespace of the database.
-
-
-
-
schema_element
To create a schema, the invoking user must have the
CREATE privilege for the current database.
- Also, the TABLESPACE option requires having
- CREATE privilege for the specified tablespace.
- (Of course, superusers bypass these checks.)
+ (Of course, superusers bypass this check.)
- Create a schema sales whose tables and indexes
- will be stored in the tablespace mirrorspace by default:
-
-CREATE SCHEMA sales TABLESPACE mirrorspace;
-
-
-
-
The tablespace is the name
- of the tablespace in which the new table is to be created. If not
- supplied, the default tablespace of the table's schema will be used.
+ of the tablespace in which the new table is to be created.
+ If not specified,
+ is used, or the database's
+ default tablespace if default_tablespace is an empty
+ string.
This clause allows selection of the tablespace in which the index
associated with a UNIQUE or PRIMARY
- KEY constraint will be created. If not supplied, the index
- will be created in the same tablespace as the table.
+ KEY constraint will be created.
+ If not specified,
+ is used, or the database's
+ default tablespace if default_tablespace is an empty
+ string.
A user with appropriate privileges can pass
- tablespacename to CREATE
- DATABASE, CREATE SCHEMA, CREATE TABLE,
+ tablespacename to
+ CREATE DATABASE, CREATE TABLE,
CREATE INDEX or ADD CONSTRAINT to have the data
files for these objects stored within the specified tablespace.
-
ON DATABASE dbname [, ...]
TO { username | GROUP groupname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
-GRANT { CREATE | ALL [ PRIVILEGES ] }
- ON TABLESPACE tablespacename [, ...]
- TO { username | GROUP groupname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
-
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION funcname ([type, ...]) [, ...]
TO { username | GROUP groupname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
GRANT { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
ON SCHEMA schemaname [, ...]
TO { username | GROUP groupname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
+
+GRANT { CREATE | ALL [ PRIVILEGES ] }
+ ON TABLESPACE tablespacename [, ...]
+ TO { username | GROUP groupname | PUBLIC } [, ...] [ WITH GRANT OPTION ]
The GRANT command gives specific privileges on
- an object (table, view, sequence, database, tablespace, function,
- procedural language, or schema) to
+ an object (table, view, sequence, database, function,
+ procedural language, schema, or tablespace) to
one or more users or groups of users. These privileges are added
to those already granted, if any.
For databases, allows new schemas to be created within the database.
- For tablespaces, allows tables to be created within the tablespace,
- and allows databases and schemas to be created that have the tablespace
- as their default tablespace. (Note that revoking this privilege
- will not alter the behavior of existing databases and schemas.)
-
For schemas, allows new objects to be created within the schema.
To rename an existing object, you must own the object and
have this privilege for the containing schema.
+ For tablespaces, allows tables and indexes to be created within the
+ tablespace, and allows databases to be created that have the tablespace
+ as their default tablespace. (Note that revoking this privilege
+ will not alter the placement of existing objects.)
+
FROM { username | GROUP groupname | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
-REVOKE [ GRANT OPTION FOR ]
- { CREATE | ALL [ PRIVILEGES ] }
- ON TABLESPACE tablespacename [, ...]
- FROM { username | GROUP groupname | PUBLIC } [, ...]
- [ CASCADE | RESTRICT ]
-
REVOKE [ GRANT OPTION FOR ]
{ EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION funcname ([type, ...]) [, ...]
ON SCHEMA schemaname [, ...]
FROM { username | GROUP groupname | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]
+
+REVOKE [ GRANT OPTION FOR ]
+ { CREATE | ALL [ PRIVILEGES ] }
+ ON TABLESPACE tablespacename [, ...]
+ FROM { username | GROUP groupname | PUBLIC } [, ...]
+ [ CASCADE | RESTRICT ]
Tablespaces allow administrators to select the file systems
- used for storage of databases, schemas, tables, or
- indexes. This improves performance and control over disk space
+ used for storage of tables, indexes, and entire databases.
+ This improves performance and control over disk space
usage. Prior releases used
initlocation and manual symlink management for such tasks.
+
+ default_tablespace (string)
+
+ This variable specifies the default tablespace in which to create
+ objects (tables and indexes) when a CREATE command does
+ not explicitly specify a tablespace.
+
+
+ The value is either the name of a tablespace, or an empty string
+ to specify using the default tablespace of the current database.
+ If the value does not match the name of any existing tablespace,
+
PostgreSQL will automatically use the default+ tablespace of the current database.
+
+
+ For more information on tablespaces,
+ see .
+
+
+
+
check_function_bodies (boolean)
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/namespace.c,v 1.71 2004/09/16 16:58:27 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/namespace.c,v 1.72 2004/11/05 19:15:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* that access the temp namespace for my own backend skip
* permissions checks on it.
*/
- namespaceId = NamespaceCreate(namespaceName, BOOTSTRAP_USESYSID, 0);
+ namespaceId = NamespaceCreate(namespaceName, BOOTSTRAP_USESYSID);
/* Advance command counter to make namespace visible */
CommandCounterIncrement();
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_namespace.c,v 1.10 2004/08/29 04:12:29 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_namespace.c,v 1.11 2004/11/05 19:15:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* ---------------
*/
Oid
-NamespaceCreate(const char *nspName, int32 ownerSysId, Oid nspTablespace)
+NamespaceCreate(const char *nspName, int32 ownerSysId)
{
Relation nspdesc;
HeapTuple tup;
namestrcpy(&nname, nspName);
values[Anum_pg_namespace_nspname - 1] = NameGetDatum(&nname);
values[Anum_pg_namespace_nspowner - 1] = Int32GetDatum(ownerSysId);
- values[Anum_pg_namespace_nsptablespace - 1] = Int32GetDatum(nspTablespace);
nulls[Anum_pg_namespace_nspacl - 1] = 'n';
nspdesc = heap_openr(NamespaceRelationName, RowExclusiveLock);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/indexcmds.c,v 1.126 2004/09/13 20:06:29 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/indexcmds.c,v 1.127 2004/11/05 19:15:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_proc.h"
+#include "catalog/pg_tablespace.h"
#include "commands/dbcommands.h"
#include "commands/defrem.h"
#include "commands/tablecmds.h"
* that a nonconflicting default name should be picked.
* 'accessMethodName': name of the AM to use.
* 'tableSpaceName': name of the tablespace to create the index in.
- * NULL specifies using the same tablespace as the parent relation.
+ * NULL specifies using the appropriate default.
* 'attributeList': a list of IndexElem specifying columns and expressions
* to index on.
* 'predicate': the partial-index condition, or NULL if none.
get_namespace_name(namespaceId));
}
- /* Determine tablespace to use */
+ /*
+ * Select tablespace to use. If not specified, use default_tablespace
+ * (which may in turn default to database's default).
+ */
if (tableSpaceName)
{
- AclResult aclresult;
-
tablespaceId = get_tablespace_oid(tableSpaceName);
if (!OidIsValid(tablespaceId))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("tablespace \"%s\" does not exist",
tableSpaceName)));
- /* check permissions */
+ }
+ else
+ {
+ tablespaceId = GetDefaultTablespace();
+ /* note InvalidOid is OK in this case */
+ }
+
+ /* Check permissions except when using database's default */
+ if (OidIsValid(tablespaceId))
+ {
+ AclResult aclresult;
+
aclresult = pg_tablespace_aclcheck(tablespaceId, GetUserId(),
ACL_CREATE);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_TABLESPACE,
- tableSpaceName);
- }
- else
- {
- /* Use the parent rel's tablespace */
- tablespaceId = get_rel_tablespace(relationId);
- /* Note there is no additional permission check in this path */
+ get_tablespace_name(tablespaceId));
}
+ /*
+ * Force shared indexes into the pg_global tablespace. This is a bit of
+ * a hack but seems simpler than marking them in the BKI commands.
+ */
+ if (rel->rd_rel->relisshared)
+ tablespaceId = GLOBALTABLESPACE_OID;
+
/*
* Select name for index if caller didn't specify
*/
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/schemacmds.c,v 1.25 2004/09/02 00:22:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/schemacmds.c,v 1.26 2004/11/05 19:15:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_namespace.h"
#include "commands/dbcommands.h"
#include "commands/schemacmds.h"
-#include "commands/tablespace.h"
#include "miscadmin.h"
#include "parser/analyze.h"
#include "tcop/utility.h"
const char *schemaName = stmt->schemaname;
const char *authId = stmt->authid;
Oid namespaceId;
- Oid tablespaceId;
List *parsetree_list;
ListCell *parsetree_item;
const char *owner_name;
errmsg("unacceptable schema name \"%s\"", schemaName),
errdetail("The prefix \"pg_\" is reserved for system schemas.")));
- /*
- * Select default tablespace for schema. If not given, use zero which
- * implies the database's default tablespace.
- */
- if (stmt->tablespacename)
- {
- AclResult aclresult;
-
- tablespaceId = get_tablespace_oid(stmt->tablespacename);
- if (!OidIsValid(tablespaceId))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("tablespace \"%s\" does not exist",
- stmt->tablespacename)));
- /* check permissions */
- aclresult = pg_tablespace_aclcheck(tablespaceId, GetUserId(),
- ACL_CREATE);
- if (aclresult != ACLCHECK_OK)
- aclcheck_error(aclresult, ACL_KIND_TABLESPACE,
- stmt->tablespacename);
- }
- else
- {
- tablespaceId = InvalidOid;
- /* note there is no permission check in this path */
- }
-
/* Create the schema's namespace */
- namespaceId = NamespaceCreate(schemaName, owner_userid, tablespaceId);
+ namespaceId = NamespaceCreate(schemaName, owner_userid);
/* Advance cmd counter to make the namespace visible */
CommandCounterIncrement();
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.138 2004/10/30 20:52:56 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.139 2004/11/05 19:15:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static int findAttrByName(const char *attributeName, List *schema);
static void setRelhassubclassInRelation(Oid relationId, bool relhassubclass);
static bool needs_toast_table(Relation rel);
-static void check_tablespace_exists(Oid tablespaceId, Oid namespaceId);
static int transformColumnNameList(Oid relId, List *colList,
int16 *attnums, Oid *atttypids);
static int transformFkeyGetPrimaryKey(Relation pkrel, Oid *indexOid,
}
/*
- * Select tablespace to use. If not specified, use containing
- * schema's default tablespace (which may in turn default to
- * database's default).
+ * Select tablespace to use. If not specified, use default_tablespace
+ * (which may in turn default to database's default).
*/
if (stmt->tablespacename)
{
- AclResult aclresult;
-
tablespaceId = get_tablespace_oid(stmt->tablespacename);
if (!OidIsValid(tablespaceId))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("tablespace \"%s\" does not exist",
stmt->tablespacename)));
- /* check permissions */
+ }
+ else
+ {
+ tablespaceId = GetDefaultTablespace();
+ /* note InvalidOid is OK in this case */
+ }
+
+ /* Check permissions except when using database's default */
+ if (OidIsValid(tablespaceId))
+ {
+ AclResult aclresult;
+
aclresult = pg_tablespace_aclcheck(tablespaceId, GetUserId(),
ACL_CREATE);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_TABLESPACE,
- stmt->tablespacename);
- }
- else
- {
- tablespaceId = get_namespace_tablespace(namespaceId);
- /* note no permission check on tablespace in this case */
- /* check to see that schema's tablespace still exists */
- if (OidIsValid(tablespaceId))
- check_tablespace_exists(tablespaceId, namespaceId);
+ get_tablespace_name(tablespaceId));
}
/*
return (tuple_length > TOAST_TUPLE_THRESHOLD);
}
-/*
- * Verify that a schema's tablespace still exists
- *
- * We need this because DROP TABLESPACE cannot check whether the target
- * tablespace is the default tablespace for any schemas. (It could check
- * in the current database, but that doesn't seem very helpful.) Subsequent
- * attempts to create tables in that tablespace will fail. This code just
- * exists to ensure that we give a helpful error message.
- */
-static void
-check_tablespace_exists(Oid tablespaceId, Oid namespaceId)
-{
- Relation pg_tablespace;
- ScanKeyData entry[1];
- HeapScanDesc scan;
- HeapTuple tuple;
-
- /* There's no syscache for pg_tablespace, so must look the hard way */
- pg_tablespace = heap_openr(TableSpaceRelationName, AccessShareLock);
- ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber,
- BTEqualStrategyNumber, F_OIDEQ,
- ObjectIdGetDatum(tablespaceId));
- scan = heap_beginscan(pg_tablespace, SnapshotNow, 1, entry);
- tuple = heap_getnext(scan, ForwardScanDirection);
- if (!HeapTupleIsValid(tuple))
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("tablespace with OID %u does not exist",
- tablespaceId),
- errdetail("The default tablespace for schema \"%s\" has been dropped.",
- get_namespace_name(namespaceId))));
- heap_endscan(scan);
- heap_close(pg_tablespace, AccessShareLock);
-}
-
/*
* This code supports
* tablespace.c
* Commands to manipulate table spaces
*
- *
* Tablespaces in PostgreSQL are designed to allow users to determine
* where the data file(s) for a given database object reside on the file
* system.
* $PGDATA/global/relfilenode
* $PGDATA/base/dboid/relfilenode
*
- * The implementation is designed to be backwards compatible. For this reason
- * (and also as a feature unto itself) when a user creates an object without
- * specifying a tablespace, we look at the object's parent and place
- * the object in the parent's tablespace. The hierarchy is as follows:
- * database > schema > table > index
- *
* To allow CREATE DATABASE to give a new database a default tablespace
* that's different from the template database's default, we make the
* provision that a zero in pg_class.reltablespace means the database's
* default tablespace. Without this, CREATE DATABASE would have to go in
- * and munge the system catalogs of the new database. This special meaning
- * of zero also applies in pg_namespace.nsptablespace.
+ * and munge the system catalogs of the new database.
*
*
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/tablespace.c,v 1.13 2004/11/05 17:11:05 petere Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/tablespace.c,v 1.14 2004/11/05 19:15:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
+#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
+/* GUC variable */
+char *default_tablespace = NULL;
+
+
static bool remove_tablespace_directories(Oid tablespaceoid, bool redo);
static void set_short_version(const char *path);
return true;
}
-/*
- * get_tablespace_oid - given a tablespace name, look up the OID
- *
- * Returns InvalidOid if tablespace name not found.
- */
-Oid
-get_tablespace_oid(const char *tablespacename)
-{
- Oid result;
- Relation rel;
- HeapScanDesc scandesc;
- HeapTuple tuple;
- ScanKeyData entry[1];
-
- /* Search pg_tablespace */
- rel = heap_openr(TableSpaceRelationName, AccessShareLock);
-
- ScanKeyInit(&entry[0],
- Anum_pg_tablespace_spcname,
- BTEqualStrategyNumber, F_NAMEEQ,
- CStringGetDatum(tablespacename));
- scandesc = heap_beginscan(rel, SnapshotNow, 1, entry);
- tuple = heap_getnext(scandesc, ForwardScanDirection);
-
- if (HeapTupleIsValid(tuple))
- result = HeapTupleGetOid(tuple);
- else
- result = InvalidOid;
-
- heap_endscan(scandesc);
- heap_close(rel, AccessShareLock);
-
- return result;
-}
-
-/*
- * get_tablespace_name - given a tablespace OID, look up the name
- *
- * Returns a palloc'd string, or NULL if no such tablespace.
- */
-char *
-get_tablespace_name(Oid spc_oid)
-{
- char *result;
- Relation rel;
- HeapScanDesc scandesc;
- HeapTuple tuple;
- ScanKeyData entry[1];
-
- /* Search pg_tablespace */
- rel = heap_openr(TableSpaceRelationName, AccessShareLock);
-
- ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber,
- BTEqualStrategyNumber, F_OIDEQ,
- ObjectIdGetDatum(spc_oid));
- scandesc = heap_beginscan(rel, SnapshotNow, 1, entry);
- tuple = heap_getnext(scandesc, ForwardScanDirection);
-
- /* We assume that there can be at most one matching tuple */
- if (HeapTupleIsValid(tuple))
- result = pstrdup(NameStr(((Form_pg_tablespace) GETSTRUCT(tuple))->spcname));
- else
- result = NULL;
-
- heap_endscan(scandesc);
- heap_close(rel, AccessShareLock);
-
- return result;
-}
-
/*
* Rename a tablespace
*/
heap_close(rel, NoLock);
}
+
+/*
+ * Routines for handling the GUC variable 'default_tablespace'.
+ */
+
+/* assign_hook: validate new default_tablespace, do extra actions as needed */
+const char *
+assign_default_tablespace(const char *newval, bool doit, GucSource source)
+{
+ /*
+ * If we aren't inside a transaction, we cannot do database access so
+ * cannot verify the name. Must accept the value on faith.
+ */
+ if (IsTransactionState())
+ {
+ if (newval[0] != '\0' &&
+ !OidIsValid(get_tablespace_oid(newval)))
+ {
+ if (source >= PGC_S_INTERACTIVE)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("tablespace \"%s\" does not exist",
+ newval)));
+ return NULL;
+ }
+ }
+
+ return newval;
+}
+
+/*
+ * GetDefaultTablespace -- get the OID of the current default tablespace
+ *
+ * May return InvalidOid to indicate "use the database's default tablespace"
+ *
+ * This exists to hide (and possibly optimize the use of) the
+ * default_tablespace GUC variable.
+ */
+Oid
+GetDefaultTablespace(void)
+{
+ Oid result;
+
+ /* Fast path for default_tablespace == "" */
+ if (default_tablespace == NULL || default_tablespace[0] == '\0')
+ return InvalidOid;
+ /*
+ * It is tempting to cache this lookup for more speed, but then we would
+ * fail to detect the case where the tablespace was dropped since the
+ * GUC variable was set. Note also that we don't complain if the value
+ * fails to refer to an existing tablespace; we just silently return
+ * InvalidOid, causing the new object to be created in the database's
+ * tablespace.
+ */
+ result = get_tablespace_oid(default_tablespace);
+ /*
+ * Allow explicit specification of database's default tablespace in
+ * default_tablespace without triggering permissions checks.
+ */
+ if (result == MyDatabaseTableSpace)
+ result = InvalidOid;
+ return result;
+}
+
+
+/*
+ * get_tablespace_oid - given a tablespace name, look up the OID
+ *
+ * Returns InvalidOid if tablespace name not found.
+ */
+Oid
+get_tablespace_oid(const char *tablespacename)
+{
+ Oid result;
+ Relation rel;
+ HeapScanDesc scandesc;
+ HeapTuple tuple;
+ ScanKeyData entry[1];
+
+ /* Search pg_tablespace */
+ rel = heap_openr(TableSpaceRelationName, AccessShareLock);
+
+ ScanKeyInit(&entry[0],
+ Anum_pg_tablespace_spcname,
+ BTEqualStrategyNumber, F_NAMEEQ,
+ CStringGetDatum(tablespacename));
+ scandesc = heap_beginscan(rel, SnapshotNow, 1, entry);
+ tuple = heap_getnext(scandesc, ForwardScanDirection);
+
+ if (HeapTupleIsValid(tuple))
+ result = HeapTupleGetOid(tuple);
+ else
+ result = InvalidOid;
+
+ heap_endscan(scandesc);
+ heap_close(rel, AccessShareLock);
+
+ return result;
+}
+
+/*
+ * get_tablespace_name - given a tablespace OID, look up the name
+ *
+ * Returns a palloc'd string, or NULL if no such tablespace.
+ */
+char *
+get_tablespace_name(Oid spc_oid)
+{
+ char *result;
+ Relation rel;
+ HeapScanDesc scandesc;
+ HeapTuple tuple;
+ ScanKeyData entry[1];
+
+ /* Search pg_tablespace */
+ rel = heap_openr(TableSpaceRelationName, AccessShareLock);
+
+ ScanKeyInit(&entry[0],
+ ObjectIdAttributeNumber,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(spc_oid));
+ scandesc = heap_beginscan(rel, SnapshotNow, 1, entry);
+ tuple = heap_getnext(scandesc, ForwardScanDirection);
+
+ /* We assume that there can be at most one matching tuple */
+ if (HeapTupleIsValid(tuple))
+ result = pstrdup(NameStr(((Form_pg_tablespace) GETSTRUCT(tuple))->spcname));
+ else
+ result = NULL;
+
+ heap_endscan(scandesc);
+ heap_close(rel, AccessShareLock);
+
+ return result;
+}
+
+
/*
* TABLESPACE resource manager's routines
*/
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.292 2004/08/29 05:06:43 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.293 2004/11/05 19:15:59 tgl Exp $
*
*-------------------------------------------------------------------------
*/
COPY_STRING_FIELD(schemaname);
COPY_STRING_FIELD(authid);
- COPY_STRING_FIELD(tablespacename);
COPY_NODE_FIELD(schemaElts);
return newnode;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.231 2004/08/29 05:06:43 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.232 2004/11/05 19:15:59 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
COMPARE_STRING_FIELD(schemaname);
COMPARE_STRING_FIELD(authid);
- COMPARE_STRING_FIELD(tablespacename);
COMPARE_NODE_FIELD(schemaElts);
return true;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.478 2004/10/01 16:39:59 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.479 2004/11/05 19:16:02 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
*****************************************************************************/
CreateSchemaStmt:
- CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptTableSpace OptSchemaEltList
+ CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
/* One can omit the schema name or the authorization id. */
else
n->schemaname = $5;
n->authid = $5;
- n->tablespacename = $6;
- n->schemaElts = $7;
+ n->schemaElts = $6;
$$ = (Node *)n;
}
- | CREATE SCHEMA ColId OptTableSpace OptSchemaEltList
+ | CREATE SCHEMA ColId OptSchemaEltList
{
CreateSchemaStmt *n = makeNode(CreateSchemaStmt);
/* ...but not both */
n->schemaname = $3;
n->authid = NULL;
- n->tablespacename = $4;
- n->schemaElts = $5;
+ n->schemaElts = $4;
$$ = (Node *)n;
}
;
* back to source text
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.184 2004/10/27 18:09:38 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.185 2004/11/05 19:16:11 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
#include "catalog/pg_operator.h"
#include "catalog/pg_shadow.h"
#include "catalog/pg_trigger.h"
-#include "commands/tablespace.h"
#include "executor/spi.h"
#include "lib/stringinfo.h"
#include "miscadmin.h"
int prettyFlags);
static char *pg_get_expr_worker(text *expr, Oid relid, char *relname,
int prettyFlags);
-static Oid get_constraint_index(Oid constraintRelOid, Oid constraintOid);
static void make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
int prettyFlags);
static void make_viewdef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
{
appendStringInfoChar(&buf, ')');
- /*
- * If the index is in a different tablespace from its parent, tell
- * about that
- */
- if (idxrelrec->reltablespace != get_rel_tablespace(indrelid))
- {
- char *spcname;
-
- if (OidIsValid(idxrelrec->reltablespace))
- spcname = get_tablespace_name(idxrelrec->reltablespace);
- else
- spcname = get_tablespace_name(MyDatabaseTableSpace);
-
- if (spcname) /* just paranoia... */
- {
- appendStringInfo(&buf, " TABLESPACE %s",
- quote_identifier(spcname));
- pfree(spcname);
- }
- }
-
/*
* If it's a partial index, decompile and append the predicate
*/
{
Datum val;
bool isnull;
- Oid indexOid;
/* Start off the constraint definition */
if (conForm->contype == CONSTRAINT_PRIMARY)
decompile_column_index_array(val, conForm->conrelid, &buf);
appendStringInfo(&buf, ")");
-
- /* Add TABLESPACE if it's not default */
- indexOid = get_constraint_index(RelationGetRelid(conDesc),
- constraintId);
- if (OidIsValid(indexOid))
- {
- Oid reltablespace;
- Oid indtablespace;
-
- reltablespace = get_rel_tablespace(conForm->conrelid);
- indtablespace = get_rel_tablespace(indexOid);
- if (OidIsValid(indtablespace) &&
- indtablespace != reltablespace)
- {
- char *spcname = get_tablespace_name(indtablespace);
-
- if (spcname) /* just paranoia... */
- {
- appendStringInfo(&buf, " USING INDEX TABLESPACE %s",
- quote_identifier(spcname));
- pfree(spcname);
- }
- }
- }
break;
}
case CONSTRAINT_CHECK:
PG_RETURN_NULL();
}
-/*
- * get_constraint_index
- * Given the OID of a unique or primary-key constraint,
- * look up the OID of the underlying index.
- *
- * We make the caller pass in the OID of pg_constraint, too, simply because
- * it's probably got it at hand already.
- *
- * Returns InvalidOid if index can't be found.
- */
-static Oid
-get_constraint_index(Oid constraintRelOid, Oid constraintOid)
-{
- Oid result = InvalidOid;
- Relation depRel;
- ScanKeyData key[3];
- SysScanDesc scan;
- HeapTuple tup;
-
- /* Search the dependency table for the dependent index */
- depRel = heap_openr(DependRelationName, AccessShareLock);
-
- ScanKeyInit(&key[0],
- Anum_pg_depend_refclassid,
- BTEqualStrategyNumber, F_OIDEQ,
- ObjectIdGetDatum(constraintRelOid));
- ScanKeyInit(&key[1],
- Anum_pg_depend_refobjid,
- BTEqualStrategyNumber, F_OIDEQ,
- ObjectIdGetDatum(constraintOid));
- ScanKeyInit(&key[2],
- Anum_pg_depend_refobjsubid,
- BTEqualStrategyNumber, F_INT4EQ,
- Int32GetDatum(0));
-
- scan = systable_beginscan(depRel, DependReferenceIndex, true,
- SnapshotNow, 3, key);
-
- while (HeapTupleIsValid(tup = systable_getnext(scan)))
- {
- Form_pg_depend deprec = (Form_pg_depend) GETSTRUCT(tup);
-
- /*
- * We assume any internal dependency of a relation on the
- * constraint must be what we are looking for.
- */
- if (deprec->classid == RelOid_pg_class &&
- deprec->objsubid == 0 &&
- deprec->deptype == DEPENDENCY_INTERNAL)
- {
- result = deprec->objid;
- break;
- }
- }
-
- systable_endscan(scan);
- heap_close(depRel, AccessShareLock);
-
- return result;
-}
-
/* ----------
* deparse_expression - General utility for deparsing expressions
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/cache/lsyscache.c,v 1.117 2004/10/20 16:04:49 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/cache/lsyscache.c,v 1.118 2004/11/05 19:16:14 tgl Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
return InvalidOid;
}
-/*
- * get_rel_tablespace
- * Returns the pg_tablespace OID associated with a given relation.
- *
- * Note: failure return is InvalidOid, which cannot be distinguished from
- * "default tablespace for this database", but that seems OK.
- */
-Oid
-get_rel_tablespace(Oid relid)
-{
- HeapTuple tp;
-
- tp = SearchSysCache(RELOID,
- ObjectIdGetDatum(relid),
- 0, 0, 0);
- if (HeapTupleIsValid(tp))
- {
- Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
- Oid result;
-
- result = reltup->reltablespace;
- ReleaseSysCache(tp);
- return result;
- }
- else
- return InvalidOid;
-}
-
/*
* get_rel_type_id
*
return NULL;
}
-/*
- * get_namespace_tablespace
- * Returns the default tablespace of a given namespace
- *
- * Note: failure return is InvalidOid, which cannot be distinguished from
- * "default tablespace for this database", but that seems OK.
- */
-Oid
-get_namespace_tablespace(Oid nspid)
-{
- HeapTuple tp;
-
- tp = SearchSysCache(NAMESPACEOID,
- ObjectIdGetDatum(nspid),
- 0, 0, 0);
- if (HeapTupleIsValid(tp))
- {
- Form_pg_namespace nsptup = (Form_pg_namespace) GETSTRUCT(tp);
- Oid result;
-
- result = nsptup->nsptablespace;
- ReleaseSysCache(tp);
- return result;
- }
- else
- return InvalidOid;
-}
-
/* ---------- PG_SHADOW CACHE ---------- */
/*
* Written by Peter Eisentraut
. *
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.247 2004/11/04 19:08:42 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/misc/guc.c,v 1.248 2004/11/05 19:16:16 tgl Exp $
*
*--------------------------------------------------------------------
*/
extern int CommitDelay;
extern int CommitSiblings;
extern int DebugSharedBuffers;
+extern char *default_tablespace;
static const char *assign_log_destination(const char *value,
bool doit, GucSource source);
"ISO, MDY", assign_datestyle, NULL
},
+ {
+ {"default_tablespace", PGC_USERSET, CLIENT_CONN_STATEMENT,
+ gettext_noop("Sets the default tablespace to create tables and indexes in."),
+ gettext_noop("An empty string selects the database's default tablespace.")
+ },
+ &default_tablespace,
+ "", assign_default_tablespace, NULL
+ },
+
{
{"default_transaction_isolation", PGC_USERSET, CLIENT_CONN_STATEMENT,
gettext_noop("Sets the transaction isolation level of each new transaction."),
# - Statement Behavior -
#search_path = '$user,public' # schema names
+#default_tablespace = '' # a tablespace name, or '' for default
#check_function_bodies = true
#default_transaction_isolation = 'read committed'
#default_transaction_read_only = false
* by PostgreSQL
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.c,v 1.390 2004/10/22 16:04:35 petere Exp $
+ * $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.c,v 1.391 2004/11/05 19:16:19 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static NamespaceInfo *g_namespaces;
static int g_numNamespaces;
-/* need the name of the database's default tablespace */
-static char *dbDefaultTableSpace;
-
/* flag to turn on/off dollar quoting */
static int disable_dollar_quoting = 0;
encoding = PQgetvalue(res, 0, i_encoding);
tablespace = PQgetvalue(res, 0, i_tablespace);
- /* save dattablespace name for later dump routines */
- dbDefaultTableSpace = strdup(tablespace);
-
appendPQExpBuffer(creaQry, "CREATE DATABASE %s WITH TEMPLATE = template0",
fmtId(datname));
if (strlen(encoding) > 0)
int i_oid;
int i_nspname;
int i_usename;
- int i_nsptablespace;
int i_nspacl;
/*
nsinfo[0].dobj.name = strdup("public");
nsinfo[0].usename = strdup("");
nsinfo[0].nspacl = strdup("");
- nsinfo[0].nsptablespace = strdup("");
selectDumpableNamespace(&nsinfo[0]);
nsinfo[1].dobj.name = strdup("pg_catalog");
nsinfo[1].usename = strdup("");
nsinfo[1].nspacl = strdup("");
- nsinfo[0].nsptablespace = strdup("");
selectDumpableNamespace(&nsinfo[1]);
* we fetch all namespaces including system ones, so that every object
* we read in can be linked to a containing namespace.
*/
- if (g_fout->remoteVersion >= 80000)
- {
- appendPQExpBuffer(query, "SELECT tableoid, oid, nspname, "
- "(select usename from pg_user where nspowner = usesysid) as usename, "
- "nspacl, "
- "(SELECT spcname FROM pg_tablespace t WHERE t.oid = nsptablespace) AS nsptablespace "
- "FROM pg_namespace");
- }
- else
- {
- appendPQExpBuffer(query, "SELECT tableoid, oid, nspname, "
- "(select usename from pg_user where nspowner = usesysid) as usename, "
- "nspacl, NULL AS nsptablespace "
- "FROM pg_namespace");
- }
+ appendPQExpBuffer(query, "SELECT tableoid, oid, nspname, "
+ "(select usename from pg_user where nspowner = usesysid) as usename, "
+ "nspacl FROM pg_namespace");
res = PQexec(g_conn, query->data);
check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
i_nspname = PQfnumber(res, "nspname");
i_usename = PQfnumber(res, "usename");
i_nspacl = PQfnumber(res, "nspacl");
- i_nsptablespace = PQfnumber(res, "nsptablespace");
for (i = 0; i < ntups; i++)
{
nsinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_nspname));
nsinfo[i].usename = strdup(PQgetvalue(res, i, i_usename));
nsinfo[i].nspacl = strdup(PQgetvalue(res, i, i_nspacl));
- nsinfo[i].nsptablespace = strdup(PQgetvalue(res, i, i_nsptablespace));
/* Decide whether to dump this namespace */
selectDumpableNamespace(&nsinfo[i]);
*/
appendPQExpBuffer(delq, "DROP SCHEMA %s;\n", qnspname);
- appendPQExpBuffer(q, "CREATE SCHEMA %s AUTHORIZATION %s",
+ appendPQExpBuffer(q, "CREATE SCHEMA %s AUTHORIZATION %s;\n",
qnspname, fmtId(nspinfo->usename));
- /* Add tablespace qualifier, if not default for database */
- if (strlen(nspinfo->nsptablespace) != 0)
- appendPQExpBuffer(q, " TABLESPACE %s",
- fmtId(nspinfo->nsptablespace));
-
- appendPQExpBuffer(q, ";\n");
-
ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
nspinfo->dobj.name,
NULL, strcmp(nspinfo->dobj.name, "public") == 0 ? nspinfo->usename : "",
appendPQExpBuffer(q, ")");
}
- /* Output tablespace clause if different from parent schema's */
- if (strcmp(tbinfo->reltablespace,
- tbinfo->dobj.namespace->nsptablespace) != 0)
- {
- if (strlen(tbinfo->reltablespace) != 0)
- appendPQExpBuffer(q, " TABLESPACE %s",
- fmtId(tbinfo->reltablespace));
- else if (strlen(dbDefaultTableSpace) != 0)
- appendPQExpBuffer(q, " TABLESPACE %s",
- fmtId(dbDefaultTableSpace));
- }
+ /* Output tablespace clause if not database's default */
+ if (strlen(tbinfo->reltablespace) != 0)
+ appendPQExpBuffer(q, " TABLESPACE %s",
+ fmtId(tbinfo->reltablespace));
appendPQExpBuffer(q, ";\n");
appendPQExpBuffer(q, ")");
- /* Output tablespace clause if different from parent table's */
- if (strcmp(indxinfo->tablespace,
- indxinfo->indextable->reltablespace) != 0)
- {
- if (strlen(indxinfo->tablespace) != 0)
- appendPQExpBuffer(q, " USING INDEX TABLESPACE %s",
- fmtId(indxinfo->tablespace));
- else if (strlen(dbDefaultTableSpace) != 0)
- appendPQExpBuffer(q, " USING INDEX TABLESPACE %s",
- fmtId(dbDefaultTableSpace));
- }
+ /* Output tablespace clause if not database's default */
+ if (strlen(indxinfo->tablespace) != 0)
+ appendPQExpBuffer(q, " USING INDEX TABLESPACE %s",
+ fmtId(indxinfo->tablespace));
appendPQExpBuffer(q, ";\n");
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.h,v 1.112 2004/08/29 05:06:53 momjian Exp $
+ * $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.h,v 1.113 2004/11/05 19:16:19 tgl Exp $
*
*-------------------------------------------------------------------------
*/
DumpableObject dobj;
char *usename; /* name of owner, or empty string */
char *nspacl;
- char *nsptablespace; /* default tablespace */
bool dump; /* true if need to dump definition */
} NamespaceInfo;
*
* Copyright (c) 2000-2004, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/bin/psql/describe.c,v 1.108 2004/10/12 21:54:44 petere Exp $
+ * $PostgreSQL: pgsql/src/bin/psql/describe.c,v 1.109 2004/11/05 19:16:21 tgl Exp $
*/
#include "postgres_fe.h"
#include "describe.h"
PGresult *res;
printQueryOpt myopt = pset.popt;
- if (pset.sversion < 70500)
+ if (pset.sversion < 80000)
{
fprintf(stderr, _("The server version (%d) does not support tablespaces.\n"),
pset.sversion);
"SELECT relhasindex, relkind, relchecks, reltriggers, relhasrules, \n"
"relhasoids %s \n"
"FROM pg_catalog.pg_class WHERE oid = '%s'",
- pset.sversion >= 70500 ? ", reltablespace" : "",
+ pset.sversion >= 80000 ? ", reltablespace" : "",
oid);
res = PSQLexec(buf.data, false);
if (!res)
tableinfo.hasindex = strcmp(PQgetvalue(res, 0, 0), "t") == 0;
tableinfo.hasrules = strcmp(PQgetvalue(res, 0, 4), "t") == 0;
tableinfo.hasoids = strcmp(PQgetvalue(res, 0, 5), "t") == 0;
- tableinfo.tablespace = (pset.sversion >= 70500) ?
+ tableinfo.tablespace = (pset.sversion >= 80000) ?
atooid(PQgetvalue(res, 0, 6)) : 0;
PQclear(res);
*
* Copyright (c) 2000-2004, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/bin/psql/tab-complete.c,v 1.117 2004/11/02 16:10:05 petere Exp $
+ * $PostgreSQL: pgsql/src/bin/psql/tab-complete.c,v 1.118 2004/11/05 19:16:22 tgl Exp $
*/
/*----------------------------------------------------------------------
"debug_print_plan",
"debug_print_rewritten",
"default_statistics_target",
+ "default_tablespace",
"default_transaction_isolation",
"default_transaction_read_only",
"default_with_oids",
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/catalog/catversion.h,v 1.251 2004/10/11 17:24:40 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/catalog/catversion.h,v 1.252 2004/11/05 19:16:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
/* yyyymmddN */
-#define CATALOG_VERSION_NO 200410111
+#define CATALOG_VERSION_NO 200411041
#endif
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/catalog/pg_namespace.h,v 1.14 2004/08/29 05:06:55 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/catalog/pg_namespace.h,v 1.15 2004/11/05 19:16:33 tgl Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
{
NameData nspname;
int4 nspowner;
- Oid nsptablespace; /* default table space for name space */
aclitem nspacl[1]; /* VARIABLE LENGTH FIELD */
} FormData_pg_namespace;
* ----------------
*/
-#define Natts_pg_namespace 4
+#define Natts_pg_namespace 3
#define Anum_pg_namespace_nspname 1
#define Anum_pg_namespace_nspowner 2
-#define Anum_pg_namespace_nsptablespace 3
-#define Anum_pg_namespace_nspacl 4
+#define Anum_pg_namespace_nspacl 3
/* ----------------
* ---------------
*/
-DATA(insert OID = 11 ( "pg_catalog" PGUID 0 _null_ ));
+DATA(insert OID = 11 ( "pg_catalog" PGUID _null_ ));
DESCR("System catalog schema");
#define PG_CATALOG_NAMESPACE 11
-DATA(insert OID = 99 ( "pg_toast" PGUID 0 _null_ ));
+DATA(insert OID = 99 ( "pg_toast" PGUID _null_ ));
DESCR("Reserved schema for TOAST tables");
#define PG_TOAST_NAMESPACE 99
-DATA(insert OID = 2200 ( "public" PGUID 0 _null_ ));
+DATA(insert OID = 2200 ( "public" PGUID _null_ ));
DESCR("Standard public schema");
#define PG_PUBLIC_NAMESPACE 2200
/*
* prototypes for functions in pg_namespace.c
*/
-extern Oid NamespaceCreate(const char *nspName, int32 ownerSysId,
- Oid nspTablespace);
+extern Oid NamespaceCreate(const char *nspName, int32 ownerSysId);
#endif /* PG_NAMESPACE_H */
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/commands/tablespace.h,v 1.6 2004/10/17 20:47:21 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/commands/tablespace.h,v 1.7 2004/11/05 19:16:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Oid ts_id;
} xl_tblspc_drop_rec;
+
extern void CreateTableSpace(CreateTableSpaceStmt *stmt);
extern void DropTableSpace(DropTableSpaceStmt *stmt);
extern void RenameTableSpace(const char *oldname, const char *newname);
extern void TablespaceCreateDbspace(Oid spcNode, Oid dbNode, bool isRedo);
+extern Oid GetDefaultTablespace(void);
+
extern Oid get_tablespace_oid(const char *tablespacename);
extern char *get_tablespace_name(Oid spc_oid);
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/nodes/parsenodes.h,v 1.269 2004/08/29 05:06:57 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/parsenodes.h,v 1.270 2004/11/05 19:16:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
NodeTag type;
char *schemaname; /* the name of the schema to create */
char *authid; /* the owner of the created schema */
- char *tablespacename; /* default tablespace for schema, or NULL */
List *schemaElts; /* schema components (list of parsenodes) */
} CreateSchemaStmt;
* Copyright (c) 2000-2004, PostgreSQL Global Development Group
* Written by Peter Eisentraut
. *
- * $PostgreSQL: pgsql/src/include/utils/guc.h,v 1.54 2004/10/22 19:48:19 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/utils/guc.h,v 1.55 2004/11/05 19:16:41 tgl Exp $
*--------------------------------------------------------------------
*/
#ifndef GUC_H
/* in utils/adt/datetime.c */
extern bool ClearDateCache(bool newval, bool doit, GucSource source);
+/* in commands/tablespace.c */
+extern const char *assign_default_tablespace(const char *newval,
+ bool doit, GucSource source);
+
/* in utils/adt/regexp.c */
extern const char *assign_regex_flavor(const char *value,
bool doit, GucSource source);
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/utils/lsyscache.h,v 1.91 2004/10/20 16:04:50 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/utils/lsyscache.h,v 1.92 2004/11/05 19:16:41 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern Oid get_system_catalog_relid(const char *catname);
extern char *get_rel_name(Oid relid);
extern Oid get_rel_namespace(Oid relid);
-extern Oid get_rel_tablespace(Oid relid);
extern Oid get_rel_type_id(Oid relid);
extern char get_rel_relkind(Oid relid);
extern bool get_typisdefined(Oid typid);
Datum *values, int nvalues,
float4 *numbers, int nnumbers);
extern char *get_namespace_name(Oid nspid);
-extern Oid get_namespace_tablespace(Oid nspid);
extern int32 get_usesysid(const char *username);
#define is_array_type(typid) (get_element_type(typid) != InvalidOid)
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/preproc.y,v 1.299 2004/11/01 13:17:12 davec Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/preproc.y,v 1.300 2004/11/05 19:16:43 tgl Exp $ */
/* Copyright comment */
%{
*
*****************************************************************************/
-CreateSchemaStmt: CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptTableSpace OptSchemaEltList
- { $$ = cat_str(6, make_str("create schema"), $3, make_str("authorization"), $5, $6, $7); }
- | CREATE SCHEMA ColId OptTableSpace OptSchemaEltList
- { $$ = cat_str(4, make_str("create schema"), $3, $4, $5); }
+CreateSchemaStmt: CREATE SCHEMA OptSchemaName AUTHORIZATION UserId OptSchemaEltList
+ { $$ = cat_str(5, make_str("create schema"), $3, make_str("authorization"), $5, $6); }
+ | CREATE SCHEMA ColId OptSchemaEltList
+ { $$ = cat_str(3, make_str("create schema"), $3, $4); }
;
OptSchemaName: ColId { $$ = $1; }
-- create a tablespace we can use
CREATE TABLESPACE testspace LOCATION '@testtablespace@';
--- create a schema in the tablespace
-CREATE SCHEMA testschema TABLESPACE testspace;
-
--- sanity check
-SELECT nspname, spcname FROM pg_catalog.pg_tablespace t, pg_catalog.pg_namespace n
- where n.nsptablespace = t.oid and n.nspname = 'testschema';
+-- create a schema we can use
+CREATE SCHEMA testschema;
-- try a table
-CREATE TABLE testschema.foo (i int);
+CREATE TABLE testschema.foo (i int) TABLESPACE testspace;
SELECT relname, spcname FROM pg_catalog.pg_tablespace t, pg_catalog.pg_class c
where c.reltablespace = t.oid AND c.relname = 'foo';
INSERT INTO testschema.foo VALUES(2);
-- index
-CREATE INDEX foo_idx on testschema.foo(i);
+CREATE INDEX foo_idx on testschema.foo(i) TABLESPACE testspace;
SELECT relname, spcname FROM pg_catalog.pg_tablespace t, pg_catalog.pg_class c
where c.reltablespace = t.oid AND c.relname = 'foo_idx';
-- create a tablespace we can use
CREATE TABLESPACE testspace LOCATION '@testtablespace@';
--- create a schema in the tablespace
-CREATE SCHEMA testschema TABLESPACE testspace;
--- sanity check
-SELECT nspname, spcname FROM pg_catalog.pg_tablespace t, pg_catalog.pg_namespace n
- where n.nsptablespace = t.oid and n.nspname = 'testschema';
- nspname | spcname
-------------+-----------
- testschema | testspace
-(1 row)
-
+-- create a schema we can use
+CREATE SCHEMA testschema;
-- try a table
-CREATE TABLE testschema.foo (i int);
+CREATE TABLE testschema.foo (i int) TABLESPACE testspace;
SELECT relname, spcname FROM pg_catalog.pg_tablespace t, pg_catalog.pg_class c
where c.reltablespace = t.oid AND c.relname = 'foo';
relname | spcname
INSERT INTO testschema.foo VALUES(1);
INSERT INTO testschema.foo VALUES(2);
-- index
-CREATE INDEX foo_idx on testschema.foo(i);
+CREATE INDEX foo_idx on testschema.foo(i) TABLESPACE testspace;
SELECT relname, spcname FROM pg_catalog.pg_tablespace t, pg_catalog.pg_class c
where c.reltablespace = t.oid AND c.relname = 'foo_idx';
relname | spcname
projects / postgresql.git / commitdiff