diff --git a/SQLiteViewer.py b/SQLiteViewer.py index 701efb3..6b552d4 100644 --- a/SQLiteViewer.py +++ b/SQLiteViewer.py @@ -33,12 +33,21 @@ APP_TITLE = "SQLite Viewer Pro" APP_VERSION = "2.1.0" DEFAULT_LIMIT = 1000 +# Obergrenze für SQL-Tab-Ergebnisse: fetchall() lud bei „SELECT * FROM große_tabelle“ sonst Millionen +# Zeilen in Speicher und Treeview und fror die App ein. +SQL_RESULT_MAX_ROWS = 10_000 +SEARCH_DEBOUNCE_MS = 250 # Tabellensuche beim Tippen erst nach kurzer Pause starten MAX_CELL_DISPLAY_LEN = 500 APP_ICON_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "SQLiteViewer.ico") _CSV_FORMULA_PREFIXES = ("=", "+", "-", "@") _CSV_IGNORABLE_PREFIX = "".join(chr(code) for code in range(0x21)) + "\ufeff" +def _casefold_sql(value: Any): + """SQL-Funktion casefold(): Text Unicode-gefaltet, andere Typen unverändert (LIKE wandelt sie selbst).""" + return value.casefold() if isinstance(value, str) else value + + def _csv_safe_value(value: Any): """Neutralisiert Stringwerte, die Tabellenkalkulationen als Formel deuten können.""" if not isinstance(value, str): @@ -602,8 +611,8 @@ def _build_toolbar(self): self.search_var = tk.StringVar() self.search_entry = ttk.Entry(bar, textvariable=self.search_var, width=20) self.search_entry.pack(side=tk.LEFT, padx=4) - self.search_entry.bind("", lambda e: self._search_data()) - self.search_entry.bind("", lambda e: self._search_data()) + self.search_entry.bind("", lambda e: SqlViewer._search_now(self)) + self.search_entry.bind("", lambda e: SqlViewer._schedule_search(self, e)) self.search_entry.bind("", self._clear_search) add_tip(self.search_entry, "Volltextsuche in aktiver Tabelle (Eingabe / Escape zum Leeren)") @@ -1080,7 +1089,9 @@ def execute_sql(self): # Das ist robuster als ein Prefix-Check und fängt auch Kommentare # vor SELECT/WITH/PRAGMA/EXPLAIN korrekt ab. if cur.description is not None: - rows = cur.fetchall() + rows = cur.fetchmany(SQL_RESULT_MAX_ROWS + 1) + truncated = len(rows) > SQL_RESULT_MAX_ROWS + rows = rows[:SQL_RESULT_MAX_ROWS] cols = [desc[0] for desc in cur.description] SqlViewer._set_sql_result_state( self, @@ -1089,7 +1100,7 @@ def execute_sql(self): view="query", table=self.table_var.get() or None, query=sql, - row_limit=None, + row_limit=SQL_RESULT_MAX_ROWS if truncated else None, search_term=None, sort_column=None, sort_descending=None, @@ -1097,7 +1108,12 @@ def execute_sql(self): self._populate_sql_result(cols, rows) SqlViewer._update_export_actions(self) elapsed = (datetime.now() - start_time).total_seconds() - if rows: + if truncated: + self.sql_status.config( + text=f"✓ erste {len(rows)} Zeilen (Ergebnis hat {SQL_RESULT_MAX_ROWS}+; " + f"mit LIMIT/WHERE eingrenzen) in {elapsed:.3f}s" + ) + elif rows: self.sql_status.config(text=f"✓ {len(rows)} Zeilen in {elapsed:.3f}s") else: self.sql_status.config(text="✓ Keine Ergebnisse") @@ -1477,13 +1493,23 @@ def _search_data(self): if not cols: return - conditions = " OR ".join([f"{self._ident(col)} LIKE ? ESCAPE '\\'" for col in cols]) + # SQLite-LIKE ignoriert Groß/Klein nur bei ASCII: „übersicht“ fand „Übersicht“ nicht. Für + # Begriffe mit Nicht-ASCII beide Seiten per Python-casefold vergleichen; reine ASCII-Begriffe + # bleiben beim schnellen nativen LIKE (Suche läuft bei jedem Tastendruck). + if search_term.isascii(): + column_expr, like_term = "{}", search_term + else: + self.conn.create_function("casefold", 1, _casefold_sql, deterministic=True) + column_expr, like_term = "casefold({})", search_term.casefold() + conditions = " OR ".join( + [f"{column_expr.format(self._ident(col))} LIKE ? ESCAPE '\\'" for col in cols] + ) order_clause = "" if self.sort_column and self.sort_column in cols: direction = "DESC" if self.sort_reverse else "ASC" order_clause = f" ORDER BY {self._ident(self.sort_column)} {direction}" query = f"SELECT * FROM {self._ident(table)} WHERE {conditions}{order_clause} LIMIT ?" - escaped_term = self._escape_like_pattern(search_term) + escaped_term = self._escape_like_pattern(like_term) params = [f"%{escaped_term}%" for _ in cols] params.append(limit) @@ -1527,6 +1553,25 @@ def _search_data(self): except Exception as e: self._set_status(f"Suchfehler: {e}") + def _cancel_scheduled_search(self): + if getattr(self, "_search_job", None) is not None: + try: + self.after_cancel(self._search_job) + except Exception: + pass + self._search_job = None + + def _schedule_search(self, _event=None): + """Tippen: Suche entprellt einplanen statt bei jedem Tastendruck die ganze Tabelle zu scannen + (200 000 Zeilen: 0,2–0,8 s pro Taste).""" + SqlViewer._cancel_scheduled_search(self) + self._search_job = self.after(SEARCH_DEBOUNCE_MS, lambda: SqlViewer._search_now(self)) + + def _search_now(self): + """Enter bzw. abgelaufene Entprellzeit: geplante Suche verwerfen und sofort suchen.""" + SqlViewer._cancel_scheduled_search(self) + self._search_data() + def _focus_search(self): self.search_entry.focus_set() self.search_entry.select_range(0, tk.END) @@ -1656,6 +1701,7 @@ def _on_close(self): except Exception: pass self._sql_highlight_job = None + SqlViewer._cancel_scheduled_search(self) self.close_db() self.destroy() diff --git a/tests/test_bugsweep_20261114.py b/tests/test_bugsweep_20261114.py new file mode 100644 index 0000000..f6f1ce3 --- /dev/null +++ b/tests/test_bugsweep_20261114.py @@ -0,0 +1,98 @@ +"""Regressionstests — Bugsweep SQLiteViewer 2026-11-14.""" +from __future__ import annotations + +import SQLiteViewer +from test_execute_sql import _build_fake_viewer + + +def test_sql_tab_does_not_load_an_unbounded_result(): + """Die Tabellenansicht hält sich an ein Zeilenlimit, der SQL-Tab holte per fetchall() alles: + „SELECT * FROM große_tabelle“ lud Millionen Zeilen in Speicher und Treeview — App friert ein.""" + fake, conn, status, calls = _build_fake_viewer("SELECT * FROM items") + limit = SQLiteViewer.SQL_RESULT_MAX_ROWS + conn.executemany("INSERT INTO items (name) VALUES (?)", [(f"n{i}",) for i in range(limit + 500)]) + conn.commit() + try: + SQLiteViewer.SqlViewer.execute_sql(fake) + finally: + conn.close() + columns, rows = calls["populate"] + assert len(rows) == limit + assert str(limit) in status.get("text", "") and "+" in status.get("text", ""), status + + +def test_table_search_ignores_case_of_umlauts(): + """SQLite-LIKE ignoriert Groß/Klein nur bei ASCII: „übersicht“ fand „Übersicht“ nicht, „ärzte“ nicht + „Ärzte“ — im Deutschen stehen Ä/Ö/Ü oft am Wortanfang (gleiches Muster wie ProSync/DokuZen).""" + from test_bugsweep_20260627 import _build_fake_for_search + + fake, conn, status, tree = _build_fake_for_search(["id", "name"], search_term="übersicht") + conn.executemany("INSERT INTO items (name) VALUES (?)", [("Übersicht 2026",), ("Ärzte",), ("Notiz",)]) + conn.commit() + try: + SQLiteViewer.SqlViewer._search_data(fake) + found = [row[1] for row in fake.current_data] + fake.search_var.set("ärzte") + SQLiteViewer.SqlViewer._search_data(fake) + found_aerzte = [row[1] for row in fake.current_data] + fake.search_var.set("50%") # Wildcards bleiben maskiert + SQLiteViewer.SqlViewer._search_data(fake) + found_percent = fake.current_data + finally: + conn.close() + assert "Suchfehler" not in status.get("text", ""), status + assert found == ["Übersicht 2026"] + assert found_aerzte == ["Ärzte"] + assert found_percent == [] + + +def test_search_export_context_keeps_the_typed_term(): + from test_bugsweep_20260627 import _build_fake_for_search + + fake, conn, status, tree = _build_fake_for_search(["id", "name"], search_term="Übersicht") + try: + SQLiteViewer.SqlViewer._search_data(fake) + finally: + conn.close() + assert fake.export_context["search_term"] == "Übersicht" + + +def test_search_typing_is_debounced(): + """Die Tabellensuche lief bei jedem Tastendruck () als voller Tabellenscan — bei + 200 000 Zeilen 0,2–0,8 s Verzögerung pro Taste. Tippen plant die Suche jetzt entprellt ein, + Enter sucht sofort, Schließen bricht eine geplante Suche ab.""" + from types import SimpleNamespace + + scheduled, cancelled, searched = [], [], [] + + class MockApp: + _search_job = None + _sql_highlight_job = None + + def after(self, ms, callback): + scheduled.append((ms, callback)) + return f"job_{len(scheduled)}" + + def after_cancel(self, job_id): + cancelled.append(job_id) + + def _search_data(self): + searched.append(True) + + def close_db(self): + pass + + def destroy(self): + pass + + app = MockApp() + key = SimpleNamespace(keysym="a") + SQLiteViewer.SqlViewer._schedule_search(app, key) + SQLiteViewer.SqlViewer._schedule_search(app, key) + assert searched == [] and cancelled == ["job_1"] and app._search_job == "job_2" + assert scheduled[-1][0] == SQLiteViewer.SEARCH_DEBOUNCE_MS + SQLiteViewer.SqlViewer._search_now(app) # Enter + assert searched == [True] and "job_2" in cancelled and app._search_job is None + SQLiteViewer.SqlViewer._schedule_search(app, key) + SQLiteViewer.SqlViewer._on_close(app) + assert "job_3" in cancelled