pg_query 2.2.1 → 4.2.1

data/ext/pg_query/src_backend_parser_parse_expr.c

@@ -1,313 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - operator_precedence_warning
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * parse_expr.c
- *	  handle expressions in parser
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/backend/parser/parse_expr.c
- *
- *-------------------------------------------------------------------------
- */
-
-#include "postgres.h"
-
-#include "catalog/pg_type.h"
-#include "commands/dbcommands.h"
-#include "miscadmin.h"
-#include "nodes/makefuncs.h"
-#include "nodes/nodeFuncs.h"
-#include "optimizer/optimizer.h"
-#include "parser/analyze.h"
-#include "parser/parse_agg.h"
-#include "parser/parse_clause.h"
-#include "parser/parse_coerce.h"
-#include "parser/parse_collate.h"
-#include "parser/parse_expr.h"
-#include "parser/parse_func.h"
-#include "parser/parse_oper.h"
-#include "parser/parse_relation.h"
-#include "parser/parse_target.h"
-#include "parser/parse_type.h"
-#include "utils/builtins.h"
-#include "utils/date.h"
-#include "utils/lsyscache.h"
-#include "utils/timestamp.h"
-#include "utils/xml.h"
-
-/* GUC parameters */
-__thread bool		operator_precedence_warning = false;
-
-
-
-/*
- * Node-type groups for operator precedence warnings
- * We use zero for everything not otherwise classified
- */
-#define PREC_GROUP_POSTFIX_IS	1	/* postfix IS tests (NullTest, etc) */
-#define PREC_GROUP_INFIX_IS		2	/* infix IS (IS DISTINCT FROM, etc) */
-#define PREC_GROUP_LESS			3	/* < > */
-#define PREC_GROUP_EQUAL		4	/* = */
-#define PREC_GROUP_LESS_EQUAL	5	/* <= >= <> */
-#define PREC_GROUP_LIKE			6	/* LIKE ILIKE SIMILAR */
-#define PREC_GROUP_BETWEEN		7	/* BETWEEN */
-#define PREC_GROUP_IN			8	/* IN */
-#define PREC_GROUP_NOT_LIKE		9	/* NOT LIKE/ILIKE/SIMILAR */
-#define PREC_GROUP_NOT_BETWEEN	10	/* NOT BETWEEN */
-#define PREC_GROUP_NOT_IN		11	/* NOT IN */
-#define PREC_GROUP_POSTFIX_OP	12	/* generic postfix operators */
-#define PREC_GROUP_INFIX_OP		13	/* generic infix operators */
-#define PREC_GROUP_PREFIX_OP	14	/* generic prefix operators */
-
-/*
- * Map precedence groupings to old precedence ordering
- *
- * Old precedence order:
- * 1. NOT
- * 2. =
- * 3. < >
- * 4. LIKE ILIKE SIMILAR
- * 5. BETWEEN
- * 6. IN
- * 7. generic postfix Op
- * 8. generic Op, including <= => <>
- * 9. generic prefix Op
- * 10. IS tests (NullTest, BooleanTest, etc)
- *
- * NOT BETWEEN etc map to BETWEEN etc when considered as being on the left,
- * but to NOT when considered as being on the right, because of the buggy
- * precedence handling of those productions in the old grammar.
- */
-
-
-
-static Node *transformExprRecurse(ParseState *pstate, Node *expr);
-static Node *transformParamRef(ParseState *pstate, ParamRef *pref);
-static Node *transformAExprOp(ParseState *pstate, A_Expr *a);
-static Node *transformAExprOpAny(ParseState *pstate, A_Expr *a);
-static Node *transformAExprOpAll(ParseState *pstate, A_Expr *a);
-static Node *transformAExprDistinct(ParseState *pstate, A_Expr *a);
-static Node *transformAExprNullIf(ParseState *pstate, A_Expr *a);
-static Node *transformAExprOf(ParseState *pstate, A_Expr *a);
-static Node *transformAExprIn(ParseState *pstate, A_Expr *a);
-static Node *transformAExprBetween(ParseState *pstate, A_Expr *a);
-static Node *transformBoolExpr(ParseState *pstate, BoolExpr *a);
-static Node *transformFuncCall(ParseState *pstate, FuncCall *fn);
-static Node *transformMultiAssignRef(ParseState *pstate, MultiAssignRef *maref);
-static Node *transformCaseExpr(ParseState *pstate, CaseExpr *c);
-static Node *transformSubLink(ParseState *pstate, SubLink *sublink);
-static Node *transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
-								Oid array_type, Oid element_type, int32 typmod);
-static Node *transformRowExpr(ParseState *pstate, RowExpr *r, bool allowDefault);
-static Node *transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c);
-static Node *transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m);
-static Node *transformSQLValueFunction(ParseState *pstate,
-									   SQLValueFunction *svf);
-static Node *transformXmlExpr(ParseState *pstate, XmlExpr *x);
-static Node *transformXmlSerialize(ParseState *pstate, XmlSerialize *xs);
-static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
-static Node *transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr);
-static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
-static Node *transformWholeRowRef(ParseState *pstate,
-								  ParseNamespaceItem *nsitem,
-								  int sublevels_up, int location);
-static Node *transformIndirection(ParseState *pstate, A_Indirection *ind);
-static Node *transformTypeCast(ParseState *pstate, TypeCast *tc);
-static Node *transformCollateClause(ParseState *pstate, CollateClause *c);
-static Node *make_row_comparison_op(ParseState *pstate, List *opname,
-									List *largs, List *rargs, int location);
-static Node *make_row_distinct_op(ParseState *pstate, List *opname,
-								  RowExpr *lrow, RowExpr *rrow, int location);
-static Expr *make_distinct_op(ParseState *pstate, List *opname,
-							  Node *ltree, Node *rtree, int location);
-static Node *make_nulltest_from_distinct(ParseState *pstate,
-										 A_Expr *distincta, Node *arg);
-static int	operator_precedence_group(Node *node, const char **nodename);
-static void emit_precedence_warnings(ParseState *pstate,
-									 int opgroup, const char *opname,
-									 Node *lchild, Node *rchild,
-									 int location);
-
-
-/*
- * transformExpr -
- *	  Analyze and transform expressions. Type checking and type casting is
- *	  done here.  This processing converts the raw grammar output into
- *	  expression trees with fully determined semantics.
- */
-
-
-
-
-/*
- * helper routine for delivering "column does not exist" error message
- *
- * (Usually we don't have to work this hard, but the general case of field
- * selection from an arbitrary node needs it.)
- */
-
-
-
-
-/*
- * Transform a ColumnRef.
- *
- * If you find yourself changing this code, see also ExpandColumnRefStar.
- */
-
-
-
-
-/* Test whether an a_expr is a plain NULL constant or not */
-
-
-
-
-
-
-
-
-
-
-
-
-/*
- * Checking an expression for match to a list of type names. Will result
- * in a boolean constant node.
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*
- * transformArrayExpr
- *
- * If the caller specifies the target type, the resulting array will
- * be of exactly that type.  Otherwise we try to infer a common type
- * for the elements using select_common_type().
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*
- * Construct a whole-row reference to represent the notation "relation.*".
- */
-
-
-/*
- * Handle an explicit CAST construct.
- *
- * Transform the argument, look up the type name, and apply any necessary
- * coercion function(s).
- */
-
-
-/*
- * Handle an explicit COLLATE clause.
- *
- * Transform the argument, and look up the collation name.
- */
-
-
-/*
- * Transform a "row compare-op row" construct
- *
- * The inputs are lists of already-transformed expressions.
- * As with coerce_type, pstate may be NULL if no special unknown-Param
- * processing is wanted.
- *
- * The output may be a single OpExpr, an AND or OR combination of OpExprs,
- * or a RowCompareExpr.  In all cases it is guaranteed to return boolean.
- * The AND, OR, and RowCompareExpr cases further imply things about the
- * behavior of the operators (ie, they behave as =, <>, or < <= > >=).
- */
-
-
-/*
- * Transform a "row IS DISTINCT FROM row" construct
- *
- * The input RowExprs are already transformed
- */
-
-
-/*
- * make the node for an IS DISTINCT FROM operator
- */
-
-
-/*
- * Produce a NullTest node from an IS [NOT] DISTINCT FROM NULL construct
- *
- * "arg" is the untransformed other argument
- */
-
-
-/*
- * Identify node's group for operator precedence warnings
- *
- * For items in nonzero groups, also return a suitable node name into *nodename
- *
- * Note: group zero is used for nodes that are higher or lower precedence
- * than everything that changed precedence; we need never issue warnings
- * related to such nodes.
- */
-
-
-/*
- * helper routine for delivering 9.4-to-9.5 operator precedence warnings
- *
- * opgroup/opname/location represent some parent node
- * lchild, rchild are its left and right children (either could be NULL)
- *
- * This should be called before transforming the child nodes, since if a
- * precedence-driven parsing change has occurred in a query that used to work,
- * it's quite possible that we'll get a semantic failure while analyzing the
- * child expression.  We want to produce the warning before that happens.
- * In any case, operator_precedence_group() expects untransformed input.
- */
-
-
-/*
- * Produce a string identifying an expression by kind.
- *
- * Note: when practical, use a simple SQL keyword for the result.  If that
- * doesn't work well, check call sites to see whether custom error message
- * strings are required.
- */
-

