remove -enum-poly-variant

Gleb Patsiia · Gleb Patsiia · commit cfc56e40be6e · 2025-10-06T12:04:23.000Z
make variants are generated by the default
until custom module is specified
diff --git a/lib/sql.ml b/lib/sql.ml
@@ -249,8 +249,9 @@ module Meta = struct
   let of_list list = List.fold_left (fun map (k, v) -> StringMap.add k v map) StringMap.empty list
   
   let empty () = StringMap.empty
-  
   let find_opt k map = StringMap.find_opt map k
+  
+  let mem k map = StringMap.mem map k
   let pp fmt t =
     if StringMap.is_empty t then
       Format.fprintf fmt "{}"
diff --git a/src/cli.ml b/src/cli.ml
@@ -127,7 +127,6 @@ let main () =
     "-show-tables", Arg.Unit Tables.print_all, " Show all current tables";
     "-show-table", Arg.String Tables.print1, "<name> Show specified table";
     "-allow-write-notnull-null", Arg.Unit (fun () -> Sqlgg_config.allow_write_notnull_null true), "Treat writing NULL to NOT NULL columns as error";
-    "-enum-poly-variant", Arg.Unit (fun () -> Sqlgg_config.enum_as_poly_variant := true), " Represent enums as variants in generated code";
     "-dialect", Arg.String set_dialect, "mysql|sqlite|postgresql|tidb Set SQL dialect - will only allow this dialect's features in SQL queries";
     "-no-check", Arg.String set_no_check, "{all|<feature>{,<feature>}+} Disable dialect feature checks (possible features: collation|join_on_subquery|create_table_as_select) - do not enforce dialect feature checks";
     "-", Arg.Unit (fun () -> work "-"), " Read sql from stdin";
diff --git a/src/gen_caml.ml b/src/gen_caml.ml
@@ -171,23 +171,22 @@ let get_column index attr =
   let format_t_get_column type_name =
     sprintf "(T.get_column_%s%s stmt %u)" type_name nullable_suffix index
   in
-  let rec format_column_expr attr =
-    match attr with
-    | { domain={ t = Union {ctors; _}; _ }; _ } when !Sqlgg_config.enum_as_poly_variant ->
-      sprintf "(%s.get_column%s stmt %u)" (get_enum_name ctors) nullable_suffix index
-    | { domain={ t = Union _; _ }; _ } as c ->
-      format_column_expr { c with domain = { c.domain with t = Text } }
-    | _ ->
-      match Sql.Meta.find_opt attr.meta "module" with
-      | None ->
-        let lang_type_name = L.as_lang_type attr.domain in
-        format_t_get_column lang_type_name
-      | Some m ->
+  let format_column_expr attr =
+    match Sql.Meta.find_opt attr.meta "module" with
+    | Some m ->
         let runtime_repr_name = L.as_runtime_repr_name attr.domain in
         let inner_get_column_expr = format_t_get_column runtime_repr_name in
         let get_column = "get_column" in
         let get_column_name = get_column |> Sql.Meta.find_opt attr.meta |> Option.default get_column in
         sprintf "(%s.%s%s %s)" m get_column_name nullable_suffix inner_get_column_expr
+    | None ->
+        begin match attr.domain with
+        | { t = Union { ctors; _ }; _ } ->
+            sprintf "(%s.get_column%s stmt %u)" (get_enum_name ctors) nullable_suffix index
+        | _ ->
+            let lang_type_name = L.as_lang_type attr.domain in
+            format_t_get_column lang_type_name
+        end
   in
   format_column_expr attr
 
@@ -286,28 +285,32 @@ let match_variant_pattern i name args ~is_poly =
     else
       variant_name ^ " (" ^ String.concat ", " patterns ^ ")"
 
-let rec set_param ~meta index param =
+let set_param ~meta index param =
   let nullable = is_param_nullable param in
   let pname = show_param_name param index in
   let ptype = show_param_type param in
   let set_param_nullable v r = output "begin match %s with None -> T.set_param_null p | Some %s -> %s end;" pname v r in
