http://git-wip-us.apache.org/repos/asf/cayenne/blob/c1272b17/cayenne-server/src/main/java/org/apache/cayenne/exp/parser/ExpressionParser.java
----------------------------------------------------------------------
diff --git 
a/cayenne-server/src/main/java/org/apache/cayenne/exp/parser/ExpressionParser.java
 
b/cayenne-server/src/main/java/org/apache/cayenne/exp/parser/ExpressionParser.java
index e644066..25bcce0 100644
--- 
a/cayenne-server/src/main/java/org/apache/cayenne/exp/parser/ExpressionParser.java
+++ 
b/cayenne-server/src/main/java/org/apache/cayenne/exp/parser/ExpressionParser.java
@@ -21,2737 +21,2735 @@
 
 package org.apache.cayenne.exp.parser;
 
-import java.math.BigDecimal;
-import java.math.BigInteger;
 import org.apache.cayenne.exp.Expression;
 
 /**
-  * Parser of Cayenne Expressions. 
-  *
-  * @since 1.1
-  */
+ * Parser of Cayenne Expressions.
+ *
+ * @since 1.1
+ */
 public class ExpressionParser/*@bgen(jjtree)*/implements 
ExpressionParserTreeConstants, ExpressionParserConstants {/*@bgen(jjtree)*/
-  protected JJTExpressionParserState jjtree = new JJTExpressionParserState();
+    protected JJTExpressionParserState jjtree = new JJTExpressionParserState();
 
-  final public Expression expression() throws ParseException {
-    orCondition();
-    jj_consume_token(0);
+    final public Expression expression() throws ParseException {
+        orCondition();
+        jj_consume_token(0);
         {if (true) return (Expression) jjtree.rootNode();}
-    throw new Error("Missing return statement in function");
-  }
-
-  final public void orCondition() throws ParseException {
-    andCondition();
-    label_1:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 1:
-        ;
-        break;
-      default:
-        jj_la1[0] = jj_gen;
-        break label_1;
-      }
-      jj_consume_token(1);
-                                ASTOr jjtn001 = new ASTOr(JJTOR);
-                                boolean jjtc001 = true;
-                                jjtree.openNodeScope(jjtn001);
-      try {
+        throw new Error("Missing return statement in function");
+    }
+
+    final public void orCondition() throws ParseException {
         andCondition();
-      } catch (Throwable jjte001) {
-                                if (jjtc001) {
-                                  jjtree.clearNodeScope(jjtn001);
-                                  jjtc001 = false;
-                                } else {
-                                  jjtree.popNode();
-                                }
-                                if (jjte001 instanceof RuntimeException) {
-                                  {if (true) throw (RuntimeException)jjte001;}
-                                }
-                                if (jjte001 instanceof ParseException) {
-                                  {if (true) throw (ParseException)jjte001;}
-                                }
-                                {if (true) throw (Error)jjte001;}
-      } finally {
-                                if (jjtc001) {
-                                  jjtree.closeNodeScope(jjtn001,  2);
-                                }
-      }
-    }
-  }
-
-  final public void andCondition() throws ParseException {
-    notCondition();
-    label_2:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 2:
-        ;
-        break;
-      default:
-        jj_la1[1] = jj_gen;
-        break label_2;
-      }
-      jj_consume_token(2);
-                                 ASTAnd jjtn001 = new ASTAnd(JJTAND);
-                                 boolean jjtc001 = true;
-                                 jjtree.openNodeScope(jjtn001);
-      try {
-        notCondition();
-      } catch (Throwable jjte001) {
-                                 if (jjtc001) {
-                                   jjtree.clearNodeScope(jjtn001);
-                                   jjtc001 = false;
-                                 } else {
-                                   jjtree.popNode();
-                                 }
-                                 if (jjte001 instanceof RuntimeException) {
-                                   {if (true) throw (RuntimeException)jjte001;}
-                                 }
-                                 if (jjte001 instanceof ParseException) {
-                                   {if (true) throw (ParseException)jjte001;}
-                                 }
-                                 {if (true) throw (Error)jjte001;}
-      } finally {
-                                 if (jjtc001) {
-                                   jjtree.closeNodeScope(jjtn001,  2);
-                                 }
-      }
-    }
-  }
-
-  final public void notCondition() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 3:
-    case 4:
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 3:
-        jj_consume_token(3);
-        break;
-      case 4:
-        jj_consume_token(4);
-        break;
-      default:
-        jj_la1[2] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-                                  ASTNot jjtn001 = new ASTNot(JJTNOT);
-                                  boolean jjtc001 = true;
-                                  jjtree.openNodeScope(jjtn001);
-      try {
-        simpleCondition();
-      } catch (Throwable jjte001) {
-                                  if (jjtc001) {
-                                    jjtree.clearNodeScope(jjtn001);
-                                    jjtc001 = false;
-                                  } else {
-                                    jjtree.popNode();
-                                  }
-                                  if (jjte001 instanceof RuntimeException) {
-                                    {if (true) throw 
(RuntimeException)jjte001;}
-                                  }
-                                  if (jjte001 instanceof ParseException) {
-                                    {if (true) throw (ParseException)jjte001;}
-                                  }
-                                  {if (true) throw (Error)jjte001;}
-      } finally {
-                                  if (jjtc001) {
-                                    jjtree.closeNodeScope(jjtn001,  1);
-                                  }
-      }
-      break;
-    case 16:
-    case 25:
-    case 26:
-    case 28:
-    case NULL:
-    case TRUE:
-    case FALSE:
-    case AVG:
-    case MIN:
-    case MAX:
-    case SUM:
-    case COUNT:
-    case CONCAT:
-    case SUBSTRING:
-    case TRIM:
-    case LOWER:
-    case UPPER:
-    case LENGTH:
-    case LOCATE:
-    case ABS:
-    case SQRT:
-    case MOD:
-    case CURRENT_DATE:
-    case CURRENT_TIME:
-    case CURRENT_TIMESTAMP:
-    case YEAR:
-    case MONTH:
-    case WEEK:
-    case DAY_OF_YEAR:
-    case DAY:
-    case DAY_OF_MONTH:
-    case DAY_OF_WEEK:
-    case HOUR:
-    case MINUTE:
-    case SECOND:
-    case 65:
-    case 66:
-    case 67:
-    case 68:
-    case PROPERTY_PATH:
-    case SINGLE_QUOTED_STRING:
-    case DOUBLE_QUOTED_STRING:
-    case INT_LITERAL:
-    case FLOAT_LITERAL:
-      simpleCondition();
-      break;
-    default:
-      jj_la1[3] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void simpleCondition() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case TRUE:
-            ASTTrue jjtn001 = new ASTTrue(JJTTRUE);
+        label_1:
+        while (true) {
+            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                case 1:
+                    ;
+                    break;
+                default:
+                    jj_la1[0] = jj_gen;
+                    break label_1;
+            }
+            jj_consume_token(1);
+            ASTOr jjtn001 = new ASTOr(JJTOR);
             boolean jjtc001 = true;
             jjtree.openNodeScope(jjtn001);
