insert and update from BaseModel

Author: brunovcosta

abstra_json_sql/apply.py

@@ -267,9 +267,9 @@ def apply_expression(expression: Expression, ctx: dict):
                     )
                 )
             elif expression.name.lower() == "bool_or":
-                assert (
-                    len(expression.args) == 1
-                ), "Bool_or function requires one argument"
+                assert len(expression.args) == 1, (
+                    "Bool_or function requires one argument"
+                )
                 return any(
                     apply_expression(expression.args[0], {**ctx, **row})
                     for row in ctx["__grouped_rows"]
@@ -279,9 +279,9 @@ def apply_expression(expression: Expression, ctx: dict):
                     )
                 )
             elif expression.name.lower() == "bool_and":
-                assert (
-                    len(expression.args) == 1
-                ), "Bool_and function requires one argument"
+                assert len(expression.args) == 1, (
+                    "Bool_and function requires one argument"
+                )
                 return all(
                     apply_expression(expression.args[0], {**ctx, **row})
                     for row in ctx["__grouped_rows"]
@@ -291,9 +291,9 @@ def apply_expression(expression: Expression, ctx: dict):
                     )
                 )
             elif expression.name.lower() == "bit_or":
-                assert (
-                    len(expression.args) == 1
-                ), "Bit_or function requires one argument"
+                assert len(expression.args) == 1, (
+                    "Bit_or function requires one argument"
+                )
                 not_null_rows = [
                     row
                     for row in ctx["__grouped_rows"]
@@ -309,9 +309,9 @@ def apply_expression(expression: Expression, ctx: dict):
                     result_bits |= apply_expression(expression.args[0], {**ctx, **row})
                 return result_bits
             elif expression.name.lower() == "bit_and":
-                assert (
-                    len(expression.args) == 1
-                ), "Bit_and function requires one argument"
+                assert len(expression.args) == 1, (
+                    "Bit_and function requires one argument"
+                )
                 not_null_rows = [
                     row
                     for row in ctx["__grouped_rows"]
@@ -327,17 +327,17 @@ def apply_expression(expression: Expression, ctx: dict):
                     result_bits &= apply_expression(expression.args[0], {**ctx, **row})
                 return result_bits
             elif expression.name.lower() == "array_agg":
-                assert (
-                    len(expression.args) == 1
-                ), "Array_agg function requires one argument"
+                assert len(expression.args) == 1, (
+                    "Array_agg function requires one argument"
+                )
                 return [
                     apply_expression(expression.args[0], {**ctx, **row})
                     for row in ctx["__grouped_rows"]
                 ]
             elif expression.name.lower() == "string_agg":
-                assert (
-                    len(expression.args) == 2
-                ), "String_agg function requires two arguments"
+                assert len(expression.args) == 2, (
+                    "String_agg function requires two arguments"
+                )
                 separator = apply_expression(expression.args[1], ctx)
                 return separator.join(
                     str(apply_expression(expression.args[0], {**ctx, **row}))
@@ -350,14 +350,14 @@ def apply_expression(expression: Expression, ctx: dict):
         else:
             args = [apply_expression(arg, ctx) for arg in expression.args]
             if expression.name == "lower":
-                assert isinstance(
-                    args[0], str
-                ), "lower function requires a string argument"
+                assert isinstance(args[0], str), (
+                    "lower function requires a string argument"
+                )
                 return args[0].lower()
             elif expression.name == "upper":
-                assert isinstance(
-                    args[0], str
-                ), "upper function requires a string argument"
+                assert isinstance(args[0], str), (
+                    "upper function requires a string argument"
+                )
                 return args[0].upper()
             else:
                 raise ValueError(f"Unknown function: {expression.name}")

abstra_json_sql/parser.py

@@ -435,9 +435,9 @@ def parse_fields(tokens: List[Token]) -> Tuple[List[SelectField], List[Token]]:
             ):
                 tokens = tokens[1:]
                 alias_token = tokens[0]
-                assert (
-                    alias_token.type == "name"
-                ), f"Expected alias name, got {alias_token}"
+                assert alias_token.type == "name", (
+                    f"Expected alias name, got {alias_token}"
+                )
                 field.alias = alias_token.value
                 tokens = tokens[1:]
             fields.append(field)
@@ -668,9 +668,9 @@ def parse_update(tokens: List[Token]) -> Tuple[Ast, List[Token]]:
     else:
         table_alias = None
 
-    assert (
-        tokens[0].type == "keyword" and tokens[0].value.upper() == "SET"
-    ), f"Expecting SET assignments, got '{tokens[0].value}'"
+    assert tokens[0].type == "keyword" and tokens[0].value.upper() == "SET", (
+        f"Expecting SET assignments, got '{tokens[0].value}'"
+    )
     tokens = tokens[1:]
 
     changes = []
@@ -754,9 +754,9 @@ def parse_with(tokens: List[Token]) -> Tuple[Optional[Ast], List[Token]]:
         tokens = tokens[1:]
 
         as_token = tokens[0]
-        assert (
-            as_token.type == "keyword" and as_token.value.upper() == "AS"
-        ), f"Expected AS, got {as_token}"
+        assert as_token.type == "keyword" and as_token.value.upper() == "AS", (
+            f"Expected AS, got {as_token}"
+        )
         tokens = tokens[1:]
 
         cmd, tokens = parse_expression(tokens)

abstra_json_sql/persistence/extended.py

@@ -100,7 +100,7 @@ def change_column_type(
                         return
         self.snapshot.change_column_type(table_name, column_name, new_type)
 
-    def insert(self, table_name: str, row: dict):
+    def _insert(self, table_name: str, row: dict):
         for table in self.extra_tables:
             if table.name == table_name:
                 # Convert row from column names to column IDs
@@ -109,7 +109,7 @@ def insert(self, table_name: str, row: dict):
                 return
         self.snapshot.insert(table_name, row)
 
-    def update(self, table_name, idx, changes):
+    def _update(self, table_name, idx, changes):
         for table in self.extra_tables:
             if table.name == table_name:
                 # Convert changes from column names to column IDs
@@ -118,7 +118,7 @@ def update(self, table_name, idx, changes):
                 return
         self.snapshot.update(table_name, idx, changes)
 
-    def delete(self, table_name: str, idxs: List[int]):
+    def _delete(self, table_name: str, idxs: List[int]):
         for table in self.extra_tables:
             if table.name == table_name:
                 # Sort indices in descending order to avoid index shifting

abstra_json_sql/persistence/json.py

@@ -152,7 +152,7 @@ def rename_table(self, old_name: str, new_name: str):
         # Update metadata with new name
         self._save_table_metadata(table_id, new_name, columns)
 
-    def insert(self, table_name: str, row: dict):
+    def _insert(self, table_name: str, row: dict):
         table_id, columns = self._get_table_metadata_by_name(table_name)
         if table_id is None:
             raise ValueError(f"Table {table_name} not found")
@@ -165,9 +165,9 @@ def insert(self, table_name: str, row: dict):
         temp_table = Table(name=table_name, columns=columns, data=[], table_id=table_id)
 
         rows = json.loads(table_path.read_text())
-        assert isinstance(
-            rows, list
-        ), f"File {table_path} does not contain a list of rows"
+        assert isinstance(rows, list), (
+            f"File {table_path} does not contain a list of rows"
+        )
 
         # Convert row to column ID format
         row_with_ids = temp_table.convert_row_to_column_ids(row)
@@ -184,9 +184,9 @@ def add_column(self, table_name: str, column: Column):
             raise FileNotFoundError(f"File {table_path} does not exist")
 
         rows = json.loads(table_path.read_text())
-        assert isinstance(
-            rows, list
-        ), f"File {table_path} does not contain a list of rows"
+        assert isinstance(rows, list), (
+            f"File {table_path} does not contain a list of rows"
+        )
 
         # Check if column already exists
         if any(col.name == column.name for col in existing_columns):
@@ -213,9 +213,9 @@ def remove_column(self, table_name: str, column_name: str):
             raise FileNotFoundError(f"File {table_path} does not exist")
 
         rows = json.loads(table_path.read_text())
-        assert isinstance(
-            rows, list
-        ), f"File {table_path} does not contain a list of rows"
+        assert isinstance(rows, list), (
+            f"File {table_path} does not contain a list of rows"
+        )
 
         # Remove column from data using column ID
         column_to_remove = None
@@ -244,9 +244,9 @@ def rename_column(self, table_name: str, old_name: str, new_name: str):
             raise FileNotFoundError(f"File {table_path} does not exist")
 
         rows = json.loads(table_path.read_text())
-        assert isinstance(
-            rows, list
-        ), f"File {table_path} does not contain a list of rows"
+        assert isinstance(rows, list), (
+            f"File {table_path} does not contain a list of rows"
+        )
 
         # Data doesn't need to change for rename_column since we use column IDs
         # Only metadata needs to be updated
@@ -271,7 +271,7 @@ def change_column_type(
             raise ValueError(f"Column {column_name} not found in table {table_name}")
         self._save_table_metadata(table_id, table_name, columns)
 
-    def update(self, table_name: str, idx: int, changes: dict):
+    def _update(self, table_name: str, idx: int, changes: dict):
         table_id, columns = self._get_table_metadata_by_name(table_name)
         if table_id is None:
             raise ValueError(f"Table {table_name} not found")
@@ -284,9 +284,9 @@ def update(self, table_name: str, idx: int, changes: dict):
         temp_table = Table(name=table_name, columns=columns, data=[], table_id=table_id)
 
         rows = json.loads(table_path.read_text())
-        assert isinstance(
-            rows, list
-        ), f"File {table_path} does not contain a list of rows"
+        assert isinstance(rows, list), (
+            f"File {table_path} does not contain a list of rows"
+        )
         if idx < 0 or idx >= len(rows):
             raise IndexError(f"Index {idx} out of range for table {table_name}")
 
@@ -295,7 +295,7 @@ def update(self, table_name: str, idx: int, changes: dict):
         rows[idx].update(changes_with_ids)
         table_path.write_text(json.dumps(rows, indent=2))
 
-    def delete(self, table_name: str, idxs: List[int]):
+    def _delete(self, table_name: str, idxs: List[int]):
         table_id, _ = self._get_table_metadata_by_name(table_name)
         if table_id is None:
             raise ValueError(f"Table {table_name} not found")
@@ -305,9 +305,9 @@ def delete(self, table_name: str, idxs: List[int]):
             raise FileNotFoundError(f"File {table_path} does not exist")
 
         rows = json.loads(table_path.read_text())
-        assert isinstance(
-            rows, list
-        ), f"File {table_path} does not contain a list of rows"
+        assert isinstance(rows, list), (
+            f"File {table_path} does not contain a list of rows"
+        )
 
         # Sort indices in descending order to avoid index shifting
         for idx in sorted(idxs, reverse=True):

abstra_json_sql/persistence/jsonl.py

@@ -296,7 +296,7 @@ def change_column_type(
             raise ValueError(f"Column {column_name} not found in table {table_name}")
         self._save_table_metadata(table_id, table_name, columns)
 
-    def insert(self, table_name: str, row: dict):
+    def _insert(self, table_name: str, row: dict):
         table_id, columns = self._get_table_metadata_by_name(table_name)
         if table_id is None:
             raise ValueError(f"Table {table_name} not found")
@@ -310,7 +310,7 @@ def insert(self, table_name: str, row: dict):
             row_with_ids = temp_table.convert_row_to_column_ids(row)
             f.write(json.dumps(row_with_ids) + "\n")
 
-    def update(self, table_name: str, idx: int, changes: dict):
+    def _update(self, table_name: str, idx: int, changes: dict):
         table_id, columns = self._get_table_metadata_by_name(table_name)
         if table_id is None:
             raise ValueError(f"Table {table_name} not found")
@@ -340,7 +340,7 @@ def update(self, table_name: str, idx: int, changes: dict):
             for row in rows:
                 f.write(json.dumps(row) + "\n")
 
-    def delete(self, table_name: str, idxs: List[int]):
+    def _delete(self, table_name: str, idxs: List[int]):
         table_id, _ = self._get_table_metadata_by_name(table_name)
         if table_id is None:
             raise ValueError(f"Table {table_name} not found")

abstra_json_sql/persistence/memory.py

@@ -3,6 +3,20 @@
 
 
 class InMemoryTables(ITablesSnapshot):
+    def _update(self, table: str, idx: int, changes: dict):
+        table_obj = self._get_internal_table(table)
+        if table_obj is None:
+            raise ValueError(f"Table {table} not found")
+        # Convert changes from column names to column IDs
+        changes_with_ids = table_obj.convert_row_to_column_ids(changes)
+        table_obj.data[idx].update(changes_with_ids)
+
+    def _delete(self, table: str, idxs: List[int]):
+        table_obj = self._get_internal_table(table)
+        if table_obj is None:
+            raise ValueError(f"Table {table} not found")
+        table_obj.data = [row for i, row in enumerate(table_obj.data) if i not in idxs]
+
     def __init__(self, tables: List[Table] = None):
         if tables is None:
             self.tables = []
@@ -125,7 +139,7 @@ def change_column_type(
             raise ValueError(f"Column {column_name} not found in table {table_name}")
         column.schema = new_type
 
-    def insert(self, table: str, row: dict):
+    def _insert(self, table: str, row: dict):
         table_obj = self._get_internal_table(table)
         if table_obj is None:
             raise ValueError(f"Table {table} not found")

abstra_json_sql/string_utils.py

@@ -0,0 +1,10 @@
+import re
+
+
+def snake_case(name: str) -> str:
+    """Convert a string to snake_case."""
+    s = re.sub(r"[\s\-]+", "_", name)
+    s = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s)
+    s = re.sub(r"([a-zA-Z])([0-9])", r"\1_\2", s)
+    s = re.sub(r"([0-9])([a-zA-Z])", r"\1_\2", s)
+    return s.lower()

abstra_json_sql/string_utils_test.py

@@ -0,0 +1,15 @@
+from unittest import TestCase, main
+from abstra_json_sql.string_utils import snake_case
+
+
+class TestSnakeCaseUtils(TestCase):
+    def test_snake_case(self):
+        self.assertEqual(snake_case("Hello World"), "hello_world")
+        self.assertEqual(snake_case("snake_case"), "snake_case")
+        self.assertEqual(snake_case("Test123"), "test_123")
+        self.assertEqual(snake_case("test with spaces"), "test_with_spaces")
+        self.assertEqual(snake_case("UPPERCASE"), "uppercase")
+
+
+if __name__ == "__main__":
+    main()