feat: add SQLite export and store tooling

Author: Lukas Geiger

.github/workflows/stale.yml

@@ -13,7 +13,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@v10
         with:
           stale-issue-message: >
             This issue has been automatically marked as stale because it has not had

.github/workflows/welcome.yml

@@ -14,19 +14,19 @@ jobs:
   welcome:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/first-interaction@v1
+      - uses: actions/first-interaction@v3
         with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-          issue-message: |
-            Welcome! 👋 Thanks for opening your first issue in this repository.
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          issue_message: |
+            Welcome! Thanks for opening your first issue in this repository.
 
             We'll review it as soon as possible. In the meantime:
             - Check if there's a similar issue already open
             - Add as much detail as possible (steps to reproduce, expected behavior, environment)
 
             If you'd like to contribute a fix, PRs are always welcome!
-          pr-message: |
-            Welcome! 👋 Thanks for your first pull request in this repository.
+          pr_message: |
+            Welcome! Thanks for your first pull request in this repository.
 
             A maintainer will review it soon. Please make sure:
             - [ ] Your changes are tested

CHANGELOG.md

@@ -3,16 +3,33 @@
 ## [Unreleased]
 
 ### Added
-- Local release bundle in `releases/v2.0.0/` refreshed from the current `dist/SQLiteViewer.exe` build.
+- Local release bundle workflow documented for the ignored `releases/` workspace; public source files stay lightweight.
 - Application icon support in the Tk window.
 - Optional startup argument for opening a database file directly.
 - `RELEASES.md` documents the local release bundle layout.
 - `SQLiteViewer.spec` is tracked for reproducible PyInstaller builds.
+- Optional JSON companion export `sqliteviewer-export-v1.json` with source metadata, row limits, visible columns, and serialized result rows.
+- `EXPORTFORMAT.md` documents the JSON export contract for desktop-to-web/mobile companion workflows.
+- Reproducible Windows Store screenshot generation under `_WARTUNG/generate_store_screenshots.py`; generated screenshots stay in the ignored local `releases/windowsstore/screenshots/` workspace while `README/screenshots/main.png` is refreshed for GitHub.
+- Local WACK notes remain in the ignored `releases/windowsstore/` workspace; public root docs now describe only the source-controlled workflow.
 
 ### Changed
 - README now embeds the existing GUI screenshot from `README/screenshots/main.png`.
 - Repository URLs and community health files now point to `file-bricks/SQLiteViewer`.
 - `START.bat` now forwards command-line arguments and reports missing Python cleanly.