-      try {
-        jj_consume_token(TRUE);
-      } finally {
-            if (jjtc001) {
-              jjtree.closeNodeScope(jjtn001, true);
-            }
-      }
-      break;
-    case FALSE:
-            ASTFalse jjtn002 = new ASTFalse(JJTFALSE);
-            boolean jjtc002 = true;
-            jjtree.openNodeScope(jjtn002);
-      try {
-        jj_consume_token(FALSE);
-      } finally {
-            if (jjtc002) {
-              jjtree.closeNodeScope(jjtn002, true);
-            }
-      }
-      break;
-    case 16:
-    case 25:
-    case 26:
-    case 28:
-    case NULL:
-    case AVG:
-    case MIN:
-    case MAX:
-    case SUM:
-    case COUNT:
-    case CONCAT:
-    case SUBSTRING:
-    case TRIM:
-    case LOWER:
-    case UPPER:
-    case LENGTH:
-    case LOCATE:
-    case ABS:
-    case SQRT:
-    case MOD:
-    case CURRENT_DATE:
-    case CURRENT_TIME:
-    case CURRENT_TIMESTAMP:
-    case YEAR:
-    case MONTH:
-    case WEEK:
-    case DAY_OF_YEAR:
-    case DAY:
-    case DAY_OF_MONTH:
-    case DAY_OF_WEEK:
-    case HOUR:
-    case MINUTE:
-    case SECOND:
-    case 65:
-    case 66:
-    case 67:
-    case 68:
-    case PROPERTY_PATH:
-    case SINGLE_QUOTED_STRING:
-    case DOUBLE_QUOTED_STRING:
-    case INT_LITERAL:
-    case FLOAT_LITERAL:
-      conditionExpression();
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 3:
-      case 4:
-      case 5:
-      case 6:
-      case 7:
-      case 8:
-      case 9:
-      case 10:
-      case 11:
-      case 12:
-      case 13:
-      case 14:
-      case 15:
-      case 18:
-        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-        case 5:
-        case 6:
-          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-          case 5:
-            jj_consume_token(5);
-            break;
-          case 6:
-            jj_consume_token(6);
-            break;
-          default:
-            jj_la1[4] = jj_gen;
-            jj_consume_token(-1);
-            throw new ParseException();
-          }
-                          ASTEqual jjtn003 = new ASTEqual(JJTEQUAL);
-                          boolean jjtc003 = true;
-                          jjtree.openNodeScope(jjtn003);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte003) {
-                          if (jjtc003) {
-                            jjtree.clearNodeScope(jjtn003);
-                            jjtc003 = false;
-                          } else {
-                            jjtree.popNode();
-                          }
-                          if (jjte003 instanceof RuntimeException) {
-                            {if (true) throw (RuntimeException)jjte003;}
-                          }
-                          if (jjte003 instanceof ParseException) {
-                            {if (true) throw (ParseException)jjte003;}
-                          }
-                          {if (true) throw (Error)jjte003;}
-          } finally {
-                          if (jjtc003) {
-                            jjtree.closeNodeScope(jjtn003,  2);
-                          }
-          }
-          break;
-        case 7:
-        case 8:
-          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-          case 7:
-            jj_consume_token(7);
-            break;
-          case 8:
-            jj_consume_token(8);
-            break;
-          default:
-            jj_la1[5] = jj_gen;
-            jj_consume_token(-1);
-            throw new ParseException();
-          }
-                           ASTNotEqual jjtn004 = new ASTNotEqual(JJTNOTEQUAL);
-                           boolean jjtc004 = true;
-                           jjtree.openNodeScope(jjtn004);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte004) {
-                           if (jjtc004) {
-                             jjtree.clearNodeScope(jjtn004);
-                             jjtc004 = false;
-                           } else {
-                             jjtree.popNode();
-                           }
-                           if (jjte004 instanceof RuntimeException) {
-                             {if (true) throw (RuntimeException)jjte004;}
-                           }
-                           if (jjte004 instanceof ParseException) {
-                             {if (true) throw (ParseException)jjte004;}
-                           }
-                           {if (true) throw (Error)jjte004;}
-          } finally {
-                           if (jjtc004) {
-                             jjtree.closeNodeScope(jjtn004,  2);
-                           }
-          }
-          break;
-        case 9:
-          jj_consume_token(9);
-                 ASTLessOrEqual jjtn005 = new ASTLessOrEqual(JJTLESSOREQUAL);
-                 boolean jjtc005 = true;
-                 jjtree.openNodeScope(jjtn005);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte005) {
-                 if (jjtc005) {
-                   jjtree.clearNodeScope(jjtn005);
-                   jjtc005 = false;
-                 } else {
-                   jjtree.popNode();
-                 }
-                 if (jjte005 instanceof RuntimeException) {
-                   {if (true) throw (RuntimeException)jjte005;}
-                 }
-                 if (jjte005 instanceof ParseException) {
-                   {if (true) throw (ParseException)jjte005;}
-                 }
-                 {if (true) throw (Error)jjte005;}
-          } finally {
-                 if (jjtc005) {
-                   jjtree.closeNodeScope(jjtn005,  2);
-                 }
-          }
-          break;
-        case 10:
-          jj_consume_token(10);
-                ASTLess jjtn006 = new ASTLess(JJTLESS);
-                boolean jjtc006 = true;
-                jjtree.openNodeScope(jjtn006);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte006) {
-                if (jjtc006) {
-                  jjtree.clearNodeScope(jjtn006);
-                  jjtc006 = false;
+            try {
+                andCondition();
+            } catch (Throwable jjte001) {
+                if (jjtc001) {
+                    jjtree.clearNodeScope(jjtn001);
+                    jjtc001 = false;
                 } else {
-                  jjtree.popNode();
+                    jjtree.popNode();
                 }
-                if (jjte006 instanceof RuntimeException) {
-                  {if (true) throw (RuntimeException)jjte006;}
+                if (jjte001 instanceof RuntimeException) {
+                    {if (true) throw (RuntimeException)jjte001;}
                 }
-                if (jjte006 instanceof ParseException) {
-                  {if (true) throw (ParseException)jjte006;}
+                if (jjte001 instanceof ParseException) {
+                    {if (true) throw (ParseException)jjte001;}
                 }
-                {if (true) throw (Error)jjte006;}
-          } finally {
-                if (jjtc006) {
-                  jjtree.closeNodeScope(jjtn006,  2);
+                {if (true) throw (Error)jjte001;}
+            } finally {
+                if (jjtc001) {
+                    jjtree.closeNodeScope(jjtn001,  2);
                 }
-          }
-          break;
-        case 11:
-          jj_consume_token(11);
-                 ASTGreater jjtn007 = new ASTGreater(JJTGREATER);
-                 boolean jjtc007 = true;
-                 jjtree.openNodeScope(jjtn007);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte007) {
-                 if (jjtc007) {
-                   jjtree.clearNodeScope(jjtn007);
-                   jjtc007 = false;
-                 } else {
-                   jjtree.popNode();
-                 }
-                 if (jjte007 instanceof RuntimeException) {
-                   {if (true) throw (RuntimeException)jjte007;}
-                 }
-                 if (jjte007 instanceof ParseException) {
-                   {if (true) throw (ParseException)jjte007;}
-                 }
-                 {if (true) throw (Error)jjte007;}
-          } finally {
-                 if (jjtc007) {
-                   jjtree.closeNodeScope(jjtn007,  2);
-                 }
-          }
-          break;
-        case 12:
-          jj_consume_token(12);
-                 ASTGreaterOrEqual jjtn008 = new 
ASTGreaterOrEqual(JJTGREATEROREQUAL);
-                 boolean jjtc008 = true;
-                 jjtree.openNodeScope(jjtn008);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte008) {
-                 if (jjtc008) {
-                   jjtree.clearNodeScope(jjtn008);
-                   jjtc008 = false;
-                 } else {
-                   jjtree.popNode();
-                 }
-                 if (jjte008 instanceof RuntimeException) {
-                   {if (true) throw (RuntimeException)jjte008;}
-                 }
-                 if (jjte008 instanceof ParseException) {
-                   {if (true) throw (ParseException)jjte008;}
-                 }
-                 {if (true) throw (Error)jjte008;}
-          } finally {
-                 if (jjtc008) {
-                   jjtree.closeNodeScope(jjtn008,  2);
-                 }
-          }
-          break;
-        case 13:
-          jj_consume_token(13);
-                   ASTLike jjtn009 = new ASTLike(JJTLIKE);
-                   boolean jjtc009 = true;
-                   jjtree.openNodeScope(jjtn009);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte009) {
-                   if (jjtc009) {
-                     jjtree.clearNodeScope(jjtn009);
-                     jjtc009 = false;
-                   } else {
-                     jjtree.popNode();
-                   }
-                   if (jjte009 instanceof RuntimeException) {
-                     {if (true) throw (RuntimeException)jjte009;}
-                   }
-                   if (jjte009 instanceof ParseException) {
-                     {if (true) throw (ParseException)jjte009;}
-                   }
-                   {if (true) throw (Error)jjte009;}
-          } finally {
-                   if (jjtc009) {
-                     jjtree.closeNodeScope(jjtn009,  2);
-                   }
-          }
-          break;
-        case 14:
-          jj_consume_token(14);
-                              ASTLikeIgnoreCase jjtn010 = new 
ASTLikeIgnoreCase(JJTLIKEIGNORECASE);
-                              boolean jjtc010 = true;
-                              jjtree.openNodeScope(jjtn010);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte010) {
-                              if (jjtc010) {
-                                jjtree.clearNodeScope(jjtn010);
-                                jjtc010 = false;
-                              } else {
-                                jjtree.popNode();
-                              }
-                              if (jjte010 instanceof RuntimeException) {
-                                {if (true) throw (RuntimeException)jjte010;}
-                              }
-                              if (jjte010 instanceof ParseException) {
-                                {if (true) throw (ParseException)jjte010;}
-                              }
-                              {if (true) throw (Error)jjte010;}
-          } finally {
-                              if (jjtc010) {
-                                jjtree.closeNodeScope(jjtn010,  2);
-                              }
-          }
-          break;
-        case 15:
-          jj_consume_token(15);
-                 ASTIn jjtn011 = new ASTIn(JJTIN);
-                 boolean jjtc011 = true;
-                 jjtree.openNodeScope(jjtn011);
-          try {
+            }
+        }
+    }
+
+    final public void andCondition() throws ParseException {
+        notCondition();
+        label_2:
+        while (true) {
             switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-            case 65:
-              namedParameter();
-              break;
+                case 2:
+                    ;
+                    break;
+                default:
+                    jj_la1[1] = jj_gen;
+                    break label_2;
+            }
+            jj_consume_token(2);
+            ASTAnd jjtn001 = new ASTAnd(JJTAND);
+            boolean jjtc001 = true;
+            jjtree.openNodeScope(jjtn001);
+            try {
+                notCondition();
+            } catch (Throwable jjte001) {
+                if (jjtc001) {
+                    jjtree.clearNodeScope(jjtn001);
+                    jjtc001 = false;
+                } else {
+                    jjtree.popNode();
+                }
+                if (jjte001 instanceof RuntimeException) {
+                    {if (true) throw (RuntimeException)jjte001;}
+                }
+                if (jjte001 instanceof ParseException) {
+                    {if (true) throw (ParseException)jjte001;}
+                }
+                {if (true) throw (Error)jjte001;}
+            } finally {
+                if (jjtc001) {
+                    jjtree.closeNodeScope(jjtn001,  2);
+                }
+            }
+        }
+    }
+
+    final public void notCondition() throws ParseException {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case 3:
+            case 4:
+                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                    case 3:
+                        jj_consume_token(3);
+                        break;
+                    case 4:
+                        jj_consume_token(4);
+                        break;
+                    default:
+                        jj_la1[2] = jj_gen;
+                        jj_consume_token(-1);
+                        throw new ParseException();
+                }
+                ASTNot jjtn001 = new ASTNot(JJTNOT);
+                boolean jjtc001 = true;
+                jjtree.openNodeScope(jjtn001);
+                try {
+                    simpleCondition();
+                } catch (Throwable jjte001) {
+                    if (jjtc001) {
+                        jjtree.clearNodeScope(jjtn001);
+                        jjtc001 = false;
+                    } else {
+                        jjtree.popNode();
+                    }
+                    if (jjte001 instanceof RuntimeException) {
+                        {if (true) throw (RuntimeException)jjte001;}
+                    }
+                    if (jjte001 instanceof ParseException) {
+                        {if (true) throw (ParseException)jjte001;}
+                    }
+                    {if (true) throw (Error)jjte001;}
+                } finally {
+                    if (jjtc001) {
+                        jjtree.closeNodeScope(jjtn001,  1);
+                    }
+                }
+                break;
             case 16:
-              jj_consume_token(16);
-              scalarCommaList();
-              jj_consume_token(17);
-              break;
+            case 25:
+            case 26:
+            case 28:
+            case NULL:
+            case TRUE:
+            case FALSE:
+            case AVG:
+            case MIN:
+            case MAX:
+            case SUM:
+            case COUNT:
+            case CONCAT:
+            case SUBSTRING:
+            case TRIM:
+            case LOWER:
+            case UPPER:
+            case LENGTH:
+            case LOCATE:
+            case ABS:
+            case SQRT:
+            case MOD:
+            case CURRENT_DATE:
+            case CURRENT_TIME:
+            case CURRENT_TIMESTAMP:
+            case YEAR:
+            case MONTH:
+            case WEEK:
+            case DAY_OF_YEAR:
+            case DAY:
+            case DAY_OF_MONTH:
+            case DAY_OF_WEEK:
+            case HOUR:
+            case MINUTE:
+            case SECOND:
+            case 65:
+            case 66:
+            case 67:
+            case 68:
+            case PROPERTY_PATH:
+            case SINGLE_QUOTED_STRING:
+            case DOUBLE_QUOTED_STRING:
+            case INT_LITERAL:
+            case FLOAT_LITERAL:
+                simpleCondition();
+                break;
             default:
-              jj_la1[6] = jj_gen;
-              jj_consume_token(-1);
-              throw new ParseException();
-            }
-          } catch (Throwable jjte011) {
-                 if (jjtc011) {
-                   jjtree.clearNodeScope(jjtn011);
-                   jjtc011 = false;
-                 } else {
-                   jjtree.popNode();
-                 }
-                 if (jjte011 instanceof RuntimeException) {
-                   {if (true) throw (RuntimeException)jjte011;}
-                 }
-                 if (jjte011 instanceof ParseException) {
-                   {if (true) throw (ParseException)jjte011;}
-                 }
-                 {if (true) throw (Error)jjte011;}
-          } finally {
-                 if (jjtc011) {
-                   jjtree.closeNodeScope(jjtn011,  2);
-                 }
-          }
-          break;
-        case 18:
-          jj_consume_token(18);
-          scalarExpression();
-          jj_consume_token(2);
-                                                ASTBetween jjtn012 = new 
ASTBetween(JJTBETWEEN);
-                                                boolean jjtc012 = true;
-                                                jjtree.openNodeScope(jjtn012);
-          try {
-            scalarExpression();
-          } catch (Throwable jjte012) {
-                                                if (jjtc012) {
-                                                  
jjtree.clearNodeScope(jjtn012);
-                                                  jjtc012 = false;
-                                                } else {
-                                                  jjtree.popNode();
-                                                }
-                                                if (jjte012 instanceof 
RuntimeException) {
-                                                  {if (true) throw 
(RuntimeException)jjte012;}
-                                                }
-                                                if (jjte012 instanceof 
ParseException) {
-                                                  {if (true) throw 
(ParseException)jjte012;}
-                                                }
-                                                {if (true) throw 
(Error)jjte012;}
-          } finally {
-                                                if (jjtc012) {
-                                                  
jjtree.closeNodeScope(jjtn012,  3);
-                                                }
-          }
-          break;
-        case 3:
-        case 4:
-          simpleNotCondition();
-          break;
-        default:
-          jj_la1[7] = jj_gen;
-          jj_consume_token(-1);
-          throw new ParseException();
+                jj_la1[3] = jj_gen;
+                jj_consume_token(-1);
+                throw new ParseException();
         }
-        break;
-      default:
-        jj_la1[8] = jj_gen;
-        ;
-      }
-      break;
-    default:
-      jj_la1[9] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void simpleNotCondition() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 3:
-      jj_consume_token(3);
-      break;
-    case 4:
-      jj_consume_token(4);
-      break;
-    default:
-      jj_la1[10] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 13:
-      jj_consume_token(13);
-                         ASTNotLike jjtn001 = new ASTNotLike(JJTNOTLIKE);
-                         boolean jjtc001 = true;
-                         jjtree.openNodeScope(jjtn001);
-      try {
-        scalarExpression();
-      } catch (Throwable jjte001) {
-                         if (jjtc001) {
-                           jjtree.clearNodeScope(jjtn001);
-                           jjtc001 = false;
-                         } else {
-                           jjtree.popNode();
-                         }
-                         if (jjte001 instanceof RuntimeException) {
-                           {if (true) throw (RuntimeException)jjte001;}
-                         }
-                         if (jjte001 instanceof ParseException) {
-                           {if (true) throw (ParseException)jjte001;}
-                         }
-                         {if (true) throw (Error)jjte001;}
-      } finally {
-                         if (jjtc001) {
-                           jjtree.closeNodeScope(jjtn001,  2);
-                         }
-      }
-      break;
-    case 14:
-      jj_consume_token(14);
-                                ASTNotLikeIgnoreCase jjtn002 = new 
ASTNotLikeIgnoreCase(JJTNOTLIKEIGNORECASE);
-                                boolean jjtc002 = true;
-                                jjtree.openNodeScope(jjtn002);
-      try {
-        scalarExpression();
-      } catch (Throwable jjte002) {
-                                if (jjtc002) {
-                                  jjtree.clearNodeScope(jjtn002);
-                                  jjtc002 = false;
-                                } else {
-                                  jjtree.popNode();
+    }
+
+    final public void simpleCondition() throws ParseException {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case TRUE:
+                ASTTrue jjtn001 = new ASTTrue(JJTTRUE);
+                boolean jjtc001 = true;
+                jjtree.openNodeScope(jjtn001);
+                try {
+                    jj_consume_token(TRUE);
+                } finally {
+                    if (jjtc001) {
+                        jjtree.closeNodeScope(jjtn001, true);
+                    }
+                }
+                break;
+            case FALSE:
+                ASTFalse jjtn002 = new ASTFalse(JJTFALSE);
+                boolean jjtc002 = true;
+                jjtree.openNodeScope(jjtn002);
+                try {
+                    jj_consume_token(FALSE);
+                } finally {
+                    if (jjtc002) {
+                        jjtree.closeNodeScope(jjtn002, true);
+                    }
+                }
+                break;
+            case 16:
+            case 25:
+            case 26:
+            case 28:
+            case NULL:
+            case AVG:
+            case MIN:
+            case MAX:
+            case SUM:
+            case COUNT:
+            case CONCAT:
+            case SUBSTRING:
+            case TRIM:
+            case LOWER:
+            case UPPER:
+            case LENGTH:
+            case LOCATE:
+            case ABS:
+            case SQRT:
+            case MOD:
+            case CURRENT_DATE:
+            case CURRENT_TIME:
+            case CURRENT_TIMESTAMP:
+            case YEAR:
+            case MONTH:
+            case WEEK:
+            case DAY_OF_YEAR:
+            case DAY:
+            case DAY_OF_MONTH:
+            case DAY_OF_WEEK:
+            case HOUR:
+            case MINUTE:
+            case SECOND:
+            case 65:
+            case 66:
+            case 67:
+            case 68:
+            case PROPERTY_PATH:
+            case SINGLE_QUOTED_STRING:
+            case DOUBLE_QUOTED_STRING:
+            case INT_LITERAL:
+            case FLOAT_LITERAL:
+                conditionExpression();
+                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                    case 8:
+                    case 9:
+                    case 10:
+                    case 11:
+                    case 12:
+                    case 13:
+                    case 14:
+                    case 15:
+                    case 18:
+                        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                            case 5:
+                            case 6:
+                                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                                    case 5:
+                                        jj_consume_token(5);
+                                        break;
+                                    case 6:
+                                        jj_consume_token(6);
+                                        break;
+                                    default:
+                                        jj_la1[4] = jj_gen;
+                                        jj_consume_token(-1);
+                                        throw new ParseException();
                                 }
-                                if (jjte002 instanceof RuntimeException) {
-                                  {if (true) throw (RuntimeException)jjte002;}
+                                ASTEqual jjtn003 = new ASTEqual(JJTEQUAL);
+                                boolean jjtc003 = true;
+                                jjtree.openNodeScope(jjtn003);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte003) {
+                                    if (jjtc003) {
+                                        jjtree.clearNodeScope(jjtn003);
+                                        jjtc003 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte003 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte003;}
+                                    }
+                                    if (jjte003 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte003;}
+                                    }
+                                    {if (true) throw (Error)jjte003;}
+                                } finally {
+                                    if (jjtc003) {
+                                        jjtree.closeNodeScope(jjtn003,  2);
+                                    }
                                 }
