Fix Oracle adapter cursor leak

Author: Maxteabag

sqlit/core/keymap.py

@@ -376,8 +376,6 @@ def _build_action_keys(self) -> list[ActionKeyDef]:
             ActionKeyDef("z", "toggle_result_section", "results"),
             ActionKeyDef("escape", "results_filter_close", "results_filter"),
             ActionKeyDef("enter", "results_filter_accept", "results_filter"),
-            ActionKeyDef("n", "results_filter_next", "results_filter"),
-            ActionKeyDef("N", "results_filter_prev", "results_filter"),
             # Value view
             ActionKeyDef("q", "close_value_view", "value_view"),
             ActionKeyDef("escape", "close_value_view", "value_view"),

sqlit/domains/connections/providers/oracle/adapter.py

@@ -100,110 +100,144 @@ def get_databases(self, conn: Any) -> list[str]:
     def get_tables(self, conn: Any, database: str | None = None) -> list[TableInfo]:
         """Get list of tables from Oracle. Returns (schema, name) with empty schema."""
         cursor = conn.cursor()
-        cursor.execute("SELECT table_name FROM user_tables ORDER BY table_name")
-        # user_tables returns only current user's tables, so no schema prefix needed
-        return [("", row[0]) for row in cursor.fetchall()]
+        try:
+            cursor.execute("SELECT table_name FROM user_tables ORDER BY table_name")
+            # user_tables returns only current user's tables, so no schema prefix needed
+            return [("", row[0]) for row in cursor.fetchall()]
+        finally:
+            cursor.close()
 
     def get_views(self, conn: Any, database: str | None = None) -> list[TableInfo]:
         """Get list of views from Oracle. Returns (schema, name) with empty schema."""
         cursor = conn.cursor()
-        cursor.execute("SELECT view_name FROM user_views ORDER BY view_name")
-        return [("", row[0]) for row in cursor.fetchall()]
+        try:
+            cursor.execute("SELECT view_name FROM user_views ORDER BY view_name")
+            return [("", row[0]) for row in cursor.fetchall()]
+        finally:
+            cursor.close()
 
     def get_columns(
         self, conn: Any, table: str, database: str | None = None, schema: str | None = None
     ) -> list[ColumnInfo]:
         """Get columns for a table from Oracle. Schema parameter is ignored."""
-        cursor = conn.cursor()
-
         # Get primary key columns
-        cursor.execute(
-            "SELECT cols.column_name "
-            "FROM user_constraints cons "
-            "JOIN user_cons_columns cols ON cons.constraint_name = cols.constraint_name "
-            "WHERE cons.constraint_type = 'P' AND cons.table_name = :1",
-            (table.upper(),),
-        )
-        pk_columns = {row[0] for row in cursor.fetchall()}
+        pk_cursor = conn.cursor()
+        try:
+            pk_cursor.execute(
+                "SELECT cols.column_name "
+                "FROM user_constraints cons "
+                "JOIN user_cons_columns cols ON cons.constraint_name = cols.constraint_name "
+                "WHERE cons.constraint_type = 'P' AND cons.table_name = :1",
+                (table.upper(),),
+            )
+            pk_columns = {row[0] for row in pk_cursor.fetchall()}
+        finally:
+            pk_cursor.close()
 
         # Get all columns
-        cursor.execute(
-            "SELECT column_name, data_type FROM user_tab_columns " "WHERE table_name = :1 ORDER BY column_id",
-            (table.upper(),),
-        )
-        return [ColumnInfo(name=row[0], data_type=row[1], is_primary_key=row[0] in pk_columns) for row in cursor.fetchall()]
+        cursor = conn.cursor()
+        try:
+            cursor.execute(
+                "SELECT column_name, data_type FROM user_tab_columns " "WHERE table_name = :1 ORDER BY column_id",
+                (table.upper(),),
+            )
+            return [ColumnInfo(name=row[0], data_type=row[1], is_primary_key=row[0] in pk_columns) for row in cursor.fetchall()]
+        finally:
+            cursor.close()
 
     def get_procedures(self, conn: Any, database: str | None = None) -> list[str]:
         """Get stored procedures from Oracle."""
         cursor = conn.cursor()