+- Store listings and Store metadata now reflect the current CSV/JSON export feature set and the active `file-bricks/SQLiteViewer` privacy/support links.
+- `PORTIERUNGSPLAN.md` marks the Store listing and screenshot workflow refresh as completed without requiring ignored release artifacts in the public repo.
+- Community workflows now use `actions/stale@v10` and `actions/first-interaction@v3` with current input names.
+
+### Fixed
+- SQL Editor now detects result-returning statements via `cursor.description`, so
+  queries with leading comments are rendered correctly instead of being treated as DML.
+- SQL Editor now refreshes the currently selected table after data-changing
+  statements instead of jumping back to the first table in the database.
+- Search now escapes `%`, `_`, and `\` correctly so literal LIKE searches do not
+  fail on wildcard-containing terms.
+- Opening a database now only closes the current session after the new read-only
+  connection succeeds, so failed open attempts keep the existing database in place.
 
 ## [2.0.0] - 2026-02-01
 

EXPORTFORMAT.md

@@ -0,0 +1,81 @@
+# Exportformat – `sqliteviewer-export-v1.json`
+
+Stand: 2026-05-25
+
+## Zweck
+
+`sqliteviewer-export-v1.json` ist ein optionaler Companion-Export für Web/PWA-, Review- und Austausch-Workflows. CSV bleibt der Standardexport für einfache Tabellenweitergabe. JSON ergänzt diesen Pfad um Metadaten zur Herkunft und zur aktuell sichtbaren Ansicht.
+
+## Grundsätze
+
+- Der Export ist additiv: CSV bleibt unverändert verfügbar.
+- Es werden nur aktuell sichtbare Ergebniszeilen exportiert.
+- Der Export ist offline-first und enthält keine Cloud-Synchronisation.
+- BLOB-Werte werden JSON-kompatibel als Base64-Struktur serialisiert.
+
+## Struktur
+
+```json
+{
+  "schema_version": "sqliteviewer-export-v1",
+  "app_name": "SQLite Viewer Pro",
+  "app_version": "2.0.0",
+  "exported_at": "2026-05-25T11:34:56+02:00",
+  "source": {
+    "database_path": "C:/path/demo.sqlite",
+    "database_name": "demo.sqlite",
+    "view": "table",
+    "table": "items",
+    "query": null,
+    "row_limit": 1000,
+    "search_term": null,
+    "sort_column": "id",
+    "sort_descending": false
+  },
+  "columns": ["id", "name"],
+  "row_count": 2,
+  "result_rows": [
+    {"id": 1, "name": "Alpha"},
+    {"id": 2, "name": "Beta"}
+  ]
+}
+```
+
+## Feldbedeutung
+
+- `schema_version`: Stabile Kennung des Exportvertrags.
+- `app_name` / `app_version`: Herkunft des Exports.
+- `exported_at`: ISO-8601-Zeitstempel mit Zeitzone.
+- `source.database_path`: Ursprünglicher Datenbankpfad auf dem exportierenden System.
+- `source.database_name`: Dateiname der Datenbank.
+- `source.view`: Herkunft der sichtbaren Daten, aktuell `table`, `table_search` oder `query`.
+- `source.table`: Aktive Tabelle, falls vorhanden.
+- `source.query`: Ausgeführte SQL-Abfrage bei Query-Exporten.
+- `source.row_limit`: Aktives Zeilenlimit der Ansicht.
+- `source.search_term`: Aktiver Suchbegriff in der Tabellenansicht.
+- `source.sort_column` / `source.sort_descending`: Sortierzustand der Tabellenansicht.
+- `columns`: Sichtbare Spaltenreihenfolge.
+- `row_count`: Anzahl exportierter Ergebniszeilen.
+- `result_rows`: Ergebniszeilen als Objekte mit Spaltennamen.
+
+## Wertkodierung
+
+- `null`, `string`, `number` und `boolean` bleiben direkt erhalten.
+- `bytes` werden als Objekt exportiert:
+
+```json
+{
+  "type": "blob",
+  "encoding": "base64",
+  "size_bytes": 12,
+  "data": "AAEC"
+}
+```
+
+- Nicht direkt JSON-kompatible Sonderfälle werden als String serialisiert.
+
+## Nicht-Ziele
+
+- Kein vollständiger Dump interner SQLite-Metadaten.
+- Kein bidirektionaler Importvertrag in v1.
+- Keine Synchronisation kompletter Datenbanken zwischen Geräten.

PORTIERUNGSPLAN.md

@@ -0,0 +1,87 @@
+# Portierungsplan - SQLite Viewer Pro
+
+Stand: 2026-05-27  
+Scope: Windows Store, plattformübergreifende Desktop-Nutzung, Web-/Mobile-Companion
+
+## Ausgangslage
+
+SQLite Viewer Pro ist ein leichtgewichtiger SQLite-Datenbank-Browser auf Basis von Python, Tkinter und `sqlite3` aus der Standardbibliothek. Die Anwendung ist bereits als Windows-Desktop-App mit Store-Artefakten vorbereitet und laut README grundsätzlich für Windows, Linux und macOS geeignet.
+
+Der Kernnutzen liegt im schnellen lokalen Öffnen, Durchsuchen, Abfragen und Exportieren von SQLite-Datenbanken. Die App verarbeitet lokale Datenbankdateien, oft mit potenziell sensiblen Inhalten. Deshalb bleibt ein offline-first Desktop-Modell wichtig; mobile und Web-Nutzung sollen primär kleine, bewusst importierte Datenausschnitte statt kompletter lokaler Datenbanken adressieren.
+
+## Entscheidung
+
+Windows Store bleibt der primäre Release-Kanal. macOS und Linux werden als Source-/Build-Smoke-Ziele aus derselben Tkinter-Codebasis geführt. Android, iOS und Web werden nicht als vollständige native Desktop-Clones geplant, sondern als Web/PWA-Companion für kleine SQLite-Dateien, Demo-Datenbanken und CSV-/JSON-Exporte.
+
+Begründung:
+
+- Nachfrage: SQLite ist ein Entwickler- und Power-User-Format; der größte Bedarf liegt weiter auf Desktop-Systemen mit lokalem Dateizugriff.
+- Mobilität: Auf Mobilgeräten ist vollständiger Dateisystemzugriff eingeschränkt, aber das schnelle Prüfen kleiner Datenbankauszüge oder Exporte ist sinnvoll.
+- Datenschutz: Lokale Datenbanken sollen ohne Cloud-Zwang geöffnet werden. Eine Web/PWA-Linie darf nur explizit ausgewählte Dateien oder Exporte verarbeiten.
+- Aufwand: Die bestehende Tkinter-App ist für Desktop pragmatisch. Ein nativer Mobile-Clone würde viel UI- und Datei-Handling neu bauen, ohne den Kernnutzen stark zu erhöhen.
+
+## Plattformbewertung
+
+| Option | Bewertung | Entscheidung |
+| --- | --- | --- |
+| Windows Store | Sehr sinnvoll: Zielgruppe, bestehende MSIX-/Store-Artefakte und MIT-Lizenz passen. | P0 für Listing/Screenshots abgeschlossen; WACK-Protokoll bleibt im lokalen, ignorierten `releases/`-Workspace. |
+| Android-Version oder Android-Clone | Native Vollversion nicht sinnvoll, weil SQLite-Dateizugriff und große Tabellen auf Mobilgeräten sperrig sind. | Nur PWA-Testziel für kleine Dateien/Exports. |
+| Webapp | Sinnvoll als Companion: kleine `.sqlite`-Dateien im Browser öffnen, CSV/JSON ansehen, Demo-DBs prüfen. | P2: Web/PWA-Prototyp mit lokalem Browser-Speicher. |
+| iOS-Version | Native App aktuell zu hoher Aufwand wegen Sandbox und App-Store-Review. | Nur PWA-Testziel nach Web-Prototyp. |
+| Mac App | Sinnvoll als Source-/Build-Ziel, da Python/Tkinter portabel ist. | P3: macOS-Smoke-Test dokumentieren. |
+| Linux-Version | Sinnvoll als Source-/Build-Ziel; optional später AppImage/Flathub prüfen. | P3: Linux-Smoke-Test dokumentieren. |
+
+## Zielarchitektur
+
+### Desktop-Kern
+
+- Python/Tkinter bleibt die Desktop-Codebasis.
+- SQLite-Dateien werden lokal und read-only geöffnet.
+- CSV-Export bleibt das kleinste stabile Austauschformat.
+- Optionales zusätzliches JSON-Exportformat `sqliteviewer-export-v1.json` ist für sichtbare Ergebnisse umgesetzt und transportiert Tabellenmetadaten, aktive Query, Spalten, Zeilenlimit und Ergebniszeilen.
+
+### Web/PWA-Companion
+
+- Separater Web-Prototyp, keine direkte Kopplung an Tkinter.
+- Browser-seitige Verarbeitung kleiner Dateien über `sql.js` oder eine vergleichbare WebAssembly-SQLite-Engine.
+- Keine Server-Uploads als Standard; der Datenschutz-Hinweis "lokal im Browser" soll sichtbar dokumentiert werden.
+- Unterstützte Startfälle: Demo-DB öffnen, kleine `.sqlite` öffnen, CSV/JSON-Export anzeigen, Query-Ergebnis filtern.
+
+### Export von Desktop zu Web/Mobile
+
+- Kurzfristig CSV als vorhandener Exportpfad.
+- `sqliteviewer-export-v1.json` ist als optionaler, stabiler Companion-Vertrag eingeführt.
+- Keine Synchronisation vollständiger Datenbanken ohne separate Datenschutz- und Größenstrategie.
+
+## Roadmap
+
+### P0 - Store-Readiness
+
+- Store-Screenshots sind jetzt reproduzierbar über `_WARTUNG/generate_store_screenshots.py` erzeugbar. Die generierten Store-Dateien bleiben lokal im ignorierten `releases/windowsstore/screenshots/`-Workspace; `README/screenshots/main.png` ist der source-kontrollierte GitHub-Screenshot.
+- Store-Listing DE/EN ist gegen echte Umlaute, JSON-Export und aktuelle Support-/Privacy-Links synchronisiert.
+- MSIX-/WACK-Testnotizen werden lokal im ignorierten `releases/windowsstore/`-Workspace gepflegt; der öffentliche Repo-Stand verweist nur auf source-kontrollierte Store- und Build-Helfer.
+
+### P1 - Companion-Vertrag
+
+- `sqliteviewer-export-v1.json` ist spezifiziert: App-Version, Quelle, Tabelle/Query, Spalten, Zeilen, Limit und Exportzeit sind dokumentiert.
+- Desktop-Export ist optional neben CSV im Menü verfügbar.
+- Datenschutzgrenzen für Companion-Dateien dokumentieren.
+
+### P2 - Web/PWA-Prototyp
+
+- Separaten `webapp/`-Prototyp erst bei Umsetzungsstart anlegen.
+- Browser-seitiges Öffnen kleiner SQLite-Dateien evaluieren.
+- Android/iOS über PWA-Installierbarkeit und Touch-Tabellenansicht testen.
+
+### P3 - Desktop-Smoke-Tests
+
+- Linux-Start aus Source mit Tkinter prüfen.
+- macOS-Start aus Source mit Tkinter prüfen.
+- Packaging für Linux/macOS nur nach belastbarer Nachfrage planen.
+
+## Nicht-Ziele
+
+- Kein nativer Android-/iOS-Clone in der ersten Portierungsphase.
+- Kein Cloud-Datenbankservice.
+- Kein automatischer Upload lokaler Datenbanken.
+- Keine gemeinsame Desktop-/Mobile-Codebasis, wenn sie die einfache Tkinter-Desktop-App unnötig verkompliziert.

README.md

@@ -1,6 +1,6 @@
 # SQLite Viewer Pro
 
-Ein leichtgewichtiger, schneller SQLite-Datenbank-Browser mit Python und Tkinter. Oeffne, durchsuche und analysiere jede SQLite-Datenbank -- ohne SQL-Kenntnisse.
+Ein leichtgewichtiger, schneller SQLite-Datenbank-Browser mit Python und Tkinter. Öffne, durchsuche und analysiere jede SQLite-Datenbank -- ohne SQL-Kenntnisse.
 
 ![Python](https://img.shields.io/badge/Python-3.10+-blue)
 ![License](https://img.shields.io/badge/License-MIT-green)
@@ -10,36 +10,37 @@ Ein leichtgewichtiger, schneller SQLite-Datenbank-Browser mit Python und Tkinter
 
 - **Tabellen-Browser** - Listet alle Tabellen mit sortierbarem Datenraster auf
 - **Schema-Ansicht** - CREATE TABLE Statements mit Syntax-Highlighting anzeigen
-- **SQL-Editor** - Eigene Abfragen mit Syntax-Highlighting und Ergebnisansicht ausfuehren
-- **Volltextsuche** - Echtzeit-Suche ueber alle Spalten
+- **SQL-Editor** - Eigene Abfragen mit Syntax-Highlighting und Ergebnisansicht ausführen
+- **Volltextsuche** - Echtzeit-Suche über alle Spalten
 - **CSV-Export** - Tabellen oder Abfrageergebnisse als CSV exportieren
-- **Sortierung** - Spaltenkoepfe anklicken fuer auf-/absteigende Sortierung
-- **Tastenkuerzel** - Ctrl+O (Oeffnen), Ctrl+F (Suche), Ctrl+E (Export), F5 (Aktualisieren), F9 (SQL ausfuehren)
-- **Direktstart mit Datei** - Optional eine Datenbankdatei beim Start uebergeben
+- **JSON-Export** - Sichtbare Ergebnisse optional als `sqliteviewer-export-v1.json` mit Metadaten exportieren
+- **Sortierung** - Spaltenköpfe anklicken für auf-/absteigende Sortierung
+- **Tastenkürzel** - Ctrl+O (Öffnen), Ctrl+F (Suche), Ctrl+E (Export), F5 (Aktualisieren), F9 (SQL ausführen)
+- **Direktstart mit Datei** - Optional eine Datenbankdatei beim Start übergeben
 
 ## Screenshots
 
 ![SQLite Viewer Pro - Hauptfenster](README/screenshots/main.png)
 
-Die aktuelle Aufnahme zeigt den Daten-Browser mit den integrierten Tabs fuer Schema-Ansicht und SQL-Editor.
+Die aktuelle Aufnahme zeigt den Daten-Browser mit den integrierten Tabs für Schema-Ansicht und SQL-Editor.
 
 ### Daten-Browser
-Oeffne beliebige `.db`-, `.sqlite`- oder `.sqlite3`-Dateien und durchsuche Tabellen sofort.
+Öffne beliebige `.db`-, `.sqlite`- oder `.sqlite3`-Dateien und durchsuche Tabellen sofort.
 
 ### Schema-Ansicht
 Tabellenstrukturen mit syntaxhervorgehobenen CREATE TABLE Statements anzeigen.
 
 ### SQL-Editor
-SQL-Abfragen mit Echtzeit-Syntax-Highlighting schreiben und ausfuehren.
+SQL-Abfragen mit Echtzeit-Syntax-Highlighting schreiben und ausführen.
 
 ## Installation
 
 ### Voraussetzungen
 
-- Python 3.10 oder hoeher
+- Python 3.10 oder höher
 - Tkinter (bei den meisten Python-Installationen enthalten)
 
-Keine zusaetzlichen Abhaengigkeiten -- nutzt ausschliesslich die Python-Standardbibliothek.
+Keine zusätzlichen Abhängigkeiten -- nutzt ausschließlich die Python-Standardbibliothek.
 
 ### Aus dem Quellcode starten
 
@@ -57,32 +58,34 @@ Doppelklick auf `START.bat` oder:
 python SQLiteViewer.py
 ```
 