-                                if (jjte002 instanceof ParseException) {
-                                  {if (true) throw (ParseException)jjte002;}
+                                break;
+                            case 7:
+                            case 8:
+                                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                                    case 7:
+                                        jj_consume_token(7);
+                                        break;
+                                    case 8:
+                                        jj_consume_token(8);
+                                        break;
+                                    default:
+                                        jj_la1[5] = jj_gen;
+                                        jj_consume_token(-1);
+                                        throw new ParseException();
                                 }
-                                {if (true) throw (Error)jjte002;}
-      } finally {
-                                if (jjtc002) {
-                                  jjtree.closeNodeScope(jjtn002,  2);
+                                ASTNotEqual jjtn004 = new 
ASTNotEqual(JJTNOTEQUAL);
+                                boolean jjtc004 = true;
+                                jjtree.openNodeScope(jjtn004);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte004) {
+                                    if (jjtc004) {
+                                        jjtree.clearNodeScope(jjtn004);
+                                        jjtc004 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte004 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte004;}
+                                    }
+                                    if (jjte004 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte004;}
+                                    }
+                                    {if (true) throw (Error)jjte004;}
+                                } finally {
+                                    if (jjtc004) {
+                                        jjtree.closeNodeScope(jjtn004,  2);
+                                    }
                                 }
-      }
-      break;
-    case 15:
-      jj_consume_token(15);
-                       ASTNotIn jjtn003 = new ASTNotIn(JJTNOTIN);
-                       boolean jjtc003 = true;
-                       jjtree.openNodeScope(jjtn003);
-      try {
-        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-        case 65:
-          namedParameter();
-          break;
-        case 16:
-          jj_consume_token(16);
-          scalarCommaList();
-          jj_consume_token(17);
-          break;
-        default:
-          jj_la1[11] = jj_gen;
-          jj_consume_token(-1);
-          throw new ParseException();
+                                break;
+                            case 9:
+                                jj_consume_token(9);
+                                ASTLessOrEqual jjtn005 = new 
ASTLessOrEqual(JJTLESSOREQUAL);
+                                boolean jjtc005 = true;
+                                jjtree.openNodeScope(jjtn005);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte005) {
+                                    if (jjtc005) {
+                                        jjtree.clearNodeScope(jjtn005);
+                                        jjtc005 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte005 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte005;}
+                                    }
+                                    if (jjte005 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte005;}
+                                    }
+                                    {if (true) throw (Error)jjte005;}
+                                } finally {
+                                    if (jjtc005) {
+                                        jjtree.closeNodeScope(jjtn005,  2);
+                                    }
+                                }
+                                break;
+                            case 10:
+                                jj_consume_token(10);
+                                ASTLess jjtn006 = new ASTLess(JJTLESS);
+                                boolean jjtc006 = true;
+                                jjtree.openNodeScope(jjtn006);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte006) {
+                                    if (jjtc006) {
+                                        jjtree.clearNodeScope(jjtn006);
+                                        jjtc006 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte006 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte006;}
+                                    }
+                                    if (jjte006 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte006;}
+                                    }
+                                    {if (true) throw (Error)jjte006;}
+                                } finally {
+                                    if (jjtc006) {
+                                        jjtree.closeNodeScope(jjtn006,  2);
+                                    }
+                                }
+                                break;
+                            case 11:
+                                jj_consume_token(11);
+                                ASTGreater jjtn007 = new 
ASTGreater(JJTGREATER);
+                                boolean jjtc007 = true;
+                                jjtree.openNodeScope(jjtn007);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte007) {
+                                    if (jjtc007) {
+                                        jjtree.clearNodeScope(jjtn007);
+                                        jjtc007 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte007 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte007;}
+                                    }
+                                    if (jjte007 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte007;}
+                                    }
+                                    {if (true) throw (Error)jjte007;}
+                                } finally {
+                                    if (jjtc007) {
+                                        jjtree.closeNodeScope(jjtn007,  2);
+                                    }
+                                }
+                                break;
+                            case 12:
+                                jj_consume_token(12);
+                                ASTGreaterOrEqual jjtn008 = new 
ASTGreaterOrEqual(JJTGREATEROREQUAL);
+                                boolean jjtc008 = true;
+                                jjtree.openNodeScope(jjtn008);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte008) {
+                                    if (jjtc008) {
+                                        jjtree.clearNodeScope(jjtn008);
+                                        jjtc008 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte008 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte008;}
+                                    }
+                                    if (jjte008 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte008;}
+                                    }
+                                    {if (true) throw (Error)jjte008;}
+                                } finally {
+                                    if (jjtc008) {
+                                        jjtree.closeNodeScope(jjtn008,  2);
+                                    }
+                                }
+                                break;
+                            case 13:
+                                jj_consume_token(13);
+                                ASTLike jjtn009 = new ASTLike(JJTLIKE);
+                                boolean jjtc009 = true;
+                                jjtree.openNodeScope(jjtn009);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte009) {
+                                    if (jjtc009) {
+                                        jjtree.clearNodeScope(jjtn009);
+                                        jjtc009 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte009 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte009;}
+                                    }
+                                    if (jjte009 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte009;}
+                                    }
+                                    {if (true) throw (Error)jjte009;}
+                                } finally {
+                                    if (jjtc009) {
+                                        jjtree.closeNodeScope(jjtn009,  2);
+                                    }
+                                }
+                                break;
+                            case 14:
+                                jj_consume_token(14);
+                                ASTLikeIgnoreCase jjtn010 = new 
ASTLikeIgnoreCase(JJTLIKEIGNORECASE);
+                                boolean jjtc010 = true;
+                                jjtree.openNodeScope(jjtn010);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte010) {
+                                    if (jjtc010) {
+                                        jjtree.clearNodeScope(jjtn010);
+                                        jjtc010 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte010 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte010;}
+                                    }
+                                    if (jjte010 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte010;}
+                                    }
+                                    {if (true) throw (Error)jjte010;}
+                                } finally {
+                                    if (jjtc010) {
+                                        jjtree.closeNodeScope(jjtn010,  2);
+                                    }
+                                }
+                                break;
+                            case 15:
+                                jj_consume_token(15);
+                                ASTIn jjtn011 = new ASTIn(JJTIN);
+                                boolean jjtc011 = true;
+                                jjtree.openNodeScope(jjtn011);
+                                try {
+                                    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                                        case 65:
+                                            namedParameter();
+                                            break;
+                                        case 16:
+                                            jj_consume_token(16);
+                                            scalarCommaList();
+                                            jj_consume_token(17);
+                                            break;
+                                        default:
+                                            jj_la1[6] = jj_gen;
+                                            jj_consume_token(-1);
+                                            throw new ParseException();
+                                    }
+                                } catch (Throwable jjte011) {
+                                    if (jjtc011) {
+                                        jjtree.clearNodeScope(jjtn011);
+                                        jjtc011 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte011 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte011;}
+                                    }
+                                    if (jjte011 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte011;}
+                                    }
+                                    {if (true) throw (Error)jjte011;}
+                                } finally {
+                                    if (jjtc011) {
+                                        jjtree.closeNodeScope(jjtn011,  2);
+                                    }
+                                }
+                                break;
+                            case 18:
+                                jj_consume_token(18);
+                                scalarExpression();
+                                jj_consume_token(2);
+                                ASTBetween jjtn012 = new 
ASTBetween(JJTBETWEEN);
+                                boolean jjtc012 = true;
+                                jjtree.openNodeScope(jjtn012);
+                                try {
+                                    scalarExpression();
+                                } catch (Throwable jjte012) {
+                                    if (jjtc012) {
+                                        jjtree.clearNodeScope(jjtn012);
+                                        jjtc012 = false;
+                                    } else {
+                                        jjtree.popNode();
+                                    }
+                                    if (jjte012 instanceof RuntimeException) {
+                                        {if (true) throw 
(RuntimeException)jjte012;}
+                                    }
+                                    if (jjte012 instanceof ParseException) {
+                                        {if (true) throw 
(ParseException)jjte012;}
+                                    }
+                                    {if (true) throw (Error)jjte012;}
+                                } finally {
+                                    if (jjtc012) {
+                                        jjtree.closeNodeScope(jjtn012,  3);
+                                    }
+                                }
+                                break;
+                            case 3:
+                            case 4:
+                                simpleNotCondition();
+                                break;
+                            default:
+                                jj_la1[7] = jj_gen;
+                                jj_consume_token(-1);
+                                throw new ParseException();
+                        }
+                        break;
+                    default:
+                        jj_la1[8] = jj_gen;
+                        ;
+                }
+                break;
+            default:
+                jj_la1[9] = jj_gen;
+                jj_consume_token(-1);
+                throw new ParseException();
         }
