*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.2 1997/11/26 01:11:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.3 1997/11/26 03:42:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_target.h"
#include "utils/syscache.h"
+static bool contain_agg_clause(Node *clause);
+static bool exprIsAggOrGroupCol(Node *expr, List *groupClause);
+static bool tleIsAggOrGroupCol(TargetEntry *tle, List *groupClause);
+
/*
* AddAggToParseState -
* add the aggregate to the list of unique aggregates in pstate.
*
* Returns true if any aggregate found.
*/
-bool
+static bool
contain_agg_clause(Node *clause)
{
if (clause == NULL)
* exprIsAggOrGroupCol -
* returns true if the expression does not contain non-group columns.
*/
-bool
+static bool
exprIsAggOrGroupCol(Node *expr, List *groupClause)
{
List *gl;
* tleIsAggOrGroupCol -
* returns true if the TargetEntry is Agg or GroupCol.
*/
-bool
+static bool
tleIsAggOrGroupCol(TargetEntry *tle, List *groupClause)
{
Node *expr = tle->expr;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.2 1997/11/26 01:11:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.3 1997/11/26 03:42:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
-/*
- * parseFromClause -
- * turns the table references specified in the from-clause into a
- * range table. The range table may grow as we transform the expressions
- * in the target list. (Note that this happens because in POSTQUEL, we
- * allow references to relations not specified in the from-clause. We
- * also allow that in our POST-SQL)
- *
- */
-void
-parseFromClause(ParseState *pstate, List *frmList)
-{
- List *fl;
-
- foreach(fl, frmList)
- {
- RangeVar *r = lfirst(fl);
- RelExpr *baserel = r->relExpr;
- char *relname = baserel->relname;
- char *refname = r->name;
- RangeTblEntry *rte;
-
- if (refname == NULL)
- refname = relname;
-
- /*
- * marks this entry to indicate it comes from the FROM clause. In
- * SQL, the target list can only refer to range variables
- * specified in the from clause but we follow the more powerful
- * POSTQUEL semantics and automatically generate the range
- * variable if not specified. However there are times we need to
- * know whether the entries are legitimate.
- *
- * eg. select * from foo f where f.x = 1; will generate wrong answer
- * if we expand * to foo.x.
- */
- rte = addRangeTableEntry(pstate, relname, refname, baserel->inh, TRUE);
- }
-}
+static TargetEntry *find_targetlist_entry(ParseState *pstate,
+ SortGroupBy *sortgroupby, List *tlist);
+static void parseFromClause(ParseState *pstate, List *frmList);
/*
* makeRangeTable -
/* will close relation later */
}
-/*****************************************************************************
- *
- * Where Clause
- *
- *****************************************************************************/
-
/*
* transformWhereClause -
* transforms the qualification and make sure it is of type Boolean
return qual;
}
-/*****************************************************************************
- *
- * Sort Clause
+/*
+ * parseFromClause -
+ * turns the table references specified in the from-clause into a
+ * range table. The range table may grow as we transform the expressions
+ * in the target list. (Note that this happens because in POSTQUEL, we
+ * allow references to relations not specified in the from-clause. We
+ * also allow that in our POST-SQL)
*
- *****************************************************************************/
+ */
+static void
+parseFromClause(ParseState *pstate, List *frmList)
+{
+ List *fl;
+
+ foreach(fl, frmList)
+ {
+ RangeVar *r = lfirst(fl);
+ RelExpr *baserel = r->relExpr;
+ char *relname = baserel->relname;
+ char *refname = r->name;
+ RangeTblEntry *rte;
+
+ if (refname == NULL)
+ refname = relname;
+
+ /*
+ * marks this entry to indicate it comes from the FROM clause. In
+ * SQL, the target list can only refer to range variables
+ * specified in the from clause but we follow the more powerful
+ * POSTQUEL semantics and automatically generate the range
+ * variable if not specified. However there are times we need to
+ * know whether the entries are legitimate.
+ *
+ * eg. select * from foo f where f.x = 1; will generate wrong answer
+ * if we expand * to foo.x.
+ */
+ rte = addRangeTableEntry(pstate, relname, refname, baserel->inh, TRUE);
+ }
+}
/*
* find_targetlist_entry -
* and range
*
*/
-TargetEntry *
+static TargetEntry *
find_targetlist_entry(ParseState *pstate, SortGroupBy *sortgroupby, List *tlist)
{
List *i;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.2 1997/11/26 01:11:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.3 1997/11/26 03:42:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/params.h"
#include "nodes/relation.h"
#include "parse.h"
+#include "parser/gramparse.h"
#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_node.h"
#include "parser/parse_target.h"
#include "utils/builtins.h"
-Oid param_type(int t); /* from gram.y */
+static Node *parser_typecast(Value *expr, TypeName *typename, int typlen);
/*
* transformExpr -
return (retval);
}
-Node *
+static Node *
parser_typecast(Value *expr, TypeName *typename, int typlen)
{
/* check for passing non-ints */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.2 1997/11/26 01:11:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.3 1997/11/26 03:42:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/lsyscache.h"
#include "utils/syscache.h"
+static Node *ParseComplexProjection(ParseState *pstate,
+ char *funcname,
+ Node *first_arg,
+ bool *attisset);
+static Oid ** argtype_inherit(int nargs, Oid *oid_array);
+static bool can_coerce(int nargs, Oid *input_typeids, Oid *func_typeids);
+static int find_inheritors(Oid relid, Oid **supervec);
+static CandidateList func_get_candidates(char *funcname, int nargs);
+static bool func_get_detail(char *funcname,
+ int nargs,
+ Oid *oid_array,
+ Oid *funcid, /* return value */
+ Oid *rettype, /* return value */
+ bool *retset, /* return value */
+ Oid **true_typeids);
+static Oid * func_select_candidate(int nargs,
+ Oid *input_typeids,
+ CandidateList candidates);
+static Oid funcid_get_rettype(Oid funcid);
+static Oid **gen_cross_product(InhPaths *arginh, int nargs);
+static void make_arguments(int nargs,
+ List *fargs,
+ Oid *input_typeids,
+ Oid *function_typeids);
+static int match_argtypes(int nargs,
+ Oid *input_typeids,
+ CandidateList function_typeids,
+ CandidateList *candidates);
+static List *setup_tlist(char *attname, Oid relid);
+static List *setup_base_tlist(Oid typeid);
+
#define ISCOMPLEX(type) (typeidTypeRelid(type) ? true : false)
#define MAXFARGS 8 /* max # args to a c or postquel function */
return (retval);
}
-Oid
+static Oid
funcid_get_rettype(Oid funcid)
{
HeapTuple func_tuple = NULL;
* get a list of all argument type vectors for which a function named
* funcname taking nargs arguments exists
*/
-CandidateList
+static CandidateList
func_get_candidates(char *funcname, int nargs)
{
Relation heapRelation;
/*
* can input_typeids be coerced to func_typeids?
*/
-bool
+static bool
can_coerce(int nargs, Oid *input_typeids, Oid *func_typeids)
{
int i;
* that match the input typeids (either exactly or by coercion), and
* return the number of such arrays
*/
-int
+static int
match_argtypes(int nargs,
Oid *input_typeids,
CandidateList function_typeids,
* returns the selected argtype array if the conflict can be resolved,
* otherwise returns NULL
*/
-Oid *
+static Oid *
func_select_candidate(int nargs,
Oid *input_typeids,
CandidateList candidates)
return (NULL);
}
-bool
+static bool
func_get_detail(char *funcname,
int nargs,
Oid *oid_array,
* not defined. There are lots of these (mostly builtins) in the
* catalogs.
*/
-Oid **
+static Oid **
argtype_inherit(int nargs, Oid *oid_array)
{
Oid relid;
arginh[i].self = oid_array[i];
if ((relid = typeidTypeRelid(oid_array[i])) != InvalidOid)
{
- arginh[i].nsupers = findsupers(relid, &(arginh[i].supervec));
+ arginh[i].nsupers = find_inheritors(relid, &(arginh[i].supervec));
}
else
{
}
/* return an ordered cross-product of the classes involved */
- return (genxprod(arginh, nargs));
+ return (gen_cross_product(arginh, nargs));
}
-int findsupers(Oid relid, Oid **supervec)
+static int find_inheritors(Oid relid, Oid **supervec)
{
Oid *relidvec;
Relation inhrel;
return (nvisited);
}
-Oid **
-genxprod(InhPaths *arginh, int nargs)
+static Oid **
+gen_cross_product(InhPaths *arginh, int nargs)
{
int nanswers;
Oid **result,
** Given the number and types of arguments to a function, and the
** actual arguments and argument types, do the necessary typecasting.
*/
-void
+static void
make_arguments(int nargs,
List *fargs,
Oid *input_typeids,
** on a tuple parameter or return value. Due to a bug in 4.0,
** it's not possible to refer to system attributes in this case.
*/
-List *
+static List *
setup_tlist(char *attname, Oid relid)
{
TargetEntry *tle;
** Build a tlist that extracts a base type from the tuple
** returned by the executor.
*/
-List *
+static List *
setup_base_tlist(Oid typeid)
{
TargetEntry *tle;
* handles function calls with a single argument that is of complex type.
* This routine returns NULL if it can't handle the projection (eg. sets).
*/
-Node *
+static Node *
ParseComplexProjection(ParseState *pstate,
char *funcname,
Node *first_arg,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.2 1997/11/26 01:11:22 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.3 1997/11/26 03:42:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/builtins.h"
#include "utils/syscache.h"
+static void disallow_setop(char *op, Type optype, Node *operand);
+static Node *make_operand(char *opname,
+ Node *tree,
+ Oid orig_typeId,
+ Oid true_typeId);
+
/*
* make_parsestate() --
* allocate and initialize a new ParseState.
return (pstate);
}
-Node *
+static Node *
make_operand(char *opname,
Node *tree,
Oid orig_typeId,
}
-void
+static void
disallow_setop(char *op, Type optype, Node *operand)
{
if (operand == NULL)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.2 1997/11/26 01:11:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.3 1997/11/26 03:42:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "storage/bufmgr.h"
#include "utils/syscache.h"
+static int binary_oper_get_candidates(char *opname,
+ Oid leftTypeId,
+ Oid rightTypeId,
+ CandidateList *candidates);
+static CandidateList binary_oper_select_candidate(Oid arg1,
+ Oid arg2,
+ CandidateList candidates);
+static bool equivalentOpersAfterPromotion(CandidateList candidates);
+static void op_error(char *op, Oid arg1, Oid arg2);
+static int unary_oper_get_candidates(char *op,
+ Oid typeId,
+ CandidateList *candidates,
+ char rightleft);
+
+
Oid
any_ordering_op(int restype)
{
* opname exists, such that leftTypeId can be coerced to arg1 and
* rightTypeId can be coerced to arg2
*/
-int
+static int
binary_oper_get_candidates(char *opname,
Oid leftTypeId,
Oid rightTypeId,
* the all the candidates operate on the same data types after
* promotion (int2, int4, float4 -> float8).
*/
-bool
+static bool
equivalentOpersAfterPromotion(CandidateList candidates)
{
CandidateList result;
* given a choice of argument type pairs for a binary operator,
* try to choose a default pair
*/
-CandidateList
+static CandidateList
binary_oper_select_candidate(Oid arg1,
Oid arg2,
CandidateList candidates)
* a right/left unary operator named opname exists,
* such that typeId can be coerced to it
*/
-int
+static int
unary_oper_get_candidates(char *op,
Oid typeId,
CandidateList *candidates,
* Give a somewhat useful error message when the operator for two types
* is not found.
*/
-void
+static void
op_error(char *op, Oid arg1, Oid arg2)
{
Type tp1 = NULL,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.2 1997/11/26 01:11:28 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.3 1997/11/26 03:42:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/builtins.h"
#include "utils/lsyscache.h"
+static void checkTargetTypes(ParseState *pstate, char *target_colname,
+ char *refname, char *colname);
+
struct
{
char *field;
* checkTargetTypes -
* checks value and target column types
*/
-void
+static void
checkTargetTypes(ParseState *pstate, char *target_colname,
char *refname, char *colname)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.2 1997/11/26 01:11:30 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.3 1997/11/26 03:42:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_target.h"
#include "utils/builtins.h"
+static List *expandAllTables(ParseState *pstate);
+static char *figureColname(Node *expr, Node *resval);
+static TargetEntry *make_targetlist_expr(ParseState *pstate,
+ char *colname,
+ Node *expr,
+ List *arrayRef);
+
/*
* transformTargetList -
* turns a list of ResTarget's into a list of TargetEntry's
*
* arrayRef is a list of transformed A_Indices
*/
-TargetEntry *
+static TargetEntry *
make_targetlist_expr(ParseState *pstate,
char *colname,
Node *expr,
* turns '*' (in the target list) into a list of attributes
* (of all relations in the range table)
*/
-List *
+static List *
expandAllTables(ParseState *pstate)
{
List *target = NIL;
* list, we have to guess.
*
*/
-char *
+static char *
figureColname(Node *expr, Node *resval)
{
switch (nodeTag(expr))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.11 1997/11/24 05:09:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.12 1997/11/26 03:42:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/palloc.h"
#include "utils/tqual.h"
+static bool heapisoverride(void);
+
extern bool PostgresIsInitialized;
/*
}
}
-/* static */
-bool
+static bool
heapisoverride()
{
if (!TransactionIdIsValid(HeapSpecialTransactionId))
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: gramparse.h,v 1.5 1997/09/08 21:53:37 momjian Exp $
+ * $Id: gramparse.h,v 1.6 1997/11/26 03:43:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void init_io(void);
/* from gram.y */
+extern Oid param_type(int t);
extern void parser_init(Oid *typev, int nargs);
extern int yyparse(void);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_agg.h,v 1.2 1997/11/26 01:13:58 momjian Exp $
+ * $Id: parse_agg.h,v 1.3 1997/11/26 03:43:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void AddAggToParseState(ParseState *pstate, Aggreg *aggreg);
extern void finalizeAggregates(ParseState *pstate, Query *qry);
-extern bool contain_agg_clause(Node *clause);
-extern bool exprIsAggOrGroupCol(Node *expr, List *groupClause);
-extern bool tleIsAggOrGroupCol(TargetEntry *tle, List *groupClause);
extern void parseCheckAggregates(ParseState *pstate, Query *qry);
extern Aggreg *ParseAgg(char *aggname, Oid basetype, Node *target);
extern void agg_error(char *caller, char *aggname, Oid basetypeID);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_clause.h,v 1.2 1997/11/26 01:14:00 momjian Exp $
+ * $Id: parse_clause.h,v 1.3 1997/11/26 03:43:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
-extern void parseFromClause(ParseState *pstate, List *frmList);
extern void makeRangeTable(ParseState *pstate, char *relname, List *frmList);
extern Node *transformWhereClause(ParseState *pstate, Node *a_expr);
-extern TargetEntry *find_targetlist_entry(ParseState *pstate,
- SortGroupBy *sortgroupby, List *tlist);
extern List *transformGroupClause(ParseState *pstate, List *grouplist,
List *targetlist);
extern List *transformSortClause(ParseState *pstate,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_expr.h,v 1.2 1997/11/26 01:14:02 momjian Exp $
+ * $Id: parse_expr.h,v 1.3 1997/11/26 03:43:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Node *transformIdent(ParseState *pstate, Node *expr, int precedence);
extern Oid exprType(Node *expr);
extern Node *handleNestedDots(ParseState *pstate, Attr *attr, int *curr_resno);
-extern Node *parser_typecast(Value *expr, TypeName *typename, int typlen);
extern Node *parser_typecast2(Node *expr, Oid exprType, Type tp, int typlen);
#endif /* PARSE_EXPR_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_func.h,v 1.2 1997/11/26 01:14:04 momjian Exp $
+ * $Id: parse_func.h,v 1.3 1997/11/26 03:43:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Node *ParseFunc(ParseState *pstate, char *funcname, List *fargs,
int *curr_resno);
-extern Oid funcid_get_rettype(Oid funcid);
-extern CandidateList func_get_candidates(char *funcname, int nargs);
-extern bool can_coerce(int nargs, Oid *input_typeids, Oid *func_typeids);
-extern int match_argtypes(int nargs,
- Oid *input_typeids,
- CandidateList function_typeids,
- CandidateList *candidates);
-extern Oid * func_select_candidate(int nargs,
- Oid *input_typeids,
- CandidateList candidates);
-extern bool func_get_detail(char *funcname,
- int nargs,
- Oid *oid_array,
- Oid *funcid, /* return value */
- Oid *rettype, /* return value */
- bool *retset, /* return value */
- Oid **true_typeids);
-extern Oid ** argtype_inherit(int nargs, Oid *oid_array);
-extern int findsupers(Oid relid, Oid **supervec);
-extern Oid **genxprod(InhPaths *arginh, int nargs);
-extern void make_arguments(int nargs,
- List *fargs,
- Oid *input_typeids,
- Oid *function_typeids);
-extern List *setup_tlist(char *attname, Oid relid);
-extern List *setup_base_tlist(Oid typeid);
-extern Node *ParseComplexProjection(ParseState *pstate,
- char *funcname,
- Node *first_arg,
- bool *attisset);
extern void func_error(char *caller, char *funcname, int nargs, Oid *argtypes);
#endif /* PARSE_FUNC_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_node.h,v 1.2 1997/11/26 01:14:05 momjian Exp $
+ * $Id: parse_node.h,v 1.3 1997/11/26 03:43:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
} ParseState;
extern ParseState *make_parsestate(void);
-extern Node *make_operand(char *opname,
- Node *tree,
- Oid orig_typeId,
- Oid true_typeId);
-extern void disallow_setop(char *op, Type optype, Node *operand);
extern Expr *make_op(char *opname, Node *ltree, Node *rtree);
extern Var *make_var(ParseState *pstate, char *refname, char *attrname, Oid *type_id);
extern ArrayRef *make_array_ref(Node *expr,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_oper.h,v 1.2 1997/11/26 01:14:07 momjian Exp $
+ * $Id: parse_oper.h,v 1.3 1997/11/26 03:43:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Oid any_ordering_op(int restype);
extern Oid oprid(Operator op);
-extern int binary_oper_get_candidates(char *opname,
- Oid leftTypeId,
- Oid rightTypeId,
- CandidateList *candidates);
-extern bool equivalentOpersAfterPromotion(CandidateList candidates);
-extern CandidateList binary_oper_select_candidate(Oid arg1,
- Oid arg2,
- CandidateList candidates);
extern Operator oper(char *op, Oid arg1, Oid arg2, bool noWarnings);
-extern int unary_oper_get_candidates(char *op,
- Oid typeId,
- CandidateList *candidates,
- char rightleft);
extern Operator right_oper(char *op, Oid arg);
extern Operator left_oper(char *op, Oid arg);
-extern void op_error(char *op, Oid arg1, Oid arg2);
#endif /* PARSE_OPER_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_relation.h,v 1.2 1997/11/26 01:14:08 momjian Exp $
+ * $Id: parse_relation.h,v 1.3 1997/11/26 03:43:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Oid attnumTypeId(Relation rd, int attid);
extern void handleTargetColname(ParseState *pstate, char **resname,
char *refname, char *colname);
-extern void checkTargetTypes(ParseState *pstate, char *target_colname,
- char *refname, char *colname);
#endif /* PARSE_RANGE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_target.h,v 1.2 1997/11/26 01:14:10 momjian Exp $
+ * $Id: parse_target.h,v 1.3 1997/11/26 03:43:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define EXPR_RELATION_FIRST 2
extern List *transformTargetList(ParseState *pstate, List *targetlist);
-extern TargetEntry *make_targetlist_expr(ParseState *pstate,
- char *colname,
- Node *expr,
- List *arrayRef);
-extern List *expandAllTables(ParseState *pstate);
-extern char *figureColname(Node *expr, Node *resval);
extern List *makeTargetNames(ParseState *pstate, List *cols);
#endif /* PARSE_TARGET_H */
projects / postgresql.git / commitdiff