Merge pull request #117 from Maxteabag/feature/execute-selection-by-default

Execute selection by default, fix comment execution, add gcS

Author: Maxteabag

sqlit/core/keymap.py

@@ -282,6 +282,7 @@ def _build_leader_commands(self) -> list[LeaderCommandDef]:
             LeaderCommandDef("k", "up", "Comment line up", "Comment", menu="gc"),
             LeaderCommandDef("G", "to_end", "Comment to end", "Comment", menu="gc"),
             LeaderCommandDef("s", "selection", "Toggle selection", "Comment", menu="gc"),
+            LeaderCommandDef("S", "statement", "Toggle statement", "Comment", menu="gc"),
             # ry results yank menu
             LeaderCommandDef("c", "cell", "Copy cell", "Copy", menu="ry"),
             LeaderCommandDef("y", "row", "Copy row", "Copy", menu="ry"),

sqlit/domains/query/app/alerts.py

@@ -46,8 +46,6 @@ class AlertSeverity(IntEnum):
 _DOUBLE_QUOTE_RE = re.compile(r'"[^"]*"')
 _BACKTICK_RE = re.compile(r"`[^`]*`")
 _BRACKET_RE = re.compile(r"\[[^\]]*]")
-_LINE_COMMENT_RE = re.compile(r"--[^\n]*")
-_BLOCK_COMMENT_RE = re.compile(r"/\*.*?\*/", re.DOTALL)
 
 
 def parse_alert_mode(value: str | int | None) -> AlertMode | None:
@@ -113,8 +111,9 @@ def _classify_statement(statement: str) -> AlertSeverity:
 
 def _strip_comments_and_literals(sql: str) -> str:
     """Remove comments and quoted literals/identifiers for keyword scanning."""
-    cleaned = _LINE_COMMENT_RE.sub("", sql)
-    cleaned = _BLOCK_COMMENT_RE.sub("", cleaned)
+    from sqlit.domains.query.editing.comments import strip_all_comments
+
+    cleaned = strip_all_comments(sql)
     cleaned = _SINGLE_QUOTE_RE.sub("''", cleaned)
     cleaned = _DOUBLE_QUOTE_RE.sub('""', cleaned)
     cleaned = _BACKTICK_RE.sub("``", cleaned)

sqlit/domains/query/app/multi_statement.py