-      } catch (Throwable jjte003) {
-                       if (jjtc003) {
-                         jjtree.clearNodeScope(jjtn003);
-                         jjtc003 = false;
-                       } else {
-                         jjtree.popNode();
-                       }
-                       if (jjte003 instanceof RuntimeException) {
-                         {if (true) throw (RuntimeException)jjte003;}
-                       }
-                       if (jjte003 instanceof ParseException) {
-                         {if (true) throw (ParseException)jjte003;}
-                       }
-                       {if (true) throw (Error)jjte003;}
-      } finally {
-                       if (jjtc003) {
-                         jjtree.closeNodeScope(jjtn003,  2);
-                       }
-      }
-      break;
-    case 18:
-      jj_consume_token(18);
-      scalarExpression();
-      jj_consume_token(2);
-                                                      ASTNotBetween jjtn004 = 
new ASTNotBetween(JJTNOTBETWEEN);
-                                                      boolean jjtc004 = true;
-                                                      
jjtree.openNodeScope(jjtn004);
-      try {
-        scalarExpression();
-      } catch (Throwable jjte004) {
-                                                      if (jjtc004) {
-                                                        
jjtree.clearNodeScope(jjtn004);
-                                                        jjtc004 = false;
-                                                      } else {
-                                                        jjtree.popNode();
-                                                      }
-                                                      if (jjte004 instanceof 
RuntimeException) {
-                                                        {if (true) throw 
(RuntimeException)jjte004;}
-                                                      }
-                                                      if (jjte004 instanceof 
ParseException) {
-                                                        {if (true) throw 
(ParseException)jjte004;}
-                                                      }
-                                                      {if (true) throw 
(Error)jjte004;}
-      } finally {
-                                                      if (jjtc004) {
-                                                        
jjtree.closeNodeScope(jjtn004,  3);
-                                                      }
-      }
-      break;
-    default:
-      jj_la1[12] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void scalarCommaList() throws ParseException {
-          ASTList jjtn001 = new ASTList(JJTLIST);
-          boolean jjtc001 = true;
-          jjtree.openNodeScope(jjtn001);
-    try {
-      scalarConstExpression();
-      label_3:
-      while (true) {
+    }
+
+    final public void simpleNotCondition() throws ParseException {
         switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-        case 19:
-          ;
-          break;
-        default:
-          jj_la1[13] = jj_gen;
-          break label_3;
+            case 3:
+                jj_consume_token(3);
+                break;
+            case 4:
+                jj_consume_token(4);
+                break;
+            default:
+                jj_la1[10] = jj_gen;
+                jj_consume_token(-1);
+                throw new ParseException();
         }
-        jj_consume_token(19);
-        scalarConstExpression();
-      }
-    } catch (Throwable jjte001) {
-          if (jjtc001) {
-            jjtree.clearNodeScope(jjtn001);
-            jjtc001 = false;
-          } else {
-            jjtree.popNode();
-          }
-          if (jjte001 instanceof RuntimeException) {
-            {if (true) throw (RuntimeException)jjte001;}
-          }
-          if (jjte001 instanceof ParseException) {
-            {if (true) throw (ParseException)jjte001;}
-          }
-          {if (true) throw (Error)jjte001;}
-    } finally {
-          if (jjtc001) {
-            jjtree.closeNodeScope(jjtn001, true);
-          }
-    }
-  }
-
-  final public void conditionExpression() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 16:
-    case 25:
-    case 26:
-    case 28:
-    case LENGTH:
-    case LOCATE:
-    case ABS:
-    case SQRT:
-    case MOD:
-    case YEAR:
-    case MONTH:
-    case WEEK:
-    case DAY_OF_YEAR:
-    case DAY:
-    case DAY_OF_MONTH:
-    case DAY_OF_WEEK:
-    case HOUR:
-    case MINUTE:
-    case SECOND:
-    case 65:
-    case 66:
-    case 67:
-    case 68:
-    case PROPERTY_PATH:
-    case INT_LITERAL:
-    case FLOAT_LITERAL:
-      numericExpression();
-      break;
-    case CONCAT:
-    case SUBSTRING:
-    case TRIM:
-    case LOWER:
-    case UPPER:
-    case SINGLE_QUOTED_STRING:
-    case DOUBLE_QUOTED_STRING:
-      stringExpression();
-      break;
-    case NULL:
-                  ASTScalar jjtn001 = new ASTScalar(JJTSCALAR);
-                  boolean jjtc001 = true;
-                  jjtree.openNodeScope(jjtn001);
-      try {
-        jj_consume_token(NULL);
-      } finally {
-                  if (jjtc001) {
-                    jjtree.closeNodeScope(jjtn001,  0);
-                  }
-      }
-      break;
-    case AVG:
-    case MIN:
-    case MAX:
-    case SUM:
-    case COUNT:
-      aggregateExpression();
-      break;
-    case CURRENT_DATE:
-    case CURRENT_TIME:
-    case CURRENT_TIMESTAMP:
-      dateTimeFunction();
-      break;
-    default:
-      jj_la1[14] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void stringParameter() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 66:
-    case 67:
-    case 68:
-    case PROPERTY_PATH:
-      pathExpression();
-      break;
-    case CONCAT:
-    case SUBSTRING:
-    case TRIM:
-    case LOWER:
-    case UPPER:
-    case SINGLE_QUOTED_STRING:
-    case DOUBLE_QUOTED_STRING:
-      stringExpression();
-      break;
-    default:
-      jj_la1[15] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void stringExpression() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case SINGLE_QUOTED_STRING:
-      jj_consume_token(SINGLE_QUOTED_STRING);
-                             ASTScalar jjtn001 = new ASTScalar(JJTSCALAR);
-                             boolean jjtc001 = true;
-                             jjtree.openNodeScope(jjtn001);
-      try {
-                             jjtree.closeNodeScope(jjtn001,  0);
-                             jjtc001 = false;
-                             jjtn001.setValue(token_source.literalValue);
-      } finally {
-                             if (jjtc001) {
-                               jjtree.closeNodeScope(jjtn001,  0);
-                             }
-      }
-      break;
-    case DOUBLE_QUOTED_STRING:
-      jj_consume_token(DOUBLE_QUOTED_STRING);
-                             ASTScalar jjtn002 = new ASTScalar(JJTSCALAR);
-                             boolean jjtc002 = true;
-                             jjtree.openNodeScope(jjtn002);
-      try {
-                             jjtree.closeNodeScope(jjtn002,  0);
-                             jjtc002 = false;
-                             jjtn002.setValue(token_source.literalValue);
-      } finally {
-                             if (jjtc002) {
-                               jjtree.closeNodeScope(jjtn002,  0);
-                             }
-      }
-      break;
-    case CONCAT:
-    case SUBSTRING:
-    case TRIM:
-    case LOWER:
-    case UPPER:
-      functionsReturningStrings();
-      break;
-    default:
-      jj_la1[16] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void scalarExpression() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 16:
-    case 25:
-    case 26:
-    case 28:
-    case NULL:
-    case AVG:
-    case MIN:
-    case MAX:
-    case SUM:
-    case COUNT:
-    case CONCAT:
-    case SUBSTRING:
-    case TRIM:
-    case LOWER:
-    case UPPER:
-    case LENGTH:
-    case LOCATE:
-    case ABS:
-    case SQRT:
-    case MOD:
-    case CURRENT_DATE:
-    case CURRENT_TIME:
-    case CURRENT_TIMESTAMP:
-    case YEAR:
-    case MONTH:
-    case WEEK:
-    case DAY_OF_YEAR:
-    case DAY:
-    case DAY_OF_MONTH:
-    case DAY_OF_WEEK:
-    case HOUR:
-    case MINUTE:
-    case SECOND:
-    case 65:
-    case 66:
-    case 67:
-    case 68:
-    case PROPERTY_PATH:
-    case SINGLE_QUOTED_STRING:
-    case DOUBLE_QUOTED_STRING:
-    case INT_LITERAL:
-    case FLOAT_LITERAL:
-      conditionExpression();
-      break;
-    case TRUE:
-      jj_consume_token(TRUE);
-                   ASTScalar jjtn001 = new ASTScalar(JJTSCALAR);
-                   boolean jjtc001 = true;
-                   jjtree.openNodeScope(jjtn001);
-      try {
-                   jjtree.closeNodeScope(jjtn001,  0);
-                   jjtc001 = false;
-                   jjtn001.setValue(true);
-      } finally {
-                   if (jjtc001) {
-                     jjtree.closeNodeScope(jjtn001,  0);
-                   }
-      }
-      break;
-    case FALSE:
-      jj_consume_token(FALSE);
-                    ASTScalar jjtn002 = new ASTScalar(JJTSCALAR);
-                    boolean jjtc002 = true;
-                    jjtree.openNodeScope(jjtn002);
-      try {
-                    jjtree.closeNodeScope(jjtn002,  0);
-                    jjtc002 = false;
-                    jjtn002.setValue(false);
-      } finally {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case 13:
+                jj_consume_token(13);
+                ASTNotLike jjtn001 = new ASTNotLike(JJTNOTLIKE);
+                boolean jjtc001 = true;
+                jjtree.openNodeScope(jjtn001);
+                try {
+                    scalarExpression();
+                } catch (Throwable jjte001) {
+                    if (jjtc001) {
+                        jjtree.clearNodeScope(jjtn001);
+                        jjtc001 = false;
+                    } else {
+                        jjtree.popNode();
+                    }
+                    if (jjte001 instanceof RuntimeException) {
+                        {if (true) throw (RuntimeException)jjte001;}
+                    }
+                    if (jjte001 instanceof ParseException) {
+                        {if (true) throw (ParseException)jjte001;}
+                    }
+                    {if (true) throw (Error)jjte001;}
+                } finally {
+                    if (jjtc001) {
+                        jjtree.closeNodeScope(jjtn001,  2);
+                    }
+                }
+                break;
+            case 14:
+                jj_consume_token(14);
+                ASTNotLikeIgnoreCase jjtn002 = new 
ASTNotLikeIgnoreCase(JJTNOTLIKEIGNORECASE);
+                boolean jjtc002 = true;
+                jjtree.openNodeScope(jjtn002);
+                try {
+                    scalarExpression();
+                } catch (Throwable jjte002) {
                     if (jjtc002) {
-                      jjtree.closeNodeScope(jjtn002,  0);
+                        jjtree.clearNodeScope(jjtn002);
+                        jjtc002 = false;
+                    } else {
+                        jjtree.popNode();
                     }
-      }
-      break;
-    default:
-      jj_la1[17] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void scalarConstExpression() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case SINGLE_QUOTED_STRING:
-      jj_consume_token(SINGLE_QUOTED_STRING);
-                                   ASTScalar jjtn001 = new 
ASTScalar(JJTSCALAR);
-                                   boolean jjtc001 = true;
-                                   jjtree.openNodeScope(jjtn001);
-      try {
-                                   jjtree.closeNodeScope(jjtn001,  0);
-                                   jjtc001 = false;
-                                   jjtn001.setValue(token_source.literalValue);
-      } finally {
-                                   if (jjtc001) {
-                                     jjtree.closeNodeScope(jjtn001,  0);
-                                   }
-      }
-      break;
-    case DOUBLE_QUOTED_STRING:
-      jj_consume_token(DOUBLE_QUOTED_STRING);
-                                   ASTScalar jjtn002 = new 
ASTScalar(JJTSCALAR);
-                                   boolean jjtc002 = true;
-                                   jjtree.openNodeScope(jjtn002);
-      try {
-                                   jjtree.closeNodeScope(jjtn002,  0);
-                                   jjtc002 = false;
-                                   jjtn002.setValue(token_source.literalValue);
-      } finally {
-                                   if (jjtc002) {
-                                     jjtree.closeNodeScope(jjtn002,  0);
-                                   }
-      }
-      break;
-    case 65:
-      namedParameter();
-      break;
-    case INT_LITERAL:
-      jj_consume_token(INT_LITERAL);
-                            ASTScalar jjtn003 = new ASTScalar(JJTSCALAR);
-                            boolean jjtc003 = true;
-                            jjtree.openNodeScope(jjtn003);
-      try {
-                            jjtree.closeNodeScope(jjtn003,  0);
-                            jjtc003 = false;
-                            jjtn003.setValue(token_source.literalValue);
-      } finally {
-                            if (jjtc003) {
-                              jjtree.closeNodeScope(jjtn003,  0);
-                            }
-      }
-      break;
-    case FLOAT_LITERAL:
-      jj_consume_token(FLOAT_LITERAL);
-                            ASTScalar jjtn004 = new ASTScalar(JJTSCALAR);
-                            boolean jjtc004 = true;
-                            jjtree.openNodeScope(jjtn004);
-      try {
-                            jjtree.closeNodeScope(jjtn004,  0);
-                            jjtc004 = false;
-                            jjtn004.setValue(token_source.literalValue);
-      } finally {
-                            if (jjtc004) {
-                              jjtree.closeNodeScope(jjtn004,  0);
-                            }
-      }
-      break;
-    case TRUE:
-      jj_consume_token(TRUE);
-                    ASTScalar jjtn005 = new ASTScalar(JJTSCALAR);
-                    boolean jjtc005 = true;
-                    jjtree.openNodeScope(jjtn005);
-      try {
-                    jjtree.closeNodeScope(jjtn005,  0);
-                    jjtc005 = false;
-                    jjtn005.setValue(true);
-      } finally {
-                    if (jjtc005) {
-                      jjtree.closeNodeScope(jjtn005,  0);
+                    if (jjte002 instanceof RuntimeException) {
+                        {if (true) throw (RuntimeException)jjte002;}
                     }
-      }
-      break;
-    case FALSE:
-      jj_consume_token(FALSE);
-                    ASTScalar jjtn006 = new ASTScalar(JJTSCALAR);
-                    boolean jjtc006 = true;
-                    jjtree.openNodeScope(jjtn006);
-      try {
-                    jjtree.closeNodeScope(jjtn006,  0);
-                    jjtc006 = false;
-                    jjtn006.setValue(false);
-      } finally {
-                    if (jjtc006) {
-                      jjtree.closeNodeScope(jjtn006,  0);
+                    if (jjte002 instanceof ParseException) {
+                        {if (true) throw (ParseException)jjte002;}
                     }
-      }
-      break;
-    default:
-      jj_la1[18] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void numericExpression() throws ParseException {
-    bitwiseOr();
-  }
-
-  final public void bitwiseOr() throws ParseException {
-    bitwiseXor();
-    label_4:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 20:
-        ;
-        break;
-      default:
-        jj_la1[19] = jj_gen;
-        break label_4;
-      }
-      jj_consume_token(20);
-              ASTBitwiseOr jjtn001 = new ASTBitwiseOr(JJTBITWISEOR);
-              boolean jjtc001 = true;
-              jjtree.openNodeScope(jjtn001);
-      try {
-        bitwiseXor();
-      } catch (Throwable jjte001) {
-              if (jjtc001) {
-                jjtree.clearNodeScope(jjtn001);
-                jjtc001 = false;
-              } else {
-                jjtree.popNode();
-              }
-              if (jjte001 instanceof RuntimeException) {
-                {if (true) throw (RuntimeException)jjte001;}
-              }
-              if (jjte001 instanceof ParseException) {
-                {if (true) throw (ParseException)jjte001;}
-              }
-              {if (true) throw (Error)jjte001;}
-      } finally {
-              if (jjtc001) {
-                jjtree.closeNodeScope(jjtn001,  2);
-              }
-      }
-    }
-  }
-
-  final public void bitwiseXor() throws ParseException {
-    bitwiseAnd();
-    label_5:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 21:
-        ;
-        break;
-      default:
-        jj_la1[20] = jj_gen;
-        break label_5;
-      }
-      jj_consume_token(21);
-              ASTBitwiseXor jjtn001 = new ASTBitwiseXor(JJTBITWISEXOR);
-              boolean jjtc001 = true;
-              jjtree.openNodeScope(jjtn001);
-      try {
-        bitwiseAnd();
-      } catch (Throwable jjte001) {
-              if (jjtc001) {
-                jjtree.clearNodeScope(jjtn001);
-                jjtc001 = false;
-              } else {
-                jjtree.popNode();
-              }
-              if (jjte001 instanceof RuntimeException) {
-                {if (true) throw (RuntimeException)jjte001;}
-              }
-              if (jjte001 instanceof ParseException) {
-                {if (true) throw (ParseException)jjte001;}
-              }
-              {if (true) throw (Error)jjte001;}
-      } finally {
-              if (jjtc001) {
-                jjtree.closeNodeScope(jjtn001,  2);
-              }
-      }
-    }
-  }
-
-  final public void bitwiseAnd() throws ParseException {
-    bitwiseShift();
-    label_6:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 22:
-        ;
-        break;
-      default:
-        jj_la1[21] = jj_gen;
-        break label_6;
-      }
-      jj_consume_token(22);
-              ASTBitwiseAnd jjtn001 = new ASTBitwiseAnd(JJTBITWISEAND);
-              boolean jjtc001 = true;
-              jjtree.openNodeScope(jjtn001);
-      try {
-        bitwiseShift();
-      } catch (Throwable jjte001) {
-              if (jjtc001) {
-                jjtree.clearNodeScope(jjtn001);
-                jjtc001 = false;
-              } else {
-                jjtree.popNode();
-              }
-              if (jjte001 instanceof RuntimeException) {
-                {if (true) throw (RuntimeException)jjte001;}
-              }
-              if (jjte001 instanceof ParseException) {
-                {if (true) throw (ParseException)jjte001;}
-              }
-              {if (true) throw (Error)jjte001;}
-      } finally {
-              if (jjtc001) {
-                jjtree.closeNodeScope(jjtn001,  2);
-              }
-      }
-    }
-  }
-
-  final public void bitwiseShift() throws ParseException {
-    arithmeticExp();
-    label_7:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 23:
-      case 24:
-        ;
-        break;
-      default:
-        jj_la1[22] = jj_gen;
-        break label_7;
-      }
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 23:
-        jj_consume_token(23);
-               ASTBitwiseLeftShift jjtn001 = new 
ASTBitwiseLeftShift(JJTBITWISELEFTSHIFT);
-               boolean jjtc001 = true;
-               jjtree.openNodeScope(jjtn001);
-        try {
-          arithmeticExp();
-        } catch (Throwable jjte001) {
-               if (jjtc001) {
-                 jjtree.clearNodeScope(jjtn001);
-                 jjtc001 = false;
-               } else {
-                 jjtree.popNode();
-               }
-               if (jjte001 instanceof RuntimeException) {
-                 {if (true) throw (RuntimeException)jjte001;}
-               }
-               if (jjte001 instanceof ParseException) {
-                 {if (true) throw (ParseException)jjte001;}
-               }
-               {if (true) throw (Error)jjte001;}
-        } finally {
-               if (jjtc001) {
-                 jjtree.closeNodeScope(jjtn001,  2);
-               }
-        }
-        break;
-      case 24:
-        jj_consume_token(24);
-               ASTBitwiseRightShift jjtn002 = new 
ASTBitwiseRightShift(JJTBITWISERIGHTSHIFT);
-               boolean jjtc002 = true;
-               jjtree.openNodeScope(jjtn002);
-        try {
-          arithmeticExp();
-        } catch (Throwable jjte002) {
-               if (jjtc002) {
-                 jjtree.clearNodeScope(jjtn002);
-                 jjtc002 = false;
-               } else {
-                 jjtree.popNode();
-               }
-               if (jjte002 instanceof RuntimeException) {
-                 {if (true) throw (RuntimeException)jjte002;}
-               }
-               if (jjte002 instanceof ParseException) {
-                 {if (true) throw (ParseException)jjte002;}
-               }
-               {if (true) throw (Error)jjte002;}
-        } finally {
-               if (jjtc002) {
-                 jjtree.closeNodeScope(jjtn002,  2);
-               }
+                    {if (true) throw (Error)jjte002;}
+                } finally {
+                    if (jjtc002) {
+                        jjtree.closeNodeScope(jjtn002,  2);
+                    }
+                }
+                break;
+            case 15:
+                jj_consume_token(15);
+                ASTNotIn jjtn003 = new ASTNotIn(JJTNOTIN);
+                boolean jjtc003 = true;
+                jjtree.openNodeScope(jjtn003);
+                try {
+                    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                        case 65:
+                            namedParameter();
+                            break;
+                        case 16:
+                            jj_consume_token(16);
+                            scalarCommaList();
+                            jj_consume_token(17);
+                            break;
+                        default:
+                            jj_la1[11] = jj_gen;
+                            jj_consume_token(-1);
+                            throw new ParseException();
+                    }
+                } catch (Throwable jjte003) {
+                    if (jjtc003) {
+                        jjtree.clearNodeScope(jjtn003);
+                        jjtc003 = false;
+                    } else {
+                        jjtree.popNode();
+                    }
+                    if (jjte003 instanceof RuntimeException) {
+                        {if (true) throw (RuntimeException)jjte003;}
+                    }
+                    if (jjte003 instanceof ParseException) {
+                        {if (true) throw (ParseException)jjte003;}
+                    }
+                    {if (true) throw (Error)jjte003;}
+                } finally {
+                    if (jjtc003) {
+                        jjtree.closeNodeScope(jjtn003,  2);
+                    }
+                }
+                break;
+            case 18:
+                jj_consume_token(18);
+                scalarExpression();
+                jj_consume_token(2);
+                ASTNotBetween jjtn004 = new ASTNotBetween(JJTNOTBETWEEN);
+                boolean jjtc004 = true;
+                jjtree.openNodeScope(jjtn004);
+                try {
+                    scalarExpression();
+                } catch (Throwable jjte004) {
+                    if (jjtc004) {
+                        jjtree.clearNodeScope(jjtn004);
+                        jjtc004 = false;
+                    } else {
+                        jjtree.popNode();
+                    }
+                    if (jjte004 instanceof RuntimeException) {
+                        {if (true) throw (RuntimeException)jjte004;}
+                    }
+                    if (jjte004 instanceof ParseException) {
+                        {if (true) throw (ParseException)jjte004;}
+                    }
+                    {if (true) throw (Error)jjte004;}
+                } finally {
+                    if (jjtc004) {
+                        jjtree.closeNodeScope(jjtn004,  3);
+                    }
+                }
+                break;
+            default:
+                jj_la1[12] = jj_gen;
+                jj_consume_token(-1);
+                throw new ParseException();
         }
