Various fixes

lexer-parser/pom.xml

@@ -53,14 +53,14 @@
                 <configuration>
                     <executable>java</executable>
                     <arguments>
-                        <argument>-Xmx1g</argument>
+                        <argument>-Xmx768m</argument>
                         <argument>-classpath</argument>
                         <classpath/>
                         <argument>org.antlr.Tool</argument>
                         <argument>-o</argument>
                         <argument>${project.build.directory}/generated-sources/antlr3/br/com/porcelli/parser/plsql/
                         </argument>
-			<argument>-Xmultithreaded</argument>
+			<!-- <argument>-Xmultithreaded</argument> -->
                         <argument>-lib</argument>
                         <argument>${project.basedir}/src/main/antlr3/br/com/porcelli/parser/plsql/imports/</argument>
                         <argument>${project.basedir}/src/main/antlr3/br/com/porcelli/parser/plsql/PLSQLLexer.g
@@ -73,7 +73,6 @@
             <plugin>
                 <groupId>org.antlr</groupId>
                 <artifactId>maven-gunit-plugin</artifactId>
-                <version>3.2</version>
                 <executions>
                     <execution>
                         <id>maven-gunit-plugin</id>

parsers/PLSQLCommons.g

@@ -511,6 +511,12 @@ concatenation_op
     |    VERTICAL_BAR VERTICAL_BAR
     ;
 
+multiset_op
+    :    multiset_key
+         ( except_key | intersect_key | union_key )
+         ( all_key | distinct_key )?
+    ;
+
 outer_join_sign
     :    LEFT_PAREN PLUS_SIGN RIGHT_PAREN
     ;

parsers/PLSQLKeys.g

@@ -1514,7 +1514,8 @@ over_key
     ;
 
 multiset_key
-    :    {input.LT(1).getText().equalsIgnoreCase("multiset")}?=> REGULAR_ID
+//    :    {input.LT(1).getText().equalsIgnoreCase("multiset")}?=> REGULAR_ID
+	:	PLSQL_NON_RESERVED_MULTISET
     ;
 
 connect_by_root_key
@@ -2082,7 +2083,8 @@ match_key
     ;
 
 cast_key
-    :    {input.LT(1).getText().equalsIgnoreCase("cast")}? REGULAR_ID -> CAST_VK[$REGULAR_ID]
+//    :    {input.LT(1).getText().equalsIgnoreCase("cast")}? REGULAR_ID -> CAST_VK[$REGULAR_ID]
+    :    PLSQL_NON_RESERVED_CAST
     ;
 
 full_key:    {input.LT(1).getText().equalsIgnoreCase("full")}?=> REGULAR_ID -> FULL_VK[$REGULAR_ID]

parsers/PLSQLLexer.g