-Eine Datenbank kann direkt beim Start geoeffnet werden:
+Eine Datenbank kann direkt beim Start geöffnet werden:
 
 ```cmd
 python SQLiteViewer.py pfad\zur\datenbank.sqlite
 ```
 
 ## Verwendung
 
-1. **Datenbank oeffnen**: `File > Open Database`, `Ctrl+O` oder per Startargument
-2. **Tabellen durchsuchen**: Tabelle aus dem Dropdown waehlen
+1. **Datenbank öffnen**: `File > Open Database`, `Ctrl+O` oder per Startargument
+2. **Tabellen durchsuchen**: Tabelle aus dem Dropdown wählen
 3. **Suchen**: Im Suchfeld tippen, um Zeilen zu filtern
 4. **Schema ansehen**: Zum Schema-Tab wechseln
-5. **SQL ausfuehren**: Zum SQL-Editor-Tab wechseln, Abfrage schreiben, `F9` druecken
-6. **Exportieren**: `File > Export as CSV` oder `Ctrl+E`
+5. **SQL ausführen**: Zum SQL-Editor-Tab wechseln, Abfrage schreiben, `F9` drücken
+6. **Exportieren**: `File > Export as CSV`, `Ctrl+E` oder `File > Export as JSON`
 
-## Tastenkuerzel
+## Tastenkürzel
 