-        break;
-      default:
-        jj_la1[23] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-    }
-  }
-
-  final public void arithmeticExp() throws ParseException {
-    multiplySubtractExp();
-    label_8:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 25:
-      case 26:
-        ;
-        break;
-      default:
-        jj_la1[24] = jj_gen;
-        break label_8;
-      }
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 25:
-        jj_consume_token(25);
-              ASTAdd jjtn001 = new ASTAdd(JJTADD);
-              boolean jjtc001 = true;
-              jjtree.openNodeScope(jjtn001);
+    }
+
+    final public void scalarCommaList() throws ParseException {
+        ASTList jjtn001 = new ASTList(JJTLIST);
+        boolean jjtc001 = true;
+        jjtree.openNodeScope(jjtn001);
         try {
-          multiplySubtractExp();
+            scalarConstExpression();
+            label_3:
+            while (true) {
+                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+                    case 19:
+                        ;
+                        break;
+                    default:
+                        jj_la1[13] = jj_gen;
+                        break label_3;
+                }
+                jj_consume_token(19);
+                scalarConstExpression();
+            }
         } catch (Throwable jjte001) {
-              if (jjtc001) {
+            if (jjtc001) {
                 jjtree.clearNodeScope(jjtn001);
                 jjtc001 = false;
-              } else {
+            } else {
                 jjtree.popNode();
-              }
-              if (jjte001 instanceof RuntimeException) {
+            }
+            if (jjte001 instanceof RuntimeException) {
                 {if (true) throw (RuntimeException)jjte001;}
-              }
-              if (jjte001 instanceof ParseException) {
+            }
+            if (jjte001 instanceof ParseException) {
                 {if (true) throw (ParseException)jjte001;}
-              }
-              {if (true) throw (Error)jjte001;}
+            }
+            {if (true) throw (Error)jjte001;}
         } finally {
-              if (jjtc001) {
-                jjtree.closeNodeScope(jjtn001,  2);
-              }
+            if (jjtc001) {
+                jjtree.closeNodeScope(jjtn001, true);
+            }
         }
