CREATE TABLE(SQL)                 Postgres95                 CREATE TABLE(SQL)

       create table — create a new class

       create table  classname (attname-1 type-1 {, attname-i type-i})
            [inherits ( classname-1 {, classname-i} )]
            [archive = archive_mode]
            [store = “smgr_name”]
            [arch_store = “smgr_name”]

       Create table will enter a new class into the current data base.  The
       class will be “owned” by the user issuing the command.  The name of the
       class is classname and the attributes are as specified in the list of
       attnames.  The ith attribute is created with the type specified by
       type-i.  Each type may be a simple type, a complex type (set) or an
       array type.

       Each array attribute stores arrays that must have the same number of
       dimensions but may have different sizes and array index bounds.  An
       array of dimension n is specified by appending n pairs of square
       att_name = type[][]..[]

       The optional inherits clause specifies a collection of class names from
       which this class automatically inherits all fields.  If any inherited
       field name appears more than once, Postgres reports an error.  Postgres
       automatically allows the created class to inherit functions on classes
       above it in the inheritance hierarchy.  Inheritance of functions is
       done according to the conventions of the Common Lisp Object System

       Each new class classname is automatically created as a type.
       Therefore, one or more instances from the class are automatically a
       type and can be used in altertable(l) or other create table statements.
       See introduction(l) for a further discussion of this point.

       The optional store and arch_store keywords may be used to specify a
       storage manager to use for the new class.  The released version of
       Postgres supports only “magnetic disk” as a storage manager name; the
       research system at UC Berkeley provides additional storage managers.
       Store controls the location of current data, and arch_store controls
       the location of historical data.  Arch_store may only be specified if
       archive is also specified.  If either store or arch_store is not
       declared, it defaults to “magnetic disk”.

       The new class is created as a heap with no initial data.  A class can
       have no more than 1600 attributes (realistically, this is limited by
       the fact that tuple sizes must be less than 8192 bytes), but this limit
       may be configured lower at some sites.  A class cannot have the same
       name as a system catalog class.

       The archive keyword specifies whether historical data is to be saved or
       discarded.  Arch_mode may be one of:

       none      No historical access is supported.

       light     Historical access is allowed and optimized for light update

       heavy     Historical access is allowed and optimized for heavy update

       Arch_mode defaults to “none”.  Once the archive status is set, there is
       no way to change it.  For details of the optimization, see [STON87].

       -- Create class emp with attributes name, sal and bdate
       create table emp (name char16, salary float4, bdate abstime)
       --Create class permemp with pension information that
       --inherits all fields of emp
       create table permemp (plan char16) inherits (emp)
       --Create class foo on magnetic disk and archive historical data
       create table foo (bar int4) archive = heavy
           store = "magnetic disk"
       --Create class tictactoe to store noughts-and-crosses
       --boards as a 2-dimensional array
       create table tictactoe (game int4, board = char[][])
       --Create a class newemp with a set attribute "manager".  A
       --set (complex) attribute may be of the same type as the
       --relation being defined (as here) or of a different complex
       --type.  The type must exist in the "pg_type" catalog or be
       --the one currently being defined.
       create table newemp (name text, manager = newemp)

       drop table(l).

Postgres95                         11/05/95                  CREATE TABLE(SQL)