up

Author: brunovcosta

abstra_json_sql/cli.py

@@ -32,7 +32,7 @@ def interactive_create_table(workdir: Path):
     """Create a table interactively by asking user for table name, columns, etc."""
     try:
         tables = FileSystemJsonLTables(workdir=workdir)
-        
+
         # Get table name
         print("Creating a new table...")
         while True:
@@ -44,49 +44,65 @@ def interactive_create_table(workdir: Path):
                 # Check if table already exists
                 existing_table = tables.get_table(table_name)
                 if existing_table:
-                    print(f"Table '{table_name}' already exists. Please choose a different name.")
+                    print(
+                        f"Table '{table_name}' already exists. Please choose a different name."
+                    )
                     continue
                 break
             except FileNotFoundError:
                 # Table doesn't exist, which is what we want
                 break
-        
+
         # Get columns
         columns = []
         print(f"\nNow let's add columns to the '{table_name}' table.")
         print("Available column types: int, string, float, bool")
         print("Press Enter with empty column name to finish adding columns.\n")
-        
+
         while True:
             column_name = input("Column name: ").strip()
             if not column_name:
                 if len(columns) == 0:
                     print("At least one column is required. Please add a column.")
                     continue
                 break
-            
+
             # Check if column name already exists
             if any(col.name == column_name for col in columns):
-                print(f"Column '{column_name}' already exists. Please choose a different name.")
+                print(
+                    f"Column '{column_name}' already exists. Please choose a different name."
+                )
                 continue
-            
+
             # Get column type
             while True:
-                column_type_str = input(f"Column type for '{column_name}' (int/string/float/bool): ").strip().lower()
+                column_type_str = (
+                    input(f"Column type for '{column_name}' (int/string/float/bool): ")
+                    .strip()
+                    .lower()
+                )
                 if column_type_str in ["int", "string", "float", "bool"]:
                     column_type = ColumnType(column_type_str)
                     break
                 else:
-                    print("Invalid column type. Please enter: int, string, float, or bool")
-            
+                    print(
+                        "Invalid column type. Please enter: int, string, float, or bool"
+                    )
+
             # Ask if it's a primary key
-            is_primary = input(f"Is '{column_name}' a primary key? (y/N): ").strip().lower()
-            is_primary_key = is_primary in ['y', 'yes']
-            
+            is_primary = (
+                input(f"Is '{column_name}' a primary key? (y/N): ").strip().lower()
+            )
+            is_primary_key = is_primary in ["y", "yes"]
+
             # Ask for default value
             default_value = None
-            has_default = input(f"Does '{column_name}' have a default value? (y/N): ").strip().lower()
-            if has_default in ['y', 'yes']:
+            has_default = (
+                input(f"Does '{column_name}' have a default value? (y/N): ")
+                .strip()
+                .lower()
+            )
+            if has_default in ["y", "yes"]:
                 while True:
                     default_str = input(f"Default value for '{column_name}': ").strip()
                     try:
@@ -96,41 +112,45 @@ def interactive_create_table(workdir: Path):
                         elif column_type == ColumnType.float:
                             default_value = float(default_str) if default_str else None
                         elif column_type == ColumnType.bool:
-                            if default_str.lower() in ['true', '1', 'yes', 'y']:
+                            if default_str.lower() in ["true", "1", "yes", "y"]:
                                 default_value = True
-                            elif default_str.lower() in ['false', '0', 'no', 'n']:
+                            elif default_str.lower() in ["false", "0", "no", "n"]:
                                 default_value = False
-                            elif default_str == '':
+                            elif default_str == "":
                                 default_value = None
                             else:
                                 raise ValueError("Invalid boolean value")
                         else:  # string
                             default_value = default_str if default_str else None
                         break
                     except ValueError:
-                        print(f"Invalid default value for {column_type.value} type. Please try again.")
-            
+                        print(
+                            f"Invalid default value for {column_type.value} type. Please try again."
+                        )
+
             # Create column
             column = Column(
                 name=column_name,
                 type=column_type,
                 is_primary_key=is_primary_key,
-                default=default_value
+                default=default_value,
             )
             columns.append(column)
             print(f"✓ Added column '{column_name}' ({column_type.value})")
