enhance

Author: JingsongLi

docs/content/pypaimon/cli.md

@@ -670,27 +670,56 @@ paimon sql "SELECT * FROM users LIMIT 5" --format json
 
 ### Interactive REPL
 
-Start an interactive SQL session by running `paimon sql` without a query argument:
+Start an interactive SQL session by running `paimon sql` without a query argument. The REPL supports arrow keys for line editing, and command history is persisted across sessions in `~/.paimon_history`.
 
 ```shell
 paimon sql
 ```
 
 Output:
 ```
-Paimon SQL (powered by pypaimon-rust + DataFusion)
-Type your SQL queries. Use Ctrl+D or 'exit' to quit.
+    ____        _
+   / __ \____ _(_)___ ___  ____  ____
+  / /_/ / __ `/ / __ `__ \/ __ \/ __ \
+ / ____/ /_/ / / / / / / / /_/ / / / /
+/_/    \__,_/_/_/ /_/ /_/\____/_/ /_/
 
-paimon> SELECT count(*) AS cnt FROM users
- cnt
-   5
+  Powered by pypaimon-rust + DataFusion
+  Type 'help' for usage, 'exit' to quit.
 
-paimon> SELECT * FROM users WHERE age > 25 ORDER BY age
- id    name  age      city
-  2     Bob   30  Shanghai
-  3 Charlie   35 Guangzhou
+paimon> SHOW DATABASES;
+default
+mydb
+
+paimon> USE mydb;
+Using database 'mydb'.
+
+paimon> SHOW TABLES;
+orders
+users
+
+paimon> SELECT count(*) AS cnt
+     > FROM users
+     > WHERE age > 18;
+ cnt
+  42
+(1 row in 0.05s)
 
 paimon> exit
+Bye!
 ```
 
+SQL statements end with `;` and can span multiple lines. The continuation prompt `     >` indicates that more input is expected.
+
+**REPL Commands:**
+
+| Command | Description |
+|---|---|
+| `USE <database>;` | Switch the default database |
+| `SHOW DATABASES;` | List all databases |
+| `SHOW TABLES;` | List tables in the current database |
+| `SELECT ...;` | Execute a SQL query |
+| `help` | Show usage information |
+| `exit` / `quit` | Exit the REPL |
+
 For more details on SQL syntax and the Python API, see [SQL Query]({{< ref "pypaimon/sql" >}}).

paimon-python/pypaimon/cli/cli_sql.py

