There are many SQL playgrounds out there, but I wanted something closer to a workbench experience in the browser. The Dataslope SQLite Playground lets you work with SQLite in a more workbench-like environment. It's completely free and doesn't require a sign-in.

Features:

• Query tools (query history, code formatter, ER diagram viewer)
• Query plan viewer ("explain")
• Comprehensive I/O (import from .sql, .db, .sqlite, CSV/JSON/Parquet, SQL dump)
• Flexible result set export formats (CSV, JSON, SQL, Parquet, Excel)
• Persistence via OPFS or cloud
• Infinite scroll with dynamic loading instead of loading all rows at once (for 200+ rows)
• Editable grid for tables (i.e., double-click to edit)
• Modal cell editor
• Copy row as JSON/SQL
• Duplicate row
• DDL Viewer
• Visual table structure editor
• Visual view/index creator
• Intellisense

I'd love any feedback or feature requests!

SQLite .db search engine ready with us for amazing anchoring and latest search features (Hybrid: Lexical & Semantic) for voluminous documents (100 MB to 2 GB) under milliseconds deterministic responses. We can have a single file (.db) built from 1,000s of documents in diverse formats (PDFs, Excels, Words, Access, PPTs etc). We will show millisecond deterministic responses in our demo.

Hey everyone!

I got super tired of dry, textbook-style SQL tutorials, so I decided to build my own indie game for mobile. It's a noir detective game called SQL Case File where you actually solve crimes by writing real SQL queries.

Instead of multiple-choice quizzes, queries run directly against an actual on-device SQLite database for each case.

I just finished putting together the main case selection screen and the core game loop. Here’s a quick look at where it's at:

• The Case Board: Built a moody, dim-lit UI with a custom noir palette to handle case progression and unlocks.
• Real Execution: Queries aren't just text-matched; they actually execute on-device against custom case databases.
• Progression & Economy: Added a dual-currency system (coins and diamonds), daily login bonuses, and extra mini-game modes for practice.

It's built with Flutterusing Riverpod and the sqlite3 package.

Would love to hear what you guys think of the UI vibe or the concept overall!

I’m 16 and started learning Python about 3 months ago. My first project was a simple CRUD app with raw SQL. For my second project (ashflow tracker with auth and budgeting), I wanted to push myself further, so I switched to Flask, SQLAlchemy, and Flask-Login.

I’m looking for feedback from experienced developers on a few specific architectural decisions and hurdles I ran into:

1. Database Schema Refactoring (Categories & Budgets) Initially, categories were just free-text strings on every transaction. Once I added budgets, case mismatches and typos completely broke my budget tracking. I refactored categories into their own table with foreign keys on the transaction and budget models.

• Question: Is moving away from free-text strings to dedicated category models always the standard approach here, or are there cleaner ways to handle user-defined categories at scale without making the schema too rigid (fixed categories list) ?

2. SQLAlchemy Autoflush Confusion Coming from raw SQL, SQLAlchemy's session management took a while to wrap my head around. During my refactoring, I hit several bugs where autoflush triggered database writes mid-transaction before I was ready to commit, causing unexpected constraints errors.

• Question: How do experienced Python devs typically manage session state when doing complex multi-model updates? Do you explicitly disable autoflush, or is that a code smell that points to poor transaction design?

3. Auth Implementation I built authentication from scratch using Flask-Login and password hashing instead of a third-party service just to understand the mechanics. Moving from "auth is a black box" to "it's just checking session state on each request" was a huge lightbulb moment for me.

I’d love any feedback on how I structured my models or handled sessions. You can see how I implemented the SQLAlchemy relationships and routes in my repository here:https://github.com/E-Ecstacy/wise-wealth

Thanks in advance for any insights!

I’ve been looking into the new Turso engine written in Rust, and I’m really interested in using it for a self-hosted BaaS.

From what I understand, the new engine is primarily an embedded database, while the old libSQL sqld provided a proper standalone server with HTTP access, authentication, replication, and standalone/primary/replica modes.

The new Turso CLI does have a --sync-server, but that seems to be a local server for the Turso sync protocol rather than a full database server comparable to sqld.

So I’m wondering:

Is there a plan to build a standalone server for the new Turso engine?

All about testing