-        
+
         # Create and add the table
         table = Table(name=table_name, columns=columns, data=[])
         tables.add_table(table)
-        
+
         print(f"\n✓ Table '{table_name}' created successfully!")
         print("Columns:")
         for col in columns:
             pk_indicator = " (PRIMARY KEY)" if col.is_primary_key else ""
-            default_indicator = f" (default: {col.default})" if col.default is not None else ""
+            default_indicator = (
+                f" (default: {col.default})" if col.default is not None else ""
+            )
             print(f"  - {col.name}: {col.type.value}{pk_indicator}{default_indicator}")
-        
+
     except KeyboardInterrupt:
         print("\n\nTable creation cancelled.")
     except Exception as e:
@@ -139,7 +159,7 @@ def interactive_create_table(workdir: Path):
 
 def main():
     parser = ArgumentParser(description="Run SQL queries on JSON files.")
-    
+
     # Add top-level arguments for backward compatibility
     parser.add_argument("--code", type=str, help="SQL query to execute", default=None)
     parser.add_argument(
@@ -161,13 +181,15 @@ def main():
         choices=["json", "csv"],
         help="Output format (default: json)",
     )
-    
+
     # Add subcommands
     subparsers = parser.add_subparsers(dest="command", help="Available commands")
-    
+
     # Query command
     query_parser = subparsers.add_parser("query", help="Run SQL queries")
-    query_parser.add_argument("--code", type=str, help="SQL query to execute", default=None)
+    query_parser.add_argument(
+        "--code", type=str, help="SQL query to execute", default=None
+    )
     query_parser.add_argument(
         "--workdir",
         type=Path,
@@ -187,26 +209,26 @@ def main():
         choices=["json", "csv"],
         help="Output format (default: json)",
     )
-    
+
     # Create table command
     create_parser = subparsers.add_parser("create", help="Create database objects")
-    create_subparsers = create_parser.add_subparsers(dest="create_command", help="Create commands")
-    
+    create_subparsers = create_parser.add_subparsers(
+        dest="create_command", help="Create commands"
+    )
+
     table_parser = create_subparsers.add_parser("table", help="Create a table")
     table_parser.add_argument(
-        "--interactive", 
-        action="store_true", 
-        help="Create table interactively"
+        "--interactive", action="store_true", help="Create table interactively"
     )
     table_parser.add_argument(
         "--workdir",
         type=Path,
         default=Path.cwd(),
         help="Directory to create the table in",
     )
-    
+
     args = parser.parse_args()
-    
+
     # Handle commands
     if args.command == "create" and args.create_command == "table":
         if args.interactive:
@@ -246,7 +268,9 @@ def main():
         else:
             print("JSON SQL CLI")
             print("Type 'exit' to quit.")
-            print("Tip: Use 'abstra-json-sql create table --interactive' to create tables.")
+            print(
+                "Tip: Use 'abstra-json-sql create table --interactive' to create tables."
+            )
             while True:
                 try:
                     code = input("> ")

abstra_json_sql/persistence/README.md

@@ -0,0 +1,34 @@
+# Persistence Implementations
+
+This directory contains the different persistence implementations for the table storage system.
+
+## Structure
+
+- `memory.py` - In-memory table storage (`InMemoryTables`)
+- `json.py` - File system storage using JSON files (`FileSystemJsonTables`)
+- `jsonl.py` - File system storage using JSONL files (`FileSystemJsonLTables`) 
+- `extended.py` - Extended tables that combine a base persistence layer with additional in-memory tables (`ExtendedTables`)
+
+## Usage
+
+All persistence implementations conform to the `ITablesSnapshot` interface defined in the main `tables.py` file. You can import them directly from the main module:
+
+```python
+from abstra_json_sql.tables import (
+    InMemoryTables,
+    FileSystemJsonTables, 
+    FileSystemJsonLTables,
+    ExtendedTables
+)
+```
+
+Or import them from the persistence module:
+
+```python
+from abstra_json_sql.persistence import (
+    InMemoryTables,
+    FileSystemJsonTables,
+    FileSystemJsonLTables, 
+    ExtendedTables
+)
+```

abstra_json_sql/persistence/__init__.py

