schema instead of type for column

brunovcosta · brunovcosta · commit 545f85715ec1 · 2025-07-12T16:51:38.000-03:00
diff --git a/abstra_json_sql/apply.py b/abstra_json_sql/apply.py
@@ -748,7 +748,8 @@ def apply_with(with_clause: With, tables: ITablesSnapshot, ctx: dict):
             name=part.name,
             columns=[
                 Column(
-                    name=field_name(field), type=infer_expression(field.expression, ctx)
+                    name=field_name(field),
+                    schema=infer_expression(field.expression, ctx),
                 )
                 for field in part.command.field_parts
             ],
diff --git a/abstra_json_sql/cli.py b/abstra_json_sql/cli.py
@@ -132,7 +132,7 @@ def interactive_create_table(workdir: Path):
             # Create column
             column = Column(
                 name=column_name,
-                type=column_type,
+                schema=column_type,
                 is_primary_key=is_primary_key,
                 default=default_value,
             )
diff --git a/abstra_json_sql/eval_test.py b/abstra_json_sql/eval_test.py
diff --git a/abstra_json_sql/persistence/base_test.py b/abstra_json_sql/persistence/base_test.py
@@ -16,8 +16,8 @@ def setUp(self):
         test_table = Table(
             name="test_table",
             columns=[
-                Column(name="id", type=ColumnType.int),
-                Column(name="name", type=ColumnType.string),
+                Column(name="id", schema=ColumnType.int),
+                Column(name="name", schema=ColumnType.string),
             ],
             data=[],
         )
@@ -30,8 +30,8 @@ def setUp(self):
         test_table_l = Table(
             name="test_table",
             columns=[
-                Column(name="id", type=ColumnType.int),
-                Column(name="name", type=ColumnType.string),
+                Column(name="id", schema=ColumnType.int),
+                Column(name="name", schema=ColumnType.string),
             ],
             data=[],
         )
