sqlsaber 0.9.0__tar.gz → 0.11.0__tar.gz

{sqlsaber-0.9.0 → sqlsaber-0.11.0}/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to SQLSaber will be documented in this file.
 
 ## [Unreleased]
 
+## [0.11.0] - 2025-07-09
+
+### Changed
+
+- Removed row counting from `list_tables` tool for all database types
+
+## [0.10.0] - 2025-07-08
+
+### Added
+
+- Support for reading queries from stdin via pipe operator
+  - `echo 'show me all users' | saber` now works
+  - `cat query.txt | saber` reads query from file via stdin
+  - Allows integration with other command-line tools and scripts
+
 ## [0.9.0] - 2025-07-08
 
 ### Changed

{sqlsaber-0.9.0 → sqlsaber-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.9.0
+Version: 0.11.0
 Summary: SQLSaber - Agentic SQL assistant like Claude Code
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -139,6 +139,13 @@ Execute a single natural language query:
 saber "show me all users created this month"
 ```
 
+You can also pipe queries from stdin:
+
+```bash
+echo "show me all users created this month" | saber
+cat query.txt | saber
+```
+
 ### Database Selection
 
 Use a specific database connection:

{sqlsaber-0.9.0 → sqlsaber-0.11.0}/README.md

@@ -118,6 +118,13 @@ Execute a single natural language query:
 saber "show me all users created this month"
 ```
 
+You can also pipe queries from stdin:
+
+```bash
+echo "show me all users created this month" | saber
+cat query.txt | saber
+```
+
 ### Database Selection
 
 Use a specific database connection:

{sqlsaber-0.9.0 → sqlsaber-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlsaber"
-version = "0.9.0"
+version = "0.11.0"
 description = "SQLSaber - Agentic SQL assistant like Claude Code"
 readme = "README.md"
 requires-python = ">=3.12"

sqlsaber-0.11.0/src/sqlsaber/__init__.py

@@ -0,0 +1 @@
+"""SQLSaber CLI - Agentic SQL assistant like Claude Code but for SQL."""

{sqlsaber-0.9.0 → sqlsaber-0.11.0}/src/sqlsaber/cli/commands.py

@@ -51,9 +51,11 @@ def meta_handler(
     Query your database using natural language.
 
     Examples:
-        saber                             # Start interactive mode
-        saber "show me all users"         # Run a single query with default database
-        saber -d mydb "show me users"     # Run a query with specific database
+        saber                                  # Start interactive mode
+        saber "show me all users"              # Run a single query with default database
+        saber -d mydb "show me users"          # Run a query with specific database
+        echo "show me all users" | saber       # Read query from stdin
+        cat query.txt | saber                  # Read query from file via stdin
     """
     # Store database in app context for commands to access
     app.meta["database"] = database
@@ -64,7 +66,7 @@ def query(
     query_text: Annotated[
         str | None,
         cyclopts.Parameter(
-            help="SQL query in natural language (if not provided, starts interactive mode)",
+            help="SQL query in natural language (if not provided, reads from stdin or starts interactive mode)",
         ),
     ] = None,
     database: Annotated[
@@ -77,11 +79,28 @@ def query(
 ):
     """Run a query against the database or start interactive mode.
 
-    When called without arguments, starts interactive mode.
+    When called without arguments:
+    - If stdin has data, reads query from stdin
+    - Otherwise, starts interactive mode
+
     When called with a query string, executes that query and exits.
+
+    Examples:
+        saber                             # Start interactive mode
+        saber "show me all users"         # Run a single query
+        echo "show me all users" | saber  # Read query from stdin
     """
 
     async def run_session():
+        # Check if query_text is None and stdin has data
+        actual_query = query_text
+        if query_text is None and not sys.stdin.isatty():
+            # Read from stdin
+            actual_query = sys.stdin.read().strip()
+            if not actual_query:
+                # If stdin was empty, fall back to interactive mode
+                actual_query = None
+
         # Get database configuration or handle direct CSV file
         if database:
             # Check if this is a direct CSV file path
@@ -119,13 +138,13 @@ def query(
         agent = AnthropicSQLAgent(db_conn, db_name)
 
         try:
-            if query_text:
+            if actual_query:
                 # Single query mode with streaming
                 streaming_handler = StreamingQueryHandler(console)
                 console.print(
                     f"[bold blue]Connected to:[/bold blue] {db_name} {agent._get_database_type_name()}\n"
                 )
-                await streaming_handler.execute_streaming_query(query_text, agent)
+                await streaming_handler.execute_streaming_query(actual_query, agent)
             else:
                 # Interactive mode
                 session = InteractiveSession(console, agent)

{sqlsaber-0.9.0 → sqlsaber-0.11.0}/src/sqlsaber/cli/display.py

@@ -125,7 +125,6 @@ class DisplayManager:
                 {"name": "Schema", "style": "cyan"},
                 {"name": "Table Name", "style": "white"},
                 {"name": "Type", "style": "yellow"},
-                {"name": "Row Count", "justify": "right", "style": "magenta"},
             ]
             table = self._create_table(columns)
 
@@ -134,12 +133,8 @@ class DisplayManager:
                 schema = table_info.get("schema", "")
                 name = table_info.get("name", "")
                 table_type = table_info.get("type", "")
-                row_count = table_info.get("row_count", 0)
 
-                # Format row count with commas for readability
-                formatted_count = f"{row_count:,}" if row_count else "0"
-
-                table.add_row(schema, name, table_type, formatted_count)
+                table.add_row(schema, name, table_type)
 
             self.console.print(table)
 

{sqlsaber-0.9.0 → sqlsaber-0.11.0}/src/sqlsaber/database/schema.py

@@ -42,7 +42,7 @@ class BaseSchemaIntrospector(ABC):
         pass
 
     @abstractmethod
-    async def list_tables_info(self, connection) -> dict[str, Any]:
+    async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information."""
         pass
 
@@ -182,32 +182,31 @@ class PostgreSQLSchemaIntrospector(BaseSchemaIntrospector):
             """
             return await conn.fetch(pk_query)
 
-    async def list_tables_info(self, connection) -> dict[str, Any]:
+    async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for PostgreSQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
-            # Get tables with row counts
+            # Get tables without row counts for better performance
             tables_query = """
-                WITH table_stats AS (
-                    SELECT
-                        schemaname,
-                        relname as tablename,
-                        n_live_tup as approximate_row_count
-                    FROM pg_stat_user_tables
-                )
                 SELECT
                     t.table_schema,
                     t.table_name,
-                    t.table_type,
-                    COALESCE(ts.approximate_row_count, 0) as row_count
+                    t.table_type
                 FROM information_schema.tables t
-                LEFT JOIN table_stats ts
-                    ON t.table_schema = ts.schemaname
-                    AND t.table_name = ts.tablename
                 WHERE t.table_schema NOT IN ('pg_catalog', 'information_schema')
                 ORDER BY t.table_schema, t.table_name;
             """
-            return await conn.fetch(tables_query)
+            records = await conn.fetch(tables_query)
+
+            # Convert asyncpg.Record objects to dictionaries
+            return [
+                {
+                    "table_schema": record["table_schema"],
+                    "table_name": record["table_name"],
+                    "table_type": record["table_type"],
+                }
+                for record in records
+            ]
 
 
 class MySQLSchemaIntrospector(BaseSchemaIntrospector):
@@ -353,24 +352,33 @@ class MySQLSchemaIntrospector(BaseSchemaIntrospector):
                 await cursor.execute(pk_query)
                 return await cursor.fetchall()
 
-    async def list_tables_info(self, connection) -> dict[str, Any]:
+    async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for MySQL."""
         pool = await connection.get_pool()
         async with pool.acquire() as conn:
             async with conn.cursor() as cursor:
-                # Get tables with row counts
+                # Get tables without row counts for better performance
                 tables_query = """
                     SELECT
                         t.table_schema,
                         t.table_name,
-                        t.table_type,
-                        COALESCE(t.table_rows, 0) as row_count
+                        t.table_type
                     FROM information_schema.tables t
                     WHERE t.table_schema NOT IN ('information_schema', 'performance_schema', 'mysql', 'sys')
                     ORDER BY t.table_schema, t.table_name;
                 """
                 await cursor.execute(tables_query)
-                return await cursor.fetchall()
+                rows = await cursor.fetchall()
+
+                # Convert rows to dictionaries
+                return [
+                    {
+                        "table_schema": row["table_schema"],
+                        "table_name": row["table_name"],
+                        "table_type": row["table_type"],
+                    }
+                    for row in rows
+                ]
 
 
 class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
@@ -496,9 +504,9 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
         return primary_keys
 
-    async def list_tables_info(self, connection) -> dict[str, Any]:
+    async def list_tables_info(self, connection) -> list[dict[str, Any]]:
         """Get list of tables with basic information for SQLite."""
-        # First get the table names
+        # Get table names without row counts for better performance
         tables_query = """
             SELECT
                 'main' as table_schema,
@@ -512,34 +520,15 @@ class SQLiteSchemaIntrospector(BaseSchemaIntrospector):
 
         tables = await self._execute_query(connection, tables_query)
 
-        # Now get row counts for each table
-        result = []
-        for table in tables:
-            table_name = table["table_name"]
-            table_type = table["table_type"]
-
-            # Only count rows for tables, not views
-            if table_type.lower() == "table":
-                try:
-                    count_query = f"SELECT COUNT(*) as count FROM [{table_name}]"
-                    count_result = await self._execute_query(connection, count_query)
-                    row_count = count_result[0]["count"] if count_result else 0
-                except Exception:
-                    # If count fails (e.g., table locked), default to 0
-                    row_count = 0
-            else:
-                # For views, we don't count rows as it could be expensive
-                row_count = 0
-
-            result.append(
-                {
-                    "table_schema": table["table_schema"],
-                    "table_name": table_name,
-                    "table_type": table_type,
-                    "row_count": row_count,
-                }
-            )
-        return result
+        # Convert to expected format
+        return [
+            {
+                "table_schema": table["table_schema"],
+                "table_name": table["table_name"],
+                "table_type": table["table_type"],
+            }
+            for table in tables
+        ]
 
 
 class SchemaManager:
@@ -682,7 +671,7 @@ class SchemaManager:
                 )
 
     async def list_tables(self) -> dict[str, Any]:
-        """Get a list of all tables with basic information like row counts."""
+        """Get a list of all tables with basic information."""
         # Check cache first
         cache_key = "list_tables"
         cached_data = self._get_cached_tables(cache_key)
@@ -702,7 +691,6 @@ class SchemaManager:
                     "name": table["table_name"],
                     "full_name": f"{table['table_schema']}.{table['table_name']}",
                     "type": table["table_type"],
-                    "row_count": table["row_count"],
                 }
             )
 

{sqlsaber-0.9.0 → sqlsaber-0.11.0}/uv.lock

@@ -918,7 +918,7 @@ wheels = [
 
 [[package]]
 name = "sqlsaber"
-version = "0.9.0"
+version = "0.11.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiomysql" },

sqlsaber-0.9.0/src/sqlsaber/__init__.py

@@ -1,3 +0,0 @@
-"""SQLSaber CLI - SQL like Claude Code."""
-
-__version__ = "0.1.0"