2 $Header: /cvsroot/pgsql/doc/src/sgml/ref/create_table.sgml,v 1.64 2003/04/14 15:24:46 tgl Exp $
3 PostgreSQL documentation
6 <refentry id="SQL-CREATETABLE">
8 <refentrytitle id="sql-createtable-title">CREATE TABLE</refentrytitle>
9 <refmiscinfo>SQL - Language Statements</refmiscinfo>
13 <refname>CREATE TABLE</refname>
14 <refpurpose>define a new table</refpurpose>
19 CREATE [ [ LOCAL ] { TEMPORARY | TEMP } ] TABLE <replaceable class="PARAMETER">table_name</replaceable> (
20 { <replaceable class="PARAMETER">column_name</replaceable> <replaceable class="PARAMETER">data_type</replaceable> [ DEFAULT <replaceable>default_expr</> ] [ <replaceable class="PARAMETER">column_constraint</replaceable> [, ... ] ]
21 | <replaceable>table_constraint</replaceable> } [, ... ]
23 [ INHERITS ( <replaceable>parent_table</replaceable> [, ... ] ) ]
24 [ WITH OIDS | WITHOUT OIDS ]
25 [ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
27 where <replaceable class="PARAMETER">column_constraint</replaceable> is:
29 [ CONSTRAINT <replaceable class="PARAMETER">constraint_name</replaceable> ]
30 { NOT NULL | NULL | UNIQUE | PRIMARY KEY |
31 CHECK (<replaceable class="PARAMETER">expression</replaceable>) |
32 REFERENCES <replaceable class="PARAMETER">reftable</replaceable> [ ( <replaceable class="PARAMETER">refcolumn</replaceable> ) ] [ MATCH FULL | MATCH PARTIAL ]
33 [ ON DELETE <replaceable class="parameter">action</replaceable> ] [ ON UPDATE <replaceable class="parameter">action</replaceable> ] }
34 [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
36 and <replaceable class="PARAMETER">table_constraint</replaceable> is:
38 [ CONSTRAINT <replaceable class="PARAMETER">constraint_name</replaceable> ]
39 { UNIQUE ( <replaceable class="PARAMETER">column_name</replaceable> [, ... ] ) |
40 PRIMARY KEY ( <replaceable class="PARAMETER">column_name</replaceable> [, ... ] ) |
41 CHECK ( <replaceable class="PARAMETER">expression</replaceable> ) |
42 FOREIGN KEY ( <replaceable class="PARAMETER">column_name</replaceable> [, ... ] ) REFERENCES <replaceable class="PARAMETER">reftable</replaceable> [ ( <replaceable class="PARAMETER">refcolumn</replaceable> [, ... ] ) ]
43 [ MATCH FULL | MATCH PARTIAL ] [ ON DELETE <replaceable class="parameter">action</replaceable> ] [ ON UPDATE <replaceable class="parameter">action</replaceable> ] }
44 [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
49 <refsect1 id="SQL-CREATETABLE-description">
50 <title>Description</title>
53 <command>CREATE TABLE</command> will create a new, initially empty table
54 in the current database. The table will be owned by the user issuing the
59 If a schema name is given (for example, <literal>CREATE TABLE
60 myschema.mytable ...</>) then the table is created in the
61 specified schema. Otherwise it is created in the current schema (the one
62 at the front of the search path; see <literal>CURRENT_SCHEMA()</>).
63 TEMP tables exist in a special schema, so a schema name may not be
64 given when creating a TEMP table.
65 The table name must be distinct from the name of any other table,
66 sequence, index, or view in the same schema.
70 <command>CREATE TABLE</command> also automatically creates a data
71 type that represents the tuple type (structure type) corresponding
72 to one row of the table. Therefore, tables cannot have the same
73 name as any existing data type in the same schema.
77 A table cannot have more than 1600 columns. (In practice, the
78 effective limit is lower because of tuple-length constraints).
82 The optional constraint clauses specify constraints (or tests) that
83 new or updated rows must satisfy for an insert or update operation
84 to succeed. A constraint is a named rule: an SQL object which
85 helps define valid sets of values by putting limits on the results
86 of insert, update, or delete operations performed on a table.
90 There are two ways to define constraints: table constraints and
91 column constraints. A column constraint is defined as part of a
92 column definition. A table constraint definition is not tied to a
93 particular column, and it can encompass more than one column.
94 Every column constraint can also be written as a table constraint;
95 a column constraint is only a notational convenience if the
96 constraint only affects one column.
101 <title>Parameters</title>
106 <term><literal>[LOCAL] TEMPORARY</> or <literal>[LOCAL] TEMP</></term>
109 If specified, the table is created as a temporary table.
110 Temporary tables are automatically dropped at the end of a
111 session, or optionally at the end of the current transaction
112 (see ON COMMIT below). Existing permanent tables with the same
113 name are not visible to the current session while the temporary
114 table exists, unless they are referenced with schema-qualified
115 names. Any indexes created on a temporary table are automatically
120 The <literal>LOCAL</literal> word is optional. But see under
121 <xref linkend="sql-createtable-compatibility"
122 endterm="sql-createtable-compatibility-title">.
128 <term><replaceable class="PARAMETER">table_name</replaceable></term>
131 The name (optionally schema-qualified) of the table to be created.
137 <term><replaceable class="PARAMETER">column_name</replaceable></term>
140 The name of a column to be created in the new table.
146 <term><replaceable class="PARAMETER">data_type</replaceable></term>
149 The data type of the column. This may include array specifiers.
155 <term><literal>DEFAULT
156 <replaceable>default_expr</replaceable></literal></term>
159 The <literal>DEFAULT</> clause assigns a default data value for
160 the column whose column definition it appears within. The value
161 is any variable-free expression (subselects and cross-references
162 to other columns in the current table are not allowed). The
163 data type of the default expression must match the data type of the
168 The default expression will be used in any insert operation that
169 does not specify a value for the column. If there is no default
170 for a column, then the default is NULL.
176 <term><literal>INHERITS ( <replaceable>parent_table</replaceable> [, ... ] )</literal></term>
179 The optional <literal>INHERITS</> clause specifies a list of
180 tables from which the new table automatically inherits all
181 columns. If the same column name exists in more than one parent
182 table, an error is reported unless the data types of the columns
183 match in each of the parent tables. If there is no conflict,
184 then the duplicate columns are merged to form a single column in
185 the new table. If the column name list of the new table
186 contains a column that is also inherited, the data type must
187 likewise match the inherited column(s), and the column
188 definitions are merged into one. However, inherited and new
189 column declarations of the same name need not specify identical
190 constraints: all constraints provided from any declaration are
191 merged together and all are applied to the new table. If the
192 new table explicitly specifies a default value for the column,
193 this default overrides any defaults from inherited declarations
194 of the column. Otherwise, any parents that specify default
195 values for the column must all specify the same default, or an
196 error will be reported.
200 <application>PostgreSQL</application> automatically allows the
201 created table to inherit
202 functions on tables above it in the inheritance hierarchy; that
203 is, if we create table <literal>foo</literal> inheriting from
204 <literal>bar</literal>, then functions that accept the tuple
205 type <literal>bar</literal> can also be applied to instances of
206 <literal>foo</literal>. (Currently, this works reliably for
207 functions on the first or only parent table, but not so well for
208 functions on additional parents.)
215 <term><literal>WITH OIDS</> or <literal>WITHOUT OIDS</></term>
218 This optional clause specifies whether rows of the new table
219 should have OIDs (object identifiers) assigned to them. The
220 default is to have OIDs. (If the new table inherits from any
221 tables that have OIDs, then <literal>WITH OIDS</> is forced even
222 if the command says <literal>WITHOUT OIDS</>.)
226 Specifying <literal>WITHOUT OIDS</> allows the user to suppress
227 generation of OIDs for rows of a table. This may be worthwhile
228 for large tables, since it will reduce OID consumption and
229 thereby postpone wraparound of the 32-bit OID counter. Once the
230 counter wraps around, uniqueness of OIDs can no longer be
231 assumed, which considerably reduces their usefulness. Specifying
232 <literal>WITHOUT OIDS</literal> also reduces the space required
233 to store the table on disk by 4 bytes per row of the table,
234 thereby improving performance.
240 <term><literal>CONSTRAINT <replaceable class="PARAMETER">constraint_name</replaceable></literal></term>
243 An optional name for a column or table constraint. If not specified,
244 the system generates a name.
250 <term><literal>NOT NULL</></term>
253 The column is not allowed to contain NULL values.
259 <term><literal>NULL</></term>
262 The column is allowed to contain NULL values. This is the default.
266 This clause is only available for compatibility with
267 non-standard SQL databases. Its use is discouraged in new
274 <term><literal>UNIQUE</> (column constraint)</term>
275 <term><literal>UNIQUE ( <replaceable class="PARAMETER">column_name</replaceable> [, ... ] )</> (table constraint)</term>
279 The <literal>UNIQUE</literal> constraint specifies a rule that a
280 group of one or more distinct columns of a table may contain
281 only unique values. The behavior of the unique table constraint
282 is the same as that for column constraints, with the additional
283 capability to span multiple columns.
287 For the purpose of a unique constraint, NULL values are not
292 Each unique table constraint must name a set of columns that is
293 different from the set of columns named by any other unique or
294 primary key constraint defined for the table. (Otherwise it
295 would just be the same constraint listed twice.)
301 <term><literal>PRIMARY KEY</> (column constraint)</term>
302 <term><literal>PRIMARY KEY ( <replaceable class="PARAMETER">column_name</replaceable> [, ... ] )</> (table constraint)</term>
305 The primary key constraint specifies that a column or columns of a table
306 may contain only unique (non-duplicate), non-NULL values.
307 Technically, <literal>PRIMARY KEY</literal> is merely a
308 combination of <literal>UNIQUE</> and <literal>NOT NULL</>, but
309 identifying a set of columns as primary key also provides
310 meta-data about the design of the schema, as a primary key
311 implies that other tables
312 may rely on this set of columns as a unique identifier for rows.
316 Only one primary key can be specified for a table, whether as a
317 column constraint or a table constraint.
321 The primary key constraint should name a set of columns that is
322 different from other sets of columns named by any unique
323 constraint defined for the same table.
329 <term><literal>CHECK (<replaceable class="PARAMETER">expression</replaceable>)</literal></term>
332 <literal>CHECK</> clauses specify integrity constraints or tests
333 which new or updated rows must satisfy for an insert or update
334 operation to succeed. Each constraint must be an expression
335 producing a Boolean result. A condition appearing within a
336 column definition should reference that column's value only,
337 while a condition appearing as a table constraint may reference
342 Currently, <literal>CHECK</literal> expressions cannot contain
343 subselects nor refer to variables other than columns of the
352 <term><literal>REFERENCES <replaceable class="parameter">reftable</replaceable> [ ( <replaceable class="parameter">refcolumn</replaceable> ) ] [ MATCH <replaceable class="parameter">matchtype</replaceable> ] [ ON DELETE <replaceable class="parameter">action</replaceable> ] [ ON UPDATE <replaceable class="parameter">action</replaceable> ]</literal> (column constraint)</term>
354 <term><literal>FOREIGN KEY ( <replaceable class="parameter">column</replaceable> [, ... ] )
355 REFERENCES <replaceable class="parameter">reftable</replaceable> [ ( <replaceable class="parameter">refcolumn</replaceable> [, ... ] ) ]
356 [ MATCH <replaceable class="parameter">matchtype</replaceable> ]
357 [ ON DELETE <replaceable class="parameter">action</replaceable> ]
358 [ ON UPDATE <replaceable class="parameter">action</replaceable> ]</literal>
359 (table constraint)</term>
363 The <literal>REFERENCES</literal> column constraint specifies
364 that a group of one or more columns of the new table must only
365 contain values which match against values in the referenced
366 column(s) <replaceable class="parameter">refcolumn</replaceable>
367 of the referenced table <replaceable
368 class="parameter">reftable</replaceable>. If <replaceable
369 class="parameter">refcolumn</replaceable> is omitted, the
370 primary key of the <replaceable
371 class="parameter">reftable</replaceable> is used. The
372 referenced columns must be the columns of a unique or primary
373 key constraint in the referenced table.
377 A value added to these columns is matched against the values of
378 the referenced table and referenced columns using the given
379 match type. There are three match types: <literal>MATCH
380 FULL</>, <literal>MATCH PARTIAL</>, and a default match type if
381 none is specified. <literal>MATCH FULL</> will not allow one
382 column of a multicolumn foreign key to be NULL unless all
383 foreign key columns are NULL. The default match type allows some
384 foreign key columns to be NULL while other parts of the foreign
385 key are not NULL. <literal>MATCH PARTIAL</> is not yet
390 In addition, when the data in the referenced columns is changed,
391 certain actions are performed on the data in this table's
392 columns. The <literal>ON DELETE</literal> clause specifies the
393 action to do when a referenced row in the referenced table is
394 being deleted. Likewise, the <literal>ON UPDATE</literal>
395 clause specifies the action to perform when a referenced column
396 in the referenced table is being updated to a new value. If the
397 row is updated, but the referenced column is not actually
398 changed, no action is done. There are the following possible
399 actions for each clause:
403 <term><literal>NO ACTION</literal></term>
406 Produce an error indicating that the deletion or update
407 would create a foreign key constraint violation. This is
414 <term><literal>RESTRICT</literal></term>
417 Same as <literal>NO ACTION</literal>.
423 <term><literal>CASCADE</literal></term>
426 Delete any rows referencing the deleted row, or update the
427 value of the referencing column to the new value of the
428 referenced column, respectively.
434 <term><literal>SET NULL</literal></term>
437 Set the referencing column values to NULL.
443 <term><literal>SET DEFAULT</literal></term>
446 Set the referencing column values to their default value.
453 If primary key column is updated frequently, it may be wise to
454 add an index to the <literal>REFERENCES</literal> column so that
455 <literal>NO ACTION</literal> and <literal>CASCADE</literal>
456 actions associated with the <literal>REFERENCES</literal>
457 column can be more efficiently performed.
464 <term><literal>DEFERRABLE</literal> or <literal>NOT DEFERRABLE</literal></term>
467 This controls whether the constraint can be deferred. A
468 constraint that is not deferrable will be checked immediately
469 after every command. Checking of constraints that are
470 deferrable may be postponed until the end of the transaction
471 (using the <xref linkend="sql-set-constraints" endterm="sql-set-constraints-title"> command).
472 <literal>NOT DEFERRABLE</literal> is the default. Only foreign
473 key constraints currently accept this clause. All other
474 constraint types are not deferrable.
480 <term><literal>INITIALLY IMMEDIATE</literal> or <literal>INITIALLY DEFERRED</literal></term>
483 If a constraint is deferrable, this clause specifies the default
484 time to check the constraint. If the constraint is
485 <literal>INITIALLY IMMEDIATE</literal>, it is checked after each
486 statement. This is the default. If the constraint is
487 <literal>INITIALLY DEFERRED</literal>, it is checked only at the
488 end of the transaction. The constraint check time can be
489 altered with the <xref linkend="sql-set-constraints" endterm="sql-set-constraints-title"> command.
495 <term><literal>ON COMMIT</literal></term>
498 The behavior of temporary tables at the end of a transaction
499 block can be controlled using <literal>ON COMMIT</literal>.
500 The three options are:
504 <term><literal>PRESERVE ROWS</literal></term>
507 No special action is taken at the ends of transactions.
508 This is the default behavior.
514 <term><literal>DELETE ROWS</literal></term>
517 All rows in the temporary table will be deleted at the
518 end of each transaction block. Essentially, an automatic
519 <xref linkend="sql-truncate"> is done at each commit.
525 <term><literal>DROP</literal></term>
528 The temporary table will be dropped at the end of the current
541 <refsect1 id="SQL-CREATETABLE-diagnostics">
542 <title>Diagnostics</title>
549 <simpara><computeroutput>CREATE TABLE</computeroutput></simpara>
556 Message returned if table is successfully created.
566 <simpara><computeroutput>ERROR</computeroutput></simpara>
573 Message returned if table creation failed. This is usually
574 accompanied by some descriptive text, such as:
575 <computeroutput>ERROR: Relation '<replaceable
576 class="parameter">table</replaceable>' already
577 exists</computeroutput>, which occurs at run time if the table
578 specified already exists in the database.
586 <refsect1 id="SQL-CREATETABLE-notes">
592 Whenever an application makes use of OIDs to identify specific
593 rows of a table, it is recommended to create a unique constraint
594 on the <structfield>oid</> column of that table, to ensure that
595 OIDs in the table will indeed uniquely identify rows even after
596 counter wraparound. Avoid assuming that OIDs are unique across
597 tables; if you need a database-wide unique identifier, use the
598 combination of <structfield>tableoid</> and row OID for the
599 purpose. (It is likely that future <productname>PostgreSQL</>
600 releases will use a separate OID counter for each table, so that
601 it will be <emphasis>necessary</>, not optional, to include
602 <structfield>tableoid</> to have a unique identifier
608 The use of <literal>WITHOUT OIDS</literal> is not recommended
609 for tables with no primary key, since without either an OID or a
610 unique data key, it is difficult to identify specific rows.
617 <productname>PostgreSQL</productname> automatically creates an
618 index for each unique constraint and primary key constraint to
619 enforce the uniqueness. Thus, it is not necessary to create an
620 explicit index for primary key columns. (See <xref
621 linkend="sql-createindex" endterm="sql-createindex-title"> for more information.)
627 The SQL92 standard says that <literal>CHECK</> column constraints
628 may only refer to the column they apply to; only
629 <literal>CHECK</> table constraints may refer to multiple
630 columns. <productname>PostgreSQL</productname> does not enforce
631 this restriction; it treats column and table check constraints
638 Unique constraints and primary keys are not inherited in the
639 current implementation. This makes the combination of
640 inheritance and unique constraints rather dysfunctional.
647 <refsect1 id="SQL-CREATETABLE-examples">
648 <title>Examples</title>
651 Create table <structname>films</> and table
652 <structname>distributors</>:
656 code CHARACTER(5) CONSTRAINT firstkey PRIMARY KEY,
657 title CHARACTER VARYING(40) NOT NULL,
658 did DECIMAL(3) NOT NULL,
661 len INTERVAL HOUR TO MINUTE
666 CREATE TABLE distributors (
667 did DECIMAL(3) PRIMARY KEY DEFAULT NEXTVAL('serial'),
668 name VARCHAR(40) NOT NULL CHECK (name <> '')
674 Create a table with a 2-dimensional array:
684 Define a unique table constraint for the table films. Unique table
685 constraints can be defined on one or more columns of the table:
694 len INTERVAL HOUR TO MINUTE,
695 CONSTRAINT production UNIQUE(date_prod)
701 Define a check column constraint:
704 CREATE TABLE distributors (
705 did DECIMAL(3) CHECK (did > 100),
712 Define a check table constraint:
715 CREATE TABLE distributors (
718 CONSTRAINT con1 CHECK (did > 100 AND name <> '')
724 Define a primary key table constraint for the table
725 <structname>films</>. Primary key table constraints can be defined
726 on one or more columns of the table.
735 len INTERVAL HOUR TO MINUTE,
736 CONSTRAINT code_title PRIMARY KEY(code,title)
742 Define a primary key constraint for table
743 <structname>distributors</>. The following two examples are
744 equivalent, the first using the table constraint syntax, the second
745 the column constraint notation.
748 CREATE TABLE distributors (
750 name CHAR VARYING(40),
756 CREATE TABLE distributors (
757 did DECIMAL(3) PRIMARY KEY,
764 This assigns a literal constant default value for the column
765 <literal>name</literal>, and arranges for the default value of
766 column <literal>did</literal> to be generated by selecting the next
767 value of a sequence object. The default value of
768 <literal>modtime</literal> will be the time at which the row is
772 CREATE TABLE distributors (
773 name VARCHAR(40) DEFAULT 'luso films',
774 did INTEGER DEFAULT NEXTVAL('distributors_serial'),
775 modtime TIMESTAMP DEFAULT CURRENT_TIMESTAMP
781 Define two <literal>NOT NULL</> column constraints on the table
782 <classname>distributors</classname>, one of which is explicitly
786 CREATE TABLE distributors (
787 did DECIMAL(3) CONSTRAINT no_null NOT NULL,
788 name VARCHAR(40) NOT NULL
794 Define a unique constraint for the <literal>name</literal> column:
797 CREATE TABLE distributors (
799 name VARCHAR(40) UNIQUE
803 The above is equivalent to the following specified as a table constraint:
806 CREATE TABLE distributors (
816 <refsect1 id="SQL-CREATETABLE-compatibility">
817 <title id="SQL-CREATETABLE-compatibility-title">Compatibility</title>
820 The <command>CREATE TABLE</command> conforms to SQL92 Intermediate
821 and to a subset of SQL99, with exceptions listed below and in the
826 <title>Temporary Tables</title>
829 Although the syntax of <literal>CREATE TEMPORARY TABLE</literal>
830 resembles that of SQL92, the effect is not the same. In the standard,
831 temporary tables are associated with modules; a temporary table is created
832 just once and automatically exists (starting with empty contents) in every
833 session that uses the module.
834 <productname>PostgreSQL</productname> does not have modules, and
835 requires each session to issue its own <literal>CREATE TEMPORARY
836 TABLE</literal> command for each temporary table to be used.
841 The spec-mandated behavior of temporary tables is widely ignored.
842 <productname>PostgreSQL</productname>'s behavior on this point is similar
843 to that of several other RDBMSs.
848 The optional <literal>ON COMMIT</literal> clause for temporary tables
849 also resembles SQL92, but has some differences.
850 If the <literal>ON COMMIT</> clause is omitted, SQL92 specifies that the
851 default behavior is <literal>ON COMMIT DELETE ROWS</>. However, the
852 default behavior in <productname>PostgreSQL</productname> is
853 <literal>ON COMMIT PRESERVE ROWS</literal>. The <literal>ON COMMIT
854 DROP</literal> option does not exist in SQL92 at all.
859 <title><literal>NULL</literal> <quote>Constraint</quote></title>
862 The <literal>NULL</> <quote>constraint</quote> (actually a
863 non-constraint) is a <productname>PostgreSQL</productname>
864 extension to SQL92 that is included for compatibility with some
865 other RDBMSs (and for symmetry with the <literal>NOT
866 NULL</literal> constraint). Since it is the default for any
867 column, its presence is simply noise.
872 <title>Assertions</title>
875 An assertion is a special type of integrity constraint and shares
876 the same namespace as other constraints. However, an assertion is
877 not necessarily dependent on one particular table as constraints
878 are, so SQL92 provides the <command>CREATE ASSERTION</command>
879 statement as an alternate method for defining a constraint:
882 CREATE ASSERTION <replaceable>name</replaceable> CHECK ( <replaceable>condition</replaceable> )
887 <productname>PostgreSQL</> does not implement assertions at present.
893 Domain constraints are defined by <command>CREATE
894 DOMAIN</command> or <command>ALTER DOMAIN</command> statements:
900 [ CONSTRAINT <replaceable>constraint_name</replaceable> ] CHECK <replaceable>constraint</replaceable>
901 [ {INITIALLY DEFERRED | INITIALLY IMMEDIATE} ]
902 [ [ NOT ] DEFERRABLE ]
908 <title>Inheritance</title>
911 Multiple inheritance via the <literal>INHERITS</literal> clause is
912 a <productname>PostgreSQL</productname> language extension. SQL99
913 (but not SQL92) defines single inheritance using a different
914 syntax and different semantics. SQL99-style inheritance is not
915 yet supported by <productname>PostgreSQL</productname>.
920 <title>Object IDs</title>
923 The <productname>PostgreSQL</productname> concept of OIDs is not
929 <title>Zero-column tables</title>
932 <productname>PostgreSQL</productname> allows a table of no columns
933 to be created (for example, <literal>CREATE TABLE foo();</>). This
934 is an extension from the SQL standard, which does not allow zero-column
935 tables. Zero-column tables are not in themselves very useful, but
936 disallowing them creates odd special cases for <command>ALTER TABLE
937 DROP COLUMN</>, so it seems cleaner to ignore this spec restriction.
944 <title>See Also</title>
946 <simplelist type="inline">
947 <member><xref linkend="sql-altertable" endterm="sql-altertable-title"></member>
948 <member><xref linkend="sql-droptable" endterm="sql-droptable-title"></member>
953 <!-- Keep this comment at the end of the file
958 sgml-minimize-attributes:nil
959 sgml-always-quote-attributes:t
962 sgml-parent-document:nil
963 sgml-default-dtd-file:"../reference.ced"
964 sgml-exposed-tags:nil
965 sgml-local-catalogs:"/usr/lib/sgml/catalog"
966 sgml-local-ecat-files:nil