-        cursor.execute(
-            "SELECT object_name FROM user_procedures " "WHERE object_type = 'PROCEDURE' ORDER BY object_name"
-        )
-        return [row[0] for row in cursor.fetchall()]
+        try:
+            cursor.execute(
+                "SELECT object_name FROM user_procedures " "WHERE object_type = 'PROCEDURE' ORDER BY object_name"
+            )
+            return [row[0] for row in cursor.fetchall()]
+        finally:
+            cursor.close()
 
     def get_indexes(self, conn: Any, database: str | None = None) -> list[IndexInfo]:
         """Get indexes from Oracle."""
         cursor = conn.cursor()
-        cursor.execute(
-            "SELECT index_name, table_name, uniqueness "
-            "FROM user_indexes "
-            "WHERE index_type != 'LOB' "
-            "ORDER BY table_name, index_name"
-        )
-        return [
-            IndexInfo(name=row[0], table_name=row[1], is_unique=row[2] == "UNIQUE")
-            for row in cursor.fetchall()
-        ]
+        try:
+            cursor.execute(
+                "SELECT index_name, table_name, uniqueness "
+                "FROM user_indexes "
+                "WHERE index_type != 'LOB' "
+                "ORDER BY table_name, index_name"
+            )
+            return [
+                IndexInfo(name=row[0], table_name=row[1], is_unique=row[2] == "UNIQUE")
+                for row in cursor.fetchall()
+            ]
+        finally:
+            cursor.close()
 
     def get_triggers(self, conn: Any, database: str | None = None) -> list[TriggerInfo]:
         """Get triggers from Oracle."""
         cursor = conn.cursor()
-        cursor.execute(
-            "SELECT trigger_name, table_name "
-            "FROM user_triggers "
-            "WHERE base_object_type = 'TABLE' "
-            "ORDER BY table_name, trigger_name"
-        )
-        return [TriggerInfo(name=row[0], table_name=row[1] or "") for row in cursor.fetchall()]
+        try:
+            cursor.execute(
+                "SELECT trigger_name, table_name "
+                "FROM user_triggers "
+                "WHERE base_object_type = 'TABLE' "
+                "ORDER BY table_name, trigger_name"
+            )
+            return [TriggerInfo(name=row[0], table_name=row[1] or "") for row in cursor.fetchall()]
+        finally:
+            cursor.close()
 
     def get_sequences(self, conn: Any, database: str | None = None) -> list[SequenceInfo]:
         """Get sequences from Oracle."""
         cursor = conn.cursor()
-        cursor.execute("SELECT sequence_name FROM user_sequences ORDER BY sequence_name")
-        return [SequenceInfo(name=row[0]) for row in cursor.fetchall()]
+        try:
+            cursor.execute("SELECT sequence_name FROM user_sequences ORDER BY sequence_name")
+            return [SequenceInfo(name=row[0]) for row in cursor.fetchall()]
+        finally:
+            cursor.close()
 
     def get_index_definition(
         self, conn: Any, index_name: str, table_name: str, database: str | None = None
     ) -> dict[str, Any]:
         """Get detailed information about an Oracle index."""
-        cursor = conn.cursor()
         # Get index info
-        cursor.execute(
-            "SELECT uniqueness, index_type FROM user_indexes WHERE index_name = :1",
-            (index_name.upper(),),
-        )
-        row = cursor.fetchone()
-        is_unique = row[0] == "UNIQUE" if row else False
-        index_type = row[1] if row else "NORMAL"
+        cursor = conn.cursor()
+        try:
+            cursor.execute(
+                "SELECT uniqueness, index_type FROM user_indexes WHERE index_name = :1",
+                (index_name.upper(),),
+            )
+            row = cursor.fetchone()
+            is_unique = row[0] == "UNIQUE" if row else False
+            index_type = row[1] if row else "NORMAL"
+        finally:
+            cursor.close()
 
         # Get index columns
