Implement IS OF type predicate. Can now do queries of the form:

 select value IS OF (integer, float8);

diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index f538448932ef68c3332e5d7f4380df415f7c0cc9..3cd09a9b43ca66e61e68afd7b7e05bd2a30adc50 100644 (file)
--- 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.123 2002/07/18 17:14:19 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.124 2002/08/04 06:46:12 thomas Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -282,6 +282,41 @@ transformExpr(ParseState *pstate, Node *expr)
                                                                                                          rexpr);
                                                        ((Expr *)result)->opType = DISTINCT_EXPR;
                                                }
+                                               break;
+                                       case OF:
+                                               {
+                                                       List *telem;
+                                                       A_Const *n;
+                                                       Oid ltype, rtype;
+                                                       bool matched = FALSE;
+
+                                                       /* Checking an expression for match to type.
+                                                        * Will result in a boolean constant node.
+                                                        */
+                                                       Node       *lexpr = transformExpr(pstate,
+                                                                                                                         a->lexpr);
+                                                       ltype = exprType(lexpr);
+                                                       foreach(telem, (List *) a->rexpr)
+                                                       {
+                                                               rtype = LookupTypeName(lfirst(telem));
+                                                               matched = (rtype == ltype);
+                                                               if (matched) break;
+                                                       }
+
+                                                       /* Expect two forms: equals or not equals.
+                                                        * Flip the sense of the result for not equals.
+                                                        */
+                                                       if (strcmp(strVal(lfirst(a->name)), "!=") == 0)
+                                                               matched = (! matched);
+
+                                                       n = makeNode(A_Const);
+                                                       n->val.type = T_String;
+                                                       n->val.val.str = (matched? "t": "f");
+                                                       n->typename = SystemTypeName("bool");
+
+                                                       result = transformExpr(pstate, (Node *) n);
+                                               }
+                                               break;
                                }
                                break;
                        }
@@ -589,14 +624,14 @@ transformExpr(ParseState *pstate, Node *expr)
                                break;
                        }
 
-                       /*
-                        * Quietly accept node types that may be presented when we are
-                        * called on an already-transformed tree.
-                        *
-                        * Do any other node types need to be accepted?  For now we are
-                        * taking a conservative approach, and only accepting node
-                        * types that are demonstrably necessary to accept.
-                        */
+               /*********************************************
+                * Quietly accept node types that may be presented when we are
+                * called on an already-transformed tree.
+                *
+                * Do any other node types need to be accepted?  For now we are
+                * taking a conservative approach, and only accepting node
+                * types that are demonstrably necessary to accept.
+                *********************************************/
                case T_Expr:
                case T_Var:
                case T_Const: