~ubuntu-branches/ubuntu/lucid/postgresql-8.4/lucid-proposed

 *        $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.284 2009/05/12 03:11:01 tgl Exp $

        bool            new_changeoids; /* T if we added/dropped the OID column */

         ERRCODE_UNDEFINED_TABLE,

         gettext_noop("table \"%s\" does not exist"),

         gettext_noop("table \"%s\" does not exist, skipping"),

         gettext_noop("\"%s\" is not a table"),

         gettext_noop("Use DROP TABLE to remove a table.")},

         ERRCODE_UNDEFINED_TABLE,

         gettext_noop("sequence \"%s\" does not exist"),

         gettext_noop("sequence \"%s\" does not exist, skipping"),

         gettext_noop("\"%s\" is not a sequence"),

         gettext_noop("Use DROP SEQUENCE to remove a sequence.")},

         ERRCODE_UNDEFINED_TABLE,

         gettext_noop("view \"%s\" does not exist"),

         gettext_noop("view \"%s\" does not exist, skipping"),

         gettext_noop("\"%s\" is not a view"),

         gettext_noop("Use DROP VIEW to remove a view.")},

         ERRCODE_UNDEFINED_OBJECT,

         gettext_noop("index \"%s\" does not exist"),

         gettext_noop("index \"%s\" does not exist, skipping"),

         gettext_noop("\"%s\" is not an index"),

         gettext_noop("Use DROP INDEX to remove an index.")},

         ERRCODE_UNDEFINED_OBJECT,

         gettext_noop("type \"%s\" does not exist"),

         gettext_noop("type \"%s\" does not exist, skipping"),

         gettext_noop("\"%s\" is not a type"),

         gettext_noop("Use DROP TYPE to remove a type.")},

                                          AlterTableCmd *cmd);

                                AlterTableCmd *cmd);

                                                                AlteredTableInfo *tab, Relation rel,

                                                                Node *newConstraint, bool recurse);

                                                                 AlteredTableInfo *tab, Relation rel,

                                                                 Constraint *constr,

                                                                 bool recurse, bool recursing);

                                                                 DropBehavior behavior, 

                                                                 bool recurse, bool recursing);

                                                           ForkNumber forkNum, bool istemp);

        static char        *validnsps[] = HEAP_RELOPT_NAMESPACES;

         * Create a tuple descriptor from the relation schema.  Note that this

         * while raw defaults go into a list of RawColumnDefault structs that

         * will be processed by AddRelationNewConstraints.  (We can't deal with

         * raw expressions until we can do transformExpr.)

         * Create the relation.  Inherited defaults and constraints are passed

         * in for immediate handling --- since they don't need parsing, they

         * can be stored immediately.

                         (wentry->kind != '\0') ? errhint(wentry->drophint_msg) : 0));

         * performMultipleDeletions() call.  This is to avoid unwanted

         * DROP RESTRICT errors if one of the relations depends on another.

                        relkind = 0;    /* keep compiler quiet */

         * If we are asked to restart sequences, find all the sequences,

         * lock them (we only need AccessShareLock because that's all that

         * ALTER SEQUENCE takes), and check permissions.  We want to do this

         * early since it's pointless to do all the truncation work only to fail

         * on sequence permissions.

                                Oid             seq_relid = lfirst_oid(seqcell);

                                Relation seq_rel;

         * To fire triggers, we'll need an EState as well as a ResultRelInfo

         * for each relation.

                                                  0,                    /* dummy rangetable index */

         * truncating (this is because one of them might throw an error).

         * Also, if we were to allow them to prevent statement execution,

         * that would need to be handled here.

         * last because it's nontransactional: restarts will not roll back if

         * we abort later.  Hence it's important to postpone them as long as

                List   *options = list_make1(makeDefElem("restart", NULL));

                        Oid             seq_relid = lfirst_oid(cell);

                 * using the completed newattno[] map.  Identically named constraints

                                        cooked->attnum = 0;             /* not used for constraints */

         * Don't allow ALTER TABLE on composite types.

         * We want people to use ALTER TYPE for that.

         * Grab an exclusive lock on the target table, index, sequence or

         * view, which we will NOT release until end of transaction.

 * events would try to fetch the wrong tuples.  It might be overly cautious

                                 /* translator: first %s is a SQL command, eg ALTER TABLE */

                                 /* translator: first %s is a SQL command, eg ALTER TABLE */

 * ATRewriteCatalogs performs phase 2 for each affected table.  (Note that

                         * For mostly-historical reasons, we allow ALTER TABLE to apply

                         * to all relation types.

                case AT_AddColumnToView:        /* add column via CREATE OR REPLACE VIEW */

                        AlterTableCreateToastTable(tab->relid, (Datum) 0, false);

                case AT_AddColumnToView: /* add column via CREATE OR REPLACE VIEW */

                                                 errmsg("child table \"%s\" has a conflicting \"%s\" column",

                                                        RelationGetRelationName(rel), colDef->colname)));

         * We skip this step completely for views.  For a view, we can only get

         * defaults, not even for domain-typed columns.  And in any case we mustn't

         * invoke Phase 3 on a view, since it has no storage.

                        if (defval == NULL)             /* should not happen */

         * If we are adding an OID column, we have to tell Phase 3 to rewrite

         * the table to fix that.

 * Basically this is an ADD COLUMN for the special OID column.  We have

         * If we dropped the OID column, must adjust pg_class.relhasoids and

         * tell Phase 3 to physically get rid of the column.

                                 * Note that we currently never recurse for FK constraints,

                                 * so the "recurse" flag is silently ignored.

         * a copy of the Constraint so transformExpr can't modify the original.

         * It returns a list of cooked constraints.

         * Validity checks (permission checks wait till we have the column numbers)

                                                                          true, /* islocal */

                                                                          0); /* inhcount */

                fk_trigger->actions[0] = 'i';

                fk_trigger->actions[0] = 'u';

        fk_trigger->actions[1] = '\0';

        fk_trigger->actions[0] = 'd';

        fk_trigger->actions[1] = '\0';

 

        fk_trigger->actions[0] = 'u';

        fk_trigger->actions[1] = '\0';

                                (errcode(ERRCODE_INVALID_TABLE_DEFINITION),

                                 errmsg("cannot drop inherited constraint \"%s\" of relation \"%s\"",

                                                constrName, RelationGetRelationName(rel))));

                        HeapTuple copy_tuple;

                        if (con->coninhcount <= 0)              /* shouldn't happen */

                                 * If the child constraint has other definition sources,

                                 * just decrement its inheritance count; if not, recurse

                                 * to delete it.

                                 * If we were told to drop ONLY in this table (no

                                 * recursion), we need to mark the inheritors' constraints

                                 * as locally defined rather than inherited.

                                         errmsg("constraint \"%s\" of relation \"%s\" does not exist",

                                                        constrName,

                                                        RelationGetRelationName(childrel))));

                        errmsg("cannot use window function in transform expression")));

                        errmsg("default for column \"%s\" cannot be cast to type %s",

                                   colName, format_type_be(targettype))));

        static char        *validnsps[] = HEAP_RELOPT_NAMESPACES;

                                                                         defList, NULL, validnsps, false, isReset);

                                                                repl_val, repl_null, repl_repl);

                                                                                 defList, "toast", validnsps, false, isReset);

         * Create and copy all forks of the relation, and schedule unlinking

         * of old physical files.

         *               RelationCreateStorage().

                Form_pg_constraint      parent_con = (Form_pg_constraint) GETSTRUCT(parent_tuple);

                SysScanDesc                     child_scan;

                ScanKeyData                     child_key;

                HeapTuple                       child_tuple;

                bool                            found = false;

                        Form_pg_constraint      child_con = (Form_pg_constraint) GETSTRUCT(child_tuple);

                        HeapTuple child_copy;

         * Likewise, find inherited check constraints and disinherit them.

         * To do this, we first need a list of the names of the parent's check

                bool    match;

                ListCell *lc;

                foreach (lc, connames)

                         * For mostly-historical reasons, we allow ALTER TABLE to apply

                         * to all relation types.