data/ext/pg_query/src_port_erand48.c

@@ -1,127 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - pg_lrand48
- * - _dorand48
- * - _rand48_seed
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * erand48.c
- *
- * This file supplies pg_erand48() and related functions, which except
- * for the names are just like the POSIX-standard erand48() family.
- * (We don't supply the full set though, only the ones we have found use
- * for in Postgres.  In particular, we do *not* implement lcong48(), so
- * that there is no need for the multiplier and addend to be variable.)
- *
- * We used to test for an operating system version rather than
- * unconditionally using our own, but (1) some versions of Cygwin have a
- * buggy erand48() that always returns zero and (2) as of 2011, glibc's
- * erand48() is strangely coded to be almost-but-not-quite thread-safe,
- * which doesn't matter for the backend but is important for pgbench.
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- *
- * Portions Copyright (c) 1993 Martin Birgmeier
- * All rights reserved.
- *
- * You may redistribute unmodified or modified versions of this source
- * code provided that the above copyright notice and this and the
- * following conditions are retained.
- *
- * This software is provided ``as is'', and comes with no warranties
- * of any kind. I shall in no event be liable for anything that happens
- * to anyone/anything when using this software.
- *
- * IDENTIFICATION
- *	  src/port/erand48.c
- *
- *-------------------------------------------------------------------------
- */
-
-#include "c.h"
-
-#include <math.h>
-
-/* These values are specified by POSIX */
-#define RAND48_MULT		UINT64CONST(0x0005deece66d)
-#define RAND48_ADD		UINT64CONST(0x000b)
-
-/* POSIX specifies 0x330e's use in srand48, but the other bits are arbitrary */
-#define RAND48_SEED_0	(0x330e)
-#define RAND48_SEED_1	(0xabcd)
-#define RAND48_SEED_2	(0x1234)
-
-static __thread unsigned short _rand48_seed[3] = {
-	RAND48_SEED_0,
-	RAND48_SEED_1,
-	RAND48_SEED_2
-};
-
-
-
-/*
- * Advance the 48-bit value stored in xseed[] to the next "random" number.
- *
- * Also returns the value of that number --- without masking it to 48 bits.
- * If caller uses the result, it must mask off the bits it wants.
- */
-static uint64
-_dorand48(unsigned short xseed[3])
-{
-	/*
-	 * We do the arithmetic in uint64; any type wider than 48 bits would work.
-	 */
-	uint64		in;
-	uint64		out;
-
-	in = (uint64) xseed[2] << 32 | (uint64) xseed[1] << 16 | (uint64) xseed[0];
-
-	out = in * RAND48_MULT + RAND48_ADD;
-
-	xseed[0] = out & 0xFFFF;
-	xseed[1] = (out >> 16) & 0xFFFF;
-	xseed[2] = (out >> 32) & 0xFFFF;
-
-	return out;
-}
-
-
-/*
- * Generate a random floating-point value using caller-supplied state.
- * Values are uniformly distributed over the interval [0.0, 1.0).
- */
-
-
-/*
- * Generate a random non-negative integral value using internal state.
- * Values are uniformly distributed over the interval [0, 2^31).
- */
-long
-pg_lrand48(void)
-{
-	uint64		x = _dorand48(_rand48_seed);
-
-	return (x >> 17) & UINT64CONST(0x7FFFFFFF);
-}
-
-/*
- * Generate a random signed integral value using caller-supplied state.
- * Values are uniformly distributed over the interval [-2^31, 2^31).
- */
-
-
-/*
- * Initialize the internal state using the given seed.
- *
- * Per POSIX, this uses only 32 bits from "seed" even if "long" is wider.
- * Hence, the set of possible seed values is smaller than it could be.
- * Better practice is to use caller-supplied state and initialize it with
- * random bits obtained from a high-quality source of random bits.
- *
- * Note: POSIX specifies a function seed48() that allows all 48 bits
- * of the internal state to be set, but we don't currently support that.
- */
-

data/ext/pg_query/src_port_random.c

@@ -1,31 +0,0 @@
-/*--------------------------------------------------------------------
- * Symbols referenced in this file:
- * - random
- *--------------------------------------------------------------------
- */
-
-/*-------------------------------------------------------------------------
- *
- * random.c
- *	  random() wrapper
- *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- *	  src/port/random.c
- *
- *-------------------------------------------------------------------------
- */
-
-#include "c.h"
-
-#include <math.h>
-
-
-long
-random(void)
-{
-	return pg_lrand48();
-}