@@ -21,7 +21,62 @@
 This module provides SQL query capability via pypaimon-rust + DataFusion.
 """
 
+import os
+import re
 import sys
+import time
+
+_PAIMON_BANNER = r"""
+    ____        _
+   / __ \____ _(_)___ ___  ____  ____
+  / /_/ / __ `/ / __ `__ \/ __ \/ __ \
+ / ____/ /_/ / / / / / / / /_/ / / / /
+/_/    \__,_/_/_/ /_/ /_/\____/_/ /_/
+
+  Powered by pypaimon-rust + DataFusion
+  Type 'help' for usage, 'exit' to quit.
+"""
+
+_USE_PATTERN = re.compile(
+    r"^\s*use\s+(\w+)\s*;?\s*$",
+    re.IGNORECASE,
+)
+
+_SHOW_DATABASES_PATTERN = re.compile(
+    r"^\s*show\s+databases\s*;?\s*$",
+    re.IGNORECASE,
+)
+
+_SHOW_TABLES_PATTERN = re.compile(
+    r"^\s*show\s+tables\s*;?\s*$",
+    re.IGNORECASE,
+)
+
+_HISTORY_FILE = os.path.expanduser("~/.paimon_history")
+_HISTORY_MAX_LENGTH = 1000
+
+_PROMPT = "paimon> "
+_CONTINUATION_PROMPT = "     > "
+
+
+def _setup_readline():
+    """Enable readline for arrow key support and persistent command history."""
+    try:
+        import readline
+        readline.set_history_length(_HISTORY_MAX_LENGTH)
+        if os.path.exists(_HISTORY_FILE):
+            readline.read_history_file(_HISTORY_FILE)
+    except ImportError:
+        pass
+
+
+def _save_history():
+    """Save readline history to file."""
+    try:
+        import readline
+        readline.write_history_file(_HISTORY_FILE)
+    except (ImportError, OSError):
+        pass
 
 
 def cmd_sql(args):
@@ -59,43 +114,170 @@ def _execute_query(catalog, query, output_format):
         print(f"Error: {e}", file=sys.stderr)
         sys.exit(1)
 
+    _print_result(result, output_format)
+
+
+def _print_result(result, output_format, elapsed=None):
+    """Print a PyArrow Table in the requested format."""
+    df = result.to_pandas()
     if output_format == 'json':
         import json
-        df = result.to_pandas()
         print(json.dumps(df.to_dict(orient='records'), ensure_ascii=False))
     else:
-        df = result.to_pandas()
         print(df.to_string(index=False))
 
+    row_count = len(df)
+    if elapsed is not None:
+        print(f"({row_count} {'row' if row_count == 1 else 'rows'} in {elapsed:.2f}s)")
+    else:
+        print(f"({row_count} {'row' if row_count == 1 else 'rows'})")
 
-def _interactive_repl(catalog, output_format):
-    """Run an interactive SQL REPL."""
-    print("Paimon SQL (powered by pypaimon-rust + DataFusion)")
-    print("Type your SQL queries. Use Ctrl+D or 'exit' to quit.\n")
 
+def _read_multiline_query():
+    """Read a potentially multi-line SQL query, terminated by ';'.
+
+    Returns the complete query string, or None on EOF/interrupt.
+    """
+    lines = []
+    prompt = _PROMPT
     while True:
         try:
-            query = input("paimon> ").strip()
+            line = input(prompt)
         except (EOFError, KeyboardInterrupt):
-            print()
-            break
+            if lines:
+                # Cancel current multi-line input
+                print()
+                return ""
+            return None
+
+        lines.append(line)
+        joined = "\n".join(lines).strip()
 
-        if not query:
+        if not joined:
+            lines.clear()
+            prompt = _PROMPT
             continue
-        if query.lower() in ('exit', 'quit'):
-            break
 
-        try:
-            result = catalog.sql(query)
-            df = result.to_pandas()
-            if output_format == 'json':
-                import json
-                print(json.dumps(df.to_dict(orient='records'), ensure_ascii=False))
-            else:
-                print(df.to_string(index=False))
-            print()
-        except Exception as e:
-            print(f"Error: {e}\n", file=sys.stderr)
+        # Single-word commands that don't need ';'
+        lower = joined.lower().rstrip(';').strip()
+        if lower in ('exit', 'quit', 'help'):
+            return joined
+
+        # USE / SHOW commands don't strictly need ';' either
+        if _USE_PATTERN.match(joined) or _SHOW_DATABASES_PATTERN.match(joined) or _SHOW_TABLES_PATTERN.match(joined):
+            return joined
+
+        # For SQL statements, wait for ';'
+        if joined.endswith(';'):
+            return joined
+
+        prompt = _CONTINUATION_PROMPT
+
+
+def _handle_use(catalog, match):
+    """Handle USE <database> command."""
+    database = match.group(1)
+    try:
+        catalog._get_sql_context().use_database(database)
+        print(f"Using database '{database}'.")
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+
+
+def _handle_show_databases(catalog):
+    """Handle SHOW DATABASES command."""
+    try:
+        databases = catalog.list_databases()
+        for db in databases:
+            print(db)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+
+
+def _handle_show_tables(catalog):
+    """Handle SHOW TABLES command."""
+    try:
+        ctx = catalog._get_sql_context()
+        database = ctx._default_database
+        tables = catalog.list_tables(database)
+        for table in tables:
+            print(table)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+
+
+def _interactive_repl(catalog, output_format):
+    """Run an interactive SQL REPL."""
+    _setup_readline()
+    print(_PAIMON_BANNER)
+
+    try:
+        while True:
+            query = _read_multiline_query()
+            if query is None:
+                print("\nBye!")
+                break
+
+            if not query:
+                continue
+
+            lower = query.lower().rstrip(';').strip()
+            if lower in ('exit', 'quit'):
+                print("Bye!")
+                break
+            if lower == 'help':
+                _print_help()
+                continue
+
+            # Handle USE <database>
+            use_match = _USE_PATTERN.match(query)
+            if use_match:
+                _handle_use(catalog, use_match)
+                continue
+
+            # Handle SHOW DATABASES
+            if _SHOW_DATABASES_PATTERN.match(query):
+                _handle_show_databases(catalog)
+                print()
+                continue
+
+            # Handle SHOW TABLES
+            if _SHOW_TABLES_PATTERN.match(query):
+                _handle_show_tables(catalog)
+                print()
+                continue
+
+            try:
+                start = time.time()
+                result = catalog.sql(query)
+                elapsed = time.time() - start
+                _print_result(result, output_format, elapsed)
+                print()
+            except Exception as e:
+                print(f"Error: {e}\n", file=sys.stderr)
+    finally:
+        _save_history()
+
+
+def _print_help():
+    """Print REPL help information."""
+    print("""
+Commands:
+  USE <database>;              Switch the default database
+  SHOW DATABASES;              List all databases
+  SHOW TABLES;                 List tables in the current database
+  SELECT ... FROM <table>;     Execute a SQL query
+  exit / quit                  Exit the REPL
+
+Table reference:
+  <table>                      Table in the current default database
+  <database>.<table>           Table in a specific database
+
+Tips:
+  - SQL statements end with ';' and can span multiple lines
+  - Arrow keys are supported for line editing and command history
+  - Command history is saved across sessions (~/.paimon_history)
+""")
 
 
 def add_sql_subcommand(subparsers):

paimon-python/pypaimon/sql/sql_context.py

@@ -70,6 +70,11 @@ def sql(self, query: str) -> pa.Table:
         batches = df.collect()
         return pa.Table.from_batches(batches)
 
+    def use_database(self, database: str):
+        """Switch the default database."""
+        self._default_database = database
+        self._ctx.sql(f"SET datafusion.catalog.default_schema = '{database}'")
+
     def sql_to_pandas(self, query: str):
         """Execute a SQL query and return the result as a Pandas DataFrame."""
         return self.sql(query).to_pandas()