-| Kuerzel | Aktion |
+| Kürzel | Aktion |
 |---------|--------|
-| `Ctrl+O` | Datenbank oeffnen |
+| `Ctrl+O` | Datenbank öffnen |
 | `Ctrl+Q` | Beenden |
 | `Ctrl+E` | CSV exportieren |
 | `Ctrl+F` | Suchfeld fokussieren |
 | `Ctrl+A` | Alle Zeilen markieren |
 | `F5` | Tabelle aktualisieren |
-| `F9` | SQL-Abfrage ausfuehren |
+| `F9` | SQL-Abfrage ausführen |
+
+Der JSON-Export ist bewusst additiv gehalten: CSV bleibt der schnellste Standardpfad, während `sqliteviewer-export-v1.json` die aktuelle Ansicht inklusive Metadaten für Companion-Workflows festhält. Details stehen in `EXPORTFORMAT.md`.
 
 ## Vergleich
 
@@ -93,7 +96,7 @@ python SQLiteViewer.py pfad\zur\datenbank.sqlite
 | Tabellen durchsuchen | Ja | Ja | Ja |
 | Schema-Ansicht | Ja | Ja | Ja |
 | CSV-Export | Ja | Ja | Ja |
-| Volltextsuche | Ja | Eingeschraenkt | Ja |
+| Volltextsuche | Ja | Eingeschränkt | Ja |
 | Portabel | Ja | Teilweise | Nein |
 | Leichtgewichtig | Ja | Nein | Nein |
 | Keine Installation | Ja | Nein | Nein |
