1996-07-09 08:22:35 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* pg_dump.h
|
2002-05-11 00:36:27 +02:00
|
|
|
* Common header file for the pg_dump utility
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2004-08-29 06:13:13 +02:00
|
|
|
* Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group
|
2000-01-26 06:58:53 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
1996-07-09 08:22:35 +02:00
|
|
|
*
|
2004-12-14 23:16:32 +01:00
|
|
|
* $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.h,v 1.114 2004/12/14 22:16:32 tgl Exp $
|
2000-09-15 06:35:16 +02:00
|
|
|
*
|
1996-07-09 08:22:35 +02:00
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
|
1999-10-23 05:13:33 +02:00
|
|
|
#ifndef PG_DUMP_H
|
|
|
|
#define PG_DUMP_H
|
|
|
|
|
2003-12-06 04:00:16 +01:00
|
|
|
#include "postgres_fe.h"
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pg_dump uses two different mechanisms for identifying database objects:
|
|
|
|
*
|
|
|
|
* CatalogId represents an object by the tableoid and oid of its defining
|
|
|
|
* entry in the system catalogs. We need this to interpret pg_depend entries,
|
|
|
|
* for instance.
|
|
|
|
*
|
|
|
|
* DumpId is a simple sequential integer counter assigned as dumpable objects
|
|
|
|
* are identified during a pg_dump run. We use DumpId internally in preference
|
|
|
|
* to CatalogId for two reasons: it's more compact, and we can assign DumpIds
|
|
|
|
* to "objects" that don't have a separate CatalogId. For example, it is
|
|
|
|
* convenient to consider a table, its data, and its ACL as three separate
|
|
|
|
* dumpable "objects" with distinct DumpIds --- this lets us reason about the
|
|
|
|
* order in which to dump these things.
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
Oid tableoid;
|
|
|
|
Oid oid;
|
|
|
|
} CatalogId;
|
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
typedef int DumpId;
|
2003-12-06 04:00:16 +01:00
|
|
|
|
1999-10-23 05:13:33 +02:00
|
|
|
|
2002-05-11 00:36:27 +02:00
|
|
|
/*
|
2003-12-06 04:00:16 +01:00
|
|
|
* The data structures used to store system catalog information. Every
|
|
|
|
* dumpable object is a subclass of DumpableObject.
|
2002-05-11 00:36:27 +02:00
|
|
|
*
|
|
|
|
* NOTE: the structures described here live for the entire pg_dump run;
|
|
|
|
* and in most cases we make a struct for every object we can find in the
|
2002-09-04 22:31:48 +02:00
|
|
|
* catalogs, not only those we are actually going to dump. Hence, it's
|
2002-05-11 00:36:27 +02:00
|
|
|
* best to store a minimal amount of per-object info in these structs,
|
|
|
|
* and retrieve additional per-object info when and if we dump a specific
|
2002-09-04 22:31:48 +02:00
|
|
|
* object. In particular, try to avoid retrieving expensive-to-compute
|
2003-12-06 04:00:16 +01:00
|
|
|
* information until it's known to be needed. We do, however, have to
|
|
|
|
* store enough info to determine whether an object should be dumped and
|
|
|
|
* what order to dump in.
|
2002-05-11 00:36:27 +02:00
|
|
|
*/
|
|
|
|
|
2003-12-06 04:00:16 +01:00
|
|
|
typedef enum
|
|
|
|
{
|
2004-03-03 22:28:55 +01:00
|
|
|
/* When modifying this enum, update priority tables in pg_dump_sort.c! */
|
2003-12-06 04:00:16 +01:00
|
|
|
DO_NAMESPACE,
|
|
|
|
DO_TYPE,
|
|
|
|
DO_FUNC,
|
|
|
|
DO_AGG,
|
|
|
|
DO_OPERATOR,
|
|
|
|
DO_OPCLASS,
|
|
|
|
DO_CONVERSION,
|
|
|
|
DO_TABLE,
|
|
|
|
DO_ATTRDEF,
|
|
|
|
DO_INDEX,
|
|
|
|
DO_RULE,
|
|
|
|
DO_TRIGGER,
|
|
|
|
DO_CONSTRAINT,
|
|
|
|
DO_FK_CONSTRAINT, /* see note for ConstraintInfo */
|
|
|
|
DO_PROCLANG,
|
|
|
|
DO_CAST,
|
2004-03-03 22:28:55 +01:00
|
|
|
DO_TABLE_DATA,
|
|
|
|
DO_TABLE_TYPE,
|
|
|
|
DO_BLOBS
|
2003-12-06 04:00:16 +01:00
|
|
|
} DumpableObjectType;
|
|
|
|
|
|
|
|
typedef struct _dumpableObject
|
|
|
|
{
|
|
|
|
DumpableObjectType objType;
|
|
|
|
CatalogId catId; /* zero if not a cataloged object */
|
|
|
|
DumpId dumpId; /* assigned by AssignDumpId() */
|
2004-03-03 22:28:55 +01:00
|
|
|
char *name; /* object name (should never be NULL) */
|
|
|
|
struct _namespaceInfo *namespace; /* containing namespace, or NULL */
|
2003-12-06 04:00:16 +01:00
|
|
|
DumpId *dependencies; /* dumpIds of objects this one depends on */
|
|
|
|
int nDeps; /* number of valid dependencies */
|
|
|
|
int allocDeps; /* allocated size of dependencies[] */
|
|
|
|
} DumpableObject;
|
|
|
|
|
2002-05-11 00:36:27 +02:00
|
|
|
typedef struct _namespaceInfo
|
|
|
|
{
|
2003-12-06 04:00:16 +01:00
|
|
|
DumpableObject dobj;
|
2002-05-11 00:36:27 +02:00
|
|
|
char *usename; /* name of owner, or empty string */
|
|
|
|
char *nspacl;
|
|
|
|
bool dump; /* true if need to dump definition */
|
|
|
|
} NamespaceInfo;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
typedef struct _typeInfo
|
|
|
|
{
|
2003-12-06 04:00:16 +01:00
|
|
|
DumpableObject dobj;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-03-03 22:28:55 +01:00
|
|
|
/*
|
|
|
|
* Note: dobj.name is the pg_type.typname entry. format_type() might
|
|
|
|
* produce something different than typname
|
|
|
|
*/
|
2002-05-11 00:36:27 +02:00
|
|
|
char *usename; /* name of owner, or empty string */
|
2003-12-06 04:00:16 +01:00
|
|
|
Oid typinput;
|
|
|
|
Oid typelem;
|
|
|
|
Oid typrelid;
|
2002-08-15 18:36:08 +02:00
|
|
|
char typrelkind; /* 'r', 'v', 'c', etc */
|
2002-05-11 00:36:27 +02:00
|
|
|
char typtype; /* 'b', 'c', etc */
|
|
|
|
bool isArray; /* true if user-defined array type */
|
|
|
|
bool isDefined; /* true if typisdefined */
|
2003-12-06 04:00:16 +01:00
|
|
|
/* If it's a domain, we store links to its constraints here: */
|
|
|
|
int nDomChecks;
|
|
|
|
struct _constraintInfo *domChecks;
|
1997-09-08 23:56:23 +02:00
|
|
|
} TypeInfo;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
|
|
|
typedef struct _funcInfo
|
|
|
|
{
|
2003-12-06 04:00:16 +01:00
|
|
|
DumpableObject dobj;
|
2002-05-11 00:36:27 +02:00
|
|
|
char *usename; /* name of owner, or empty string */
|
2001-08-10 20:57:42 +02:00
|
|
|
Oid lang;
|
1997-09-08 04:41:22 +02:00
|
|
|
int nargs;
|
2003-12-06 04:00:16 +01:00
|
|
|
Oid *argtypes;
|
|
|
|
Oid prorettype;
|
2002-05-19 12:08:25 +02:00
|
|
|
char *proacl;
|
1997-09-08 23:56:23 +02:00
|
|
|
} FuncInfo;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2003-12-06 04:00:16 +01:00
|
|
|
/* AggInfo is a superset of FuncInfo */
|
2002-05-11 00:36:27 +02:00
|
|
|
typedef struct _aggInfo
|
2000-07-04 16:25:28 +02:00
|
|
|
{
|
2003-12-06 04:00:16 +01:00
|
|
|
FuncInfo aggfn;
|
2002-08-22 02:01:51 +02:00
|
|
|
bool anybasetype; /* is the basetype "any"? */
|
2002-05-29 00:26:57 +02:00
|
|
|
char *fmtbasetype; /* formatted type name */
|
2002-05-11 00:36:27 +02:00
|
|
|
} AggInfo;
|
|
|
|
|
|
|
|
typedef struct _oprInfo
|
|
|
|
{
|
2003-12-06 04:00:16 +01:00
|
|
|
DumpableObject dobj;
|
2002-05-11 00:36:27 +02:00
|
|
|
char *usename;
|
2003-12-06 04:00:16 +01:00
|
|
|
Oid oprcode;
|
2002-05-11 00:36:27 +02:00
|
|
|
} OprInfo;
|
2000-07-04 16:25:28 +02:00
|
|
|
|
2002-07-30 23:56:04 +02:00
|
|
|
typedef struct _opclassInfo
|
|
|
|
{
|
2003-12-06 04:00:16 +01:00
|
|
|
DumpableObject dobj;
|
2002-07-30 23:56:04 +02:00
|
|
|
char *usename;
|
|
|
|
} OpclassInfo;
|
|
|
|
|
2003-11-21 23:32:49 +01:00
|
|
|
typedef struct _convInfo
|
|
|
|
{
|
2003-12-06 04:00:16 +01:00
|
|
|
DumpableObject dobj;
|
2003-11-21 23:32:49 +01:00
|
|
|
char *usename;
|
|
|
|
} ConvInfo;
|
|
|
|
|
1997-09-07 07:04:48 +02:00
|
|
|
typedef struct _tableInfo
|
|
|
|
{
|
2002-05-11 00:36:27 +02:00
|
|
|
/*
|
|
|
|
* These fields are collected for every table in the database.
|
|
|
|
*/
|
2003-12-06 04:00:16 +01:00
|
|
|
DumpableObject dobj;
|
2002-05-11 00:36:27 +02:00
|
|
|
char *usename; /* name of owner, or empty string */
|
1997-09-08 04:41:22 +02:00
|
|
|
char *relacl;
|
2002-01-12 00:21:55 +01:00
|
|
|
char relkind;
|
2004-06-18 08:14:31 +02:00
|
|
|
char *reltablespace; /* relation tablespace */
|
2002-01-12 00:21:55 +01:00
|
|
|
bool hasindex; /* does it have any indexes? */
|
2002-05-11 00:36:27 +02:00
|
|
|
bool hasrules; /* does it have any rules? */
|
2001-08-10 20:57:42 +02:00
|
|
|
bool hasoids; /* does it have OIDs? */
|
2002-05-11 00:36:27 +02:00
|
|
|
int ncheck; /* # of CHECK expressions */
|
|
|
|
int ntrig; /* # of triggers */
|
2002-08-19 21:33:36 +02:00
|
|
|
/* these two are set only if table is a SERIAL column's sequence: */
|
2003-12-06 04:00:16 +01:00
|
|
|
Oid owning_tab; /* OID of table owning sequence */
|
2002-08-19 21:33:36 +02:00
|
|
|
int owning_col; /* attr # of column owning sequence */
|
2002-05-11 00:36:27 +02:00
|
|
|
|
|
|
|
bool interesting; /* true if need to collect more data */
|
|
|
|
bool dump; /* true if we want to dump it */
|
|
|
|
|
|
|
|
/*
|
2002-09-04 22:31:48 +02:00
|
|
|
* These fields are computed only if we decide the table is
|
|
|
|
* interesting (it's either a table to dump, or a direct parent of a
|
|
|
|
* dumpable table).
|
2002-05-11 00:36:27 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
int numatts; /* number of attributes */
|
|
|
|
char **attnames; /* the attribute names */
|
2002-05-11 00:36:27 +02:00
|
|
|
char **atttypnames; /* attribute type names */
|
|
|
|
int *atttypmod; /* type-specific type modifiers */
|
2002-07-31 19:19:54 +02:00
|
|
|
int *attstattarget; /* attribute statistics targets */
|
2003-08-04 02:43:34 +02:00
|
|
|
char *attstorage; /* attribute storage scheme */
|
|
|
|
char *typstorage; /* type storage scheme */
|
2002-08-19 21:33:36 +02:00
|
|
|
bool *attisdropped; /* true if attr is dropped; don't dump it */
|
2002-10-09 18:20:25 +02:00
|
|
|
bool *attislocal; /* true if attr has local definition */
|
2002-08-19 21:33:36 +02:00
|
|
|
bool *attisserial; /* true if attr is serial or bigserial */
|
2002-09-04 22:31:48 +02:00
|
|
|
|
2002-05-11 00:36:27 +02:00
|
|
|
/*
|
2004-08-29 07:07:03 +02:00
|
|
|
* Note: we need to store per-attribute notnull, default, and
|
|
|
|
* constraint stuff for all interesting tables so that we can tell
|
|
|
|
* which constraints were inherited.
|
2002-05-11 00:36:27 +02:00
|
|
|
*/
|
|
|
|
bool *notnull; /* Not null constraints on attributes */
|
2004-08-29 07:07:03 +02:00
|
|
|
struct _attrDefInfo **attrdefs; /* DEFAULT expressions */
|
2002-05-11 00:36:27 +02:00
|
|
|
bool *inhAttrs; /* true if each attribute is inherited */
|
|
|
|
bool *inhAttrDef; /* true if attr's default is inherited */
|
|
|
|
bool *inhNotNull; /* true if NOT NULL is inherited */
|
2004-08-29 07:07:03 +02:00
|
|
|
struct _constraintInfo *checkexprs; /* CHECK constraints */
|
2002-05-11 00:36:27 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Stuff computed only for dumpable tables.
|
|
|
|
*/
|
|
|
|
int numParents; /* number of (immediate) parent tables */
|
2004-08-29 07:07:03 +02:00
|
|
|
struct _tableInfo **parents; /* TableInfos of immediate parents */
|
1997-09-08 23:56:23 +02:00
|
|
|
} TableInfo;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
2003-12-06 04:00:16 +01:00
|
|
|
typedef struct _attrDefInfo
|
|
|
|
{
|
|
|
|
DumpableObject dobj;
|
|
|
|
TableInfo *adtable; /* link to table of attribute */
|
|
|
|
int adnum;
|
|
|
|
char *adef_expr; /* decompiled DEFAULT expression */
|
|
|
|
bool separate; /* TRUE if must dump as separate item */
|
|
|
|
} AttrDefInfo;
|
|
|
|
|
|
|
|
typedef struct _tableDataInfo
|
|
|
|
{
|
|
|
|
DumpableObject dobj;
|
|
|
|
TableInfo *tdtable; /* link to table to dump */
|
|
|
|
bool oids; /* include OIDs in data? */
|
|
|
|
} TableDataInfo;
|
|
|
|
|
|
|
|
typedef struct _indxInfo
|
|
|
|
{
|
|
|
|
DumpableObject dobj;
|
|
|
|
TableInfo *indextable; /* link to table the index is for */
|
|
|
|
char *indexdef;
|
2004-08-02 06:28:29 +02:00
|
|
|
char *tablespace; /* tablespace in which index is stored */
|
2003-12-06 04:00:16 +01:00
|
|
|
int indnkeys;
|
|
|
|
Oid *indkeys;
|
|
|
|
bool indisclustered;
|
|
|
|
/* if there is an associated constraint object, its dumpId: */
|
|
|
|
DumpId indexconstraint;
|
|
|
|
} IndxInfo;
|
|
|
|
|
|
|
|
typedef struct _ruleInfo
|
|
|
|
{
|
|
|
|
DumpableObject dobj;
|
|
|
|
TableInfo *ruletable; /* link to table the rule is for */
|
|
|
|
char ev_type;
|
|
|
|
bool is_instead;
|
2004-12-14 23:16:32 +01:00
|
|
|
bool separate; /* TRUE if must dump as separate item */
|
|
|
|
/* separate is always true for non-ON SELECT rules */
|
2003-12-06 04:00:16 +01:00
|
|
|
} RuleInfo;
|
|
|
|
|
|
|
|
typedef struct _triggerInfo
|
|
|
|
{
|
|
|
|
DumpableObject dobj;
|
|
|
|
TableInfo *tgtable; /* link to table the trigger is for */
|
|
|
|
char *tgfname;
|
|
|
|
int tgtype;
|
|
|
|
int tgnargs;
|
|
|
|
char *tgargs;
|
|
|
|
bool tgisconstraint;
|
|
|
|
char *tgconstrname;
|
|
|
|
Oid tgconstrrelid;
|
|
|
|
char *tgconstrrelname;
|
|
|
|
bool tgdeferrable;
|
|
|
|
bool tginitdeferred;
|
|
|
|
} TriggerInfo;
|
|
|
|
|
|
|
|
/*
|
2004-08-29 07:07:03 +02:00
|
|
|
* struct ConstraintInfo is used for all constraint types. However we
|
2003-12-06 04:00:16 +01:00
|
|
|
* use a different objType for foreign key constraints, to make it easier
|
|
|
|
* to sort them the way we want.
|
|
|
|
*/
|
|
|
|
typedef struct _constraintInfo
|
|
|
|
{
|
|
|
|
DumpableObject dobj;
|
|
|
|
TableInfo *contable; /* NULL if domain constraint */
|
|
|
|
TypeInfo *condomain; /* NULL if table constraint */
|
|
|
|
char contype;
|
|
|
|
char *condef; /* definition, if CHECK or FOREIGN KEY */
|
|
|
|
DumpId conindex; /* identifies associated index if any */
|
|
|
|
bool coninherited; /* TRUE if appears to be inherited */
|
|
|
|
bool separate; /* TRUE if must dump as separate item */
|
|
|
|
} ConstraintInfo;
|
|
|
|
|
|
|
|
typedef struct _procLangInfo
|
|
|
|
{
|
|
|
|
DumpableObject dobj;
|
|
|
|
bool lanpltrusted;
|
|
|
|
Oid lanplcallfoid;
|
|
|
|
Oid lanvalidator;
|
|
|
|
char *lanacl;
|
|
|
|
} ProcLangInfo;
|
|
|
|
|
|
|
|
typedef struct _castInfo
|
|
|
|
{
|
|
|
|
DumpableObject dobj;
|
|
|
|
Oid castsource;
|
|
|
|
Oid casttarget;
|
|
|
|
Oid castfunc;
|
|
|
|
char castcontext;
|
|
|
|
} CastInfo;
|
|
|
|
|
|
|
|
/* InhInfo isn't a DumpableObject, just temporary state */
|
1997-09-07 07:04:48 +02:00
|
|
|
typedef struct _inhInfo
|
|
|
|
{
|
2003-12-06 04:00:16 +01:00
|
|
|
Oid inhrelid; /* OID of a child table */
|
|
|
|
Oid inhparent; /* OID of its parent */
|
1997-09-08 23:56:23 +02:00
|
|
|
} InhInfo;
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/* global decls */
|
2001-08-22 22:23:24 +02:00
|
|
|
extern bool force_quotes; /* double-quotes for identifiers flag */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool g_verbose; /* verbose flag */
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/* placeholders for comment starting and ending delimiters */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern char g_comment_start[10];
|
|
|
|
extern char g_comment_end[10];
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
extern char g_opaque_type[10]; /* name for the opaque type */
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* common utility functions
|
2002-05-11 00:36:27 +02:00
|
|
|
*/
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2003-12-06 04:00:16 +01:00
|
|
|
extern TableInfo *getSchemaData(int *numTablesPtr,
|
2004-08-29 07:07:03 +02:00
|
|
|
const bool schemaOnly,
|
|
|
|
const bool dataOnly);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
2001-03-22 05:01:46 +01:00
|
|
|
typedef enum _OidOptions
|
|
|
|
{
|
2001-10-28 07:26:15 +01:00
|
|
|
zeroAsOpaque = 1,
|
|
|
|
zeroAsAny = 2,
|
|
|
|
zeroAsStar = 4,
|
2002-05-11 00:36:27 +02:00
|
|
|
zeroAsNone = 8
|
2000-09-15 06:35:16 +02:00
|
|
|
} OidOptions;
|
|
|
|
|
2003-12-06 04:00:16 +01:00
|
|
|
extern void AssignDumpId(DumpableObject *dobj);
|
|
|
|
extern DumpId createDumpId(void);
|
|
|
|
extern DumpId getMaxDumpId(void);
|
|
|
|
extern DumpableObject *findObjectByDumpId(DumpId dumpId);
|
|
|
|
extern DumpableObject *findObjectByCatalogId(CatalogId catalogId);
|
|
|
|
extern void getDumpableObjects(DumpableObject ***objs, int *numObjs);
|
|
|
|
|
|
|
|
extern void addObjectDependency(DumpableObject *dobj, DumpId refId);
|
|
|
|
extern void removeObjectDependency(DumpableObject *dobj, DumpId refId);
|
|
|
|
|
|
|
|
extern TableInfo *findTableByOid(Oid oid);
|
|
|
|
extern TypeInfo *findTypeByOid(Oid oid);
|
|
|
|
extern FuncInfo *findFuncByOid(Oid oid);
|
|
|
|
extern OprInfo *findOprByOid(Oid oid);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
extern void check_conn_and_db(void);
|
2002-05-11 00:36:27 +02:00
|
|
|
extern void exit_nicely(void);
|
|
|
|
|
2003-12-06 04:00:16 +01:00
|
|
|
extern void parseOidArray(const char *str, Oid *array, int arraysize);
|
|
|
|
|
|
|
|
extern void sortDumpableObjects(DumpableObject **objs, int numObjs);
|
2004-03-03 22:28:55 +01:00
|
|
|
extern void sortDumpableObjectsByTypeName(DumpableObject **objs, int numObjs);
|
|
|
|
extern void sortDumpableObjectsByTypeOid(DumpableObject **objs, int numObjs);
|
1996-07-09 08:22:35 +02:00
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* version specific routines
|
1996-07-09 08:22:35 +02:00
|
|
|
*/
|
2002-05-11 00:36:27 +02:00
|
|
|
extern NamespaceInfo *getNamespaces(int *numNamespaces);
|
1997-09-07 07:04:48 +02:00
|
|
|
extern TypeInfo *getTypes(int *numTypes);
|
|
|
|
extern FuncInfo *getFuncs(int *numFuncs);
|
|
|
|
extern AggInfo *getAggregates(int *numAggregates);
|
|
|
|
extern OprInfo *getOperators(int *numOperators);
|
2002-07-30 23:56:04 +02:00
|
|
|
extern OpclassInfo *getOpclasses(int *numOpclasses);
|
2003-11-21 23:32:49 +01:00
|
|
|
extern ConvInfo *getConversions(int *numConversions);
|
2002-05-11 00:36:27 +02:00
|
|
|
extern TableInfo *getTables(int *numTables);
|
1997-09-07 07:04:48 +02:00
|
|
|
extern InhInfo *getInherits(int *numInherits);
|
2003-12-06 04:00:16 +01:00
|
|
|
extern void getIndexes(TableInfo tblinfo[], int numTables);
|
|
|
|
extern void getConstraints(TableInfo tblinfo[], int numTables);
|
|
|
|
extern RuleInfo *getRules(int *numRules);
|
|
|
|
extern void getTriggers(TableInfo tblinfo[], int numTables);
|
|
|
|
extern ProcLangInfo *getProcLangs(int *numProcLangs);
|
|
|
|
extern CastInfo *getCasts(int *numCasts);
|
1997-09-08 23:56:23 +02:00
|
|
|
extern void getTableAttrs(TableInfo *tbinfo, int numTables);
|
2001-10-28 07:26:15 +01:00
|
|
|
|
2001-11-05 18:46:40 +01:00
|
|
|
#endif /* PG_DUMP_H */
|