-        cursor.execute(
-            "SELECT column_name FROM user_ind_columns "
-            "WHERE index_name = :1 ORDER BY column_position",
-            (index_name.upper(),),
-        )
-        columns = [row[0] for row in cursor.fetchall()]
+        col_cursor = conn.cursor()
+        try:
+            col_cursor.execute(
+                "SELECT column_name FROM user_ind_columns "
+                "WHERE index_name = :1 ORDER BY column_position",
+                (index_name.upper(),),
+            )
+            columns = [row[0] for row in col_cursor.fetchall()]
+        finally:
+            col_cursor.close()
 
         # Try to get DDL
+        ddl_cursor = conn.cursor()
         try:
-            cursor.execute(
+            ddl_cursor.execute(
                 "SELECT DBMS_METADATA.GET_DDL('INDEX', :1) FROM dual",
                 (index_name.upper(),),
             )
-            ddl_row = cursor.fetchone()
+            ddl_row = ddl_cursor.fetchone()
             definition = str(ddl_row[0]) if ddl_row else None
         except Exception:
             definition = f"CREATE {'UNIQUE ' if is_unique else ''}INDEX {index_name} ON {table_name} ({', '.join(columns)})"
+        finally:
+            ddl_cursor.close()
 
         return {
             "name": index_name,
@@ -219,58 +253,64 @@ def get_trigger_definition(
     ) -> dict[str, Any]:
         """Get detailed information about an Oracle trigger."""
         cursor = conn.cursor()
-        cursor.execute(
-            "SELECT trigger_type, triggering_event, trigger_body "
-            "FROM user_triggers WHERE trigger_name = :1",
-            (trigger_name.upper(),),
-        )
-        row = cursor.fetchone()
-        if row:
-            # trigger_type is like "BEFORE EACH ROW" or "AFTER STATEMENT"
-            timing = row[0].split()[0] if row[0] else None
+        try:
+            cursor.execute(
+                "SELECT trigger_type, triggering_event, trigger_body "
+                "FROM user_triggers WHERE trigger_name = :1",
+                (trigger_name.upper(),),
+            )
+            row = cursor.fetchone()
+            if row:
+                # trigger_type is like "BEFORE EACH ROW" or "AFTER STATEMENT"
+                timing = row[0].split()[0] if row[0] else None
+                return {
+                    "name": trigger_name,
+                    "table_name": table_name,
+                    "timing": timing,
+                    "event": row[1],
+                    "definition": row[2],
+                }
             return {
                 "name": trigger_name,
                 "table_name": table_name,
-                "timing": timing,
-                "event": row[1],
-                "definition": row[2],
+                "timing": None,
+                "event": None,
+                "definition": None,
             }
-        return {
-            "name": trigger_name,
-            "table_name": table_name,
-            "timing": None,
-            "event": None,
-            "definition": None,
-        }
+        finally:
+            cursor.close()
 
     def get_sequence_definition(
         self, conn: Any, sequence_name: str, database: str | None = None
     ) -> dict[str, Any]:
         """Get detailed information about an Oracle sequence."""
         cursor = conn.cursor()
-        cursor.execute(
-            "SELECT min_value, max_value, increment_by, cycle_flag, last_number "
-            "FROM user_sequences WHERE sequence_name = :1",
-            (sequence_name.upper(),),
-        )
-        row = cursor.fetchone()
-        if row:
+        try:
+            cursor.execute(
+                "SELECT min_value, max_value, increment_by, cycle_flag, last_number "
+                "FROM user_sequences WHERE sequence_name = :1",
+                (sequence_name.upper(),),
+            )
+            row = cursor.fetchone()
+            if row:
+                return {
+                    "name": sequence_name,
+                    "start_value": row[4],  # last_number approximates current position
+                    "increment": row[2],
+                    "min_value": row[0],
+                    "max_value": row[1],
+                    "cycle": row[3] == "Y",
+                }
             return {
                 "name": sequence_name,
-                "start_value": row[4],  # last_number approximates current position
-                "increment": row[2],
-                "min_value": row[0],
-                "max_value": row[1],
-                "cycle": row[3] == "Y",
+                "start_value": None,
+                "increment": None,
+                "min_value": None,
+                "max_value": None,
+                "cycle": None,
             }
-        return {
-            "name": sequence_name,
-            "start_value": None,
-            "increment": None,
-            "min_value": None,
-            "max_value": None,
-            "cycle": None,
-        }
+        finally:
+            cursor.close()
 
     def quote_identifier(self, name: str) -> str:
         """Quote identifier using double quotes for Oracle.
@@ -287,24 +327,30 @@ def build_select_query(self, table: str, limit: int, database: str | None = None
     def execute_query(self, conn: Any, query: str, max_rows: int | None = None) -> tuple[list[str], list[tuple], bool]:
         """Execute a query on Oracle with optional row limit."""
         cursor = conn.cursor()
-        cursor.execute(query)
-        if cursor.description:
-            columns = [col[0] for col in cursor.description]
-            if max_rows is not None:
-                rows = cursor.fetchmany(max_rows + 1)
-                truncated = len(rows) > max_rows
-                if truncated:
-                    rows = rows[:max_rows]
-            else:
-                rows = cursor.fetchall()
-                truncated = False
-            return columns, [tuple(row) for row in rows], truncated
-        return [], [], False
+        try:
+            cursor.execute(query)
+            if cursor.description:
+                columns = [col[0] for col in cursor.description]
+                if max_rows is not None:
+                    rows = cursor.fetchmany(max_rows + 1)
+                    truncated = len(rows) > max_rows
+                    if truncated:
+                        rows = rows[:max_rows]
+                else:
+                    rows = cursor.fetchall()
+                    truncated = False
+                return columns, [tuple(row) for row in rows], truncated
+            return [], [], False
+        finally:
+            cursor.close()
 
     def execute_non_query(self, conn: Any, query: str) -> int:
         """Execute a non-query on Oracle."""
         cursor = conn.cursor()
-        cursor.execute(query)
-        rowcount = int(cursor.rowcount)
-        conn.commit()
-        return rowcount
+        try:
+            cursor.execute(query)
+            rowcount = int(cursor.rowcount)
+            conn.commit()
+            return rowcount
+        finally:
+            cursor.close()

sqlit/domains/results/state/results_filter_active.py

@@ -14,8 +14,6 @@ class ResultsFilterActiveState(BlockingState):
     def _setup_actions(self) -> None:
         self.allows("results_filter_close", help="Close filter", help_key="esc")
         self.allows("results_filter_accept", help="Select row", help_key="enter")
-        self.allows("results_filter_next", help="Next match", help_key="n/j")
-        self.allows("results_filter_prev", help="Previous match", help_key="N/k")
         self.allows("quit")
 
     def get_display_bindings(self, app: InputContext) -> tuple[list[DisplayBinding], list[DisplayBinding]]:

sqlit/domains/shell/state/machine.py

@@ -252,7 +252,6 @@ def binding(key: str, desc: str, indent: int = 4) -> str:
         lines.append(binding("<enter>", "Apply filter"))
         lines.append(binding("<esc>", "Close filter"))
         lines.append(binding("~prefix", "Fuzzy match mode"))
-        lines.append(binding("n/N", "Next/prev match (Results)"))
         lines.append("")
 
         # ═══════════════════════════════════════════════════════════════════