-  match param with
-  | { typ = { t=Union _; _}; _ } as c when not !Sqlgg_config.enum_as_poly_variant -> set_param ~meta index { c with typ = { c.typ with t = Text } }
-  | { typ = { t=Union {ctors; _}; _}; _ } when nullable -> set_param_nullable "v" @@ (get_enum_name ctors) ^ ".set_param p v"
-  | { typ = { t=Union {ctors; _}; _ }; _ } -> output "%s.set_param p %s;" (get_enum_name ctors) pname
-  | param' ->
-    let module_ = Sql.Meta.find_opt meta "module" in
-    match module_ with
-    | None -> if nullable then set_param_nullable "v" @@ sprintf "T.set_param_%s %s" (show_param_type param') "p v"
-      else output "T.set_param_%s p %s;" ptype pname
-    | Some m ->
+  let module_ = Sql.Meta.find_opt meta "module" in
+  match module_ with
+  | Some m ->
       let set_param = "set_param" in
       let set_param_name = set_param |> Sql.Meta.find_opt meta |> Option.default set_param in
-      let runtime_repr_name = L.as_runtime_repr_name param'.typ in
+      let runtime_repr_name = L.as_runtime_repr_name param.typ in
       if nullable then
-         set_param_nullable pname @@ sprintf "T.set_param_%s p (%s);" runtime_repr_name (sprintf "%s.%s %s" m set_param_name pname)
+        set_param_nullable pname @@ sprintf "T.set_param_%s p (%s);" runtime_repr_name (sprintf "%s.%s %s" m set_param_name pname)
       else
         output "T.set_param_%s p (%s);" runtime_repr_name (sprintf "%s.%s %s" m set_param_name pname)
+  | None ->
+      match param with
+      | { typ = { t=Union { ctors; _ }; _ }; _ } when nullable ->
+          set_param_nullable "v" @@ (get_enum_name ctors) ^ ".set_param p v"
+      | { typ = { t=Union { ctors; _ }; _ }; _ } ->
+          output "%s.set_param p %s;" (get_enum_name ctors) pname
+      | param' ->
+          if nullable then
+            set_param_nullable "v" @@ sprintf "T.set_param_%s %s" (show_param_type param') "p v"
+          else
+            output "T.set_param_%s p %s;" ptype pname
   
 let set_var index var =
   let execute_generators = List.iter (fun f -> f ()) in
@@ -532,16 +535,16 @@ let output_params_binder index vars =
 
 
 let make_to_literal meta typ =
-  let rec go domain = match domain with 
-    | { Type.t = Union _; _ } when not !Sqlgg_config.enum_as_poly_variant -> go { domain with Type.t = Text }
-    | { Type.t = Union { ctors; _ }; _ } -> sprintf "%s.to_literal" (get_enum_name ctors)
-    | t -> match Sql.Meta.find_opt meta "module" with
-      | None -> sprintf "T.Types.%s.to_literal" (Sql.Type.type_name t)
-      | Some m -> 
-        let set_param = "set_param" in
-        let set_param_name = set_param |> Sql.Meta.find_opt meta |> Option.default set_param in
-        sprintf "(fun v -> T.Types.%s.%s_to_literal (%s.%s v))" (Sql.Type.type_name t) (L.as_runtime_repr_name t) m set_param_name
-  in go typ
+  match Sql.Meta.find_opt meta "module" with
+  | Some m ->
+    let set_param = "set_param" in
+    let set_param_name = set_param |> Sql.Meta.find_opt meta |> Option.default set_param in
+    let trait_type_name = match typ.Type.t with | Union _ -> "Text" | StringLiteral _ -> "Text" | _ -> Sql.Type.type_name typ in
+    sprintf "(fun v -> T.Types.%s.%s_to_literal (%s.%s v))" trait_type_name (L.as_runtime_repr_name typ) m set_param_name
+  | None ->
+    match typ.Type.t with
+    | Union { ctors; _ } -> sprintf "%s.to_literal" (get_enum_name ctors)
+    | _ -> sprintf "T.Types.%s.to_literal" (Sql.Type.type_name typ)
 
 let gen_in_substitution meta var =
   if Option.is_none var.id.label then failwith "empty label in IN param";
@@ -742,25 +745,34 @@ let generate_enum_modules stmts =
     | Datetime | Decimal | Any | StringLiteral  _ | Json_path | One_or_all -> None
   in
 
-  let schemas_to_enums schemas = schemas |> List.filter_map (fun { domain; _ } -> get_enum domain) in
-
-  let rec vars_to_enums vars = List.concat_map (function
-    | Single ({ typ; _ }, _)
-    | SingleIn ({ typ; _ }, _) -> typ |> get_enum |> option_list
-    | SharedVarsGroup (vars, _)
-    | OptionActionChoice (_, vars, _, _)
-    | ChoiceIn { vars; _ } -> vars_to_enums vars
-    | Choice (_, ctor_list) -> 
-      List.concat_map ( function
-        | Simple (_, vars) -> Option.map vars_to_enums vars |> option_list |> List.concat
-        | Verbatim _ -> []
-      ) ctor_list
-    | TupleList (_,  ValueRows { types; _ }) -> 
-      List.concat_map (fun typ -> typ |> get_enum |> option_list) types
-    | TupleList (_, Where_in (types, _, _)) ->
-      List.concat_map (fun (typ, _) -> typ |> get_enum |> option_list) types
-    | TupleList (_, Insertion schema) -> schemas_to_enums schema
-  ) vars in
+  let meta_has_module m = Sql.Meta.mem m "module" in
+
+  let schemas_to_enums schemas =
+    List.filter_map (fun { domain; meta; _ } ->
+      if meta_has_module meta then None else get_enum domain
+    ) schemas
+  in
+
+  let rec vars_to_enums vars =
+    let enum_opt typ = typ |> get_enum |> option_list in
+    let enum_opt_with_meta typ meta = if meta_has_module meta then [] else enum_opt typ in
+    List.concat_map (function
+      | Single ({ typ; _ }, meta)
+      | SingleIn ({ typ; _ }, meta) -> enum_opt_with_meta typ meta
+      | SharedVarsGroup (vars, _)
+      | OptionActionChoice (_, vars, _, _)
+      | ChoiceIn { vars; _ } -> vars_to_enums vars
+      | Choice (_, ctor_list) -> 
+        List.concat_map ( function
+          | Simple (_, vars) -> Option.map vars_to_enums vars |> option_list |> List.concat
+          | Verbatim _ -> []
+        ) ctor_list
+      | TupleList (_,  ValueRows { types; _ }) -> 
+        List.concat_map enum_opt types
+      | TupleList (_, Where_in (types, _, _)) ->
+        List.concat_map (fun (typ, meta) -> enum_opt_with_meta typ meta) types
+      | TupleList (_, Insertion schema) -> schemas_to_enums schema
+    ) vars in
 
   Hashtbl.reset enums_hash_tbl;
   
@@ -794,8 +806,6 @@ let generate_enum_modules stmts =
     end 0 result in 
     ()
   )
-
-let generate_enum_modules stmts = if !Sqlgg_config.enum_as_poly_variant then generate_enum_modules stmts
   
 let generate ~gen_io name stmts =
 (*
diff --git a/src/sqlgg_config.ml b/src/sqlgg_config.ml
@@ -17,8 +17,6 @@ let gen_header : [ `Full | `Without_timestamp | `Static ] option ref = ref (Some
 
 let include_category : [ `All | `None | `Only of Stmt.category list | `Except of Stmt.category list ] ref = ref `All
 
-let enum_as_poly_variant = ref false
-
 let no_check_features: Dialect.feature list ref = ref []
 
 let set_no_check_features l = no_check_features := l
diff --git a/test/cram/test.t b/test/cram/test.t
