<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/allfiles.sgml,v 1.39 2002/04/25 21:47:07 tgl Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/allfiles.sgml,v 1.40 2002/07/18 16:47:22 tgl Exp $
PostgreSQL documentation
Complete list of usable sgml source files in this directory.
-->
<!entity dropLanguage system "drop_language.sgml">
<!entity dropOperator system "drop_operator.sgml">
<!entity dropRule system "drop_rule.sgml">
+<!entity dropSchema system "drop_schema.sgml">
<!entity dropSequence system "drop_sequence.sgml">
<!entity dropTable system "drop_table.sgml">
<!entity dropTrigger system "drop_trigger.sgml">
--- /dev/null
+<!--
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/drop_schema.sgml,v 1.1 2002/07/18 16:47:22 tgl Exp $
+PostgreSQL documentation
+-->
+
+<refentry id="SQL-DROPSCHEMA">
+ <refmeta>
+ <refentrytitle id="SQL-DROPSCHEMA-TITLE">DROP SCHEMA</refentrytitle>
+ <refmiscinfo>SQL - Language Statements</refmiscinfo>
+ </refmeta>
+ <refnamediv>
+ <refname>
+ DROP SCHEMA
+ </refname>
+ <refpurpose>
+ remove a schema
+ </refpurpose>
+ </refnamediv>
+ <refsynopsisdiv>
+ <refsynopsisdivinfo>
+ <date>2002-07-18</date>
+ </refsynopsisdivinfo>
+ <synopsis>
+DROP SCHEMA <replaceable class="PARAMETER">name</replaceable> [, ...] [ CASCADE | RESTRICT ]
+
+ </synopsis>
+
+ <refsect2 id="R2-SQL-DROPSCHEMA-1">
+ <refsect2info>
+ <date>2002-07-18</date>
+ </refsect2info>
+ <title>
+ Inputs
+ </title>
+ <para>
+ <variablelist>
+ <varlistentry>
+ <term><replaceable class="PARAMETER">name</replaceable></term>
+ <listitem>
+ <para>
+ The name of a schema.
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>CASCADE</term>
+ <listitem>
+ <para>
+ Automatically drop objects (tables, functions, etc) that are contained
+ in the schema.
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>RESTRICT</term>
+ <listitem>
+ <para>
+ Refuse to drop the schema if it contains any objects.
+ This is the default.
+ </para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+ </para>
+ </refsect2>
+
+ <refsect2 id="R2-SQL-DROPSCHEMA-2">
+ <refsect2info>
+ <date>2002-07-18</date>
+ </refsect2info>
+ <title>
+ Outputs
+ </title>
+ <para>
+
+ <variablelist>
+ <varlistentry>
+ <term><computeroutput>
+DROP SCHEMA
+ </computeroutput></term>
+ <listitem>
+ <para>
+ The message returned if the schema is successfully dropped.
+ </para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term><computeroutput>
+ERROR: Schema "<replaceable class="parameter">name</replaceable>" does not exist
+ </computeroutput></term>
+ <listitem>
+ <para>
+ This message occurs if the specified schema does not exist.
+ </para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+
+ </para>
+ </refsect2>
+ </refsynopsisdiv>
+
+ <refsect1 id="R1-SQL-DROPSCHEMA-1">
+ <refsect1info>
+ <date>2002-07-18</date>
+ </refsect1info>
+ <title>
+ Description
+ </title>
+ <para>
+ <command>DROP SCHEMA</command> removes schemas from the data base.
+ </para>
+
+ <para>
+ A schema can only be dropped by its owner or a superuser. Note that
+ the owner can drop the schema (and thereby all contained objects)
+ even if he does not own some of the objects within the schema.
+ </para>
+
+ <refsect2 id="R2-SQL-DROPSCHEMA-3">
+ <refsect2info>
+ <date>2002-07-18</date>
+ </refsect2info>
+ <title>
+ Notes
+ </title>
+ <para>
+ Refer to the <command>CREATE SCHEMA</command> statement for
+ information on how to create a schema.
+ </para>
+ </refsect2>
+ </refsect1>
+
+ <refsect1 id="R1-SQL-DROPSCHEMA-2">
+ <title>
+ Usage
+ </title>
+ <para>
+ To remove schema <literal>mystuff</literal> from the database,
+ along with everything it contains:
+
+ <programlisting>
+DROP SCHEMA mystuff CASCADE;
+ </programlisting>
+ </para>
+ </refsect1>
+
+ <refsect1 id="R1-SQL-DROPSCHEMA-3">
+ <title>
+ Compatibility
+ </title>
+
+ <refsect2 id="R2-SQL-DROPSCHEMA-4">
+ <refsect2info>
+ <date>2002-07-18</date>
+ </refsect2info>
+ <title>
+ SQL92
+ </title>
+ <para>
+ <command>DROP SCHEMA</command> is fully compatible with
+ <acronym>SQL92</acronym>, except that the standard only allows
+ one schema to be dropped per command.
+ </para>
+ </refsect2>
+ </refsect1>
+</refentry>
+
+<!-- Keep this comment at the end of the file
+Local variables:
+mode: sgml
+sgml-omittag:nil
+sgml-shorttag:t
+sgml-minimize-attributes:nil
+sgml-always-quote-attributes:t
+sgml-indent-step:1
+sgml-indent-data:t
+sgml-parent-document:nil
+sgml-default-dtd-file:"../reference.ced"
+sgml-exposed-tags:nil
+sgml-local-catalogs:"/usr/lib/sgml/catalog"
+sgml-local-ecat-files:nil
+End:
+-->
<!-- reference.sgml
-$Header: /cvsroot/pgsql/doc/src/sgml/reference.sgml,v 1.28 2002/04/25 21:47:06 tgl Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/reference.sgml,v 1.29 2002/07/18 16:47:22 tgl Exp $
PostgreSQL Reference Manual
-->
&dropLanguage;
&dropOperator;
&dropRule;
+ &dropSchema;
&dropSequence;
&dropTable;
&dropTrigger;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/dependency.c,v 1.3 2002/07/16 05:53:33 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/dependency.c,v 1.4 2002/07/18 16:47:22 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_constraint.h"
#include "catalog/pg_depend.h"
#include "catalog/pg_language.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_rewrite.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_type.h"
#include "commands/comment.h"
#include "commands/defrem.h"
#include "commands/proclang.h"
+#include "commands/schemacmds.h"
#include "commands/trigger.h"
#include "lib/stringinfo.h"
#include "miscadmin.h"
OCLASS_OPERATOR, /* pg_operator */
OCLASS_REWRITE, /* pg_rewrite */
OCLASS_TRIGGER, /* pg_trigger */
+ OCLASS_SCHEMA, /* pg_namespace */
MAX_OCLASS /* MUST BE LAST */
} ObjectClasses;
RemoveTriggerById(object->objectId);
break;
+ case OCLASS_SCHEMA:
+ RemoveSchemaById(object->objectId);
+ break;
+
default:
elog(ERROR, "doDeletion: Unsupported object class %u",
object->classId);
object_classes[OCLASS_OPERATOR] = get_system_catalog_relid(OperatorRelationName);
object_classes[OCLASS_REWRITE] = get_system_catalog_relid(RewriteRelationName);
object_classes[OCLASS_TRIGGER] = get_system_catalog_relid(TriggerRelationName);
+ object_classes[OCLASS_SCHEMA] = get_system_catalog_relid(NamespaceRelationName);
object_classes_initialized = true;
}
Assert(object->objectSubId == 0);
return OCLASS_TRIGGER;
}
+ if (object->classId == object_classes[OCLASS_SCHEMA])
+ {
+ Assert(object->objectSubId == 0);
+ return OCLASS_SCHEMA;
+ }
elog(ERROR, "getObjectClass: Unknown object class %u",
object->classId);
break;
}
+ case OCLASS_SCHEMA:
+ {
+ HeapTuple schemaTup;
+
+ schemaTup = SearchSysCache(NAMESPACEOID,
+ ObjectIdGetDatum(object->objectId),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(schemaTup))
+ elog(ERROR, "getObjectDescription: Schema %u does not exist",
+ object->objectId);
+ appendStringInfo(&buffer, "schema %s",
+ NameStr(((Form_pg_namespace) GETSTRUCT(schemaTup))->nspname));
+ ReleaseSysCache(schemaTup);
+ break;
+ }
+
default:
appendStringInfo(&buffer, "unknown object %u %u %d",
object->classId,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.209 2002/07/16 22:12:18 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.210 2002/07/18 16:47:22 tgl Exp $
*
*
* INTERFACE ROUTINES
AddNewAttributeTuples(new_rel_oid, new_rel_desc->rd_att,
relhasoids, relkind);
+ /*
+ * make a dependency link to force the relation to be deleted if
+ * its namespace is. Skip this in bootstrap mode, since we don't
+ * make dependencies while bootstrapping.
+ */
+ if (!IsBootstrapProcessingMode())
+ {
+ ObjectAddress myself,
+ referenced;
+
+ myself.classId = RelOid_pg_class;
+ myself.objectId = new_rel_oid;
+ myself.objectSubId = 0;
+ referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.objectId = relnamespace;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+ }
+
/*
* store constraints and defaults passed in the tupdesc, if any.
*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.184 2002/07/16 05:53:33 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.185 2002/07/18 16:47:23 tgl Exp $
*
*
* INTERFACE ROUTINES
* linked to the table. If it's not a CONSTRAINT, make the dependency
* directly on the table.
*
+ * We don't need a dependency on the namespace, because there'll be
+ * an indirect dependency via our parent table.
+ *
* During bootstrap we can't register any dependencies, and we don't
* try to make a constraint either.
*/
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.71 2002/07/16 22:12:18 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.72 2002/07/18 16:47:23 tgl Exp $
*
* NOTES
* these routines moved here from commands/define.c and somewhat cleaned up.
* Create dependencies for a new operator (either a freshly inserted
* complete operator, a new shell operator, or a just-updated shell).
*
- * NB: the OidIsValid tests in this routine are *all* necessary, in case
+ * NB: the OidIsValid tests in this routine are necessary, in case
* the given operator is a shell.
*/
static void
/* In case we are updating a shell, delete any existing entries */
deleteDependencyRecordsFor(myself.classId, myself.objectId);
+ /* Dependency on namespace */
+ if (OidIsValid(oper->oprnamespace))
+ {
+ referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.objectId = oper->oprnamespace;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+ }
+
/* Dependency on left type */
if (OidIsValid(oper->oprleft))
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.77 2002/07/16 22:12:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.78 2002/07/18 16:47:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
myself.objectId = retval;
myself.objectSubId = 0;
+ /* dependency on namespace */
+ referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.objectId = procNamespace;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+
/* dependency on implementation language */
referenced.classId = get_system_catalog_relid(LanguageRelationName);
referenced.objectId = languageObjectId;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.73 2002/07/12 18:43:15 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.74 2002/07/18 16:47:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_type.h"
#include "miscadmin.h"
#include "utils/builtins.h"
+#include "utils/lsyscache.h"
#include "utils/syscache.h"
NameData name;
TupleDesc tupDesc;
int i;
- ObjectAddress myself,
- referenced;
/*
* validate size specifications: either positive (fixed-length) or -1
}
/*
- * Create dependencies
+ * Create dependencies. We can/must skip this in bootstrap mode.
*/
- myself.classId = RelOid_pg_type;
- myself.objectId = typeObjectId;
- myself.objectSubId = 0;
-
- /* Normal dependencies on the I/O functions */
- referenced.classId = RelOid_pg_proc;
- referenced.objectId = inputProcedure;
- referenced.objectSubId = 0;
- recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
-
- referenced.classId = RelOid_pg_proc;
- referenced.objectId = outputProcedure;
- referenced.objectSubId = 0;
- recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
-
- if (receiveProcedure != inputProcedure)
+ if (!IsBootstrapProcessingMode())
{
+ ObjectAddress myself,
+ referenced;
+
+ myself.classId = RelOid_pg_type;
+ myself.objectId = typeObjectId;
+ myself.objectSubId = 0;
+
+ /* dependency on namespace */
+ /* skip for relation rowtype, since we have indirect dependency */
+ if (!OidIsValid(relationOid))
+ {
+ referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.objectId = typeNamespace;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+ }
+
+ /* Normal dependencies on the I/O functions */
referenced.classId = RelOid_pg_proc;
- referenced.objectId = receiveProcedure;
+ referenced.objectId = inputProcedure;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
- }
- if (sendProcedure != outputProcedure)
- {
referenced.classId = RelOid_pg_proc;
- referenced.objectId = sendProcedure;
+ referenced.objectId = outputProcedure;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
- }
- /*
- * If the type is a rowtype for a relation, mark it as internally
- * dependent on the relation. This allows it to be auto-dropped
- * when the relation is, and not otherwise.
- */
- if (OidIsValid(relationOid))
- {
- referenced.classId = RelOid_pg_class;
- referenced.objectId = relationOid;
- referenced.objectSubId = 0;
- recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
- }
+ if (receiveProcedure != inputProcedure)
+ {
+ referenced.classId = RelOid_pg_proc;
+ referenced.objectId = receiveProcedure;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+ }
+
+ if (sendProcedure != outputProcedure)
+ {
+ referenced.classId = RelOid_pg_proc;
+ referenced.objectId = sendProcedure;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+ }
- /*
- * If the type is an array type, mark it auto-dependent on the
- * base type. (This is a compromise between the typical case where the
- * array type is automatically generated and the case where it is manually
- * created: we'd prefer INTERNAL for the former case and NORMAL for the
- * latter.)
- */
- if (OidIsValid(elementType))
- {
- referenced.classId = RelOid_pg_type;
- referenced.objectId = elementType;
- referenced.objectSubId = 0;
- recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
- }
+ /*
+ * If the type is a rowtype for a relation, mark it as internally
+ * dependent on the relation. This allows it to be auto-dropped
+ * when the relation is, and not otherwise.
+ */
+ if (OidIsValid(relationOid))
+ {
+ referenced.classId = RelOid_pg_class;
+ referenced.objectId = relationOid;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
+ }
- /* Normal dependency from a domain to its base type. */
- if (OidIsValid(baseType))
- {
- referenced.classId = RelOid_pg_type;
- referenced.objectId = baseType;
- referenced.objectSubId = 0;
- recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+ /*
+ * If the type is an array type, mark it auto-dependent on the base
+ * type. (This is a compromise between the typical case where the
+ * array type is automatically generated and the case where it is
+ * manually created: we'd prefer INTERNAL for the former case and
+ * NORMAL for the latter.)
+ */
+ if (OidIsValid(elementType))
+ {
+ referenced.classId = RelOid_pg_type;
+ referenced.objectId = elementType;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_AUTO);
+ }
+
+ /* Normal dependency from a domain to its base type. */
+ if (OidIsValid(baseType))
+ {
+ referenced.classId = RelOid_pg_type;
+ referenced.objectId = baseType;
+ referenced.objectSubId = 0;
+ recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
+ }
}
/*
/*-------------------------------------------------------------------------
*
* schemacmds.c
- * schema creation command support code
+ * schema creation/manipulation commands
*
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/schemacmds.c,v 1.4 2002/06/11 13:40:50 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/schemacmds.c,v 1.5 2002/07/18 16:47:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
+#include "access/heapam.h"
#include "catalog/catalog.h"
+#include "catalog/catname.h"
+#include "catalog/dependency.h"
#include "catalog/namespace.h"
#include "catalog/pg_namespace.h"
#include "commands/schemacmds.h"
#include "tcop/utility.h"
#include "utils/acl.h"
#include "utils/lsyscache.h"
+#include "utils/syscache.h"
/*
/* Reset current user */
SetUserId(saved_userid);
}
+
+
+/*
+ * RemoveSchema
+ * Removes a schema.
+ */
+void
+RemoveSchema(List *names, DropBehavior behavior)
+{
+ char *namespaceName;
+ Oid namespaceId;
+ ObjectAddress object;
+
+ if (length(names) != 1)
+ elog(ERROR, "Schema name may not be qualified");
+ namespaceName = strVal(lfirst(names));
+
+ namespaceId = GetSysCacheOid(NAMESPACENAME,
+ CStringGetDatum(namespaceName),
+ 0, 0, 0);
+ if (!OidIsValid(namespaceId))
+ elog(ERROR, "Schema \"%s\" does not exist", namespaceName);
+
+ /* Permission check */
+ if (!pg_namespace_ownercheck(namespaceId, GetUserId()))
+ aclcheck_error(ACLCHECK_NOT_OWNER, namespaceName);
+
+ /*
+ * Do the deletion. Objects contained in the schema are removed
+ * by means of their dependency links to the schema.
+ *
+ * XXX currently, index opclasses don't have creation/deletion
+ * commands, so they will not get removed when the containing
+ * schema is removed. This is annoying but not fatal.
+ */
+ object.classId = get_system_catalog_relid(NamespaceRelationName);
+ object.objectId = namespaceId;
+ object.objectSubId = 0;
+
+ performDeletion(&object, behavior);
+}
+
+
+/*
+ * Guts of schema deletion.
+ */
+void
+RemoveSchemaById(Oid schemaOid)
+{
+ Relation relation;
+ HeapTuple tup;
+
+ relation = heap_openr(NamespaceRelationName, RowExclusiveLock);
+
+ tup = SearchSysCache(NAMESPACEOID,
+ ObjectIdGetDatum(schemaOid),
+ 0, 0, 0);
+ if (!HeapTupleIsValid(tup))
+ elog(ERROR, "RemoveSchemaById: schema %u not found",
+ schemaOid);
+
+ simple_heap_delete(relation, &tup->t_self);
+
+ ReleaseSysCache(tup);
+
+ heap_close(relation, RowExclusiveLock);
+}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.344 2002/07/18 04:43:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.345 2002/07/18 16:47:24 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
}
%type <node> stmt, schema_stmt,
- AlterDatabaseSetStmt, AlterGroupStmt, AlterSchemaStmt,
+ AlterDatabaseSetStmt, AlterGroupStmt,
AlterTableStmt, AlterUserStmt, AlterUserSetStmt,
AnalyzeStmt, ClosePortalStmt, ClusterStmt, CommentStmt,
ConstraintsSetStmt, CopyStmt, CreateAsStmt,
CreateSchemaStmt, CreateSeqStmt, CreateStmt,
CreateAssertStmt, CreateTrigStmt, CreateUserStmt,
CreatedbStmt, CursorStmt, DefineStmt, DeleteStmt,
- DropGroupStmt, DropPLangStmt, DropSchemaStmt, DropStmt,
+ DropGroupStmt, DropPLangStmt, DropStmt,
DropAssertStmt, DropTrigStmt, DropRuleStmt,
DropUserStmt, DropdbStmt, ExplainStmt, FetchStmt,
GrantStmt, IndexStmt, InsertStmt, ListenStmt, LoadStmt,
stmt :
AlterDatabaseSetStmt
| AlterGroupStmt
- | AlterSchemaStmt
| AlterTableStmt
| AlterUserStmt
| AlterUserSetStmt
| ClusterStmt
| DefineStmt
| DropStmt
- | DropSchemaStmt
| TruncateStmt
| CommentStmt
| DropGroupStmt
*
* Manipulate a schema
*
- *
*****************************************************************************/
CreateSchemaStmt:
}
;
-AlterSchemaStmt:
- ALTER SCHEMA ColId
- {
- elog(ERROR, "ALTER SCHEMA not yet supported");
- }
- ;
-
-DropSchemaStmt:
- DROP SCHEMA ColId opt_drop_behavior
- {
- elog(ERROR, "DROP SCHEMA not yet supported");
- }
- ;
-
OptSchemaName:
ColId { $$ = $1; }
| /* EMPTY */ { $$ = NULL; }
| TYPE_P { $$ = DROP_TYPE; }
| DOMAIN_P { $$ = DROP_DOMAIN; }
| CONVERSION_P { $$ = DROP_CONVERSION; }
+ | SCHEMA { $$ = DROP_SCHEMA; }
;
any_name_list:
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.270 2002/07/13 01:02:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.271 2002/07/18 16:47:25 tgl Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
if (!IsUnderPostmaster)
{
puts("\nPOSTGRES backend interactive interface ");
- puts("$Revision: 1.270 $ $Date: 2002/07/13 01:02:14 $\n");
+ puts("$Revision: 1.271 $ $Date: 2002/07/18 16:47:25 $\n");
}
/*
tag = "DROP DOMAIN";
break;
case DROP_CONVERSION:
- tag = "DROP CONVERSON";
+ tag = "DROP CONVERSION";
+ break;
+ case DROP_SCHEMA:
+ tag = "DROP SCHEMA";
break;
default:
tag = "???";
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.162 2002/07/12 18:43:17 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.163 2002/07/18 16:47:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* relation and attribute manipulation
*/
case T_CreateSchemaStmt:
- {
- CreateSchemaStmt *stmt = (CreateSchemaStmt *) parsetree;
-
- CreateSchemaCommand(stmt);
- }
+ CreateSchemaCommand((CreateSchemaStmt *) parsetree);
break;
case T_CreateStmt:
break;
case DROP_CONVERSION:
- /* RemoveDomain does its own permissions checks */
+ /* does its own permissions checks */
DropConversionCommand(names);
break;
+
+ case DROP_SCHEMA:
+ /* RemoveSchema does its own permissions checks */
+ RemoveSchema(names, stmt->behavior);
+ break;
}
/*
- * Make sure subsequent loop iterations will see
- * results of this one; needed if removing multiple
- * rules for same table, for example.
+ * We used to need to do CommandCounterIncrement()
+ * here, but now it's done inside performDeletion().
*/
- CommandCounterIncrement();
}
}
break;
# Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
# Portions Copyright (c) 1994, Regents of the University of California
#
-# $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.159 2002/07/18 02:02:30 ishii Exp $
+# $Header: /cvsroot/pgsql/src/bin/initdb/Attic/initdb.sh,v 1.160 2002/07/18 16:47:25 tgl Exp $
#
#-------------------------------------------------------------------------
INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' FROM pg_operator;
INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' FROM pg_rewrite;
INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' FROM pg_trigger;
+-- restriction here to avoid pinning the public namespace
+INSERT INTO pg_depend SELECT 0,0,0, tableoid,oid,0, 'p' FROM pg_namespace \
+ WHERE nspname LIKE 'pg%';
EOF
if [ "$?" -ne 0 ]; then
exit_nicely
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: schemacmds.h,v 1.1 2002/04/15 05:22:04 tgl Exp $
+ * $Id: schemacmds.h,v 1.2 2002/07/18 16:47:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern void CreateSchemaCommand(CreateSchemaStmt *parsetree);
+extern void RemoveSchema(List *names, DropBehavior behavior);
+extern void RemoveSchemaById(Oid schemaOid);
+
#endif /* SCHEMACMDS_H */
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.190 2002/07/18 04:43:51 momjian Exp $
+ * $Id: parsenodes.h,v 1.191 2002/07/18 16:47:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
} CreateDomainStmt;
/* ----------------------
- * Drop Table|Sequence|View|Index|Type|Domain Statement
+ * Drop Table|Sequence|View|Index|Type|Domain|Conversion|Schema Statement
* ----------------------
*/
#define DROP_TYPE 5
#define DROP_DOMAIN 6
#define DROP_CONVERSION 7
+#define DROP_SCHEMA 8
typedef struct DropStmt
{
projects / postgresql / commitdiff