simonpetit/ocaml_sql_parser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: simonpetit:334cd6af9d0df50e4d5b38bed788b0f7cb036954
Branches Tags
simonpetit:master
..
compare: simonpetit:4a42d3496f0843b220215849057918fa6a88b320
Branches Tags
simonpetit:master

No commits in common. "334cd6af9d0df50e4d5b38bed788b0f7cb036954" and "4a42d3496f0843b220215849057918fa6a88b320" have entirely different histories.
334cd6af9d ... 4a42d3496f

6 changed files with 183 additions and 417 deletions
Show Stats Expand all files Collapse all files

7
bin/main.ml
View File

@ -1,4 +1,9 @@
open Ast
open Printf
let () =
printf "hello"
let input = "SELECT aa, ab FROM b1" in
let lexbuf = Lexing.from_string input in
match Parser.main Lexer.read_token lexbuf with
| Query(Select (Column("ab")::Column("aa")::[], [Table "b1"])) -> printf("ok")
| _ -> printf("not ok")

86
lexer/lexer.mll
View File

@ -8,48 +8,44 @@ let alpha = ['a'-'z' 'A'-'Z' '_']
let alphanumeric = (alpha|digit)
rule read_token = parse
| "SELECT" { SELECT }
| "AS" { AS }
| "DATE" { DATE }
| "TIME" { TIME }
| "AVG" { AVG }
| "MAX" { MAX }
| "MIN" { MIN }
| "SUM" { SUM }
| "COUNT" { COUNT }
| "DISTINCT" { DISTINCT }
| "FROM" { FROM }
| "INNER" { INNER }
| "LEFT" { LEFT }
| "RIGHT" { RIGHT }
| "CROSS" { CROSS }
| "UNION" { UNION }
| "NATURAL" { NATURAL }
| "JOIN" { JOIN }
| "ON" { ON }
| "OR" { OR }
| "AND" { AND }
| "WHERE" { WHERE }
| "HAVING" { HAVING }
| "BETWEEN" { BETWEEN }
| "IN" { IN }
| "LIKE" { LIKE }
| "GROUP" { GROUP }
| "BY" { BY }
| "*" { ASTERISK }
| "." { DOT }
| "=" { EQUALS_OPERATOR }
| "(" { LEFT_PAREN }
| ")" { RIGHT_PAREN }
| ',' { COMMA }
| "|" { PIPE }
| "'" { QUOTE }
| "+" { PLUS_SIGN }
| "-" { MINUS_SIGN }
| ':' { COLON }
| whitespace { read_token lexbuf }
| digit+ as integer { INTEGER (int_of_string integer) }
| digit+"."digit+ { FLOAT }
| '.'digit+ { FLOAT }
| alpha alphanumeric* as ident { IDENT ident }
| eof { EOF }
| "SELECT" { SELECT }
| "AVG" { AVG }
| "MAX" { MAX }
| "MIN" { MIN }
| "SUM" { SUM }
| "COUNT" { COUNT }
| "DISTINCT" { DISTINCT }
| "FROM" { FROM }
| "INNER" { INNER }
| "LEFT" { LEFT }
| "RIGHT" { RIGHT }
| "CROSS" { CROSS }
| "UNION" { UNION }
| "NATURAL" { NATURAL }
| "JOIN" { JOIN }
| "ON" { ON }
| "OR" { OR }
| "AND" { AND }
| "WHERE" { WHERE }
| "HAVING" { HAVING }
| "BETWEEN" { BETWEEN }
| "IN" { IN }
| "LIKE" { LIKE }
| "GROUP" { GROUP }
| "BY" { BY }
| "*" { ASTERISK }
| "." { DOT }
| "=" { EQUALS_OPERATOR }
| "(" { LEFT_PAREN }
| ")" { RIGHT_PAREN }
| "," { COMMA }
| "|" { PIPE }
| "'" { QUOTE }
| "+" { PLUS_SIGN }
| "-" { MINUS_SIGN }
| whitespace { read_token lexbuf }
| digit+ { INTEGER }
| digit+"."digit+ { FLOAT }
| '.'digit+ { FLOAT }
| alpha alphanumeric* as ident { IDENT ident }
| eof { EOF }

33
lib/ast.ml
View File

