aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/backend/executor/execQual.c112
-rw-r--r--src/backend/nodes/copyfuncs.c31
-rw-r--r--src/backend/nodes/equalfuncs.c32
-rw-r--r--src/backend/nodes/outfuncs.c37
-rw-r--r--src/backend/nodes/readfuncs.c51
-rw-r--r--src/backend/optimizer/util/clauses.c30
-rw-r--r--src/backend/parser/gram.y39
-rw-r--r--src/backend/parser/keywords.c4
-rw-r--r--src/backend/parser/parse_expr.c89
-rw-r--r--src/backend/utils/adt/ruleutils.c27
-rw-r--r--src/include/nodes/makefuncs.h3
-rw-r--r--src/include/nodes/nodes.h3
-rw-r--r--src/include/nodes/parsenodes.h21
-rw-r--r--src/test/regress/expected/select.out147
-rw-r--r--src/test/regress/sql/select.sql28
15 files changed, 619 insertions, 35 deletions
diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c
index 6bb2b5fa942..4246b44dac0 100644
--- a/src/backend/executor/execQual.c
+++ b/src/backend/executor/execQual.c
@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.97 2002/07/06 20:16:35 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.98 2002/07/18 04:41:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -38,6 +38,9 @@
#include "executor/execdebug.h"
#include "executor/functions.h"
#include "executor/nodeSubplan.h"
+#include "nodes/makefuncs.h"
+#include "parser/parse.h"
+#include "parser/parse_expr.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/fcache.h"
@@ -62,6 +65,8 @@ static Datum ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull);
static Datum ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull);
static Datum ExecEvalCase(CaseExpr *caseExpr, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
+static Datum ExecEvalBetweenExpr(BetweenExpr *btest, ExprContext *econtext,
+ bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalNullTest(NullTest *ntest, ExprContext *econtext,
bool *isNull, ExprDoneCond *isDone);
static Datum ExecEvalBooleanTest(BooleanTest *btest, ExprContext *econtext,
@@ -1189,6 +1194,104 @@ ExecEvalCase(CaseExpr *caseExpr, ExprContext *econtext,
}
/* ----------------------------------------------------------------
+ * ExecEvalBetweenExpr
+ *
+ * Evaluate a BetweenExpr node. Result is
+ * a boolean. If any of the three expression
+ * parameters are NULL, result is NULL.
+ * ----------------------------------------------------------------
+ */
+static Datum
+ExecEvalBetweenExpr(BetweenExpr *btest,
+ ExprContext *econtext,
+ bool *isNull,
+ ExprDoneCond *isDone)
+{
+ Datum expr_result;
+ Datum lexpr_result;
+ Datum rexpr_result;
+ bool result = FALSE;
+ Node *expr_const;
+ Node *lexpr_const;
+ Node *rexpr_const;
+
+ /* Evaluate subexpressons and Auto-return if we find a NULL */
+ expr_result = ExecEvalExpr(btest->expr, econtext, isNull, isDone);
+ if (*isNull)
+ return (Datum) 0;
+
+ lexpr_result = ExecEvalExpr(btest->lexpr, econtext, isNull, isDone);
+ if (*isNull)
+ return (Datum) 0;
+
+ rexpr_result = ExecEvalExpr(btest->rexpr, econtext, isNull, isDone);
+ if (*isNull)
+ return (Datum) 0;
+
+ /*
+ * Make a Constant out of our newly found Datums
+ * Types were coerced during transformExpr to be common
+ */
+ expr_const = (Node *) makeConst(btest->typeId, btest->typeLen,
+ expr_result, false,
+ btest->typeByVal, false, true);
+
+ lexpr_const = (Node *) makeConst(btest->typeId, btest->typeLen,
+ lexpr_result, false,
+ btest->typeByVal, false, true);
+
+ rexpr_const = (Node *) makeConst(btest->typeId, btest->typeLen,
+ rexpr_result, false,
+ btest->typeByVal, false, true);
+
+ /*
+ * Test the between case which for the straight forward method.
+ * expr >= lexpr and expr <= rexpr
+ *
+ * Of course, can't use makeA_Expr here without requiring another
+ * transform, so we've already prepared a gthan and lthan operator
+ * set in the parsing stage.
+ */
+ btest->gthan->args = makeList2(expr_const, lexpr_const);
+ if (DatumGetBool(ExecEvalExpr((Node *) btest->gthan,
+ econtext,
+ isNull, isDone)))
+ {
+ btest->lthan->args = makeList2(expr_const, rexpr_const);
+ result = DatumGetBool(ExecEvalExpr((Node *) btest->lthan,
+ econtext,
+ isNull, isDone));
+ }
+
+ /*
+ * If this is a symmetric BETWEEN, we win a second try with the operators
+ * reversed. (a >= min(b,c) and a <= max(b,c))
+ */
+ if (!result && btest->symmetric)
+ {
+ btest->gthan->args = makeList2(expr_const, rexpr_const);
+ if (DatumGetBool(ExecEvalExpr((Node *) btest->gthan,
+ econtext,
+ isNull, isDone)))
+ {
+ btest->lthan->args = makeList2(expr_const, lexpr_const);
+ result = DatumGetBool(ExecEvalExpr((Node *) btest->lthan,
+ econtext,
+ isNull, isDone));
+ }
+ }
+
+ /* Apply NOT as necessary */
+ if (btest->not)
+ result = !result;
+
+ /* We're not returning a null */
+ *isNull = false;
+
+ return (BoolGetDatum(result));
+}
+
+/* ----------------------------------------------------------------
* ExecEvalNullTest
*
* Evaluate a NullTest node.
@@ -1524,6 +1627,12 @@ ExecEvalExpr(Node *expression,
isNull,
isDone);
break;
+ case T_BetweenExpr:
+ retDatum = ExecEvalBetweenExpr((BetweenExpr *) expression,
+ econtext,
+ isNull,
+ isDone);
+ break;
case T_NullTest:
retDatum = ExecEvalNullTest((NullTest *) expression,
econtext,
@@ -1536,7 +1645,6 @@ ExecEvalExpr(Node *expression,
isNull,
isDone);
break;
-
default:
elog(ERROR, "ExecEvalExpr: unknown expression type %d",
nodeTag(expression));
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 426180dc111..46cd8720637 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -15,7 +15,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.194 2002/07/16 22:12:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.195 2002/07/18 04:41:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -1000,6 +1000,32 @@ _copyCaseExpr(CaseExpr *from)
}
/* ----------------
+ * _copyBetweenExpr
+ * ----------------
+ */
+static BetweenExpr *
+_copyBetweenExpr(BetweenExpr *from)
+{
+ BetweenExpr *newnode = makeNode(BetweenExpr);
+
+ /*
+ * copy remainder of node
+ */
+ Node_Copy(from, newnode, expr);
+ Node_Copy(from, newnode, lexpr);
+ Node_Copy(from, newnode, rexpr);
+ Node_Copy(from, newnode, lthan);
+ Node_Copy(from, newnode, gthan);
+ newnode->symmetric = from->symmetric;
+ newnode->not = from->not;
+ newnode->typeId = from->typeId;
+ newnode->typeLen = from->typeLen;
+ newnode->typeByVal = from->typeByVal;
+
+ return newnode;
+}
+
+/* ----------------
* _copyCaseWhen
* ----------------
*/
@@ -3052,6 +3078,9 @@ copyObject(void *from)
case T_CaseExpr:
retval = _copyCaseExpr(from);
break;
+ case T_BetweenExpr:
+ retval = _copyBetweenExpr(from);
+ break;
case T_CaseWhen:
retval = _copyCaseWhen(from);
break;
diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index ed5d638f0cb..92132942948 100644
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -20,7 +20,7 @@
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.141 2002/07/16 22:12:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.142 2002/07/18 04:41:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -1770,6 +1770,33 @@ _equalCaseExpr(CaseExpr *a, CaseExpr *b)
}
static bool
+_equalBetweenExpr(BetweenExpr *a, BetweenExpr *b)
+{
+ if (!equal(a->expr, b->expr))
+ return false;
+ if (!equal(a->lexpr, b->lexpr))
+ return false;
+ if (!equal(a->rexpr, b->rexpr))
+ return false;
+ if (!equal(a->lthan, b->lthan))
+ return false;
+ if (!equal(a->gthan, b->gthan))
+ return false;
+ if (a->symmetric != b->symmetric)
+ return false;
+ if (a->not != b->not)
+ return false;
+ if (a->typeId != b->typeId)
+ return false;
+ if (a->typeLen != b->typeLen)
+ return false;
+ if (a->typeByVal != b->typeByVal)
+ return false;
+
+ return true;
+}
+
+static bool
_equalCaseWhen(CaseWhen *a, CaseWhen *b)
{
if (!equal(a->expr, b->expr))
@@ -2217,6 +2244,9 @@ equal(void *a, void *b)
case T_CaseExpr:
retval = _equalCaseExpr(a, b);
break;
+ case T_BetweenExpr:
+ retval = _equalBetweenExpr(a, b);
+ break;
case T_CaseWhen:
retval = _equalCaseWhen(a, b);
break;
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index a9e6a8382d5..04721d64754 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -5,7 +5,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.163 2002/07/16 22:12:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.164 2002/07/18 04:41:44 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
@@ -1484,6 +1484,38 @@ _outCaseWhen(StringInfo str, CaseWhen *node)
}
/*
+ * BetweenExpr
+ */
+static void
+_outBetweenExpr(StringInfo str, BetweenExpr *node)
+{
+ appendStringInfo(str, " BETWEENEXPR :expr ");
+ _outNode(str, node->expr);
+
+ appendStringInfo(str, " :not %s",
+ booltostr(node->not));
+
+ appendStringInfo(str, " :symmetric %s",
+ booltostr(node->symmetric));
+
+ appendStringInfo(str, " :lexpr ");
+ _outNode(str, node->lexpr);
+
+ appendStringInfo(str, " :rexpr ");
+ _outNode(str, node->rexpr);
+
+ appendStringInfo(str, " :gthan ");
+ _outNode(str, node->gthan);
+
+ appendStringInfo(str, " :lthan ");
+ _outNode(str, node->lthan);
+
+ appendStringInfo(str, " :typeid %u :typelen %d :typebyval %s",
+ node->typeId, node->typeLen,
+ booltostr(node->typeByVal));
+}
+
+/*
* NullTest
*/
static void
@@ -1767,6 +1799,9 @@ _outNode(StringInfo str, void *obj)
case T_CaseExpr:
_outCaseExpr(str, obj);
break;
+ case T_BetweenExpr:
+ _outBetweenExpr(str, obj);
+ break;
case T_CaseWhen:
_outCaseWhen(str, obj);
break;
diff --git a/src/backend/nodes/readfuncs.c b/src/backend/nodes/readfuncs.c
index 0a22194e47c..9598d8311e5 100644
--- a/src/backend/nodes/readfuncs.c
+++ b/src/backend/nodes/readfuncs.c
@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.124 2002/07/04 15:23:54 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.125 2002/07/18 04:41:45 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
@@ -881,6 +881,53 @@ _readCaseWhen(void)
return local_node;
}
+static BetweenExpr *
+_readBetweenExpr(void)
+{
+ BetweenExpr *local_node;
+ char *token;
+ int length;
+
+ local_node = makeNode(BetweenExpr);
+
+ token = pg_strtok(&length); /* eat :expr */
+ local_node->expr = nodeRead(true);
+
+ token = pg_strtok(&length); /* eat :not */
+ token = pg_strtok(&length); /* get not */
+ local_node->not = strtobool(token);
+
+ token = pg_strtok(&length); /* eat :symmetric */
+ token = pg_strtok(&length); /* get symmetric */
+ local_node->symmetric = strtobool(token);
+
+ token = pg_strtok(&length); /* eat :lexpr */
+ local_node->lexpr = nodeRead(true);
+
+ token = pg_strtok(&length); /* eat :rexpr */
+ local_node->rexpr = nodeRead(true);
+
+ token = pg_strtok(&length); /* eat :gthan */
+ local_node->gthan = nodeRead(true);
+
+ token = pg_strtok(&length); /* eat :lthan */
+ local_node->lthan = nodeRead(true);
+
+ token = pg_strtok(&length); /* eat :typeid */
+ token = pg_strtok(&length); /* get typeid */
+ local_node->typeId = atooid(token);
+
+ token = pg_strtok(&length); /* eat :typelen */
+ token = pg_strtok(&length); /* get typelen */
+ local_node->typeLen = atoui(token);
+
+ token = pg_strtok(&length); /* eat :typebyval */
+ token = pg_strtok(&length); /* get typebyval */
+ local_node->typeByVal = strtobool(token);
+
+ return local_node;
+}
+
/* ----------------
* _readNullTest
*
@@ -2132,6 +2179,8 @@ parsePlanString(void)
return_value = _readNullTest();
else if (length == 11 && strncmp(token, "BOOLEANTEST", length) == 0)
return_value = _readBooleanTest();
+ else if (length == 11 && strncmp(token, "BETWEENEXPR", length) == 0)
+ return_value = _readBetweenExpr();
else
elog(ERROR, "badly formatted planstring \"%.10s\"...", token);
diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 889a10b9ee3..571c7386ee5 100644
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.103 2002/07/06 20:16:35 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.104 2002/07/18 04:41:45 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@@ -1817,8 +1817,6 @@ expression_tree_walker(Node *node,
case T_Var:
case T_Param:
case T_RangeTblRef:
- /* primitive node types with no subnodes */
- break;
case T_Expr:
{
Expr *expr = (Expr *) node;
@@ -1965,6 +1963,18 @@ expression_tree_walker(Node *node,
return true;
}
break;
+ case T_BetweenExpr:
+ {
+ BetweenExpr *betwn = (BetweenExpr *) node;
+
+ if (walker(betwn->expr, context))
+ return true;
+ if (walker(betwn->lexpr, context))
+ return true;
+ if (walker(betwn->rexpr, context))
+ return true;
+ }
+ break;
default:
elog(ERROR, "expression_tree_walker: Unexpected node type %d",
nodeTag(node));
@@ -2123,8 +2133,6 @@ expression_tree_mutator(Node *node,
case T_Var:
case T_Param:
case T_RangeTblRef:
- /* primitive node types with no subnodes */
- return (Node *) copyObject(node);
case T_Expr:
{
Expr *expr = (Expr *) node;
@@ -2272,6 +2280,18 @@ expression_tree_mutator(Node *node,
return (Node *) newnode;
}
break;
+ case T_BetweenExpr:
+ {
+ BetweenExpr *bexpr = (BetweenExpr *) node;
+ BetweenExpr *newnode;
+
+ FLATCOPY(newnode, bexpr, BetweenExpr);
+ MUTATE(newnode->expr, bexpr->expr, Node *);
+ MUTATE(newnode->lexpr, bexpr->lexpr, Node *);
+ MUTATE(newnode->rexpr, bexpr->rexpr, Node *);
+ return (Node *) newnode;
+ }
+ break;
case T_SubLink:
{
/*
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index 33b534f8eff..f2220aa00b9 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -11,7 +11,7 @@
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.342 2002/07/18 02:02:30 ishii Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.343 2002/07/18 04:41:45 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
@@ -235,7 +235,7 @@ static void doNegateFloat(Value *v);
%type <list> extract_list, overlay_list, position_list
%type <list> substr_list, trim_list
-%type <ival> opt_interval
+%type <ival> opt_interval, opt_symmetry
%type <node> overlay_placing, substr_from, substr_for
%type <boolean> opt_instead, opt_cursor
@@ -320,7 +320,7 @@ static void doNegateFloat(Value *v);
/* ordinary key words in alphabetical order */
%token <keyword> ABORT_TRANS, ABSOLUTE, ACCESS, ACTION, ADD, AFTER,
AGGREGATE, ALL, ALTER, ANALYSE, ANALYZE, AND, ANY, AS, ASC,
- ASSERTION, ASSIGNMENT, AT, AUTHORIZATION,
+ ASSERTION, ASSIGNMENT, ASYMMETRIC, AT, AUTHORIZATION,
BACKWARD, BEFORE, BEGIN_TRANS, BETWEEN, BIGINT, BINARY, BIT, BOTH,
BOOLEAN, BY,
@@ -379,7 +379,7 @@ static void doNegateFloat(Value *v);
SERIALIZABLE, SESSION, SESSION_USER, SET, SETOF, SHARE,
SHOW, SIMILAR, SIMPLE, SMALLINT, SOME, STABLE, START, STATEMENT,
STATISTICS, STDIN, STDOUT, STORAGE, STRICT, SUBSTRING,
- SYSID,
+ SYMMETRIC, SYSID,
TABLE, TEMP, TEMPLATE, TEMPORARY, THEN, TIME, TIMESTAMP,
TO, TOAST, TRAILING, TRANSACTION, TREAT, TRIGGER, TRIM, TRUE_P,
@@ -5500,17 +5500,25 @@ a_expr: c_expr { $$ = $1; }
}
| a_expr IS DISTINCT FROM a_expr %prec DISTINCT
{ $$ = (Node *) makeSimpleA_Expr(DISTINCT, "=", $1, $5); }
- | a_expr BETWEEN b_expr AND b_expr %prec BETWEEN
+ | a_expr BETWEEN opt_symmetry b_expr AND b_expr %prec BETWEEN
{
- $$ = (Node *) makeA_Expr(AND, NIL,
- (Node *) makeSimpleA_Expr(OP, ">=", $1, $3),
- (Node *) makeSimpleA_Expr(OP, "<=", $1, $5));
+ BetweenExpr *n = makeNode(BetweenExpr);
+ n->expr = $1;
+ n->symmetric = $3;
+ n->lexpr = $4;
+ n->rexpr = $6;
+ n->not = false;
+ $$ = (Node *)n;
}
- | a_expr NOT BETWEEN b_expr AND b_expr %prec BETWEEN
+ | a_expr NOT BETWEEN opt_symmetry b_expr AND b_expr %prec BETWEEN
{
- $$ = (Node *) makeA_Expr(OR, NIL,
- (Node *) makeSimpleA_Expr(OP, "<", $1, $4),
- (Node *) makeSimpleA_Expr(OP, ">", $1, $6));
+ BetweenExpr *n = makeNode(BetweenExpr);
+ n->expr = $1;
+ n->symmetric = $4;
+ n->lexpr = $5;
+ n->rexpr = $7;
+ n->not = true;
+ $$ = (Node *)n;
}
| a_expr IN_P in_expr
{
@@ -5582,6 +5590,11 @@ a_expr: c_expr { $$ = $1; }
{ $$ = $1; }
;
+opt_symmetry: SYMMETRIC { $$ = TRUE; }
+ | ASYMMETRIC { $$ = FALSE; }
+ | /* EMPTY */ { $$ = FALSE; }
+ ;
+
/*
* Restricted expressions
*
@@ -6919,6 +6932,7 @@ reserved_keyword:
| ANY
| AS
| ASC
+ | ASYMMETRIC
| BOTH
| CASE
| CAST
@@ -6969,6 +6983,7 @@ reserved_keyword:
| SELECT
| SESSION_USER
| SOME
+ | SYMMETRIC
| TABLE
| THEN
| TO
diff --git a/src/backend/parser/keywords.c b/src/backend/parser/keywords.c
index 907a26baee6..cfdea14962d 100644
--- a/src/backend/parser/keywords.c
+++ b/src/backend/parser/keywords.c
@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.119 2002/07/11 07:39:26 ishii Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.120 2002/07/18 04:41:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -45,6 +45,7 @@ static const ScanKeyword ScanKeywords[] = {
{"asc", ASC},
{"assertion", ASSERTION},
{"assignment", ASSIGNMENT},
+ {"asymmetric", ASYMMETRIC},
{"at", AT},
{"authorization", AUTHORIZATION},
{"backward", BACKWARD},
@@ -272,6 +273,7 @@ static const ScanKeyword ScanKeywords[] = {
{"storage", STORAGE},
{"strict", STRICT},
{"substring", SUBSTRING},
+ {"symmetric", SYMMETRIC},
{"sysid", SYSID},
{"table", TABLE},
{"temp", TEMP},
diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index d93aeb55b5d..1ae340b670e 100644
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.121 2002/07/06 20:16:36 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.122 2002/07/18 04:41:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -69,11 +69,8 @@ parse_expr_init(void)
* here.
*
* NOTE: there are various cases in which this routine will get applied to
- * an already-transformed expression. Some examples:
- * 1. At least one construct (BETWEEN/AND) puts the same nodes
- * into two branches of the parse tree; hence, some nodes
- * are transformed twice.
- * 2. Another way it can happen is that coercion of an operator or
+ * an already-transformed expression. An examples:
+ * - Another way it can happen is that coercion of an operator or
* function argument to the required type (via coerce_type())
* can apply transformExpr to an already-transformed subexpression.
* An example here is "SELECT count(*) + 1.0 FROM table".
@@ -588,6 +585,82 @@ transformExpr(ParseState *pstate, Node *expr)
result = expr;
break;
}
+ case T_BetweenExpr:
+ {
+ BetweenExpr *b = (BetweenExpr *) expr;
+ List *typeIds = NIL;
+ HeapTuple tup;
+ Form_pg_operator opform;
+
+ /* Transform the expressions */
+ b->expr = transformExpr(pstate, b->expr);
+ b->lexpr = transformExpr(pstate, b->lexpr);
+ b->rexpr = transformExpr(pstate, b->rexpr);
+
+ /* Find coercion type for all 3 entities */
+ typeIds = lappendi(typeIds, exprType(b->expr));
+ typeIds = lappendi(typeIds, exprType(b->lexpr));
+ typeIds = lappendi(typeIds, exprType(b->rexpr));
+ b->typeId = select_common_type(typeIds, "TransformExpr");
+
+ /* Additional type information */
+ b->typeLen = get_typlen(b->typeId);
+ b->typeByVal = get_typbyval(b->typeId);
+
+ /* Coerce the three expressions to the type */
+ b->expr = coerce_to_common_type(pstate, b->expr,
+ b->typeId,
+ "TransformExpr");
+
+ b->lexpr = coerce_to_common_type(pstate, b->lexpr,
+ b->typeId,
+ "TransformExpr");
+
+ b->rexpr = coerce_to_common_type(pstate, b->rexpr,
+ b->typeId,
+ "TransformExpr");
+
+ /* Build the >= operator */
+ tup = oper(makeList1(makeString(">=")),
+ b->typeId, b->typeId, false);
+ opform = (Form_pg_operator) GETSTRUCT(tup);
+
+ /* Triple check our types */
+ if (b->typeId != opform->oprright || b->typeId != opform->oprleft)
+ elog(ERROR, "transformExpr: Unable to find appropriate"
+ " operator for between operation");
+
+ b->gthan = makeNode(Expr);
+ b->gthan->typeOid = opform->oprresult;
+ b->gthan->opType = OP_EXPR;
+ b->gthan->oper = (Node *) makeOper(oprid(tup), /* opno */
+ oprfuncid(tup), /* opid */
+ opform->oprresult, /* opresulttype */
+ get_func_retset(opform->oprcode));/* opretset */
+ ReleaseSysCache(tup);
+
+ /* Build the equation for <= operator */
+ tup = oper(makeList1(makeString("<=")),
+ b->typeId, b->typeId, false);
+ opform = (Form_pg_operator) GETSTRUCT(tup);
+
+ /* Triple check the types */
+ if (b->typeId != opform->oprright || b->typeId != opform->oprleft)
+ elog(ERROR, "transformExpr: Unable to find appropriate"
+ " operator for between operation");
+
+ b->lthan = makeNode(Expr);
+ b->lthan->typeOid = opform->oprresult;
+ b->lthan->opType = OP_EXPR;
+ b->lthan->oper = (Node *) makeOper(oprid(tup), /* opno */
+ oprfuncid(tup), /* opid */
+ opform->oprresult, /* opresulttype */
+ get_func_retset(opform->oprcode));/* opretset */
+ ReleaseSysCache(tup);
+
+ result = expr;
+ break;
+ }
/*
* Quietly accept node types that may be presented when we are
@@ -609,7 +682,6 @@ transformExpr(ParseState *pstate, Node *expr)
result = (Node *) expr;
break;
}
-
default:
/* should not reach here */
elog(ERROR, "transformExpr: does not know how to transform node %d"
@@ -890,6 +962,9 @@ exprType(Node *expr)
case T_BooleanTest:
type = BOOLOID;
break;
+ case T_BetweenExpr:
+ type = BOOLOID;
+ break;
default:
elog(ERROR, "exprType: Do not know how to get type for %d node",
nodeTag(expr));
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index bcdfe313b6b..f99ef53603d 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -3,7 +3,7 @@
* back to source text
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.109 2002/07/04 15:24:07 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.110 2002/07/18 04:41:45 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
@@ -1879,7 +1879,32 @@ get_rule_expr(Node *node, deparse_context *context)
}
}
break;
+ case T_BetweenExpr:
+ {
+ BetweenExpr *btwn = (BetweenExpr *) node;
+
+ get_rule_expr(btwn->expr, context);
+
+ if (btwn->not)
+ appendStringInfo(buf, " NOT");
+ appendStringInfo(buf, " BETWEEN");
+
+ /*
+ * Output both symmetric and asymmetric, even though
+ * asymmetric is default
+ */
+ if (btwn->symmetric)
+ appendStringInfo(buf, " SYMMETRIC ");
+ else
+ appendStringInfo(buf, " ASYMMETRIC ");
+
+ get_rule_expr(btwn->lexpr, context);
+
+ appendStringInfo(buf, " AND ");
+ get_rule_expr(btwn->rexpr, context);
+ }
+ break;
default:
elog(ERROR, "get_rule_expr: unknown node type %d", nodeTag(node));
break;
diff --git a/src/include/nodes/makefuncs.h b/src/include/nodes/makefuncs.h
index 69b9818f57b..21473ff7049 100644
--- a/src/include/nodes/makefuncs.h
+++ b/src/include/nodes/makefuncs.h
@@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: makefuncs.h,v 1.37 2002/06/20 20:29:49 momjian Exp $
+ * $Id: makefuncs.h,v 1.38 2002/07/18 04:41:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -57,5 +57,6 @@ extern RelabelType *makeRelabelType(Node *arg, Oid rtype, int32 rtypmod);
extern RangeVar *makeRangeVar(char *schemaname, char *relname);
extern TypeName *makeTypeName(char *typnam);
+extern TypeName *makeQualifiedTypeName(List *lst);
#endif /* MAKEFUNC_H */
diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
index a2980a1ff20..7d643dad681 100644
--- a/src/include/nodes/nodes.h
+++ b/src/include/nodes/nodes.h
@@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodes.h,v 1.110 2002/07/11 07:39:27 ishii Exp $
+ * $Id: nodes.h,v 1.111 2002/07/18 04:41:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -226,6 +226,7 @@ typedef enum NodeTag
T_GroupClause,
T_NullTest,
T_BooleanTest,
+ T_BetweenExpr,
T_CaseExpr,
T_CaseWhen,
T_FkConstraint,
diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index c0933f8ae7f..7f0cbd6ac2a 100644
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.187 2002/07/16 22:12:20 tgl Exp $
+ * $Id: parsenodes.h,v 1.188 2002/07/18 04:41:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -174,6 +174,25 @@ typedef struct A_Const
} A_Const;
/*
+ * BetweenExpr - an SQL99 BETWEEN expression
+ */
+
+typedef struct BetweenExpr
+{
+ NodeTag type;
+ Node *expr; /* Expression to check */
+ Node *lexpr; /* First bound */
+ Node *rexpr; /* Second bound */
+ bool not; /* Do we want inverse? */
+ bool symmetric; /* True if SYMMETRIC, false if ASYMMETRIC */
+ Oid typeId; /* Information abotu common type */
+ int16 typeLen;
+ bool typeByVal;
+ Expr *gthan;
+ Expr *lthan;
+} BetweenExpr;
+
+/*
* TypeCast - a CAST expression
*
* NOTE: for mostly historical reasons, A_Const parsenodes contain
diff --git a/src/test/regress/expected/select.out b/src/test/regress/expected/select.out
index 7974d141c54..582c893ca56 100644
--- a/src/test/regress/expected/select.out
+++ b/src/test/regress/expected/select.out
@@ -430,3 +430,150 @@ SELECT p.name, p.age FROM person* p ORDER BY age using >, name;
mary | 8
(58 rows)
+--
+-- Test between syntax
+--
+SELECT 2 BETWEEN 1 AND 3;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT 2 BETWEEN 3 AND 1;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT 2 BETWEEN ASYMMETRIC 1 AND 3;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT 2 BETWEEN ASYMMETRIC 3 AND 1;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT 2 BETWEEN SYMMETRIC 1 AND 3;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT 2 BETWEEN SYMMETRIC 3 AND 1;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT 2 NOT BETWEEN 1 AND 3;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT 2 NOT BETWEEN 3 AND 1;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT 2 NOT BETWEEN ASYMMETRIC 1 AND 3;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT 2 NOT BETWEEN ASYMMETRIC 3 AND 1;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT 2 NOT BETWEEN SYMMETRIC 1 AND 3;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT 2 NOT BETWEEN SYMMETRIC 3 AND 1;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT -4 BETWEEN -1 AND -3;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT -4 BETWEEN -3 AND -1;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT -4 BETWEEN ASYMMETRIC -1 AND -3;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT -4 BETWEEN ASYMMETRIC -3 AND -1;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT -4 BETWEEN SYMMETRIC -1 AND -3;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT -4 BETWEEN SYMMETRIC -3 AND -1;
+ ?column?
+----------
+ f
+(1 row)
+
+SELECT -4 NOT BETWEEN -1 AND -3;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT -4 NOT BETWEEN -3 AND -1;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT -4 NOT BETWEEN ASYMMETRIC -1 AND -3;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT -4 NOT BETWEEN ASYMMETRIC -3 AND -1;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT -4 NOT BETWEEN SYMMETRIC -1 AND -3;
+ ?column?
+----------
+ t
+(1 row)
+
+SELECT -4 NOT BETWEEN SYMMETRIC -3 AND -1;
+ ?column?
+----------
+ t
+ (1 row)
+
diff --git a/src/test/regress/sql/select.sql b/src/test/regress/sql/select.sql
index ee9389dc597..6a8e3bb02e9 100644
--- a/src/test/regress/sql/select.sql
+++ b/src/test/regress/sql/select.sql
@@ -103,3 +103,31 @@ SELECT p.name, p.age FROM person* p;
--
SELECT p.name, p.age FROM person* p ORDER BY age using >, name;
+--
+-- Test between syntax
+--
+SELECT 2 BETWEEN 1 AND 3;
+SELECT 2 BETWEEN 3 AND 1;
+SELECT 2 BETWEEN ASYMMETRIC 1 AND 3;
+SELECT 2 BETWEEN ASYMMETRIC 3 AND 1;
+SELECT 2 BETWEEN SYMMETRIC 1 AND 3;
+SELECT 2 BETWEEN SYMMETRIC 3 AND 1;
+SELECT 2 NOT BETWEEN 1 AND 3;
+SELECT 2 NOT BETWEEN 3 AND 1;
+SELECT 2 NOT BETWEEN ASYMMETRIC 1 AND 3;
+SELECT 2 NOT BETWEEN ASYMMETRIC 3 AND 1;
+SELECT 2 NOT BETWEEN SYMMETRIC 1 AND 3;
+SELECT 2 NOT BETWEEN SYMMETRIC 3 AND 1;
+SELECT -4 BETWEEN -1 AND -3;
+SELECT -4 BETWEEN -3 AND -1;
+SELECT -4 BETWEEN ASYMMETRIC -1 AND -3;
+SELECT -4 BETWEEN ASYMMETRIC -3 AND -1;
+SELECT -4 BETWEEN SYMMETRIC -1 AND -3;
+SELECT -4 BETWEEN SYMMETRIC -3 AND -1;
+SELECT -4 NOT BETWEEN -1 AND -3;
+SELECT -4 NOT BETWEEN -3 AND -1;
+SELECT -4 NOT BETWEEN ASYMMETRIC -1 AND -3;
+SELECT -4 NOT BETWEEN ASYMMETRIC -3 AND -1;
+SELECT -4 NOT BETWEEN SYMMETRIC -1 AND -3;
+SELECT -4 NOT BETWEEN SYMMETRIC -3 AND -1;
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-30 14:57:34 +0000