Add -f/--file option to execute SQL commands from file

   Implements the -f/--file command-line option similar to psql's behavior.
   This allows executing SQL commands from a file and then exiting.

   Features:
   - Support for -f and --file (short and long forms)
   - Multiple files can be specified (-f file1 -f file2)
   - Can be combined with -c option (-c commands execute first, then -f files)
   - Pager is disabled in file mode (consistent with -c behavior)
   - Comprehensive BDD tests added for all scenarios
   - Version bumped to 4.3.1

Author: DiegoDAF

changelog.rst

@@ -12,6 +12,10 @@ Features:
 * Add support for `single-command` to run a SQL command and exit.
     * Command line option `-c` or `--command`.
     * You can specify multiple times.
+* Add support for `file` to execute commands from a file and exit.
+    * Command line option `-f` or `--file`.
+    * You can specify multiple times.
+    * Similar to psql's `-f` option.
 
 Internal:
 ---------

pgcli/__init__.py

@@ -1 +1 @@
-__version__ = "4.3.0"
+__version__ = "4.3.1"

pgcli/main.py

@@ -911,14 +911,33 @@ def _check_ongoing_transaction_and_allow_quitting(self):
     def run_cli(self):
         logger = self.logger
 
-        # Handle command mode (-c flag) - similar to psql behavior
-        # Multiple -c options are executed sequentially
-        if hasattr(self, 'commands') and self.commands:
+        # Handle command mode (-c flag) and/or file mode (-f flag)
+        # Similar to psql behavior: execute commands/files and exit
+        has_commands = hasattr(self, 'commands') and self.commands
+        has_input_files = hasattr(self, 'input_files') and self.input_files
+
+        if has_commands or has_input_files:
             try:
-                for command in self.commands:
-                    logger.debug("Running command: %s", command)
-                    # Execute the command using the same logic as interactive mode
-                    self.handle_watch_command(command)
+                # Execute -c commands first, if any
+                if has_commands:
+                    for command in self.commands:
+                        logger.debug("Running command: %s", command)
+                        self.handle_watch_command(command)
+
+                # Then execute commands from files, if provided
+                # Multiple -f options are executed sequentially
+                if has_input_files:
+                    for input_file in self.input_files:
+                        logger.debug("Reading commands from file: %s", input_file)
+                        with open(input_file, 'r', encoding='utf-8') as f:
+                            file_content = f.read()
+
+                        # Execute the entire file content as a single command
+                        # This matches psql behavior where the file is treated as one unit
+                        if file_content.strip():
+                            logger.debug("Executing commands from file: %s", input_file)
+                            self.handle_watch_command(file_content)
+
             except PgCliQuitError:
                 # Normal exit from quit command
                 sys.exit(0)
@@ -1297,8 +1316,10 @@ def is_too_tall(self, lines):
         return len(lines) >= (self.prompt_app.output.get_size().rows - 4)
 
     def echo_via_pager(self, text, color=None):
-        # Disable pager for -c/--command mode and \watch command
-        if self.pgspecial.pager_config == PAGER_OFF or self.watch_command or (hasattr(self, 'commands') and self.commands):
+        # Disable pager for -c/--command mode, -f/--file mode, and \watch command
+        has_commands = hasattr(self, 'commands') and self.commands
+        has_input_files = hasattr(self, 'input_files') and self.input_files
+        if self.pgspecial.pager_config == PAGER_OFF or self.watch_command or has_commands or has_input_files:
             click.echo(text, color=color)
         elif self.pgspecial.pager_config == PAGER_LONG_OUTPUT and self.table_format != "csv":
             lines = text.split("\n")
@@ -1453,6 +1474,14 @@ def echo_via_pager(self, text, color=None):
     multiple=True,
     help="run command (SQL or internal) and exit. Multiple -c options are allowed.",
 )