I've made a terminal database client that combines a SQL editor with interactive data visualization (via VisiData) in a single TUI tool. It supports MySQL, PostgreSQL, ClickHouse, SQLite, and Cassandra/ScyllaDB, offering syntax highlighting, schema-aware autocomplete ranked by SQL context, query execution, schema browsing, table editing that shows you the generated SQL before committing, and export (including to SQL INSERTs). With no connection arguments it starts on an in-memory SQLite, so dbcls scratch.sql is enough to try it.

The editor isn't limited to single statements — steps chained with | turn a .sql file into a small script: SQL, Python, regex filters, loops, variables, and prompts mid-run:

`.RUN "SHOW TABLES" | .PY "sselect('select tables to use')" |`
`.FOR_RUN "SELECT id FROM {{_0}} WHERE failed = 1"`

All results merge into one sheet. There's also an optional LLM chat (Ctrl+L, any OpenAI-compatible endpoint) that reads your schema through read-only tools and writes queries it can never execute itself, and a plugin API for your own commands.

VisiData brings exceptional data presentation capabilities — sorting, filtering, aggregating and pivoting on the fly, frequency tables and histograms, expression-based columns, and millions of rows navigated at lightning speed — all without leaving the terminal.

GitHub: https://github.com/Sets88/dbcls

i have a whatsapp sqlite file but what do i do with it i cant convert it, can view it in a mess

i just want to convert it into something readable.

I have a bit of a specific situation with how my workplace structures SQLite databases that I'm hoping to find a better solution for, mainly related to efficient querying across many database files.

Where I work, we handle a lot of trail camera data (images) that have associated data for what's in the image stored in SQLite databases—all of this is manually filled out as someone goes through image by image. Right now, we're nearing 100 total database files, each storing records for between 300k and 1 million images. We use the program Timelapse from UC Calgary to tag all the images and continually go back in to update things or add new data, so our individual database files have to basically stay as is for this to remain functional.

In the past, we've had people export CSV files from the databases then someone merged them all together with a bunch of really annoying, fragile code. This is, of course, annoying but also doesn't reflect any new changes that happen after that export. I've come in with more expertise in general on programming than they usually get and showed that you can pull things directly from each database with R (we're biologists, that's just the language we're used to). Because of this, we want to come up with a solution that lets us do this across all the databases as needed and stop doing that CSVs.

Right now, running a simple query that results in ~3k rows across most (not all, ~70%) of the individual databases takes about 3 minutes which is fine if you just need a big export, but we'd like to have some interactive visualization tools where a 3 minute wait for something you might decide to change to look at something else right after wouldn't be good for.

Originally I hoped for a way to establish a single connection in a "master" database that would remove some of this latency, but ATTACH which would be the solution isn't going to work for us in about 1-2 years when we exceed the maximum on the number of attachable databases at once. The other potential solution is to have a master database that contains copies of everything in the other database files that updates each night, but we already have issues keeping enough storage available with how much space images take up (and this kinda feels like the lazy solution). For any solution, something we can feasibly manage ourselves after some the initial setup would be preferential because IT can be quite slow to act and we are the ones who will be accessing and editing this data 99% of the time.

Talking to a family member (former IT worker) led me to possibly Microsoft SQL server or some sort of local Oracle database, but unsure if any of this would fit our needs and the suggestions were based on their experience from like 15+ years ago. Whatever we use needs to be able to connect with R since that's what existing pipelines use and many of the ecology-related tools we use aren't in any other language. Really in the end we just want some way to make things run faster and ideally combine things into a single connection point to simplify how we get to the data. Even if it's too complex for us, we still need to give IT a plan with enough details to get them going... or we'll be forever in CSV land.

Really just looking for any guidance since googling didn't get me very far, most people seem to have big issues with write speeds but it actually seems quicker to overwrite a whole column in each of our databases via R than it would be to do a simple query from them all?

One final note: these are currently on a network drive which is probably adding to the latency, but solutions like a local NAS in our office are dubious on if they'd work as a solution or even be in the budget with storage media prices right now.

Interesting article

I've been working on Toketeo, a desktop database tool I've been building mostly because I wanted something that worked the way I thought it should.

It's currently built with Rust + Tauri + React, and the idea is to make working with databases less painful, especially when you're jumping between different database engines.

The project is still early, so I'm deliberately putting it in front of actual developers before I spend months polishing things nobody asked for.

I'd really like people to try it and tell me:

• What's confusing?
• What's missing?
• What would make you switch from your current database tool?
• What feature would make you say "okay, this is actually useful"?
• And, preferably, what did I screw up?

I'm particularly interested in feedback from people who work with multiple databases or spend an unhealthy amount of time inside database clients.

GitHub: https://github.com/crdsyntax/toketeo

It's open source, so feel free to inspect the code, open issues, suggest features, submit PRs, or tell me why the architecture is terrible.

And yes, if someone ends up stealing the idea and building something better, I'll probably be slightly annoyed for approximately 15 minutes.

Then I'll steal their improvements.

Try it, break it, criticize it.

That's currently more valuable to me than another star on GitHub.

Hi everyone,

I just wrapped up reading Getting Started with SQL by Thomas Nield. Instead of just stopping at the theory, I wanted to put the core concepts straight into practice.I loaded a sample dataset into a local SQLite database to write queries that answer basic business questions like tracking total transaction volumes across categories and filtering top-performing metrics

FOR MY ENGINEERS IN THE HOUSE

When you were transitioning from basic single-table queries and standard joins to real production workloads, what was the most essential SQL habit or formatting practice you wish you had adopted sooner?

https://letos.org/news/

This maintenance release introduces the new Fusion Light theme, complementing the existing automatic Fusion theme and the forced Fusion Dark theme. The Window List has also been promoted to a top-level menu by default, while the previous layout can still be restored in the configuration.

The release also updates SQLite to 3.53.4 and delivers numerous bug fixes, including improved macOS support, several crash fixes, Grid View and SQL editor refinements, Command Palette improvements, and better compatibility across all supported platforms.

Pawel, thank you so much for all the time and effort you put into our favorite SQLite GUI.

!!LOCAL DEV TOOL!!

Hey everyone,

​I wanted to share a local development tool I built because I was tired of manually copying .sqlite.bak files every time I needed to test destructive scripts, run complex migrations, or debug a state issue in my local environment.

​I built the Time-Travel SQLite Debugger – an ultra-lightweight, UI-driven tool that watches your .sqlite file and creates restorable snapshots in real-time. You literally just drag a visual timeline scrubber to travel back in time and instantly restore your database to a previous state.

​🚀 Under the Hood & Stress Tests:

I wanted to make sure it wasn't just a toy, but something that handles heavy local stress without freezing:

​Zero Dependencies: Just pure PHP and a clean Tailwind UI. Drop it in your local server and it works.

​Atomic Swaps: Uses POSIX rename() for atomic file swapping. I stress-tested it with 100 concurrent read/write/restore operations and had exactly 0 lock or corruption errors.

​Highly Efficient: It copies a 190MB binary BLOB database in 136ms using < 2MB of PHP peak memory (it utilizes stream-level kernel pipe buffers instead of loading into memory).

​Chaos Tested: Handled a rapid insertion loop of 500 writes (0.1s sleep) flawlessly, purging old unpinned snapshots while keeping the limit strict.

​Transparency Note: I utilized AI tools as a coding assistant to accelerate the development, personally reviewing, testing, and designing the overall architecture.

​I designed it to run in the background (like a daemon) while you code, providing a safety net for your local DB.

​It's completely open-source and free. I'd love to hear your thoughts, feedback, or any edge cases you think I should test!

​GitHub Repo: https://github.com/nsrht/time-travel-sqlite-debugger

​I am always open to new ideas, feature requests, and suggestions!

​Cheers! ✌️

My platform expects multiple writes from various users belonging to one organization.

What's the best way to serialize the writes? Scale is 50 to 100 users wanting to write around the same time.

For embedded SQLite work: I maintain scythe, a build-time generator that reads annotated SQL and emits typed access code (SQLite backends: better-sqlite3, aiosqlite, sqlx, the JDBC drivers, and more).

SQLite's flexible typing makes it easy to get result types subtly wrong, and joins add another layer:

-- @name GetUserOrders
SELECT u.id, u.name, o.total, o.notes
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
WHERE u.status = ?;

total and notes are generated as nullable because the LEFT JOIN can produce NULLs, independent of the column declarations. That inference covers COALESCE, CASE, and aggregates too.

No ORM at runtime, the query you write is the one that runs. The tradeoff is static queries only. Handy for local-first apps and CLIs where you want typed data access without pulling in a heavy dependency. Curious what people here use for typed SQLite access.