@@ -102,7 +105,7 @@ python SQLiteViewer.py pfad\zur\datenbank.sqlite
 
 - **Framework**: Tkinter + ttk
 - **Datenbank**: sqlite3 (stdlib)
-- **Abhaengigkeiten**: Keine (reines Python stdlib)
+- **Abhängigkeiten**: Keine (reines Python stdlib)
 - **Einzelne Datei**: ~780 Zeilen Python
 
 ---
@@ -118,6 +121,7 @@ A lightweight, fast SQLite database browser built with Python and Tkinter. Open,
 - **SQL Editor** - Execute custom queries with syntax highlighting and result view
 - **Full-Text Search** - Search across all columns in real-time
 - **CSV Export** - Export any table or query result to CSV
+- **JSON Export** - Optionally export the visible result set as `sqliteviewer-export-v1.json` with metadata
 - **Sorting** - Click column headers to sort ascending/descending
 - **Keyboard Shortcuts** - Ctrl+O (open), Ctrl+F (search), Ctrl+E (export), F5 (refresh), F9 (execute SQL)
 - **Direct file launch** - Optionally pass a database file when starting the app
@@ -175,7 +179,7 @@ python SQLiteViewer.py path\to\database.sqlite
 3. **Search**: Type in the search field to filter rows
 4. **View schema**: Switch to the Schema tab
 5. **Run SQL**: Switch to the SQL Editor tab, write a query, press `F9`