@ -1,12 +1,9 @@
type query = Query of select_stmt
and select_stmt =
| Select of column list * table list option * filter option
| Select of column list * table list * filter option
and column =
| Asterisk
(* | Column of string *)
| Column of expression * as_clause option
and as_clause =
| As of string
| Column of string
and table =
| Table of string
| Join of table * join_type * table * condition option
@ -23,7 +20,8 @@ and condition =
| And of condition * condition
| Or of condition * condition
| Not of condition
and predicand = expression
and predicand =
| Ref of string
and predicate =
| Comparison of operator * predicand
| Between of predicand * predicand
@ -41,24 +39,8 @@ and operator =
| GreaterEquals
and filter =
| Filter of condition
and aggregate =
| Aggregate of func * filter option
and func =
| Function of function_type * quantifier option * expression
and function_type =
| Avg
| Max
| Min
| Sum
| Count
and quantifier =
| All
| Distinct
and expression =
| Ref of string
| StringLiteral of string
| DateLiteral of string
| TimeLiteral of string
and search_condition =
| Search of string
let rec pp_query fmt ast =
match ast with
@ -76,9 +58,8 @@ and pp_columns cols =
and pp_column col =
match col with
| Column(Ref(name),_) -> name
| Column(name) -> name
| Asterisk -> "*"
| _ -> failwith "not supported"
and pp_tables tables =
match tables with

3
lib/logical_plan.ml
View File