@@ -76,7 +76,7 @@ import java.util.LinkedList;
                 state.tokenStartLine = input.getLine();
                 state.text = null;
                 if (input.LA(1) == CharStream.EOF) {
-                    return Token.EOF_TOKEN;
+                    return getEOFToken();
                 }
                 try {
                     int m = input.mark();
@@ -116,8 +116,12 @@ FOR_NOTATION
         {state.type = UNSIGNED_INTEGER; emit(); advanceInput();}
         '..'
         {state.type = DOUBLE_PERIOD; emit(); advanceInput();}
-        UNSIGNED_INTEGER
-        {state.type = UNSIGNED_INTEGER; emit(); advanceInput(); $channel=HIDDEN;}
+        ( UNSIGNED_INTEGER
+          {state.type = UNSIGNED_INTEGER; emit(); advanceInput(); }
+        |	REGULAR_ID
+          {state.type = REGULAR_ID; emit(); advanceInput(); }
+        )?
+        { $channel=HIDDEN; }
     ;
 
 //{ Rule #358 <NATIONAL_CHAR_STRING_LIT> - subtoken typecast in <REGULAR_ID>, it also incorporates <character_representation>
@@ -159,7 +163,7 @@ PERIOD
 EXACT_NUM_LIT
     : (
             UNSIGNED_INTEGER
-            ( '.' UNSIGNED_INTEGER
+            ( '.' UNSIGNED_INTEGER?
             |    {$type = UNSIGNED_INTEGER;}
             ) ( ('E' | 'e') ('+' | '-')? UNSIGNED_INTEGER {$type = APPROXIMATE_NUM_LIT;} )?
     |    '.' UNSIGNED_INTEGER ( ('E' | 'e') ('+' | '-')? UNSIGNED_INTEGER {$type = APPROXIMATE_NUM_LIT;} )?
@@ -228,6 +232,7 @@ RIGHT_PAREN
     :    ')'
     ;
 
+// Not allowed in SQL, but in PL/SQL(ADA) yes
 DOUBLE_ASTERISK
     :    '**'
     ;
@@ -541,15 +546,15 @@ SQL92_RESERVED_EXCEPTION
     advanceInput();
 
     $type = Token.INVALID_TOKEN_TYPE;
-    int markModel = input.mark();
+    int markException = input.mark();
 
     // Now loop over next Tokens in the input and eventually set Token's type to REGULAR_ID
 
     // Subclassed version will return NULL unless EOF is reached.
     // nextToken either returns NULL => then the next token is put into the queue tokenBuffer
     // or it returns Token.EOF, then nothing is put into the queue
     Token t1 = super.nextToken();
-    {    // This "if" handles the situation when the "model" is the last text in the input.
+    {    // This "if" handles the situation when the "exception" is the last text in the input.
         if( t1 != null && t1.getType() == Token.EOF)
         {
              $e.setType(REGULAR_ID);
@@ -579,7 +584,7 @@ SQL92_RESERVED_EXCEPTION
               } // while true
          } // else if( t1 != null && t1.getType() == Token.EOF)
     }
-    input.rewind(markModel);
+    input.rewind(markException);
     }
     ;
 
@@ -815,14 +820,22 @@ SQL92_RESERVED_WITH
     :    'with'
     ;
 
+PLSQL_NON_RESERVED_CAST
+    :    'cast'
+    ;
+
+PLSQL_NON_RESERVED_MULTISET
+	:	'multiset'
+	;
+
 PLSQL_NON_RESERVED_USING
     :    'using'
     ;
 
 PLSQL_NON_RESERVED_MODEL
     :    m='model'
     {
-         // "model" is a keyword if and only if it is followed by ("main"|"partition"|"dimension")
+         // "model" is a keyword if and only if it is followed by ("main"|"partition"|"dimension"|"unique"|"return")
          // otherwise it is a identifier(REGULAR_ID).
          // This wodoo implements something like context sensitive lexer.
          // Here we've matched the word "model". Then the Token is created and en-queued in tokenBuffer
@@ -859,10 +872,15 @@ PLSQL_NON_RESERVED_MODEL
                          t1 = super.nextToken(); if( t1 == null) { t1 = tokenBuffer.pollLast(); };
                          continue;
                      }
-
-                     if( t1.getType() != REGULAR_ID || // is something other than ("main"|"partition"|"dimension")
+
+                     if( t1.getType() == SQL92_RESERVED_UNIQUE)
+                     {
+                         break;
+                     }
+                     if( t1.getType() != REGULAR_ID || // is something other than ("main"|"partition"|"dimension"|"return")
                         ( !t1.getText().equalsIgnoreCase("main") &&
                           !t1.getText().equalsIgnoreCase("partition") &&
+                          !t1.getText().equalsIgnoreCase("return") &&
                           !t1.getText().equalsIgnoreCase("dimension")
                        ))
                      {

parsers/PLSQLParser.g

@@ -1246,7 +1246,7 @@ exception_handler
 // $>
 
 block
-    :    (declare_key? declare_spec+)?
+    :    (declare_key declare_spec+)?
         body
         -> ^(BLOCK declare_spec* body)
     ;

parsers/PLSQL_DMLParser.g

@@ -45,6 +45,7 @@ tokens {
     PIVOT_IN_ELEMENT;
     UNPIVOT_IN_ELEMENT;
     HIERARCHICAL;
+    GROUP_BY_CLAUSE;
     GROUP_BY_ELEMENT;
     GROUPIN_SET;
     MAIN_MODEL;
@@ -186,14 +187,16 @@ compilation_unit
 
 //SHOULD BE OVERRIDEN!
 seq_of_statements
-    :    select_statement
+    :
+    (    select_statement
     |    update_statement
     |    delete_statement
     |    insert_statement
     |    lock_table_statement
     |    merge_statement
     |    explain_statement
-//    |    case_statement[true]
+    )
+    (    SEMICOLON | EOF )
     ;
 
 explain_statement
@@ -265,10 +268,10 @@ query_block
         hierarchical_query_clause? 
         group_by_clause?
         model_clause?
-        -> {mode == 1}? ^(select_key from_clause distinct_key? unique_key? all_key? ASTERISK
-                into_clause? where_clause? hierarchical_query_clause? group_by_clause? model_clause?)
-        -> ^(select_key from_clause distinct_key? unique_key? all_key? ^(SELECT_LIST selected_element+)
-                into_clause? where_clause? hierarchical_query_clause? group_by_clause? model_clause?)
+        -> {mode == 1}? ^(select_key distinct_key? unique_key? all_key? ASTERISK
+                into_clause? from_clause where_clause? hierarchical_query_clause? group_by_clause? model_clause?)
+        -> ^(select_key distinct_key? unique_key? all_key? ^(SELECT_LIST selected_element+)
+                into_clause? from_clause where_clause? hierarchical_query_clause? group_by_clause? model_clause?)
     ;
 
 selected_element
@@ -381,7 +384,7 @@ pivot_in_clause
     :    in_key
         LEFT_PAREN
             (    (select_key)=> subquery {mode = 1;}
-            |    (any_key)=> any_key (COMMA any_key)* {mode = 1;}
+            |    (any_key)=> any_key (COMMA any_key)* {mode = 2;}
             |    pivot_in_clause_element (COMMA pivot_in_clause_element)*
             )
         RIGHT_PAREN
@@ -425,7 +428,7 @@ unpivot_in_elements
     :   (    column_name
         |    LEFT_PAREN column_name (COMMA column_name)* RIGHT_PAREN
         )
-        (    as_key?
+        (    as_key
         (    constant
         |    (LEFT_PAREN)=> LEFT_PAREN constant (COMMA constant)* RIGHT_PAREN
         )
@@ -446,10 +449,19 @@ start_part
     ;
 
 group_by_clause
-    :    (group_key) => group_key by_key group_by_elements ((COMMA group_by_elements)=> COMMA group_by_elements)* having_clause?
-         -> ^(group_key ^(GROUP_BY_ELEMENT group_by_elements)+ having_clause?)
-    |    (having_key) => having_clause (group_key by_key group_by_elements ((COMMA group_by_elements)=> COMMA group_by_elements)*)?
-         -> ^(group_key having_clause ^(GROUP_BY_ELEMENT group_by_elements)+)
+    :   (group_key) => group_key by_key
+			(LEFT_PAREN RIGHT_PAREN
+			| group_by_elements ((COMMA group_by_elements)=> COMMA group_by_elements)*
+			)
+		having_clause?
+		-> ^(GROUP_BY_CLAUSE[$group_key.start] ^(group_key ^(GROUP_BY_ELEMENT group_by_elements)*) having_clause?)
+    |   (having_key) => having_clause
+		(group_key by_key
+			(LEFT_PAREN RIGHT_PAREN
+			| group_by_elements ((COMMA group_by_elements)=> COMMA group_by_elements)*
+			)
+		)?
+		-> ^(GROUP_BY_CLAUSE[$having_clause.start] having_clause ^(group_key ^(GROUP_BY_ELEMENT group_by_elements)*)?)
     ;
 
 group_by_elements
@@ -520,13 +532,13 @@ model_column_list
     ;
 
 model_column
-    :    expression table_alias?
-        -> ^(MODEL_COLUMN table_alias? ^(EXPR expression))
+    :    expression column_alias?
+        -> ^(MODEL_COLUMN column_alias? ^(EXPR expression))
     ;
 
 model_rules_clause
-    :    model_rules_part? LEFT_PAREN model_rules_element (COMMA model_rules_element)* RIGHT_PAREN
-        -> ^(MODEL_RULES model_rules_element+ model_rules_part?)
+    :    model_rules_part? LEFT_PAREN (model_rules_element (COMMA model_rules_element)*)? RIGHT_PAREN
+        -> ^(MODEL_RULES model_rules_element* model_rules_part?)
     ;
 
 model_rules_part
@@ -591,10 +603,10 @@ update_statement
 
 // $<Update - Specific Clauses
 update_set_clause
-@init    {    int mode = 0;    }
+@init    {    int mode = 1;    }
     :    set_key
-    (    column_based_update_set_clause (COMMA column_based_update_set_clause)* {mode = 1;}
-    |    value_key LEFT_PAREN id RIGHT_PAREN EQUALS_OP expression
+    (    column_based_update_set_clause (COMMA column_based_update_set_clause)*
+    |    value_key LEFT_PAREN id RIGHT_PAREN EQUALS_OP expression {mode = 0;}
     )
         ->{mode == 1}? ^(set_key column_based_update_set_clause+)
         -> ^(set_key ^(value_key id ^(EXPR expression)))
@@ -667,7 +679,7 @@ insert_into_clause
     ;
 
 values_clause
-    :    values_key^ expression_list
+    :    values_key^ (expression_list | record_name)
     ;
 
 // $>
@@ -851,7 +863,7 @@ negated_expression
 
 equality_expression
 @init    {    boolean isNegated = false;    }
-    :    (multiset_expression -> multiset_expression)
+    :    (multiset_comparsion -> multiset_comparsion)
     (    is_key (not_key {isNegated = true;})?
         (    null_key
                 -> {isNegated}? ^(IS_NOT_NULL $equality_expression)
@@ -875,14 +887,14 @@ equality_expression
                 -> {isNegated}? ^(IS_NOT_OF_TYPE $equality_expression type_spec+)
                 -> ^(IS_OF_TYPE $equality_expression type_spec+)
         )
-    )*
+    )?
     ;
 
 
-multiset_expression
+multiset_comparsion
     :    (relational_expression -> relational_expression)
     (    multiset_type of_key? concatenation
-        -> ^(multiset_type $multiset_expression ^(EXPR concatenation)))?
+        -> ^(multiset_type $multiset_comparsion ^(EXPR concatenation)))?
     ;
 
 multiset_type
@@ -977,7 +989,7 @@ interval_expression
     ;
 
 model_expression
-    :    (unary_expression -> unary_expression)
+    :    (multiset_expression -> multiset_expression)
         (LEFT_BRACKET model_expression_element RIGHT_BRACKET
             -> ^(MODEL_EXPRESSION[$LEFT_BRACKET] $model_expression model_expression_element))?
     ;
@@ -1019,6 +1031,11 @@ multi_column_for_loop
         -> ^(FOR_MULTI_COLUMN[$for_key.start] column_name+ ^(in_key subquery? expression_list*))
     ;
 
+multiset_expression
+    :    unary_expression
+         ( multiset_op^ unary_expression )*
+    ;
+
 unary_expression
 options
 {
@@ -1113,18 +1130,18 @@ quantified_expression
     ;
 
 standard_function
-    :    stantard_function_enabling_over^ function_argument over_clause?
-    |    stantard_function_enabling_using^ function_argument using_clause?
+    :    stantard_function_enabling_over^ function_argument_analytic over_clause?
+    |    stantard_function_enabling_using^ function_argument_modeling using_clause?
     |    count_key^
             LEFT_PAREN!
                 ( ASTERISK | (distinct_key|unique_key|all_key)? concatenation_wrapper )
             RIGHT_PAREN! over_clause?
     |    (cast_key^|xmlcast_key^) 
             LEFT_PAREN!
-                ( (multiset_key LEFT_PAREN (select_key|with_key)) => (multiset_key! LEFT_PAREN! subquery RIGHT_PAREN!)
-                | concatenation_wrapper
-                )
-                as_key! type_spec
+            ( (multiset_key LEFT_PAREN+ (select_key|with_key)) => (multiset_key! LEFT_PAREN! subquery order_by_clause? RIGHT_PAREN!)
+              (as_key! type_spec)?
+            | concatenation_wrapper as_key! type_spec
+            )
             RIGHT_PAREN!
     |    chr_key^
             LEFT_PAREN! 
@@ -1144,12 +1161,7 @@ standard_function
             LEFT_PAREN!
                 REGULAR_ID from_key! concatenation_wrapper 
             RIGHT_PAREN!
-    |    (first_value_key^|last_value_key^) 
-            LEFT_PAREN!
-                concatenation_wrapper (ignore_key! nulls_key)? 
-            RIGHT_PAREN! over_clause
-    |    (first_value_key^|last_value_key^)
-             function_argument_analytic
+    |    (first_value_key^|last_value_key^) function_argument_analytic
              respect_or_ignore_nulls? over_clause
     |    stantard_function_pedictions^
             LEFT_PAREN!