// Define a grammar called postgresql
parser grammar PgsqlParser;

options {
	tokenVocab = PgsqlLexer;
}

@parser::preinclude {
#include "sqlast/sqlast.h"
}

@parser::includes {
}

@parser::members {
}

main returns [std::unique_ptr<sqlast::StatementList> program]
    : statement_list { $program = std::move($statement_list.result); }
    ;

statement_list returns [std::unique_ptr<sqlast::StatementList> result]
    : { $result = std::make_unique<sqlast::StatementList>(); }
      (statement SemiColon  { $result->Add(std::move($statement.result)); } | empty_statement)* 
      (statement SemiColon? { $result->Add(std::move($statement.result)); } | empty_statement )
    ;

statement returns [std::unique_ptr<sqlast::Statement> result]
    : select_stmt { $result = std::move($select_stmt.result); }
    ;

empty_statement
    : SemiColon
    ;

select_stmt returns [std::unique_ptr<sqlast::SelectStatement> result]
    : Select select_list 
        { 
            $result = std::make_unique<sqlast::SelectStatement>(); 
            $result->SetSelectList(std::move($select_list.result));
        }
       (From from_item (Comma from_item)* )? 
       (Where condition)? 
       (Group By group_by)? 
       (Order By order_by)? 
       (Having having)?
    ;

from_item
    : Ident Dot Ident from_alias?
    | Ident from_alias?
    | OpenParen select_stmt CloseParen from_alias
    | from_item (Left|Right|Full) Outer? Join from_item (join_on_condition|join_using_condition)
    | from_item Natural (Left|Right|Full) Outer? Join from_item
    ;

join_on_condition
    : On 
    ;

join_using_condition
    : Using OpenParen ident_list CloseParen (As join_using_alias)
    ;

join_using_alias
    :
    ;

ident_list
    : Ident (Comma Ident)*
    ;

from_alias
    : As? Ident (OpenParen Ident (Comma Ident)* CloseParen)?
    ;

condition
    : expr
    ;
    
group_by
    :
    ;
    
order_by
    :
    ;
    
having
    :
    ;
    

select_list returns [std::unique_ptr<sqlast::SelectList> result]
    : select_item  
        { 
            $result = std::make_unique<sqlast::SelectList>(); 
            $result->Add(std::move($select_item.result)); 
        }
        (Comma select_item)* { $result->Add(std::move($select_item.result)); }
    | 
    ;

select_item returns [std::unique_ptr<sqlast::SelectItem> result]
    : expr { $result = std::make_unique<sqlast::SelectItem>(std::move($expr.result)); }
        (As? Ident { $result->SetAlias($Ident.text); })?
    ;

expr returns [std::unique_ptr<sqlast::Expression> result]
    : expr Dot Ident
    | Ident
    | value { $result = std::move($value.result); }
    ;

value returns [std::unique_ptr<sqlast::Literal> result]
    : IntegerLiteral
    | StringLiteral { $result = std::make_unique<sqlast::StringLiteral>($StringLiteral.text); }
    ;