Database
{{ dbName }}
{{ list.tables.length }} T {{ list.views.length }} V {{ list.indexes.length }} I {{ list.triggers.length }} Tr
SQLite File
Choose Table / View

{{ schema }}
{{ error }}
{{ h }}
{{ error }}
  • {{ q }}

Download full SQL dump of the database.

Tags: Database
Export to PDF Fullscreen
:

SQLite databases are file based relational stores that keep tables, rows, and columns in a single portable file. They are useful for quick inspection, lightweight apps, and ad hoc analysis.

You can look inside a database, understand its structure, and test ideas with simple queries so you can answer practical questions faster. A natural fit is a SQLite database browser and editor when you need a short review.

Provide a .db or .sqlite file, then choose a table or view, preview rows, run a filter, and capture the result for sharing. The history panel helps you reuse frequent checks without retyping.

For example, open a staff database, select the employees table, review the first hundred rows, adjust one status value, save the change, then confirm with a quick query that returns the updated record.

Be careful with production data and always work on a backup so an unintended edit does not surprise a downstream process. Prefer small result sets while exploring and scan the schema to see key constraints.

If you return later, start with a read only pass to orient yourself, then refine with targeted queries before making edits.

Technical Details:

The underlying object is a SQLite database file that stores tables, views, indexes, and triggers. The page opens the file in a browser engine, enumerates objects from the catalog, and executes SQL statements to return result sets for review.

When you pick a table or view, the tool retrieves its creation statement and composes a browsing query that selects all columns plus an internal row identifier for safe updates. Editing is done by mapping each changed cell into a targeted update against that identifier inside a transaction.

Results reflect the database content exactly as stored. Queries that do not produce a result set show a clear status message. Comparisons across runs remain valid when you keep row limits consistent and reuse the same filters.

Processing pipeline

  1. Load the embedded SQLite engine and open the selected file as a database.
  2. Read sqlite_master (excluding internal names) to list tables, views, indexes, and triggers.
  3. On selection, fetch the CREATE statement and compose a browse query with rowid exposure.
  4. Execute user SQL and display the first result set in a scrollable grid.
  5. Capture cell edits, build per row UPDATE statements, and commit within a single transaction.
  6. Export the current grid to CSV or JSON, or export a full SQL dump of the database file.
  7. Store recent queries locally for quick reuse, keeping the most recent forty entries.
Worked example. Load sales.sqlite. Choose orders. The browse view runs SELECT *, rowid AS __rowid__ FROM orders LIMIT 100;. Edit one status cell, save, then verify with SELECT order_id, status FROM orders WHERE order_id = 123;. Interpretation: the presence of the updated value confirms a successful write.
Field Type Min Max Step/Pattern Error Text Placeholder
SQLite file File input — — .db, .sqlite — —
Browse query limit Constant 100 100 Fixed — —
Query history size Integer 0 40 1 — —
Edit prerequisite Identifier — — Requires visible __rowid__ — —
Empty result handling Status — — — No results —
Input Accepted Families Output Encoding/Precision Rounding
SQLite database file .db, .sqlite Grid preview As stored Not altered
— — CSV export Text; quotes doubled Not applicable
— — JSON export Array of objects; 2‑space indent Not applicable
— — SQL dump .sql file from engine export Not applicable
Editing from the grid writes literal values per cell. Use the Query tab for NULL, expressions, or multi row updates beyond the visible grid.

Networking & storage

  • Runs in a browser based engine; SQL executes locally in the page.
  • Recent queries are stored in local storage and capped at forty entries.
  • The full database export is generated on the device before download.

Performance & complexity

  • Response time depends on database size, query complexity, and device resources.
  • Edits commit in a single transaction for atomic apply across changed rows.

Diagnostics & determinism

  • Identical inputs yield identical outputs from the same engine version.
  • Error messages from the SQL engine are shown inline near the controls.

Security considerations

  • Avoid running untrusted statements from unknown sources.
  • Review updates before saving; prefer test datasets for experimentation.

Assumptions & limitations

  • Works with standard SQLite files; proprietary wrappers are out of scope.
  • Very large files may exceed available memory on some devices.
  • Only the first result set is displayed when statements return multiple sets.
  • Browse view limits to 100 rows; expand via a custom query if needed.
  • Edits require a visible row identifier; views without identifiers are not editable.
  • Exports reflect the current grid, not the entire table unless queried.
  • Heads‑up Edits typed as text may not match desired storage affinity.
  • History persists locally and clears when site data are cleared.

Edge cases & error sources

  • Invalid SQL returns an engine error message with the failing token.
  • Statements that do not return rows show “No results.”
  • Names that match __rowid__ may collide with the browse alias.
  • BLOB values may not render meaningfully in the grid or CSV.
  • Newlines or commas in text are quoted in CSV; verify downstream readers.
  • NULL must be set via a query, not a grid edit.
  • Dates and times are strings unless your schema enforces a format.
  • Large integers may exceed safe ranges in some environments.
  • Whitespace edits can be hard to notice; scan the edited highlight before saving.
  • Long running queries can block interaction until completion.

How‑to Guide:

SQLite databases can be inspected quickly to answer concrete questions and confirm small changes.

  1. Choose a SQLite file with the picker.
  2. Select a table or view and review the schema text.
  3. Refine the query; start with a small WHERE filter.
  4. Toggle edit to adjust a few cells; save when ready.
  5. Export the grid to CSV or JSON for sharing or auditing.
  6. Download a full SQL dump when you need a portable snapshot.

Example: Filter recent orders with WHERE created_at >= '2025-01-01', confirm totals, then export the grid.

  • Prefer specific filters to keep scans small and fast.
  • Reuse saved queries from the history panel for repeat checks.

You now have a concise workflow to inspect structure, test assumptions, and capture results.

FAQ:

Is my data stored?

No. Processing occurs in your browser, and recent queries are kept only in local storage on your device.

Clear site data to remove history.
Which files can I open?

Standard SQLite files with .db or .sqlite extensions. If a file is encrypted or proprietary, it will not open.

How accurate are the results?

Results come directly from the SQLite engine, matching what the database stores and what your statements request.

Can I edit values?

Yes for tables with a visible row identifier; the tool applies targeted updates inside a transaction. Views or tables without an identifier are read only.

How do I export a table?

Run a query that returns the rows you want, then use CSV or JSON export. Use the SQL dump to capture the entire database.

Can I connect to a remote server?

No. It opens a local file and runs queries in the page. There is no network connection to a database server.

What does “No results” mean?

The statement produced no rows. That happens with updates, schema changes, or a valid query that matches zero records.

Troubleshooting:

  • Nothing happens after file pick — verify the file uses a standard SQLite format.
  • “No results” after edit — rerun a query that selects the edited row to verify the change.
  • Unexpected text types — use the Query tab for numeric casting or NULL.
  • Large file feels sluggish — narrow the query with a selective WHERE clause.
  • CSV looks misaligned — check for embedded commas and rely on the quoted export.
  • History not updating — ensure your browser allows local storage for this site.

Glossary:

SQLite database
A single file that stores relational tables and related objects.
Table
A set of rows with named columns within the database.
View
A saved query that returns a virtual table on demand.
Index
A structure that speeds up lookups for selected columns.
Trigger
A rule that runs automatically when specific changes occur.
Schema
The set of definitions describing tables, columns, and relationships.
rowid
An internal integer key that uniquely identifies rows in most tables.
SQL dump
A sequence of statements that can recreate the database contents.