-        break;
-      case 26:
-        jj_consume_token(26);
-              ASTSubtract jjtn002 = new ASTSubtract(JJTSUBTRACT);
-              boolean jjtc002 = true;
-              jjtree.openNodeScope(jjtn002);
-        try {
-          multiplySubtractExp();
-        } catch (Throwable jjte002) {
-              if (jjtc002) {
-                jjtree.clearNodeScope(jjtn002);
-                jjtc002 = false;
-              } else {
-                jjtree.popNode();
-              }
-              if (jjte002 instanceof RuntimeException) {
-                {if (true) throw (RuntimeException)jjte002;}
-              }
-              if (jjte002 instanceof ParseException) {
-                {if (true) throw (ParseException)jjte002;}
-              }
-              {if (true) throw (Error)jjte002;}
-        } finally {
-              if (jjtc002) {
-                jjtree.closeNodeScope(jjtn002,  2);
-              }
+    }
+
+    final public void conditionExpression() throws ParseException {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case 16:
+            case 25:
+            case 26:
+            case 28:
+            case LENGTH:
+            case LOCATE:
+            case ABS:
+            case SQRT:
+            case MOD:
+            case YEAR:
+            case MONTH:
+            case WEEK:
+            case DAY_OF_YEAR:
+            case DAY:
+            case DAY_OF_MONTH:
+            case DAY_OF_WEEK:
+            case HOUR:
+            case MINUTE:
+            case SECOND:
+            case 65:
+            case 66:
+            case 67:
+            case 68:
+            case PROPERTY_PATH:
+            case INT_LITERAL:
+            case FLOAT_LITERAL:
+                numericExpression();
+                break;
+            case CONCAT:
+            case SUBSTRING:
+            case TRIM:
+            case LOWER:
+            case UPPER:
+            case SINGLE_QUOTED_STRING:
+            case DOUBLE_QUOTED_STRING:
+                stringExpression();
+                break;
+            case NULL:
+                ASTScalar jjtn001 = new ASTScalar(JJTSCALAR);
+                boolean jjtc001 = true;
+                jjtree.openNodeScope(jjtn001);
+                try {
+                    jj_consume_token(NULL);
+                } finally {
+                    if (jjtc001) {
+                        jjtree.closeNodeScope(jjtn001,  0);
+                    }
+                }
+                break;
+            case AVG:
+            case MIN:
+            case MAX:
+            case SUM:
+            case COUNT:
+                aggregateExpression();
+                break;
+            case CURRENT_DATE:
+            case CURRENT_TIME:
+            case CURRENT_TIMESTAMP:
+                dateTimeFunction();
+                break;
+            default:
+                jj_la1[14] = jj_gen;
+                jj_consume_token(-1);
+                throw new ParseException();
         }