@@ -0,0 +1,13 @@
+"""Persistence implementations for table storage."""
+
+from .memory import InMemoryTables
+from .json import FileSystemJsonTables
+from .jsonl import FileSystemJsonLTables
+from .extended import ExtendedTables
+
+__all__ = [
+    "InMemoryTables",
+    "FileSystemJsonTables",
+    "FileSystemJsonLTables",
+    "ExtendedTables",
+]

abstra_json_sql/persistence/extended.py

@@ -0,0 +1,129 @@
+from typing import List, Optional
+
+from ..tables import ITablesSnapshot, Table, Column, ColumnType
+
+
+class ExtendedTables(ITablesSnapshot):
+    snapshot: ITablesSnapshot
+    extra_tables: List[Table]
+
+    def __init__(self, snapshot: ITablesSnapshot, tables: List[Table]):
+        self.snapshot = snapshot
+        self.extra_tables = []
+
+        # Convert existing table data to column ID format if needed
+        for table in tables:
+            converted_data = []
+            for row in table.data:
+                converted_row = table.convert_row_to_column_ids(row)
+                converted_data.append(converted_row)
+            table.data = converted_data
+            self.extra_tables.append(table)
+
+    def get_table(self, name: str) -> Optional[Table]:
+        table = self.snapshot.get_table(name)
+        if table:
+            return table
+        for table in self.extra_tables:
+            if table.name == name:
+                # Create a copy with data converted to column names
+                converted_data = []
+                for row in table.data:
+                    converted_data.append(table.convert_row_from_column_ids(row))
+
+                result_table = Table(
+                    name=table.name,
+                    columns=table.columns,
+                    data=converted_data,
+                    table_id=table.table_id,
+                )
+                return result_table
+        return None
+
+    def add_table(self, table: Table):
+        self.extra_tables.append(table)
+
+    def remove_table(self, name: str):
+        self.extra_tables = [table for table in self.extra_tables if table.name != name]
+
+    def rename_table(self, old_name: str, new_name: str):
+        for table in self.extra_tables:
+            if table.name == old_name:
+                table.name = new_name
+                return
+        self.snapshot.rename_table(old_name, new_name)
+
+    def add_column(self, table_name: str, column: Column):
+        for table in self.extra_tables:
+            if table.name == table_name:
+                table.columns.append(column)
+                # Add default value to existing rows using column ID
+                for row in table.data:
+                    row[column.column_id] = column.default
+                return
+        self.snapshot.add_column(table_name, column)
+
+    def remove_column(self, table_name: str, column_name: str):
+        for table in self.extra_tables:
+            if table.name == table_name:
+                # Find the column to get its ID before removing
+                column_to_remove = table.get_column(column_name)
+                table.columns = [
+                    col for col in table.columns if col.name != column_name
+                ]
+                # Remove column from existing rows using column ID
+                if column_to_remove:
+                    for row in table.data:
+                        row.pop(column_to_remove.column_id, None)
+                return
+        self.snapshot.remove_column(table_name, column_name)
+
+    def rename_column(self, table_name: str, old_name: str, new_name: str):
+        for table in self.extra_tables:
+            if table.name == table_name:
+                # Update column name (data doesn't need to change since we use column IDs)
+                for col in table.columns:
+                    if col.name == old_name:
+                        col.name = new_name
+                        break
+                return
+        self.snapshot.rename_column(table_name, old_name, new_name)
+
+    def change_column_type(
+        self, table_name: str, column_name: str, new_type: ColumnType
+    ):
+        for table in self.extra_tables:
+            if table.name == table_name:
+                for col in table.columns:
+                    if col.name == column_name:
+                        col.type = new_type
+                        return
+        self.snapshot.change_column_type(table_name, column_name, new_type)
+
+    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
+                row_with_ids = table.convert_row_to_column_ids(row)
+                table.data.append(row_with_ids)
+                return
+        self.snapshot.insert(table_name, row)
+
+    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
+                changes_with_ids = table.convert_row_to_column_ids(changes)
+                table.data[idx].update(changes_with_ids)
+                return
+        self.snapshot.update(table_name, idx, changes)
+
+    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
+                for idx in sorted(idxs, reverse=True):
+                    if 0 <= idx < len(table.data):
+                        del table.data[idx]
+                return
+        self.snapshot.delete(table_name, idxs)