Break out query_primary_t parsing

Makes non_join_query_primary_t derive properly from query_primary_t and
make sure that parse_query_primary() properly attempts to parse a
non_join_query_primary_t first, then a joined_table_t if that failed.

Issue #78

Author: jaypipes

libsqltoast/include/sqltoast/print.h

@@ -110,9 +110,10 @@ std::ostream& operator<< (std::ostream& out, const numeric_term_t& nt);
 std::ostream& operator<< (std::ostream& out, const numeric_value_t& nv);
 std::ostream& operator<< (std::ostream& out, const position_expression_t& pe);
 std::ostream& operator<< (std::ostream& out, const query_expression_t& qe);
+std::ostream& operator<< (std::ostream& out, const query_primary_t& primary);
 std::ostream& operator<< (std::ostream& out, const query_specification_non_join_query_primary_t& primary);
 std::ostream& operator<< (std::ostream& out, const query_specification_t& qs);
-std::ostream& operator<< (std::ostream& out, const query_term_t& qt);
+std::ostream& operator<< (std::ostream& out, const query_term_t& term);
 std::ostream& operator<< (std::ostream& out, const row_value_constructor_element_t& rvce);
 std::ostream& operator<< (std::ostream& out, const row_value_constructor_t& rvc);
 std::ostream& operator<< (std::ostream& out, const row_value_expression_t& rve);

libsqltoast/include/sqltoast/query.h

@@ -125,9 +125,10 @@ typedef struct joined_table_query_primary : query_primary_t {
 } joined_table_query_primary_t;
 
 typedef struct non_join_query_term : query_term_t {
-    std::unique_ptr<non_join_query_primary_t> primary;
+    // Guaranteed to be static_castable to non_join_query_primary_t
+    std::unique_ptr<query_primary_t> primary;
     non_join_query_term(
-            std::unique_ptr<non_join_query_primary_t>& primary) :
+            std::unique_ptr<query_primary_t>& primary) :
         query_term_t(QUERY_COMPONENT_TYPE_NON_JOIN),
         primary(std::move(primary))
     {}

libsqltoast/src/parser/parse.h

@@ -143,10 +143,14 @@ bool parse_non_join_query_term(
         parse_context_t& ctx,
         token_t& cur_tok,
         std::unique_ptr<query_term_t>& out);
