*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.36 1997/12/04 00:28:03 scrappy Exp $
+ * $Id: parsenodes.h,v 1.37 1997/12/04 23:55:52 thomas Exp $
*
*-------------------------------------------------------------------------
*/
/* internal to planner */
List *base_relation_list_; /* base relation list */
List *join_relation_list_; /* list of relations */
-} Query;
+} Query;
/*****************************************************************************
NodeTag type;
char *relname; /* the relation to add attr */
bool inh; /* add recursively to children? */
- struct ColumnDef *colDef; /* the attribute definition */
+ Node *colDef; /* the attribute definition */
} AddAttrStmt;
/* ----------------------
struct AclItem *aclitem;
unsigned modechg;
List *relNames;
-} ChangeACLStmt;
+} ChangeACLStmt;
/* ----------------------
* Close Portal Statement
{
NodeTag type;
char *portalname; /* name of the portal (cursor) */
-} ClosePortalStmt;
+} ClosePortalStmt;
/* ----------------------
* Copy Statement
int direction; /* TO or FROM */
char *filename; /* if NULL, use stdin/stdout */
char *delimiter; /* delimiter character, \t by default */
-} CopyStmt;
+} CopyStmt;
/* ----------------------
* Create Table Statement
{
NodeTag type;
char *relname; /* the relation to create */
- List *tableElts; /* column definitions list of ColumnDef */
+ List *tableElts; /* column definitions list of Column */
List *inhRelnames; /* relations to inherit from list of Value
* (string) */
List *constraints; /* list of constraints (ConstaintDef) */
-} CreateStmt;
+} CreateStmt;
-typedef enum ConstrType
+typedef enum ConstrType /* type of constaints */
{
- CONSTR_NONE, CONSTR_CHECK /* type of constaints */
-} ConstrType;
+ CONSTR_NONE, CONSTR_NOTNULL, CONSTR_DEFAULT, CONSTR_CHECK, CONSTR_PRIMARY, CONSTR_UNIQUE
+} ConstrType;
-typedef struct ConstraintDef
+typedef struct Constraint
{
- ConstrType type;
+ NodeTag type;
+ ConstrType contype;
char *name; /* name */
void *def; /* definition */
-} ConstraintDef;
+ void *keys; /* list of primary keys */
+} Constraint;
/* ----------------------
* Create/Drop TRIGGER Statements
char *text; /* AS 'text' */
List *attr; /* UPDATE OF a, b,... (NI) or NULL */
char *when; /* WHEN 'a > 10 ...' (NI) or NULL */
-} CreateTrigStmt;
+} CreateTrigStmt;
typedef struct DropTrigStmt
{
NodeTag type;
char *trigname; /* TRIGGER' name */
char *relname; /* triggered relation */
-} DropTrigStmt;
+} DropTrigStmt;
/* ----------------------
char *plhandler; /* PL call handler function */
char *plcompiler; /* lancompiler text */
bool pltrusted; /* PL is trusted */
-} CreatePLangStmt;
+} CreatePLangStmt;
typedef struct DropPLangStmt
{
NodeTag type;
char *plname; /* PL name */
-} DropPLangStmt;
+} DropPLangStmt;
/* ----------------------
NodeTag type;
char *seqname; /* the relation to create */
List *options;
-} CreateSeqStmt;
+} CreateSeqStmt;
/* ----------------------
* Create Version Statement
int direction; /* FORWARD | BACKWARD */
char *fromRelname; /* relation to create a version */
char *date; /* date of the snapshot */
-} VersionStmt;
+} VersionStmt;
/* ----------------------
* Create {Operator|Type|Aggregate} Statement
int defType; /* OPERATOR|P_TYPE|AGGREGATE */
char *defname;
List *definition; /* a list of DefElem */
-} DefineStmt;
+} DefineStmt;
/* ----------------------
* Drop Table Statement
NodeTag type;
List *relNames; /* relations to be dropped */
bool sequence;
-} DestroyStmt;
+} DestroyStmt;
/* ----------------------
* Extend Index Statement
Node *whereClause; /* qualifications */
List *rangetable; /* range table, filled in by
* transformStmt() */
-} ExtendStmt;
+} ExtendStmt;
/* ----------------------
* Begin Recipe Statement
{
NodeTag type;
char *recipeName; /* name of the recipe */
-} RecipeStmt;
+} RecipeStmt;
/* ----------------------
* Fetch Statement
int howMany; /* amount to fetch ("ALL" --> 0) */
char *portalname; /* name of portal (cursor) */
bool ismove; /* TRUE if MOVE */
-} FetchStmt;
+} FetchStmt;
/* ----------------------
* Create Index Statement
* transformStmt() */
bool *lossy; /* is index lossy? */
bool unique; /* is index unique? */
-} IndexStmt;
+} IndexStmt;
/* ----------------------
* Create Function Statement
List *withClause; /* a list of ParamString */
char *as; /* the SQL statement or filename */
char *language; /* C or SQL */
-} ProcedureStmt;
+} ProcedureStmt;
/* ----------------------
* Drop Aggregate Statement
NodeTag type;
char *aggname; /* aggregate to drop */
char *aggtype; /* for this type */
-} RemoveAggrStmt;
+} RemoveAggrStmt;
/* ----------------------
* Drop Function Statement
NodeTag type;
char *funcname; /* function to drop */
List *args; /* types of the arguments */
-} RemoveFuncStmt;
+} RemoveFuncStmt;
/* ----------------------
* Drop Operator Statement
NodeTag type;
char *opname; /* operator to drop */
List *args; /* types of the arguments */
-} RemoveOperStmt;
+} RemoveOperStmt;
/* ----------------------
* Drop {Type|Index|Rule|View} Statement
NodeTag type;
int removeType; /* P_TYPE|INDEX|RULE|VIEW */
char *name; /* name to drop */
-} RemoveStmt;
+} RemoveStmt;
/* ----------------------
* Alter Table Statement
* the new name. Otherwise, rename this
* column name. */
char *newname; /* the new name */
-} RenameStmt;
+} RenameStmt;
/* ----------------------
* Create Rule Statement
struct Attr *object; /* object affected */
bool instead; /* is a 'do instead'? */
List *actions; /* the action statements */
-} RuleStmt;
+} RuleStmt;
/* ----------------------
* Notify Statement
{
NodeTag type;
char *relname; /* relation to notify */
-} NotifyStmt;
+} NotifyStmt;
/* ----------------------
* Listen Statement
{
NodeTag type;
char *relname; /* relation to listen on */
-} ListenStmt;
+} ListenStmt;
/* ----------------------
* {Begin|Abort|End} Transaction Statement
{
NodeTag type;
int command; /* BEGIN|END|ABORT */
-} TransactionStmt;
+} TransactionStmt;
/* ----------------------
* Create View Statement
NodeTag type;
char *viewname; /* name of the view */
Query *query; /* the SQL statement */
-} ViewStmt;
+} ViewStmt;
/* ----------------------
* Load Statement
{
NodeTag type;
char *filename; /* file to load */
-} LoadStmt;
+} LoadStmt;
/* ----------------------
* Createdb Statement
NodeTag type;
char *dbname; /* database to create */
char *dbpath; /* location of database */
-} CreatedbStmt;
+} CreatedbStmt;
/* ----------------------
* Destroydb Statement
{
NodeTag type;
char *dbname; /* database to drop */
-} DestroydbStmt;
+} DestroydbStmt;
/* ----------------------
* Cluster Statement (support pbrown's cluster index implementation)
NodeTag type;
char *relname; /* relation being indexed */
char *indexname; /* original index defined */
-} ClusterStmt;
+} ClusterStmt;
/* ----------------------
* Vacuum Statement
bool analyze; /* analyze data */
char *vacrel; /* table to vacuum */
List *va_spec; /* columns to analyse */
-} VacuumStmt;
+} VacuumStmt;
/* ----------------------
* Explain Statement
NodeTag type;
Query *query; /* the query */
bool verbose; /* print plan info */
-} ExplainStmt;
+} ExplainStmt;
/* ----------------------
* Set Statement
NodeTag type;
char *name;
char *value;
-} VariableSetStmt;
+} VariableSetStmt;
/* ----------------------
* Show Statement
{
NodeTag type;
char *name;
-} VariableShowStmt;
+} VariableShowStmt;
/* ----------------------
* Reset Statement
{
NodeTag type;
char *name;
-} VariableResetStmt;
+} VariableResetStmt;
/*****************************************************************************
NodeTag type;
char *relname; /* relation to delete from */
Node *whereClause; /* qualifications */
-} DeleteStmt;
+} DeleteStmt;
/* ----------------------
* Update Statement
List *targetList; /* the target list (of ResTarget) */
Node *whereClause; /* qualifications */
List *fromClause; /* the from clause */
-} ReplaceStmt;
+} ReplaceStmt;
/* ----------------------
* Create Cursor Statement
Node *whereClause; /* qualifications */
List *groupClause; /* group by clause */
List *sortClause; /* sort clause (a list of SortGroupBy's) */
-} CursorStmt;
+} CursorStmt;
/* ----------------------
* Select Statement
Node *havingClause; /* having conditional-expression */
List *selectClause; /* subselect parameters */
List *sortClause; /* sort clause (a list of SortGroupBy's) */
-} RetrieveStmt;
+} RetrieveStmt;
/****************************************************************************
Node *whereClause; /* qualifications */
List *groupClause; /* group by clause */
Node *havingClause; /* having conditional-expression */
-} SubSelect;
+} SubSelect;
/*
* TypeName - specifies a type in definitions
bool setof; /* is a set? */
List *arrayBounds; /* array bounds */
int typlen; /* length for char() and varchar() */
-} TypeName;
+} TypeName;
/*
* ParamNo - specifies a parameter reference
NodeTag type;
int number; /* the number of the parameter */
TypeName *typename; /* the typecast */
-} ParamNo;
+} ParamNo;
/*
* A_Expr - binary expressions
TypeName *typename; /* type of column */
bool is_not_null; /* flag to NOT NULL constraint */
char *defval; /* default value of column */
-} ColumnDef;
+ List *constraints; /* constraints on column */
+} ColumnDef;
/*
* Ident -
List *indirection; /* array references */
bool isRel; /* is a relation - filled in by
* transformExpr() */
-} Ident;
+} Ident;
/*
* FuncCall - a function/aggregate invocation
NodeTag type;
char *funcname; /* name of function */
List *args; /* the arguments (list of exprs) */
-} FuncCall;
+} FuncCall;
/*
* A_Indices - array reference or bounds ([lidx:uidx] or [uidx])
List *indirection; /* array references */
Node *val; /* the value of the result (A_Expr or
* Attr) (or A_Const) */
-} ResTarget;
+} ResTarget;
/*
* ParamString - used in with clauses
NodeTag type;
char *name;
char *val;
-} ParamString;
+} ParamString;
/*
* RelExpr - relation expressions
NodeTag type;
char *relname; /* the relation name */
bool inh; /* inheritance query */
-} RelExpr;
+} RelExpr;
/*
* SortGroupBy - for order by clause
char *range;
char *name; /* name of column to sort on */
char *useOp; /* operator to use */
-} SortGroupBy;
+} SortGroupBy;
/*
* RangeVar - range variable, used in from clauses
NodeTag type;
RelExpr *relExpr; /* the relation expression */
char *name; /* the name to be referenced (optional) */
-} RangeVar;
+} RangeVar;
/*
* IndexElem - index parameters (used in create index)
List *args; /* if not NULL, function index */
char *class;
TypeName *tname; /* type of index's keys (optional) */
-} IndexElem;
+} IndexElem;
/*
* DefElem -
NodeTag type;
char *defname;
Node *arg; /* a (Value *) or a (TypeName *) */
-} DefElem;
+} DefElem;
/****************************************************************************
Resdom *resdom; /* fjoin overload this to be a list?? */
Fjoin *fjoin;
Node *expr; /* can be a list too */
-} TargetEntry;
+} TargetEntry;
/*
* RangeTblEntry -
Oid relid;
bool inh; /* inheritance? */
bool inFromCl; /* comes from From Clause */
-} RangeTblEntry;
+} RangeTblEntry;
/*
* SortClause -
NodeTag type;
Resdom *resdom; /* attributes in tlist to be sorted */
Oid opoid; /* sort operators */
-} SortClause;
+} SortClause;
/*
* GroupClause -
NodeTag type;
TargetEntry *entry; /* attributes to group on */
Oid grpOpoid; /* the sort operator to use */
-} GroupClause;
+} GroupClause;
#endif /* PARSENODES_H */
projects / postgresql.git / commitdiff