cinchdb 0.1.4__tar.gz → 0.1.6__tar.gz

{cinchdb-0.1.4 → cinchdb-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.4
+Version: 0.1.6
 Summary: A Git-like SQLite database management system with branching and multi-tenancy
 Project-URL: Homepage, https://github.com/russellromney/cinchdb
 Project-URL: Documentation, https://russellromney.github.io/cinchdb
@@ -31,9 +31,9 @@ Description-Content-Type: text/markdown
 
 NOTE: CinchDB is in early alpha. This is project to test out an idea. Do not use this in production.
 
-CinchDB is for projects that need fast queries, data isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
+CinchDB is for projects that need fast queries, isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
 
-On a meta level, I made this because I wanted a database structure that I felt comfortable letting AI agents take full control over, safely, and I didn't want to run my own Postgres instance somewhere or pay for it on e.g. Neon - I don't need hyperscaling, I just need super fast queries.
+On a meta level: I made this because I wanted a database structure that I felt comfortable letting AI agents take full control over, safely, and I didn't want to run my own Postgres instance somewhere or pay for it on e.g. Neon - I don't need hyperscaling, I just need super fast queries.
 
 Because it's so lightweight and its only dependencies are pydantic, requests, and Typer, it makes for a perfect local development database that can be controlled programmatically.
 
@@ -58,6 +58,7 @@ cinch branch merge-into-main feature
 cinch tenant create customer_a
 cinch query "SELECT * FROM users" --tenant customer_a
 
+# Coming soon 
 # Connect to remote CinchDB instance
 cinch remote add production https://your-cinchdb-server.com your-api-key
 cinch remote use production
@@ -76,7 +77,7 @@ CinchDB combines SQLite with Git-like workflows for database schema management:
 - **Safe structure changes** - change merges happen atomically with zero rollback risk (seriously)
 - **Remote connectivity** - Connect to hosted CinchDB instances
 - **Type-safe SDK** - Python and TypeScript SDKs with full type safety
-- **Remote-capable** - CLI and SDK can connect to remote instances
+- **Remote-capable** - coming soon - CLI and SDK can connect to remote instances
 - **SDK generation from database schema** - Generate a typesafe SDK from your database models for CRUD operations
 
 ## Installation
@@ -128,13 +129,30 @@ db.create_table("posts", [
 # Query data
 results = db.query("SELECT * FROM posts WHERE title LIKE ?", ["%python%"])
 
-# CRUD operations
+# CRUD operations - single insert
 post_id = db.insert("posts", {"title": "Hello World", "content": "First post"})
+
+# Batch insert - multiple records at once
+posts = db.insert("posts",
+    {"title": "First", "content": "Content 1"},
+    {"title": "Second", "content": "Content 2"},
+    {"title": "Third", "content": "Content 3"}
+)
+
+# Or with a list using star expansion
+post_list = [
+    {"title": "Post A", "content": "Content A"},
+    {"title": "Post B", "content": "Content B"}
+]
+results = db.insert("posts", *post_list)
+
 db.update("posts", post_id, {"content": "Updated content"})
 ```
 
 ### Remote Connection
 
+Coming soon.
+
 ```python
 # Connect to remote instance
 db = cinchdb.connect("myapp", url="https://your-cinchdb-server.com", api_key="your-api-key")
@@ -144,7 +162,7 @@ results = db.query("SELECT * FROM users")
 user_id = db.insert("users", {"username": "alice", "email": "alice@example.com"})
 ```
 
-## Remote Access
+## Remote Access - coming soon 
 
 Connect to a remote CinchDB instance:
 

{cinchdb-0.1.4 → cinchdb-0.1.6}/README.md

@@ -4,9 +4,9 @@
 
 NOTE: CinchDB is in early alpha. This is project to test out an idea. Do not use this in production.
 
-CinchDB is for projects that need fast queries, data isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
+CinchDB is for projects that need fast queries, isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
 
-On a meta level, I made this because I wanted a database structure that I felt comfortable letting AI agents take full control over, safely, and I didn't want to run my own Postgres instance somewhere or pay for it on e.g. Neon - I don't need hyperscaling, I just need super fast queries.
+On a meta level: I made this because I wanted a database structure that I felt comfortable letting AI agents take full control over, safely, and I didn't want to run my own Postgres instance somewhere or pay for it on e.g. Neon - I don't need hyperscaling, I just need super fast queries.
 
 Because it's so lightweight and its only dependencies are pydantic, requests, and Typer, it makes for a perfect local development database that can be controlled programmatically.
 
@@ -31,6 +31,7 @@ cinch branch merge-into-main feature
 cinch tenant create customer_a
 cinch query "SELECT * FROM users" --tenant customer_a
 
+# Coming soon 
 # Connect to remote CinchDB instance
 cinch remote add production https://your-cinchdb-server.com your-api-key
 cinch remote use production
@@ -49,7 +50,7 @@ CinchDB combines SQLite with Git-like workflows for database schema management:
 - **Safe structure changes** - change merges happen atomically with zero rollback risk (seriously)
 - **Remote connectivity** - Connect to hosted CinchDB instances
 - **Type-safe SDK** - Python and TypeScript SDKs with full type safety
-- **Remote-capable** - CLI and SDK can connect to remote instances
+- **Remote-capable** - coming soon - CLI and SDK can connect to remote instances
 - **SDK generation from database schema** - Generate a typesafe SDK from your database models for CRUD operations
 
 ## Installation
@@ -101,13 +102,30 @@ db.create_table("posts", [
 # Query data
 results = db.query("SELECT * FROM posts WHERE title LIKE ?", ["%python%"])
 
-# CRUD operations
+# CRUD operations - single insert
 post_id = db.insert("posts", {"title": "Hello World", "content": "First post"})
+
+# Batch insert - multiple records at once
+posts = db.insert("posts",
+    {"title": "First", "content": "Content 1"},
+    {"title": "Second", "content": "Content 2"},
+    {"title": "Third", "content": "Content 3"}
+)
+
+# Or with a list using star expansion
+post_list = [
+    {"title": "Post A", "content": "Content A"},
+    {"title": "Post B", "content": "Content B"}
+]
+results = db.insert("posts", *post_list)
+
 db.update("posts", post_id, {"content": "Updated content"})
 ```
 
 ### Remote Connection
 
+Coming soon.
+
 ```python
 # Connect to remote instance
 db = cinchdb.connect("myapp", url="https://your-cinchdb-server.com", api_key="your-api-key")
@@ -117,7 +135,7 @@ results = db.query("SELECT * FROM users")
 user_id = db.insert("users", {"username": "alice", "email": "alice@example.com"})
 ```
 
-## Remote Access
+## Remote Access - coming soon 
 
 Connect to a remote CinchDB instance:
 

{cinchdb-0.1.4 → cinchdb-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cinchdb"
-version = "0.1.4"
+version = "0.1.6"
 description = "A Git-like SQLite database management system with branching and multi-tenancy"
 readme = "README.md"
 requires-python = ">=3.10"

{cinchdb-0.1.4 → cinchdb-0.1.6}/src/cinchdb/core/database.py

@@ -363,24 +363,69 @@ class CinchDB:
                 "POST", "/tables", json={"name": name, "columns": columns_data}
             )
 
-    def insert(self, table: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Insert a record into a table.
+    def insert(self, table: str, *data: Dict[str, Any]) -> Dict[str, Any] | List[Dict[str, Any]]:
+        """Insert one or more records into a table.
 
         Args:
             table: Table name
-            data: Record data as dictionary
+            *data: One or more record data dictionaries
 
         Returns:
-            Inserted record with generated fields
+            Single record dict if one record inserted, list of dicts if multiple
+
+        Examples:
+            # Single insert
+            db.insert("users", {"name": "John", "email": "john@example.com"})
+            
+            # Multiple inserts using star expansion
+            db.insert("users", 
+                {"name": "John", "email": "john@example.com"},
+                {"name": "Jane", "email": "jane@example.com"},
+                {"name": "Bob", "email": "bob@example.com"}
+            )
+            
+            # Or with a list using star expansion
+            users = [
+                {"name": "Alice", "email": "alice@example.com"},
+                {"name": "Charlie", "email": "charlie@example.com"}
+            ]
+            db.insert("users", *users)
         """
+        if not data:
+            raise ValueError("At least one record must be provided")
+            
         if self.is_local:
-            return self.data.create(table, data)
+            # Initialize data manager if needed
+            if self._data_manager is None:
+                from cinchdb.managers.data import DataManager
+                self._data_manager = DataManager(
+                    self.project_dir, self.database, self.branch, self.tenant
+                )
+            
+            # Single record
+            if len(data) == 1:
+                return self._data_manager.create_from_dict(table, data[0])
+            
+            # Multiple records - batch insert
+            results = []
+            for record in data:
+                result = self._data_manager.create_from_dict(table, record)
+                results.append(result)
+            return results
         else:
-            # Remote insert - use new data CRUD endpoint
-            result = self._make_request(
-                "POST", f"/tables/{table}/data", json={"data": data}
-            )
-            return result
+            # Remote insert
+            if len(data) == 1:
+                # Single record - use existing endpoint
+                result = self._make_request(
+                    "POST", f"/tables/{table}/data", json={"data": data[0]}
+                )
+                return result
+            else:
+                # Multiple records - use bulk endpoint
+                result = self._make_request(
+                    "POST", f"/tables/{table}/data/bulk", json={"records": list(data)}
+                )
+                return result
 
     def update(self, table: str, id: str, data: Dict[str, Any]) -> Dict[str, Any]:
         """Update a record in a table.

{cinchdb-0.1.4 → cinchdb-0.1.6}/src/cinchdb/managers/data.py

@@ -93,14 +93,15 @@ class DataManager:
         results = self.select(model_class, limit=1, id=record_id)
         return results[0] if results else None
 
-    def create(self, instance: T) -> T:
-        """Create a new record.
+    def create_from_dict(self, table_name: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new record from a dictionary.
 
         Args:
-            instance: Model instance to create
+            table_name: Name of the table to insert into
+            data: Dictionary containing the record data
 
         Returns:
-            Created model instance with populated ID and timestamps
+            Dictionary with created record including generated ID and timestamps
 
         Raises:
             ValueError: If record with same ID already exists
@@ -109,22 +110,20 @@ class DataManager:
         # Check maintenance mode
         check_maintenance_mode(self.project_root, self.database, self.branch)
 
-        table_name = self._get_table_name(type(instance))
-
-        # Prepare data for insertion
-        data = instance.model_dump()
+        # Make a copy to avoid modifying the original
+        record_data = data.copy()
 
         # Generate ID if not provided
-        if not data.get("id"):
-            data["id"] = str(uuid.uuid4())
+        if not record_data.get("id"):
+            record_data["id"] = str(uuid.uuid4())
 
         # Set timestamps
         now = datetime.now()
-        data["created_at"] = now
-        data["updated_at"] = now
+        record_data["created_at"] = now
+        record_data["updated_at"] = now
 
         # Build INSERT query
-        columns = list(data.keys())
+        columns = list(record_data.keys())
         placeholders = [f":{col}" for col in columns]
         query = f"""
             INSERT INTO {table_name} ({", ".join(columns)}) 
@@ -133,17 +132,39 @@ class DataManager:
 
         with DatabaseConnection(self.db_path) as conn:
             try:
-                conn.execute(query, data)
+                conn.execute(query, record_data)
                 conn.commit()
 
-                # Return updated instance
-                return type(instance)(**data)
+                # Return the created record data
+                return record_data
             except Exception as e:
                 conn.rollback()
                 if "UNIQUE constraint failed" in str(e):
-                    raise ValueError(f"Record with ID {data['id']} already exists")
+                    raise ValueError(f"Record with ID {record_data['id']} already exists")
                 raise
 
+    def create(self, instance: T) -> T:
+        """Create a new record from a model instance.
+
+        Args:
+            instance: Model instance to create
+
+        Returns:
+            Created model instance with populated ID and timestamps
+
+        Raises:
+            ValueError: If record with same ID already exists
+            MaintenanceError: If branch is in maintenance mode
+        """
+        table_name = self._get_table_name(type(instance))
+        data = instance.model_dump()
+        
+        # Use the new create_from_dict method
+        created_data = self.create_from_dict(table_name, data)
+        
+        # Return updated instance
+        return type(instance)(**created_data)
+
     def save(self, instance: T) -> T:
         """Save (upsert) a record - insert if new, update if exists.