+bool parse_query_primary(
+        parse_context_t& ctx,
+        token_t& cur_tok,
+        std::unique_ptr<query_primary_t>& out);
 bool parse_non_join_query_primary(
         parse_context_t& ctx,
         token_t& cur_tok,
-        std::unique_ptr<non_join_query_primary_t>& out);
+        std::unique_ptr<query_primary_t>& out);
 bool parse_joined_table(
         parse_context_t& ctx,
         token_t& cur_tok,

libsqltoast/src/parser/query.cc

@@ -12,10 +12,6 @@ namespace sqltoast {
 // <query expression> ::=
 //     <non-join query expression>
 //     | <joined table>
-//
-// <query primary> ::=
-//     <non-join query primary>
-//     | <joined table>
 bool parse_query_expression(
         parse_context_t& ctx,
         token_t& cur_tok,
@@ -107,14 +103,51 @@ bool parse_non_join_query_term(
         parse_context_t& ctx,
         token_t& cur_tok,
         std::unique_ptr<query_term_t>& out) {
-    std::unique_ptr<non_join_query_primary_t> njqp;
+    std::unique_ptr<query_primary_t> query_primary;
 
-    if (! parse_non_join_query_primary(ctx, cur_tok, njqp))
+    if (! parse_non_join_query_primary(ctx, cur_tok, query_primary))
         return false;
     // TODO(jaypipes): Handle INTERSECT
     if (ctx.opts.disable_statement_construction)
         return true;
-    out = std::make_unique<non_join_query_term_t>(njqp);
+    out = std::make_unique<non_join_query_term_t>(query_primary);
+    return true;
+}
+
+// <query primary> ::=
+//     <non-join query primary>
+//     | <joined table>
+bool parse_query_primary(
+        parse_context_t& ctx,
+        token_t& cur_tok,
+        std::unique_ptr<query_primary_t>& out) {
+    lexer_t& lex = ctx.lexer;
+    parse_position_t start = lex.cursor;
+    token_t start_tok = lex.current_token;
+    std::unique_ptr<joined_table_t> joined_table;
+    if (parse_non_join_query_primary(ctx, cur_tok, out))
+        return true;
+    if (ctx.result.code == PARSE_SYNTAX_ERROR)
+        return false;
+
+    // Reset cursor to before parsing of joined table attempt.
+    lex.cursor = start;
+    lex.current_token = cur_tok = start_tok;
+    if (! parse_joined_table(ctx, cur_tok, joined_table))
+        goto err_expect_joined_table;
+    goto push_joined_table_primary;
+err_expect_joined_table:
+    {
+        std::stringstream estr;
+        estr << "Expected <joined table> but found "
+             << cur_tok << std::endl;
+        create_syntax_error_marker(ctx, estr);
+        return false;
+    }
+push_joined_table_primary:
+    if (ctx.opts.disable_statement_construction)
+        return true;
+    out = std::make_unique<joined_table_query_primary_t>(joined_table);
     return true;
 }
 
@@ -129,7 +162,7 @@ bool parse_non_join_query_term(
 bool parse_non_join_query_primary(
         parse_context_t& ctx,
         token_t& cur_tok,
-        std::unique_ptr<non_join_query_primary_t>& out) {
+        std::unique_ptr<query_primary_t>& out) {
     lexer_t& lex = ctx.lexer;
     parse_position_t start = lex.cursor;
     token_t start_tok = lex.current_token;

libsqltoast/src/print/query.cc

@@ -103,6 +103,26 @@ std::ostream& operator<< (std::ostream& out, const non_join_query_term_t& term)
     return out;
 }
 
+std::ostream& operator<< (std::ostream& out, const query_primary_t& primary) {
+    switch (primary.query_component_type) {
+        case QUERY_COMPONENT_TYPE_NON_JOIN:
+            {
+                const non_join_query_primary_t& sub =
+                    static_cast<const non_join_query_primary_t&>(primary);
+                out << sub;
+            }
+            break;
+        case QUERY_COMPONENT_TYPE_JOINED_TABLE:
+            {
+                const joined_table_query_primary_t& sub =
+                    static_cast<const joined_table_query_primary_t&>(primary);
+                out << sub;
+            }
+            break;
+    }
+    return out;
+}
+
 std::ostream& operator<< (std::ostream& out, const non_join_query_primary_t& primary) {
     switch (primary.primary_type) {
         case NON_JOIN_QUERY_PRIMARY_TYPE_QUERY_SPECIFICATION:

sqltoaster/fill.h

@@ -78,6 +78,7 @@ void fill(mapping_t& node, const sqltoast::position_expression_t& expr);
 void fill(mapping_t& node, const sqltoast::predicate_t& pred);
 void fill(mapping_t& node, const sqltoast::quantified_comparison_predicate_t& pred);
 void fill(mapping_t& node, const sqltoast::query_expression_t& qe);
+void fill(mapping_t& node, const sqltoast::query_primary_t& primary);
 void fill(mapping_t& node, const sqltoast::query_specification_non_join_query_primary_t& primary);
 void fill(mapping_t& node, const sqltoast::query_specification_t& query);
 void fill(mapping_t& node, const sqltoast::query_term_t& term);

sqltoaster/node/statement.cc

@@ -293,6 +293,29 @@ void fill(mapping_t& node, const sqltoast::table_expression_t& table_exp) {
     }
 }
 
+void fill(mapping_t& node, const sqltoast::query_expression_t& qe) {
+    switch (qe.query_component_type) {
+        case sqltoast::QUERY_COMPONENT_TYPE_NON_JOIN:
+            {
+                const sqltoast::non_join_query_expression_t& sub =
+                    static_cast<const sqltoast::non_join_query_expression_t&>(qe);
+                fill(node, sub);
+            }
+            break;
+        case sqltoast::QUERY_COMPONENT_TYPE_JOINED_TABLE:
+            {
+                const sqltoast::joined_table_query_expression_t& sub =
+                    static_cast<const sqltoast::joined_table_query_expression_t&>(qe);
+                fill(node, sub);
+            }
+            break;
+    }
+}
+
+void fill(mapping_t& node, const sqltoast::non_join_query_expression_t& qe) {
+    fill(node, *qe.term);
+}
+
 void fill(mapping_t& node, const sqltoast::query_term_t& term) {
     switch (term.query_component_type) {
         case sqltoast::QUERY_COMPONENT_TYPE_NON_JOIN:
@@ -312,33 +335,29 @@ void fill(mapping_t& node, const sqltoast::query_term_t& term) {
     }
 }
 
-void fill(mapping_t& node, const sqltoast::query_expression_t& qe) {
-    switch (qe.query_component_type) {
+void fill(mapping_t& node, const sqltoast::non_join_query_term_t& term) {
+    fill(node, *term.primary);
+}
+
+void fill(mapping_t& node, const sqltoast::query_primary_t& primary) {
+    switch (primary.query_component_type) {
         case sqltoast::QUERY_COMPONENT_TYPE_NON_JOIN:
             {
-                const sqltoast::non_join_query_expression_t& sub =
-                    static_cast<const sqltoast::non_join_query_expression_t&>(qe);
+                const sqltoast::non_join_query_primary_t& sub =
+                    static_cast<const sqltoast::non_join_query_primary_t&>(primary);
                 fill(node, sub);
             }
             break;
         case sqltoast::QUERY_COMPONENT_TYPE_JOINED_TABLE:
             {
-                const sqltoast::joined_table_query_expression_t& sub =
-                    static_cast<const sqltoast::joined_table_query_expression_t&>(qe);
+                const sqltoast::joined_table_query_primary_t& sub =
+                    static_cast<const sqltoast::joined_table_query_primary_t&>(primary);
                 fill(node, sub);
             }
             break;
     }
 }
 
-void fill(mapping_t& node, const sqltoast::non_join_query_expression_t& qe) {
-    fill(node, *qe.term);
-}
-
-void fill(mapping_t& node, const sqltoast::non_join_query_term_t& term) {
-    fill(node, *term.primary);
-}
-
 void fill(mapping_t& node, const sqltoast::non_join_query_primary_t& primary) {
     switch (primary.primary_type) {
         case sqltoast::NON_JOIN_QUERY_PRIMARY_TYPE_QUERY_SPECIFICATION:

sqltoaster/print/yaml.cc

@@ -376,6 +376,25 @@ void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::non_join_query_t
     to_yaml(ptr, out, *term.primary);
 }
 
+void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::query_primary_t& primary) {
+    switch (primary.query_component_type) {
+        case sqltoast::QUERY_COMPONENT_TYPE_NON_JOIN:
+            {
+                const sqltoast::non_join_query_primary_t& sub =
+                    static_cast<const sqltoast::non_join_query_primary_t&>(primary);
+                to_yaml(ptr, out, sub);
+            }
+            break;
+        case sqltoast::QUERY_COMPONENT_TYPE_JOINED_TABLE:
+            {
+                const sqltoast::joined_table_query_primary_t& sub =
+                    static_cast<const sqltoast::joined_table_query_primary_t&>(primary);
+                to_yaml(ptr, out, sub);
+            }
+            break;
+    }
+}
+
 void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::non_join_query_primary_t& primary) {
     switch (primary.primary_type) {
         case sqltoast::NON_JOIN_QUERY_PRIMARY_TYPE_QUERY_SPECIFICATION:

sqltoaster/print/yaml.h

@@ -53,6 +53,7 @@ void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::overlaps_predica
 void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::predicate_t& pred);
 void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::quantified_comparison_predicate_t& pred);
 void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::query_expression_t& qe);
+void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::query_primary_t& primary);
 void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::query_specification_non_join_query_primary_t& primary);
 void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::query_specification_t& query);
 void to_yaml(printer_t& ptr, std::ostream& out, const sqltoast::query_term_t& term);