cowork-bot: fix mixed-type column inference to produce valid SQL

A column whose values mix a string with a numeric/boolean type was either
kept at the first-seen (often numeric) type or widened the wrong direction,
producing INSERT statements with a quoted string literal in a numeric column
(invalid SQL - rejected by PostgreSQL/MySQL). Mixed types now collapse to
TEXT, the only safe universal type.

A null value remains "unset" during inference, so a column that first sees
null can still upgrade to a concrete type when a non-null value arrives
(e.g. [null, 42] -> INTEGER). All-null columns default to TEXT.

- src/json2sql/dialects.py: clarify merge_type widening semantics
- src/json2sql/converter.py: treat null as unset; default all-null cols to TEXT
- tests/test_type_inference.py: regression tests for mixed-type columns
- tests/test_edge_cases.py: fix buggy assertion expecting INTEGER for a
  [string, int] column (that INSERT is invalid SQL)

Co-Authored-By: cowork-bot <noreply@coding-dev-tools.local>

Author: Coding-Dev-Tools

src/json2sql/converter.py

@@ -7,6 +7,7 @@
     create_table_sql,
     format_value,
     insert_sql,
+    merge_type,
     sql_type_for,
 )
 
@@ -137,12 +138,18 @@ def _infer_columns(self, objects: list[dict]) -> dict[str, str]:
         for obj in objects:
             for key, value in obj.items():
                 if key not in columns:
-                    columns[key] = sql_type_for(value, self.dialect)
+                    # A null does not constrain the column yet: keep it unset so a
+                    # later non-null value can still pick a more specific type.
+                    columns[key] = sql_type_for(value, self.dialect) if value is not None else None
                 elif value is not None:
-                    # Upgrade type if we find a non-null value
-                    inferred = sql_type_for(value, self.dialect)
-                    if columns[key] == "TEXT" and inferred != "TEXT":
-                        columns[key] = inferred
+                    cur = columns[key]
+                    columns[key] = (
+                        sql_type_for(value, self.dialect) if cur is None else merge_type(cur, value, self.dialect)
+                    )
+        # Columns that only ever held nulls default to TEXT.
+        for key, t in columns.items():
+            if t is None:
+                columns[key] = sql_type_for(None, self.dialect)
         return columns
 
     def _infer_columns_flattened(
@@ -163,22 +170,28 @@ def _infer_columns_flattened(
                     for sub_key, sub_value in value.items():
                         flat_key = f"{key}_{sub_key}"
                         if flat_key not in columns:
-                            columns[flat_key] = sql_type_for(sub_value, self.dialect)
+                            columns[flat_key] = sql_type_for(sub_value, self.dialect) if sub_value is not None else None
                             flat_map[flat_key] = (key, sub_key)
                         elif sub_value is not None:
-                            inferred = sql_type_for(sub_value, self.dialect)
-                            if columns[flat_key] == "TEXT" and inferred != "TEXT":
-                                columns[flat_key] = inferred
+                            cur = columns[flat_key]
+                            columns[flat_key] = (
+                                sql_type_for(sub_value, self.dialect) if cur is None else merge_type(cur, sub_value, self.dialect)
+                            )
                 elif isinstance(value, list) and value and isinstance(value[0], dict) and self.flatten:
                     # Skip - goes to separate table
                     pass
                 else:
                     if key not in columns:
-                        columns[key] = sql_type_for(value, self.dialect)
+                        columns[key] = sql_type_for(value, self.dialect) if value is not None else None
                     elif value is not None:
-                        inferred = sql_type_for(value, self.dialect)
-                        if columns[key] == "TEXT" and inferred != "TEXT":
-                            columns[key] = inferred
+                        cur = columns[key]
+                        columns[key] = (
+                            sql_type_for(value, self.dialect) if cur is None else merge_type(cur, value, self.dialect)
+                        )
+        # Columns that only ever held nulls default to TEXT.
+        for key, t in columns.items():
+            if t is None:
+                columns[key] = sql_type_for(None, self.dialect)
         return columns, flat_map
 
     def _flatten_nested(

src/json2sql/dialects.py

@@ -46,6 +46,40 @@ def sql_type_for(value: Any, dialect: Dialect) -> str:
     return _TYPE_MAP[dialect].get(py_type, "TEXT")
 
 
+_TYPE_RANK = {
+    "BOOLEAN": 0,
+    "TINYINT(1)": 0,
+    "INTEGER": 1,
+    "INT": 1,
+    "DOUBLE PRECISION": 2,
+    "DOUBLE": 2,
+    "REAL": 2,
+    "TEXT": 3,
+    "VARCHAR(255)": 3,
+}
+
+
+def merge_type(current: str, value: Any, dialect: Dialect) -> str:
+    """Merge a column's current inferred SQL type with a new value's type.
+
+    Widens toward the most general compatible type so a column holding mixed
+    values produces valid SQL. Any string in a column forces TEXT (a numeric
+    column cannot hold a quoted string literal). A boolean mixed with a numeric
+    type also widens to TEXT because a boolean literal is not assignable to
+    INTEGER/REAL in strict SQL dialects.
+    """
+    new_type = sql_type_for(value, dialect)
+    if new_type == "TEXT" or current == "TEXT":
+        return "TEXT"
+    cur_rank = _TYPE_RANK.get(current, 3)
+    new_rank = _TYPE_RANK.get(new_type, 3)
+    # A boolean mixed with a numeric type is unsafe to keep numeric.
+    if 0 in (cur_rank, new_rank) and max(cur_rank, new_rank) > 0:
+        return "TEXT"
+    # Otherwise widen to the broader numeric type.
+    return current if cur_rank >= new_rank else new_type
+
+
 def quote_identifier(name: str, dialect: Dialect) -> str:
     """Quote an identifier (table/column name) for the given dialect."""
     if dialect == Dialect.MYSQL:

tests/test_edge_cases.py

@@ -65,12 +65,17 @@ def test_flatten_type_upgrade_for_flattened_column(self):
         result = converter.convert(json.dumps(data))
         assert "meta_count" in result
         # After upgrade, type should be INTEGER not TEXT
-        assert "INTEGER" in result
+        assert "TEXT" in result
         assert "'five'" in result
         assert "42" in result
 
     def test_type_upgrade_for_top_level_column(self):
-        """Top-level column type upgrades from TEXT to more specific type (line 175)."""
+        """Mixed string/int column falls back to TEXT so generated SQL stays valid (line 175).
+
+        A column that holds both a string ("hello") and an int (100) cannot be
+        INTEGER: the string literal would be rejected by the database. The safe,
+        correct type is TEXT (a numeric literal fits a text column).
+        """
         from json2sql.converter import JSONToSQLConverter
 
         data = [
@@ -79,13 +84,13 @@ def test_type_upgrade_for_top_level_column(self):
         ]
         # Non-flatten path (_infer_columns)
         result = JSONToSQLConverter().convert(json.dumps(data))
-        assert "INTEGER" in result
+        assert "TEXT" in result
         assert "'hello'" in result
         assert "100" in result
 
         # Flatten path (_infer_columns_flattened else branch, line 175)
         result2 = JSONToSQLConverter(flatten=True).convert(json.dumps(data))
-        assert "INTEGER" in result2
+        assert "TEXT" in result2
         assert "'hello'" in result2
         assert "100" in result2
 

tests/test_type_inference.py

@@ -0,0 +1,51 @@
+"""Tests for robust column type inference across mixed values.
+
+Regression coverage for the bug where a column holding mixed value types
+(e.g. a string and an integer) was inferred as the non-text type, producing
+SQL that inserts a quoted string literal into a numeric column -- which is
+rejected by databases such as PostgreSQL.
+"""
+
+import json
+
+from json2sql.converter import JSONToSQLConverter
+from json2sql.dialects import Dialect
+
+
+class TestMixedTypeInference:
+    def test_string_then_int_falls_back_to_text(self):
+        conv = JSONToSQLConverter(dialect=Dialect.POSTGRES)
+        data = json.dumps([{"val": "string"}, {"val": 42}])
+        result = conv.convert(data, table_name="mixed")
+        assert '"val" TEXT' in result, "mixed string/int column must be TEXT"
+        assert "'string'" in result
+
+    def test_int_then_string_falls_back_to_text(self):
+        conv = JSONToSQLConverter(dialect=Dialect.POSTGRES)
+        data = json.dumps([{"val": 42}, {"val": "string"}])
+        result = conv.convert(data, table_name="mixed")
+        assert '"val" TEXT' in result
+
+    def test_int_float_column_widens_to_float(self):
+        conv = JSONToSQLConverter(dialect=Dialect.POSTGRES)
+        data = json.dumps([{"n": 1}, {"n": 2.5}])
+        result = conv.convert(data, table_name="nums")
+        assert '"n" DOUBLE PRECISION' in result
+
+    def test_bool_int_mixed_falls_back_to_text(self):
+        conv = JSONToSQLConverter(dialect=Dialect.POSTGRES)
+        data = json.dumps([{"flag": True}, {"flag": 1}])
+        result = conv.convert(data, table_name="flags")
+        assert '"flag" TEXT' in result
+
+    def test_uniform_types_unaffected(self):
+        conv = JSONToSQLConverter(dialect=Dialect.POSTGRES)
+        data = json.dumps([{"age": 30}, {"age": 25}])
+        result = conv.convert(data, table_name="users")
+        assert '"age" INTEGER' in result
+
+    def test_trailing_null_does_not_widen(self):
+        conv = JSONToSQLConverter(dialect=Dialect.POSTGRES)
+        data = json.dumps([{"age": 30}, {"age": None}])
+        result = conv.convert(data, table_name="users")
+        assert '"age" INTEGER' in result