diff --git a/abstra_json_sql/persistence/extended.py b/abstra_json_sql/persistence/extended.py
@@ -96,7 +96,7 @@ def change_column_type(
             if table.name == table_name:
                 for col in table.columns:
                     if col.name == column_name:
-                        col.type = new_type
+                        col.schema = new_type
                         return
         self.snapshot.change_column_type(table_name, column_name, new_type)
 
diff --git a/abstra_json_sql/persistence/extended_test.py b/abstra_json_sql/persistence/extended_test.py
@@ -13,7 +13,7 @@ def base_tables(self):
     def extra_table(self):
         return Table(
             name="extra",
-            columns=[Column(name="id", type=ColumnType.int)],
+            columns=[Column(name="id", schema=ColumnType.int)],
             data=[{"id": 1}],
         )
 
@@ -24,7 +24,7 @@ def test_extended_tables_creation(self, base_tables, extra_table):
 
     def test_get_table_from_base(self, base_tables, extra_table):
         base_table = Table(
-            name="base", columns=[Column(name="id", type=ColumnType.int)], data=[]
+            name="base", columns=[Column(name="id", schema=ColumnType.int)], data=[]
         )
         base_tables.add_table(base_table)
 
@@ -46,7 +46,7 @@ def test_get_nonexistent_table(self, base_tables, extra_table):
     def test_add_table(self, base_tables, extra_table):
         extended = ExtendedTables(base_tables, [extra_table])
         new_table = Table(
-            name="new", columns=[Column(name="id", type=ColumnType.int)], data=[]
+            name="new", columns=[Column(name="id", schema=ColumnType.int)], data=[]
         )
         extended.add_table(new_table)
 
diff --git a/abstra_json_sql/persistence/json.py b/abstra_json_sql/persistence/json.py
@@ -90,7 +90,7 @@ def get_table(self, name: str) -> Optional[Table]:
                 assert isinstance(row, dict), f"Row {row} is not a dictionary"
                 for key, value in row.items():
                     if key not in [col.name for col in columns_set]:
-                        col = Column(name=key, type=ColumnType.from_value(value))
+                        col = Column(name=key, schema=ColumnType.from_value(value))
                         columns_set.add(col)
             columns = list(columns_set)
             # Save inferred metadata
@@ -265,7 +265,7 @@ def change_column_type(
         # Update metadata
         for col in columns:
             if col.name == column_name:
-                col.type = new_type
+                col.schema = new_type
                 break
         else:
             raise ValueError(f"Column {column_name} not found in table {table_name}")
diff --git a/abstra_json_sql/persistence/json_test.py b/abstra_json_sql/persistence/json_test.py
@@ -41,9 +41,9 @@ def sample_table(self):
         return Table(
             name="users",
             columns=[
-                Column(name="id", type=ColumnType.int, is_primary_key=True),
-                Column(name="name", type=ColumnType.string),
-                Column(name="age", type=ColumnType.int),
+                Column(name="id", schema=ColumnType.int, is_primary_key=True),
+                Column(name="name", schema=ColumnType.string),
+                Column(name="age", schema=ColumnType.int),
             ],
             data=[
                 {"id": 1, "name": "Alice", "age": 30},
@@ -118,7 +118,7 @@ def test_rename_table(self, tables, sample_table, temp_dir):
     def test_add_column(self, tables, sample_table):
         tables.add_table(sample_table)
         new_column = Column(
-            name="email", type=ColumnType.string, default="test@example.com"
+            name="email", schema=ColumnType.string, default="test@example.com"
         )
         tables.add_column("users", new_column)
 
@@ -154,7 +154,7 @@ def test_change_column_type(self, tables, sample_table):
 
         table = tables.get_table("users")
         age_col = table.get_column("age")
-        assert age_col.type == ColumnType.string
+        assert age_col.schema == ColumnType.string
 
     def test_insert(self, tables, sample_table):
         tables.add_table(sample_table)
@@ -194,8 +194,8 @@ def test_new_uuid_implementation():
         table = Table(
             name="users",
             columns=[
-                Column(name="id", type=ColumnType.int, is_primary_key=True),
-                Column(name="name", type=ColumnType.string),
+                Column(name="id", schema=ColumnType.int, is_primary_key=True),
+                Column(name="name", schema=ColumnType.string),
             ],
             data=[
                 {"id": 1, "name": "Alice"},
@@ -249,8 +249,8 @@ def test_uuid_file_names_and_rename():
         table = Table(
             name="users",
             columns=[
-                Column(name="id", type=ColumnType.int, is_primary_key=True),
-                Column(name="name", type=ColumnType.string),
+                Column(name="id", schema=ColumnType.int, is_primary_key=True),
+                Column(name="name", schema=ColumnType.string),
             ],
             data=[
                 {"id": 1, "name": "Alice"},
diff --git a/abstra_json_sql/persistence/jsonl.py b/abstra_json_sql/persistence/jsonl.py
@@ -139,7 +139,7 @@ def get_table(self, name: str) -> Optional[Table]:
             for row in data:
                 for key, value in row.items():
                     if key not in [col.name for col in columns_set]:
-                        col = Column(name=key, type=ColumnType.from_value(value))
+                        col = Column(name=key, schema=ColumnType.from_value(value))
                         columns_set.add(col)
             columns = list(columns_set)
             # Save inferred metadata
@@ -290,7 +290,7 @@ def change_column_type(
         # Update metadata
         for col in columns:
             if col.name == column_name:
-                col.type = new_type
+                col.schema = new_type
                 break
         else:
             raise ValueError(f"Column {column_name} not found in table {table_name}")
diff --git a/abstra_json_sql/persistence/jsonl_test.py b/abstra_json_sql/persistence/jsonl_test.py
@@ -44,9 +44,9 @@ def sample_table(self):
         return Table(
             name="users",
             columns=[
-                Column(name="id", type=ColumnType.int, is_primary_key=True),
-                Column(name="name", type=ColumnType.string),
-                Column(name="age", type=ColumnType.int),
+                Column(name="id", schema=ColumnType.int, is_primary_key=True),
+                Column(name="name", schema=ColumnType.string),
+                Column(name="age", schema=ColumnType.int),
             ],
             data=[
                 {"id": 1, "name": "Alice", "age": 30},
@@ -118,7 +118,7 @@ def test_rename_table(self, tables, sample_table, temp_dir):
     def test_add_column(self, tables, sample_table):
         tables.add_table(sample_table)
         new_column = Column(
-            name="email", type=ColumnType.string, default="test@example.com"
+            name="email", schema=ColumnType.string, default="test@example.com"
         )
         tables.add_column("users", new_column)
 
@@ -154,7 +154,7 @@ def test_change_column_type(self, tables, sample_table):
 
         table = tables.get_table("users")
         age_col = table.get_column("age")
-        assert age_col.type == ColumnType.string
+        assert age_col.schema == ColumnType.string
 
     def test_insert(self, tables, sample_table):
         tables.add_table(sample_table)
diff --git a/abstra_json_sql/persistence/memory.py b/abstra_json_sql/persistence/memory.py
@@ -123,7 +123,7 @@ def change_column_type(
         column = table.get_column(column_name)
         if column is None:
             raise ValueError(f"Column {column_name} not found in table {table_name}")
-        column.type = new_type
+        column.schema = new_type
 
     def insert(self, table: str, row: dict):
         table_obj = self._get_internal_table(table)
diff --git a/abstra_json_sql/persistence/memory_test.py b/abstra_json_sql/persistence/memory_test.py
@@ -43,9 +43,9 @@ def sample_table(self):
         return Table(
             name="users",
             columns=[
-                Column(name="id", type=ColumnType.int, is_primary_key=True),
-                Column(name="name", type=ColumnType.string),
-                Column(name="age", type=ColumnType.int),
+                Column(name="id", schema=ColumnType.int, is_primary_key=True),
+                Column(name="name", schema=ColumnType.string),
+                Column(name="age", schema=ColumnType.int),
             ],
             data=[
                 {"id": 1, "name": "Alice", "age": 30},
@@ -101,7 +101,7 @@ def test_rename_to_existing_table(self, tables, sample_table):
 
     def test_add_column(self, tables, sample_table):
         tables.add_table(sample_table)
-        new_column = Column(name="email", type=ColumnType.string)
+        new_column = Column(name="email", schema=ColumnType.string)
         tables.add_column("users", new_column)
 
         table = tables.get_table("users")
@@ -110,7 +110,7 @@ def test_add_column(self, tables, sample_table):
 
     def test_add_duplicate_column(self, tables, sample_table):
         tables.add_table(sample_table)
-        duplicate_column = Column(name="name", type=ColumnType.string)
+        duplicate_column = Column(name="name", schema=ColumnType.string)
         with pytest.raises(ValueError, match="Column name already exists"):
             tables.add_column("users", duplicate_column)
 
@@ -128,7 +128,7 @@ def test_change_column_type(self, tables, sample_table):
 
         table = tables.get_table("users")
         age_col = table.get_column("age")
-        assert age_col.type == ColumnType.string
+        assert age_col.schema == ColumnType.string
 
     def test_insert(self, tables, sample_table):
         tables.add_table(sample_table)
diff --git a/abstra_json_sql/tables.py b/abstra_json_sql/tables.py
@@ -28,6 +28,19 @@ def from_value(value: Any) -> "ColumnType":
         else:
             return ColumnType.unknown
 
+    def to_dict(self) -> str:
+        return {
+            "type": self.value,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ColumnType":
+        """Create ColumnType from dictionary"""
+        if "type" in data:
+            return cls(data["type"])
+        else:
+            raise ValueError("Invalid data for ColumnType: missing 'type' key")
+
 
 class ForeignKey:
     def __init__(self, table: str, column: str):
@@ -47,29 +60,29 @@ class Column:
     def __init__(
         self,
         name: str,
-        type: ColumnType,
+        schema: ColumnType,
         is_primary_key: bool = False,
         foreign_key: Optional[ForeignKey] = None,
         default: Optional[Any] = None,
         column_id: str = None,
     ):
         self.name = name
-        self.type = type
+        self.schema = schema
         self.is_primary_key = is_primary_key
         self.foreign_key = foreign_key
         self.default = default
         self.column_id = column_id if column_id is not None else str(uuid.uuid4())
 
     def __hash__(self):
         # Only hash based on name and type for backward compatibility
-        return hash((self.name, self.type, self.is_primary_key, self.foreign_key))
+        return hash((self.name, self.schema, self.is_primary_key, self.foreign_key))
 
     def __eq__(self, other):
         if not isinstance(other, Column):
             return False
         return (
             self.name == other.name
-            and self.type == other.type
+            and self.schema == other.schema
             and self.is_primary_key == other.is_primary_key
             and self.foreign_key == other.foreign_key
         )
@@ -79,7 +92,7 @@ def to_dict(self):
         result = {
             "id": self.column_id,
             "name": self.name,
-            "type": self.type.value if isinstance(self.type, ColumnType) else self.type,
+            "schema": self.schema.to_dict(),
             "is_primary_key": self.is_primary_key,
             "default": self.default,
         }
@@ -98,8 +111,8 @@ def from_dict(cls, data: dict) -> "Column":
         if "id" in col_dict:
             col_dict["column_id"] = col_dict.pop("id")
         # Convert type string back to ColumnType enum
-        if "type" in col_dict:
-            col_dict["type"] = ColumnType(col_dict["type"])
+        if "schema" in col_dict:
+            col_dict["schema"] = ColumnType.from_dict(col_dict["schema"])
         # Convert foreign_key dict back to ForeignKey object
         if "foreign_key" in col_dict and col_dict["foreign_key"] is not None:
             fk_data = col_dict.pop("foreign_key")
diff --git a/abstra_json_sql/tables_test.py b/abstra_json_sql/tables_test.py
@@ -29,30 +29,30 @@ def test_from_value_unknown(self):
 
 class TestColumn:
     def test_column_creation(self):
-        col = Column(name="id", type=ColumnType.int, is_primary_key=True)
+        col = Column(name="id", schema=ColumnType.int, is_primary_key=True)
         assert col.name == "id"
-        assert col.type == ColumnType.int
+        assert col.schema == ColumnType.int
         assert col.is_primary_key is True
         assert col.foreign_key is None
         assert col.default is None
 
     def test_column_with_foreign_key(self):
         fk = ForeignKey(table="users", column="id")
-        col = Column(name="user_id", type=ColumnType.int, foreign_key=fk)
+        col = Column(name="user_id", schema=ColumnType.int, foreign_key=fk)
         assert col.foreign_key.table == "users"
         assert col.foreign_key.column == "id"
 
     def test_column_hash(self):
-        col1 = Column(name="id", type=ColumnType.int)
-        col2 = Column(name="id", type=ColumnType.int)
+        col1 = Column(name="id", schema=ColumnType.int)
+        col2 = Column(name="id", schema=ColumnType.int)
         assert hash(col1) == hash(col2)
 
 
 class TestTable:
     def test_table_creation(self):
         columns = [
-            Column(name="id", type=ColumnType.int, is_primary_key=True),
-            Column(name="name", type=ColumnType.string),
+            Column(name="id", schema=ColumnType.int, is_primary_key=True),
+            Column(name="name", schema=ColumnType.string),
         ]
         table = Table(name="users", columns=columns)
         assert table.name == "users"
@@ -61,8 +61,8 @@ def test_table_creation(self):
 
     def test_get_column(self):
         columns = [
-            Column(name="id", type=ColumnType.int),
-            Column(name="name", type=ColumnType.string),
+            Column(name="id", schema=ColumnType.int),
+            Column(name="name", schema=ColumnType.string),
         ]
         table = Table(name="users", columns=columns)
 
diff --git a/test_column_ids.py b/test_column_ids.py

Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ def interactive_create_table(workdir: Path):`
`132`	`132`	`# Create column`
`133`	`133`	`column = Column(`
`134`	`134`	`name=column_name,`
`135`		`- type=column_type,`
	`135`	`+ schema=column_type,`
`136`	`136`	`is_primary_key=is_primary_key,`
`137`	`137`	`default=default_value,`
`138`	`138`	`)`