-6. **Export**: `File > Export as CSV` or `Ctrl+E`
+6. **Export**: `File > Export as CSV`, `Ctrl+E`, or `File > Export as JSON`
 
 ### Keyboard Shortcuts
 
@@ -189,6 +193,8 @@ python SQLiteViewer.py path\to\database.sqlite
 | `F5` | Refresh table |
 | `F9` | Execute SQL query |
 
+The JSON export stays intentionally additive: CSV remains the default fast path, while `sqliteviewer-export-v1.json` captures the current visible result plus metadata for companion workflows. See `EXPORTFORMAT.md` for details.
+
 ### Comparison
 
 | Feature | SQLite Viewer Pro | DB Browser | DBeaver |
@@ -218,7 +224,7 @@ python SQLiteViewer.py path\to\database.sqlite
 
 ## Haftung / Liability
 
-Dieses Projekt ist eine **unentgeltliche Open-Source-Schenkung** im Sinne der §§ 516 ff. BGB. Die Haftung des Urhebers ist gemäß **§ 521 BGB** auf **Vorsatz und grobe Fahrlässigkeit** beschränkt. Ergänzend gelten die Haftungsausschlüsse aus GPL-3.0 / MIT / Apache-2.0 §§ 15–16 (je nach gewählter Lizenz).
+Dieses Projekt ist eine **unentgeltliche Open-Source-Schenkung** im Sinne der §§ 516 ff. BGB. Die Haftung des Urhebers ist gemäß **§ 521 BGB** auf **Vorsatz und grobe Fahrlässigkeit** beschränkt. Ergänzend gilt der Haftungsausschluss der MIT-Lizenz.
 
 Nutzung auf eigenes Risiko. Keine Wartungszusage, keine Verfügbarkeitsgarantie, keine Gewähr für Fehlerfreiheit oder Eignung für einen bestimmten Zweck.