+@click.option(
+    "-f",
+    "--file",
+    "input_files",
+    multiple=True,
+    type=click.Path(exists=True, readable=True, dir_okay=False),
+    help="execute commands from file, then exit. Multiple -f options are allowed.",
+)
 @click.argument("dbname", default=lambda: None, envvar="PGDATABASE", nargs=1)
 @click.argument("username", default=lambda: None, envvar="PGUSER", nargs=1)
 def cli(
@@ -1482,6 +1511,7 @@ def cli(
     init_command: str,
     log_file: str,
     commands: tuple,
+    input_files: tuple,
 ):
     if version:
         print("Version:", __version__)
@@ -1545,6 +1575,9 @@ def cli(
     # Store commands for -c option (can be multiple)
     pgcli.commands = commands if commands else None
 
+    # Store file paths for -f option (can be multiple)
+    pgcli.input_files = input_files if input_files else None
+
     # Choose which ever one has a valid value.
     if dbname_opt and dbname:
         # work as psql: when database is given as option and argument use the argument as user

tests/features/command_option.feature

@@ -3,7 +3,7 @@ Feature: run the cli with -c/--command option,
   and exit
 
   Scenario: run pgcli with -c and a SQL query
-     When we run pgcli with -c "SELECT 1 as test_column"
+     When we run pgcli with -c "SELECT 1 as test_diego_column"
       then we see the query result
       and pgcli exits successfully
 

tests/features/file_option.feature

@@ -0,0 +1,39 @@
+Feature: run the cli with -f/--file option,
+  execute commands from file,
+  and exit
+
+  Scenario: run pgcli with -f and a SQL query file
+     When we create a file with "SELECT 1 as test_diego_column"
+      and we run pgcli with -f and the file
+     then we see the query result
+      and pgcli exits successfully
+
+  Scenario: run pgcli with --file and a SQL query file
+     When we create a file with "SELECT 'hello' as greeting"
+      and we run pgcli with --file and the file
+     then we see the query result
+      and pgcli exits successfully
+
+  Scenario: run pgcli with -f and a file with special command
+     When we create a file with "\dt"
+      and we run pgcli with -f and the file
+     then we see the command output
+      and pgcli exits successfully
+
+  Scenario: run pgcli with -f and a file with multiple statements
+     When we create a file with "SELECT 1; SELECT 2"
+      and we run pgcli with -f and the file
+     then we see both query results
+      and pgcli exits successfully
+
+  Scenario: run pgcli with -f and a file with an invalid query
+     When we create a file with "SELECT invalid_column FROM nonexistent_table"
+      and we run pgcli with -f and the file
+     then we see an error message
+      and pgcli exits successfully
+
+  Scenario: run pgcli with both -c and -f options
+     When we create a file with "SELECT 2 as second"
+      and we run pgcli with -c "SELECT 1 as first" and -f with the file
+     then we see both query results
+      and pgcli exits successfully

tests/features/steps/command_option.py

@@ -67,7 +67,7 @@ def step_see_query_result(context):
     # Check for common query result indicators
     assert any([
         "SELECT" in output,
-        "test_column" in output,
+        "test_diego_column" in output,
         "greeting" in output,
         "hello" in output,
         "+-" in output,  # table border

tests/features/steps/file_option.py

@@ -0,0 +1,117 @@
+"""
+Steps for testing -f/--file option behavioral tests.
+Reuses common steps from command_option.py
+"""
+
+import subprocess
+import tempfile
+import os
+from behave import when
+
+
+@when('we create a file with "{content}"')
+def step_create_file_with_content(context, content):
+    """Create a temporary file with the given content."""
+    # Create a temporary file that will be cleaned up automatically
+    temp_file = tempfile.NamedTemporaryFile(
+        mode='w',
+        delete=False,
+        suffix='.sql'
+    )
+    temp_file.write(content)
+    temp_file.close()
+    context.temp_file_path = temp_file.name
+
+
+@when('we run pgcli with -f and the file')
+def step_run_pgcli_with_f(context):
+    """Run pgcli with -f flag and the temporary file."""
+    cmd = [
+        "pgcli",
+        "-h", context.conf["host"],
+        "-p", str(context.conf["port"]),
+        "-U", context.conf["user"],
+        "-d", context.conf["dbname"],
+        "-f", context.temp_file_path
+    ]
+    try:
+        context.cmd_output = subprocess.check_output(
+            cmd,
+            cwd=context.package_root,
+            stderr=subprocess.STDOUT,
+            timeout=5
+        )
+        context.exit_code = 0
+    except subprocess.CalledProcessError as e:
+        context.cmd_output = e.output
+        context.exit_code = e.returncode
+    except subprocess.TimeoutExpired as e:
+        context.cmd_output = b"Command timed out"
+        context.exit_code = -1
+    finally:
+        # Clean up the temporary file
+        if hasattr(context, 'temp_file_path') and os.path.exists(context.temp_file_path):
+            os.unlink(context.temp_file_path)
+
+
+@when('we run pgcli with --file and the file')
+def step_run_pgcli_with_file(context):
+    """Run pgcli with --file flag and the temporary file."""
+    cmd = [
+        "pgcli",
+        "-h", context.conf["host"],
+        "-p", str(context.conf["port"]),
+        "-U", context.conf["user"],
+        "-d", context.conf["dbname"],
+        "--file", context.temp_file_path
+    ]
+    try:
+        context.cmd_output = subprocess.check_output(
+            cmd,
+            cwd=context.package_root,
+            stderr=subprocess.STDOUT,
+            timeout=5
+        )
+        context.exit_code = 0
+    except subprocess.CalledProcessError as e:
+        context.cmd_output = e.output
+        context.exit_code = e.returncode
+    except subprocess.TimeoutExpired as e:
+        context.cmd_output = b"Command timed out"
+        context.exit_code = -1
+    finally:
+        # Clean up the temporary file
+        if hasattr(context, 'temp_file_path') and os.path.exists(context.temp_file_path):
+            os.unlink(context.temp_file_path)
+
+
+@when('we run pgcli with -c "{command}" and -f with the file')
+def step_run_pgcli_with_c_and_f(context, command):
+    """Run pgcli with both -c and -f flags."""
+    cmd = [
+        "pgcli",
+        "-h", context.conf["host"],
+        "-p", str(context.conf["port"]),
+        "-U", context.conf["user"],
+        "-d", context.conf["dbname"],
+        "-c", command,
+        "-f", context.temp_file_path
+    ]
+    try:
+        context.cmd_output = subprocess.check_output(
+            cmd,
+            cwd=context.package_root,
+            stderr=subprocess.STDOUT,
+            timeout=5
+        )
+        context.exit_code = 0
+    except subprocess.CalledProcessError as e:
+        context.cmd_output = e.output
+        context.exit_code = e.returncode
+    except subprocess.TimeoutExpired as e:
+        context.cmd_output = b"Command timed out"
+        context.exit_code = -1
+    finally:
+        # Clean up the temporary file
+        if hasattr(context, 'temp_file_path') and os.path.exists(context.temp_file_path):
+            os.unlink(context.temp_file_path)