5 files changed, 256 insertions, 0 deletions
diff --git a/lib/syntax/cte.ml b/lib/syntax/cte.ml
new file mode 100644
index 0000000..ff43d6d
--- /dev/null
+++ b/lib/syntax/cte.ml
@@ -0,0 +1,53 @@
+open StdLabels
+module Path = ImportDataTypes.Path
+module Expression = ImportExpression.T
+
+type t = {
+  filters : Path.t Expression.t list;
+  group : Path.t Expression.t option;
+}
+
+(** Ensure the group criteria in window functions match the global group by
+    criteria.
+
+    Traverse the configuration tree until finding a group window. *)
+
+(** Check if the expression contains a group function *)
+let matchWindowGroup : 'a ImportExpression.T.t -> bool =
+ fun expression ->
+  let exception Found in
+  let open ImportExpression.T in
+  let rec f = function
+    | Empty | Literal _ | Integer _ | Path _ -> ()
+    | Expr e -> f e
+    | Concat pp | Function' (_, pp) | Function (_, pp) | Nvl pp | Join (_, pp)
+      -> List.iter ~f pp
+    | Window (_, _, _) -> raise Found
+    | BOperator (_, arg1, arg2) ->
+        f arg1;
+        f arg2
+    | GEquality (_, arg1, args) ->
+        f arg1;
+        List.iter ~f args
+  in
+  try
+    f expression;
+    false
+  with
+  | Found -> true
+
+(** Transform a list of expression into a list of CTE to evaluate. *)
+let of_filters : Path.t Expression.t list -> t list =
+ fun filters ->
+  let last_group, prev =
+    List.fold_left filters
+      ~init:({ filters = []; group = None }, [])
+      ~f:(fun (cte, acc) expr ->
+        begin
+          if matchWindowGroup expr then
+            ( { filters = []; group = None },
+              { cte with group = Some expr } :: acc )
+          else ({ cte with filters = expr :: cte.filters }, acc)
+        end)
+  in
+  List.rev (last_group :: prev)
diff --git a/lib/syntax/cte.mli b/lib/syntax/cte.mli
new file mode 100644
index 0000000..39897ef
--- /dev/null
+++ b/lib/syntax/cte.mli
@@ -0,0 +1,17 @@
+type t = {
+  filters : ImportDataTypes.Path.t ImportExpression.T.t list;
+  group : ImportDataTypes.Path.t ImportExpression.T.t option;
+}
+(** Represent a filter to apply in the querry
+
+    The CTE can have filters applied on the previous CTE (or directly in the
+    sources if there is any yet) and can hold a group (an only one).
+
+    If there is a group, it must be applied after the others filters.
+
+    The order in which the filters are presented in the configuration can change
+    the results ; it does not matter when we only have classicals filters,
+    because all cf them can be evaluated at the same time, but as soon we have a
+    group function, the result become dependant of the previous ones. *)
+
+val of_filters : ImportDataTypes.Path.t ImportExpression.T.t list -> t list
diff --git a/lib/syntax/dune b/lib/syntax/dune
new file mode 100755
index 0000000..1459d0c
--- /dev/null
+++ b/lib/syntax/dune
@@ -0,0 +1,12 @@
+(library
+ (name importerSyntax)
+ (libraries 
+   otoml
+   importDataTypes
+   importExpression
+ )
+ (preprocess (pps 
+   ppx_deriving.show 
+   ppx_deriving.eq 
+ ))
+)
diff --git a/lib/syntax/importerSyntax.ml b/lib/syntax/importerSyntax.ml
new file mode 100644
index 0000000..7788613
--- /dev/null
+++ b/lib/syntax/importerSyntax.ml
@@ -0,0 +1,137 @@
+open StdLabels
+module E = ImportExpression.T
+module Table = ImportDataTypes.Table
+module Path = ImportDataTypes.Path
+module CTE = Cte
+
+let toml_of_table Table.{ file; tab; name } =
+  let values = [ ("file", Otoml.string file); ("name", Otoml.string name) ] in
+  let values =
+    match tab with
+    | 1 -> values
+    | tab -> ("tab", Otoml.integer tab) :: values
+  in
+
+  Otoml.table values
+
+module Extern = struct
+  type t = {
+    intern_key : Path.t E.t;
+    target : Table.t;
+    extern_key : Path.column E.t;
+    allow_missing : bool;
+    match_rule : string option;
+  }
+  [@@deriving show, eq]
+  (** Describe a relation beteween two tables *)
+
+  let toml_of_extern extern =
+    let values =
+      [
+        ( "intern_key",
+          Otoml.string
+          @@ ImportExpression.Repr.repr ~top:true Path.show extern.intern_key );
+        ( "extern_key",
+          Otoml.string
+          @@ ImportExpression.Repr.repr ~top:true
+               (fun v -> ":" ^ ImportDataTypes.Path.column_to_string v)
+               extern.extern_key );
+        ("file", Otoml.string extern.target.file);
+        ("allow_missing", Otoml.boolean extern.allow_missing);
+      ]
+    in
+
+    let values =
+      match extern.target.tab with
+      | 1 -> values
+      | tab -> ("tab", Otoml.integer tab) :: values
+    in
+
+    Otoml.table values
+
+  let toml externs =
+    List.map externs ~f:(fun e -> (e.target.name, toml_of_extern e))
+    |> Otoml.table
+end
+
+type t = {
+  version : int;
+  locale : string option;
+  source : Table.t;
+  externals : Extern.t list;
+  columns : Path.t E.t list;
+  filters : Path.t E.t list;
+  sort : Path.t E.t list;
+  uniq : Path.t E.t list;
+}
+
+let repr t =
+  let repr_expression_list l =
+    Otoml.array
+      (List.map l ~f:(fun v ->
+           Otoml.string (ImportExpression.Repr.repr ~top:true Path.show v)))
+  in
+
+  let sheet =
+    Otoml.table
+      [
+        ("columns", repr_expression_list t.columns);
+        ("filters", repr_expression_list t.filters);
+        ("sort", repr_expression_list t.sort);
+        ("uniq", repr_expression_list t.uniq);
+      ]
+  in
+
+  let values =
+    [
+      ("version", Otoml.integer t.version);
+      ("source", toml_of_table t.source);
+      ("externals", Extern.toml t.externals);
+      ("sheet", sheet);
+    ]
+  in
+
+  Otoml.table values
+
+let get_table_for_name : t -> string option -> Table.t =
+ fun conf name ->
+  match name with
+  | None -> conf.source
+  | Some name ->
+      if String.equal name conf.source.name then conf.source
+      else
+        let ext =
+          List.find conf.externals ~f:(fun (ext : Extern.t) ->
+              String.equal name ext.target.name)
+        in
+        ext.target
+
+let root_table : t -> Table.t = fun conf -> conf.source
+
+let get_dependancies_for_table : t -> Table.t -> Extern.t list =
+ fun conf source ->
+  let is_root = source = conf.source in
+
+  List.filter conf.externals ~f:(fun (ext : Extern.t) ->
+      (* Enumerate the intern_key and check the source pointed by each column *)
+      ImportExpression.T.fold_values ext.intern_key ~init:false
+        ~f:(fun acc expr ->
+          if acc then acc
+          else
+            match expr.Path.alias with
+            | Some v -> String.equal v source.name
+            | None -> is_root))
+
+let latest_version = 1
+
+let dummy_conf =
+  {
+    source = { file = ""; tab = 0; name = "" };
+    version = latest_version;
+    locale = Some "C";
+    externals = [];
+    columns = [];
+    filters = [];
+    sort = [];
+    uniq = [];
+  }
diff --git a/lib/syntax/importerSyntax.mli b/lib/syntax/importerSyntax.mli
new file mode 100644
index 0000000..49b7364
--- /dev/null
+++ b/lib/syntax/importerSyntax.mli
@@ -0,0 +1,37 @@
+module Extern : sig
+  type t = {
+    intern_key : ImportDataTypes.Path.t ImportExpression.T.t;
+    target : ImportDataTypes.Table.t;
+    extern_key : ImportDataTypes.Path.column ImportExpression.T.t;
+    allow_missing : bool;
+    match_rule : string option;
+  }
+  [@@deriving show, eq]
+end
+
+module CTE = Cte
+
+type t = {
+  version : int;
+  locale : string option;
+  source : ImportDataTypes.Table.t;
+  externals : Extern.t list;
+  columns : ImportDataTypes.Path.t ImportExpression.T.t list;
+  filters : ImportDataTypes.Path.t ImportExpression.T.t list;
+  sort : ImportDataTypes.Path.t ImportExpression.T.t list;
+  uniq : ImportDataTypes.Path.t ImportExpression.T.t list;
+}
+
+val repr : t -> Otoml.t
+
+val root_table : t -> ImportDataTypes.Table.t
+(** Get the root table, this table is the main table to load and each line in
+    this table will be processed *)
+
+val get_table_for_name : t -> string option -> ImportDataTypes.Table.t
+
+val get_dependancies_for_table : t -> ImportDataTypes.Table.t -> Extern.t list
+(** Get all the externals refered by the source *)
+
+val dummy_conf : t
+val latest_version : int