@ -19,10 +19,9 @@ let rec generate_from_clause tables =
let generate_logical_plan ast =
match ast with
| Ast.Query(Select(_, Some(tables), _)) ->
| Ast.Query(Select(_, tables, _)) ->
let base_plan = generate_from_clause tables in
base_plan
| Ast.Query(Select(_, None, _)) -> failwith "not supported"
(*let evaluate_plan plan =
match plan with

137
parser/parser.mly
View File

@ -19,11 +19,8 @@ open Ast
%token AS ON GROUP BY FILTER
%token OR AND NOT
%token TRUE FALSE UNKNOWN
%token PLUS_SIGN MINUS_SIGN
%token DATE TIME TIMESTAMP
%token <int> INTEGER
%token FLOAT
%token UNDERSCORE QUOTE COLON
%token PLUS_SIGN MINUS_SIGN INTEGER FLOAT
%token UNDERSCORE QUOTE
%token EOF
%start main
%type <query> main
@ -51,19 +48,18 @@ greater_than_or_equals_operator:
(* 5.3 LITERAL *)
literal :
| signed_numeric_literal { $1 }
| general_literal { $1 }
| signed_numeric_literal {}
| general_literal {}
unsigned_literal:
(* | unsigned_numeric_literal {}*)
| general_literal { $1 }
| general_literal {}
general_literal:
| character_string_literal { $1 }
| datetime_literal { $1 }
| character_string_literal {}
character_string_literal:
| QUOTE IDENT QUOTE { StringLiteral($2) }
| QUOTE IDENT QUOTE {}
introducer:
| UNDERSCORE { }
@ -82,65 +78,12 @@ sign:
| PLUS_SIGN {}
| MINUS_SIGN {}
unsigned_integer:
| INTEGER { $1 }
datetime_literal:
| date_literal { $1 }
| time_literal { $1 }
(*| timestamp_literal {}*)
date_literal:
| DATE date_string { DateLiteral($2) }
time_literal:
| TIME time_string { TimeLiteral($2) }
date_string:
| QUOTE unquoted_date_string QUOTE { $2 }
time_string:
| QUOTE unquoted_time_string QUOTE { $2 }
date_value:
| years_value MINUS_SIGN months_value MINUS_SIGN days_value { String.concat "-" [$1;$3;$5] }
time_value:
| hours_value COLON minutes_value COLON seconds_value { String.concat ":" [$1;$3;$5] }
unquoted_date_string:
| date_value { $1 }
unquoted_time_string:
| time_value { $1 }
years_value :
| datetime_value { $1 }
months_value :
| datetime_value { $1 }
days_value :
| datetime_value { $1 }
hours_value :
| datetime_value { $1 }
minutes_value :
| datetime_value { $1 }
seconds_value:
| datetime_value { $1 }
datetime_value :
| unsigned_integer { string_of_int $1 }
(***********)
(* 5.4 NAMES AND IDENTIFIER *)
column_name :
| IDENT { $1 }
| IDENT {}
table_name :
| IDENT { Table($1) }
@ -167,7 +110,6 @@ parenthesized_value_expression:
| LEFT_PAREN value_expression RIGHT_PAREN { $2 }
nonparenthesized_value_expression_primary:
| unsigned_value_specification { $1 }
| column_reference { Ref($1) }
(*| set_function_specification { Ref("function") } *)
@ -176,8 +118,8 @@ nonparenthesized_value_expression_primary:
(* 6.4 VALUE SPECIFCATION / TARGET SPECIFICATION *)
unsigned_value_specification:
| unsigned_literal { $1 }
(*| general_value_specification {}*)
| unsigned_literal {}
| general_value_specification {}
general_value_specification:
| {}
@ -213,7 +155,7 @@ set_function_specification:
(* 6.25 VALUE EXPRESSION *)
value_expression:
| common_value_expression { $1 }
| common_value_expression {}
common_value_expression:
(*| numeric_value_expression {}*)
@ -228,7 +170,7 @@ reference_value_expression:
(* 6.28 STRING VALUE EXPRESSION *)
string_value_expression :
| character_value_expression { $1 }
| character_value_expression {}
(* | blob_value_expression {} *)
character_primary:
@ -322,9 +264,8 @@ row_value_special_case :
(* 7.4 TABLE EXPRESSION *)
table_expression:
| { None }
| from_clause { Some($1) }
| from_clause where_clause { Some($1) }
| from_clause { $1 }
| from_clause where_clause { $1 }
(************************)
@ -454,21 +395,15 @@ query_specification :
select_list :
| ASTERISK { [Asterisk] }
| select_sublist { $1 }
| select_sublist {$1}
(*
select_sublist :
| IDENT { [Column($1)] }
| select_sublist COMMA IDENT { Column($3)::$1 }
*)
select_sublist :
| select_sublist_element { [$1] }
| select_sublist COMMA select_sublist_element { $3::$1 }
select_sublist_element :
| derived_column { $1 }
(* | qualified_asterisk {} *)
| derived_column {}
| qualified_asterisk {}
qualified_asterisk:
| asterisked_identifier_chain {}
@ -481,12 +416,12 @@ asterisked_identifier :
| IDENT {}
derived_column:
| value_expression { Column($1, None) }
| value_expression as_clause { Column($1, Some($2)) }
| value_expression {}
| value_expression as_clause {}
as_clause :
| AS column_name { As($2) }
(*| column_name { As($1) }*)
| AS column_name {}
| column_name {}
(****************************)
@ -602,31 +537,31 @@ search_condition:
(* 10.9 AGGREGATE FUNCTION *)
aggregate_function:
| COUNT LEFT_PAREN ASTERISK RIGHT_PAREN { Count }
| COUNT LEFT_PAREN ASTERISK RIGHT_PAREN filter_clause { Count }
| general_set_function { Aggregate($1) }
| general_set_function filter_clause { Aggregate($1, $2) }
| COUNT LEFT_PAREN ASTERISK RIGHT_PAREN { }
| COUNT LEFT_PAREN ASTERISK RIGHT_PAREN filter_clause { }
| general_set_function { }
| general_set_function filter_clause { }
general_set_function:
| set_function_type LEFT_PAREN value_expression RIGHT_PAREN { Function($1, None, $3) }
| set_function_type LEFT_PAREN set_quantifier value_expression RIGHT_PAREN { Function($1, $3, $4) }
| set_function_type LEFT_PAREN value_expression RIGHT_PAREN { }
| set_function_type LEFT_PAREN set_quantifier value_expression RIGHT_PAREN { }
set_function_type:
| computationnal_operation { $1 }
| computationnal_operation {}
set_quantifier :
| ALL { All }
| DISTINCT { Distinct }
| ALL {}
| DISTINCT {}
filter_clause :
| FILTER LEFT_PAREN WHERE search_condition RIGHT_PAREN { Filter($4) }
| FILTER LEFT_PAREN WHERE search_condition RIGHT_PAREN {}
computationnal_operation:
| AVG { Avg }
| MAX { Max }
| MIN { Min }
| SUM { Sum }
| COUNT { Count }
| AVG {}
| MAX {}
| MIN {}
| SUM {}
| COUNT {}
(***************************)

332
test/test_ast.ml
View File

@ -11,164 +11,70 @@ let query_testable =
Alcotest.testable Ast.pp_query equal_ast
let test_simple_select () =
let query = "SELECT a FROM t" in
let q1 = parse query in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some(
[
Table("t")
]
),
None
)
) in
Alcotest.(check query_testable) query q1 ast1;
let q1 = parse "SELECT a FROM t" in
let ast1 = Query(Select([Column("a")], [Table("t")], None)) in
Alcotest.(check query_testable) "Ok" q1 ast1;
let query = "SELECT * FROM t" in
let q2 = parse query in
let ast2 = Query(
Select(
[
Asterisk
],
Some(
[
Table("t")
]
t ),
None
)
) in
Alcotest.(check query_testable) query q2 ast2 ;
let query = "SELECT 'a'" in
let q3 = parse query in
let ast3 = Query(
Select(
[
Column(
StringLiteral("a"),
None
)
],
None,
None
)
) in
Alcotest.(check query_testable) query q3 ast3;
let q4 = parse "SELECT DATE '2024-12-25' AS date" in
let ast4 = Query(
Select(
[
Column(
DateLiteral("2024-12-25"),
Some(
As("date")
)
)
],
None,
None
)
) in
Alcotest.(check query_testable) "OK" q4 ast4
let q2 = parse "SELECT * FROM t" in
let ast2 = Query(Select([Asterisk], [Table("t")], None)) in
Alcotest.(check query_testable) "Ok2" q2 ast2
let test_default_join () =
let q1 = parse "SELECT a FROM t1 JOIN t2 ON b = c" in
let q1 = parse "SELECT a FROM t1 JOIN t2 ON a = b" in
let ast1 = Query(
Select(
[
Column(
[Column("a")],
[Join(
Table("t1"),
Left,
Table("t2"),
Some(
Condition(
Ref("a"),
None
)
],
Some(
[
Join(
Table("t1"),
Left,
Table("t2"),
Some(
Condition(
Ref("b"),
Comparison(
Equals,
Ref("c"))
)
)
Comparison(Equals, Ref("b"))
)
]
),
)
)],
None
)
) in
Alcotest.(check query_testable) "Ok" q1 ast1
let test_left_join () =
let query = "SELECT a FROM t1 LEFT JOIN t2 ON a = b" in
let q1 = parse query in
let q1 = parse "SELECT a FROM t1 LEFT JOIN t2 ON a = b" in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some(
[
Join(
Table("t1"),
Left,
Table("t2"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("b"))
)
)
Select([Column("a")],
[Join(
Table("t1"),
Left,
Table("t2"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("b"))
)
]
),
)
)],
None
)
) in
Alcotest.(check query_testable) query q1 ast1
Alcotest.(check query_testable) "Ok" q1 ast1
let test_right_join () =
let q1 = parse "SELECT a FROM t1 RIGHT JOIN t2 ON a = b" in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some(
[
Join(
Table("t1"),
Right,
Table("t2"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("b"))
)
)
Select([Column("a")],
[Join(
Table("t1"),
Right,
Table("t2"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("b"))
)
]
),
)
)],
None
)
) in
@ -177,28 +83,18 @@ let test_right_join () =
let test_inner_join () =
let q1 = parse "SELECT a FROM t1 INNER JOIN t2 ON a = b" in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some(
[
Join(
Table("t1"),
Inner,
Table("t2"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("b"))
)
)
Select([Column("a")],
[Join(
Table("t1"),
Inner,
Table("t2"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("b"))
)
]
),
)
)],
None
)
) in
@ -207,23 +103,13 @@ let test_inner_join () =
let test_union_join () =
let q1 = parse "SELECT a FROM t1 UNION JOIN t2" in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some(
[
Join(
Table("t1"),
Union,
Table("t2"),
None
)
]
),
Select([Column("a")],
[Join(
Table("t1"),
Union,
Table("t2"),
None
)],
None
)
) in
@ -232,23 +118,13 @@ let test_union_join () =
let test_cross_join () =
let q1 = parse "SELECT a FROM t1 CROSS JOIN t2" in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some(
[
Join(
Table("t1"),
Cross,
Table("t2"),
None
)
]
),
Select([Column("a")],
[Join(
Table("t1"),
Cross,
Table("t2"),
None
)],
None
)
) in
@ -257,23 +133,13 @@ let test_cross_join () =
let test_natural_join () =
let q1 = parse "SELECT a FROM t1 NATURAL JOIN t2" in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some(
[
Join(
Table("t1"),
Natural,
Table("t2"),
None
)
]
),
Select([Column("a")],
[Join(
Table("t1"),
Natural,
Table("t2"),
None
)],
None
)
) in
@ -282,37 +148,30 @@ let test_natural_join () =
let test_join_join () =
let q1 = parse "SELECT a FROM t1 JOIN t2 ON a = b JOIN t3 ON a = c" in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some([
Select([Column("a")], [
Join(
Join(
Join(
Table("t1"),
Left,
Table("t2"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("b"))
)
)
),
Table("t1"),
Left,
Table("t3"),
Table("t2"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("c"))
Comparison(Equals, Ref("b"))
)
)
),
Left,
Table("t3"),
Some(
Condition(
Ref("a"),
Comparison(Equals, Ref("c"))
)
)
]),
None
)
],
None
)
) in
Alcotest.(check query_testable) "Ok" q1 ast1
@ -321,17 +180,8 @@ let test_where_equals () =
let q1 = parse "SELECT a FROM t1 WHERE a = a OR a = b" in
let ast1 = Query(
Select(
[
Column(
Ref("a"),
None
)
],
Some(
[
Table("t1")
]
),
[Column("a")],
[Table("t1")],
None
)
) in