-        break;
-      default:
-        jj_la1[25] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-    }
-  }
-
-  final public void multiplySubtractExp() throws ParseException {
-    numericTermExt();
-    label_9:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 27:
-      case ASTERISK:
-        ;
-        break;
-      default:
-        jj_la1[26] = jj_gen;
-        break label_9;
-      }
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case ASTERISK:
-        jj_consume_token(ASTERISK);
-                     ASTMultiply jjtn001 = new ASTMultiply(JJTMULTIPLY);
-                     boolean jjtc001 = true;
-                     jjtree.openNodeScope(jjtn001);
-        try {
-          numericTermExt();
-        } catch (Throwable jjte001) {
-                     if (jjtc001) {
-                       jjtree.clearNodeScope(jjtn001);
-                       jjtc001 = false;
-                     } else {
-                       jjtree.popNode();
-                     }
-                     if (jjte001 instanceof RuntimeException) {
-                       {if (true) throw (RuntimeException)jjte001;}
-                     }
-                     if (jjte001 instanceof ParseException) {
-                       {if (true) throw (ParseException)jjte001;}
-                     }
-                     {if (true) throw (Error)jjte001;}
-        } finally {
-                     if (jjtc001) {
-                       jjtree.closeNodeScope(jjtn001,  2);
-                     }
+    }
+
+    final public void stringParameter() throws ParseException {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case 66:
+            case 67:
+            case 68:
+            case PROPERTY_PATH:
+                pathExpression();
+                break;
+            case CONCAT:
+            case SUBSTRING:
+            case TRIM:
+            case LOWER:
+            case UPPER:
+            case SINGLE_QUOTED_STRING:
+            case DOUBLE_QUOTED_STRING:
+                stringExpression();
+                break;
+            default:
+                jj_la1[15] = jj_gen;
+                jj_consume_token(-1);
+                throw new ParseException();
         }
-        break;
-      case 27:
-        jj_consume_token(27);
-              ASTDivide jjtn002 = new ASTDivide(JJTDIVIDE);
-              boolean jjtc002 = true;
-              jjtree.openNodeScope(jjtn002);
-        try {
-          numericTermExt();
-        } catch (Throwable jjte002) {
-              if (jjtc002) {
-                jjtree.clearNodeScope(jjtn002);
-                jjtc002 = false;
-              } else {
-                jjtree.popNode();
-              }
-              if (jjte002 instanceof RuntimeException) {
-                {if (true) throw (RuntimeException)jjte002;}
-              }
-              if (jjte002 instanceof ParseException) {
-                {if (true) throw (ParseException)jjte002;}
-              }
-              {if (true) throw (Error)jjte002;}
-        } finally {
-              if (jjtc002) {
-                jjtree.closeNodeScope(jjtn002,  2);
-              }
+    }
+
+    final public void stringExpression() throws ParseException {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+            case SINGLE_QUOTED_STRING:
+                jj_consume_token(SINGLE_QUOTED_STRING);
+                ASTScalar jjtn001 = new ASTScalar(JJTSCALAR);
+                boolean jjtc001 = true;
+                jjtree.openNodeScope(jjtn001);
+                try {
+                    jjtree.closeNodeScope(jjtn001,  0);
+                    jjtc001 = false;
+                    jjtn001.setValue(token_source.literalValue);
+                } finally {
+                    if (jjtc001) {
+                        jjtree.closeNodeScope(jjtn001,  0);
+                    }
+                }
+                break;
+            case DOUBLE_QUOTED_STRING:
+                jj_consume_token(DOUBLE_QUOTED_STRING);
+                ASTScalar jjtn002 = new ASTScalar(JJTSCALAR);
+                boolean jjtc002 = true;
+                jjtree.openNodeScope(jjtn002);
+                try {
+                    jjtree.closeNodeScope(jjtn002,  0);
+                    jjtc002 = false;
+                    jjtn002.setValue(token_source.literalValue);
+                } finally {
+                    if (jjtc002) {
+                        jjtree.closeNodeScope(jjtn002,  0);
+                    }
+                }
+                break;
+            case CONCAT:
+            case SUBSTRING:
+            case TRIM:
+            case LOWER:
+            case UPPER:
+                functionsReturningStrings();
+                break;
+            default:
+                jj_la1[16] = jj_gen;
+                jj_consume_token(-1);
+                throw new ParseException();
         }
-        break;
-      default:
-        jj_la1[27] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-    }
-  }
-
-  final public void numericTermExt() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 16:
-    case 25:
-    case 26:
-    case LENGTH:
-    case LOCATE:
-    case ABS:
-    case SQRT:
-    case MOD:
-    case YEAR:
-    case MONTH:
-    case WEEK:
-    case DAY_OF_YEAR:
-    case DAY:
-    case DAY_OF_MONTH:
-    case DAY_OF_WEEK:
-    case HOUR:
-    case MINUTE:
-    case SECOND:
-    case 65:
-    case 66:
-    case 67:
-    case 68:
-    case PROPERTY_PATH:
-    case INT_LITERAL:
-    case FLOAT_LITERAL:
-      numericTerm();
-      break;
-    case 28:
-      jj_consume_token(28);
-              ASTBitwiseNot jjtn001 = new ASTBitwiseNot(JJTBITWISENOT);
-              boolean jjtc001 = true;
-              jjtree.openNodeScope(jjtn001);
-      try {
-        numericTerm();
-      } catch (Throwable jjte001) {
-              if (jjtc001) {
-                jjtree.clearNodeScope(jjtn001);
-                jjtc001 = false;
-              } else {
-                jjtree.popNode();
-              }
-              if (jjte001 instanceof RuntimeException) {
-                {if (true) throw (RuntimeException)jjte001;}
-              }
-              if (jjte001 instanceof ParseException) {
-                {if (true) throw (ParseException)jjte001;}
-              }
-              {if (true) throw (Error)jjte001;}
-      } finally {
-              if (jjtc001) {
-                jjtree.closeNodeScope(jjtn001,  1);
-              }
-      }
-      break;
-    default:
-      jj_la1[28] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-  }
-
-  final public void numericTerm() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 16:
-    case 25:
-    case LENGTH:
-    case LOCATE:
-    case ABS:
-    case SQRT:
-    case MOD:
-    case YEAR:
-    case MONTH:
-    case WEEK:
-    case DAY_OF_YEAR:
-   

<TRUNCATED>

Reply via email to