@@ -257,6 +257,28 @@ def find_statement_at_cursor(sql: str, row: int, col: int) -> tuple[str, int, in
     return ranges[0] if ranges else None
 
 
+def get_executable_sql(sql: str) -> str:
+    """Get the SQL that will actually be executed.
+
+    Filters out comment-only statements and returns the remaining SQL
+    joined with semicolons. This should be used for display in confirm
+    dialogs to show exactly what will execute.
+
+    Args:
+        sql: Raw SQL that may contain comment-only statements.
+
+    Returns:
+        SQL string with comment-only statements removed.
+    """
+    from sqlit.domains.query.editing.comments import is_comment_only_statement
+
+    statements = split_statements(sql)
+    executable = [s for s in statements if not is_comment_only_statement(s)]
+    if not executable:
+        return ""
+    return "; ".join(executable)
+
+
 def split_statements(sql: str) -> list[str]:
     """Split SQL into individual statements.
 
@@ -400,8 +422,14 @@ def execute(self, sql: str, max_rows: int | None = None) -> MultiStatementResult
         Returns:
             MultiStatementResult containing results from all executed statements.
         """
+        from sqlit.domains.query.editing.comments import is_comment_only_statement
+
         statements = split_statements(sql)
 
+        # Filter out comment-only statements - they cause "empty query" errors
+        # in some database drivers that strip comments before execution
+        statements = [s for s in statements if not is_comment_only_statement(s)]
+
         if not statements:
             return MultiStatementResult(results=[], completed=True, error_index=None)
 

sqlit/domains/query/app/query_service.py

@@ -72,20 +72,25 @@ def classify(self, query: str) -> QueryKind:
         we check the last statement to determine if results should be returned.
         Uses the same splitting logic as multi_statement.split_statements.
         """
+        from sqlit.domains.query.editing.comments import (
+            is_comment_line,
+            is_comment_only_statement,
+        )
+
         from .multi_statement import split_statements
 
         statements = split_statements(query)
         if not statements:
             return QueryKind.NON_QUERY
 
-        # Filter out comment-only statements (lines starting with --)
-        # and find the last actual SQL statement
+        # Filter out comment-only statements and find the last actual SQL statement
         for stmt in reversed(statements):
-            # Skip comment-only lines
+            if is_comment_only_statement(stmt):
+                continue
+            # Found a statement with actual SQL - get first non-comment line
             lines = [line.strip() for line in stmt.split("\n") if line.strip()]
-            non_comment_lines = [line for line in lines if not line.startswith("--")]
+            non_comment_lines = [line for line in lines if not is_comment_line(line)]
             if non_comment_lines:
-                # Found a statement with actual SQL
                 first_line = non_comment_lines[0].upper()
                 first_word = first_line.split()[0] if first_line else ""
                 return QueryKind.RETURNS_ROWS if first_word in SELECT_KEYWORDS else QueryKind.NON_QUERY

sqlit/domains/query/app/transaction.py

@@ -274,6 +274,8 @@ def atomic_execute(
         Raises:
             Exception: If any statement fails (after rollback).
         """
+        from sqlit.domains.query.editing.comments import is_comment_only_statement
+
         from .multi_statement import (
             MultiStatementResult,
             StatementResult,
@@ -285,6 +287,9 @@ def atomic_execute(
         sql = normalize_for_execution(sql)
         statements = split_statements(sql)
 
+        # Filter out comment-only statements
+        statements = [s for s in statements if not is_comment_only_statement(s)]
+
         # Create a dedicated connection for this atomic operation
         conn = self.provider.connection_factory.connect(self.config)
         try:

sqlit/domains/query/editing/comments.py

@@ -1,9 +1,94 @@
-"""Comment toggle helpers for SQL editing."""
+"""SQL comment handling - detection, toggling, and stripping.
+
+This module is the single source of truth for SQL comment logic.
+All comment-related operations should use these functions.
+"""
 
 from __future__ import annotations
 
+import re
+
 SQL_COMMENT_PREFIX = "-- "
 
+# Regex patterns for comment stripping
+_LINE_COMMENT_RE = re.compile(r"--[^\n]*")
+_BLOCK_COMMENT_RE = re.compile(r"/\*.*?\*/", re.DOTALL)
+
+
+def is_comment_line(line: str) -> bool:
+    """Check if a line is a SQL line comment.
+
+    Args:
+        line: A single line of text.
+
+    Returns:
+        True if the line (after stripping whitespace) starts with --.
+    """
+    return line.strip().startswith("--")
+
+
+def is_comment_only_statement(statement: str) -> bool:
+    """Check if a SQL statement contains only comments (no actual SQL).
+
+    A statement is comment-only if every non-empty line starts with --.
+    This is used to filter out statements that would cause "empty query"
+    errors in database drivers that strip comments before execution.
+
+    Args:
+        statement: A SQL statement (may be multi-line).
+
+    Returns:
+        True if the statement contains only comments.
+    """
+    lines = statement.strip().split("\n")
+    for line in lines:
+        stripped = line.strip()
+        if stripped and not stripped.startswith("--"):
+            return False
+    return True
+
+
+def strip_line_comments(sql: str) -> str:
+    """Remove all line comments (-- ...) from SQL.
+
+    Note: This is a simple regex-based approach that doesn't account for
+    -- inside string literals. For keyword detection this is usually fine,
+    but for actual SQL transformation, use with caution.
+
+    Args:
+        sql: SQL text that may contain line comments.
+
+    Returns:
+        SQL with line comments removed.
+    """
+    return _LINE_COMMENT_RE.sub("", sql)
+
+
+def strip_block_comments(sql: str) -> str:
+    """Remove all block comments (/* ... */) from SQL.
+
+    Args:
+        sql: SQL text that may contain block comments.
+
+    Returns:
+        SQL with block comments removed.
+    """
+    return _BLOCK_COMMENT_RE.sub("", sql)
+
+
+def strip_all_comments(sql: str) -> str:
+    """Remove all comments (both line and block) from SQL.
+
+    Args:
+        sql: SQL text that may contain comments.
+
+    Returns:
+        SQL with all comments removed.
+    """
+    result = strip_block_comments(sql)
+    result = strip_line_comments(result)
+    return result
+
 
 def toggle_comment_lines(text: str, start_row: int, end_row: int) -> tuple[str, int]:
     """Toggle SQL comments on a range of lines.
@@ -30,9 +115,8 @@ def toggle_comment_lines(text: str, start_row: int, end_row: int) -> tuple[str,
     # Determine if we should comment or uncomment based on first non-empty line
     should_comment = True
     for row in range(start_row, end_row + 1):
-        stripped = lines[row].lstrip()
-        if stripped:
-            should_comment = not stripped.startswith("--")
+        if lines[row].strip():
+            should_comment = not is_comment_line(lines[row])
             break
 
     # Apply toggle to each line

sqlit/domains/query/ui/mixins/query_editing_comments.py

@@ -90,3 +90,30 @@ def action_gc_selection(self: QueryMixinHost) -> None:
         new_text, new_col = toggle_comment_lines(text, start_row, end_row)
         self.query_input.text = new_text
         self.query_input.cursor_location = (start_row, new_col)
+
+    def action_gc_statement(self: QueryMixinHost) -> None:
+        """Toggle comment on statement at cursor (gcS)."""
+        self._clear_leader_pending()
+        from sqlit.domains.query.app.multi_statement import find_statement_at_cursor
+        from sqlit.domains.query.editing.comments import toggle_comment_lines
+
+        text = self.query_input.text
+        if not text or not text.strip():
+            return
+
+        row, col = self.query_input.cursor_location
+        result = find_statement_at_cursor(text, row, col)
+
+        if result is None:
+            return
+
+        _, start_offset, end_offset = result
+
+        # Convert character offsets to line numbers
+        start_row = text[:start_offset].count("\n")
+        end_row = text[:end_offset].count("\n")
+
+        self._push_undo_state()
+        new_text, new_col = toggle_comment_lines(text, start_row, end_row)
+        self.query_input.text = new_text
+        self.query_input.cursor_location = (start_row, new_col)

sqlit/domains/query/ui/mixins/query_execution.py

@@ -52,7 +52,7 @@ def action_execute_query_atomic(self: QueryMixinHost) -> None:
             self.notify("Connect to a server to execute queries", severity="warning")
             return
 
-        query = self.query_input.text.strip()
+        query = self._get_query_to_execute()
 
         if not query:
             self.notify("No query to execute", severity="warning")
@@ -113,13 +113,36 @@ def _proceed() -> None:
 
         self._maybe_confirm_query(statement, _proceed)
 
+    def _get_query_to_execute(self: QueryMixinHost) -> str:
+        """Return selected text if present, otherwise the full query."""
+        selection = self.query_input.selection
+        if selection.start != selection.end:
+            from sqlit.domains.query.editing import get_selection_text
+
+            start = selection.start
+            end = selection.end
+            if start > end:
+                start, end = end, start
+
+            selected_sql = get_selection_text(
+                self.query_input.text,
+                start[0],
+                start[1],
+                end[0],
+                end[1],
+            )
+            if selected_sql and selected_sql.strip():
+                return selected_sql.strip()
+
+        return self.query_input.text.strip()
+
     def _execute_query_common(self: QueryMixinHost, keep_insert_mode: bool) -> None:
         """Common query execution logic."""
         if self.current_connection is None or self.current_provider is None:
             self.notify("Connect to a server to execute queries", severity="warning")
             return
 
-        query = self.query_input.text.strip()
+        query = self._get_query_to_execute()
 
         if not query:
             self.notify("No query to execute", severity="warning")
@@ -148,6 +171,7 @@ def _maybe_confirm_query(self: QueryMixinHost, query: str, proceed: Callable[[],
             format_alert_mode,
             should_confirm,
         )
+        from sqlit.domains.query.app.multi_statement import get_executable_sql
         from sqlit.shared.ui.screens.confirm import ConfirmScreen
 
         raw_mode = getattr(self.services.runtime, "query_alert_mode", 0) or 0
@@ -160,7 +184,14 @@ def _maybe_confirm_query(self: QueryMixinHost, query: str, proceed: Callable[[],
             proceed()
             return
 
-        severity = classify_query_alert(query)
+        # Get the SQL that will actually execute (without comment-only statements)
+        executable_sql = get_executable_sql(query)
+        if not executable_sql:
+            # Nothing to execute after filtering comments
+            proceed()
+            return
+
+        severity = classify_query_alert(executable_sql)
         if severity == AlertSeverity.NONE or not should_confirm(mode, severity):
             proceed()
             return
@@ -171,13 +202,6 @@ def _maybe_confirm_query(self: QueryMixinHost, query: str, proceed: Callable[[],
         elif severity == AlertSeverity.WRITE:
             title = "Confirm write query"
 
-        description = None
-        snippet = query.strip().splitlines()[0] if query.strip() else ""
-        if snippet:
-            if len(snippet) > 120:
-                snippet = snippet[:117] + "..."
-            description = snippet
-
         def _on_result(confirmed: bool | None) -> None:
             if confirmed:
                 proceed()
@@ -188,7 +212,7 @@ def _on_result(confirmed: bool | None) -> None:
             )
 
         self.push_screen(
-            ConfirmScreen(title, description, yes_label="Run", no_label="Cancel"),
+            ConfirmScreen(title, executable_sql, yes_label="Yes", no_label="No"),
             _on_result,
         )
 
@@ -386,17 +410,20 @@ async def _run_query_async(self: QueryMixinHost, query: str, keep_insert_mode: b
 
         # Use TransactionExecutor for transaction-aware query execution
         executor = self._get_transaction_executor(config, provider)
-        # Check if this is a multi-statement query
+        # Check if this is a multi-statement query (after filtering comment-only statements)
+        from sqlit.domains.query.editing.comments import is_comment_only_statement
+
         statements = split_statements(query)
-        is_multi_statement = len(statements) > 1
+        executable_statements = [s for s in statements if not is_comment_only_statement(s)]
+        is_multi_statement = len(executable_statements) > 1
 
         try:
             start_time = time.perf_counter()
             max_rows = self.services.runtime.max_rows or MAX_FETCH_ROWS
 
             use_process_worker = self._use_process_worker(provider)
-            if use_process_worker and statements:
-                statement = statements[0].strip()
+            if use_process_worker and executable_statements:
+                statement = executable_statements[0].strip()
                 if self.in_transaction or is_transaction_start(statement) or is_transaction_end(statement):
                     use_process_worker = False
 

sqlit/shared/ui/screens/confirm.py

@@ -28,12 +28,16 @@ class ConfirmScreen(ModalScreen):
     }
 
     #confirm-dialog {
-        width: 36;
+        width: auto;
+        min-width: 36;
+        max-width: 80%;
     }
 
     #confirm-description {
         margin-bottom: 1;
         color: $text-muted;
+        max-height: 20;
+        overflow-y: auto;
     }
 
     #confirm-list {