r/DatabaseAdministators

Hi everyone! I’m the developer of LakeDB, a free and open-source desktop client for MySQL and MariaDB.

I started building it to make working across development, staging and production databases clearer and safer. It includes:

• Independent connection workspaces
• SQL editor with schema-aware autocomplete
• Table browsing and controlled data editing
• Query history, EXPLAIN and result filtering
• SSH and SSL connections
• Backup, restore, comparison and migration tools

The biggest addition in Beta 4 is QuerIA Agent Mode.

You can describe the result you need, and the agent investigates the available schema before proposing SQL. It can inspect tables, columns, relationships and indexes, then create a reviewable query involving multiple tables or databases.

LakeDB also shows the selected tables, index information and EXPLAIN validation. Nothing is executed automatically: the generated SQL remains visible and editable, and you explicitly decide whether to run it.

LakeDB is available for Windows x64 as an installer or portable executable:
https://davlagohern.github.io/LakeDB/

This is still a public beta and the Windows packages are not code-signed yet, so SmartScreen may display a first-launch warning. Downloads and SHA-256 checksums are published in the official GitHub repository.

I’d really appreciate feedback on the Windows experience, Agent Mode and anything that feels missing from your normal database workflow.

For over two decades, agency hosting economics were beautifully predictable. You bought a reseller web server or dedicated cPanel account for $50 a month, crammed 30 client WordPress sites onto it, and charged each client a flat $25 monthly maintenance fee. Your margins were clear, your server bills were static, and billing surprises were virtually non-existent. Read the comple te article here > Serverless Bill Shock: Track Vercel & Supabase Client Costs | InstaRenewal

Then came the modern web stack.

Driven by the demand for lightning-fast digital experiences, agencies aggressively migrated to decoupled architectures: Next.js, Nuxt, Vercel, Supabase, Cloudflare Workers, and serverless databases like Neon. While the performance gains of this modern paradigm are undeniable, it introduced a chaotic operational reality: micro-subscription fragmentation and variable utility billing.

I built a database IDE because I was tired of fighting my own databases

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.

Reddit suggested this website to me to ask my question.

Hi everyone!

Over the past few months I've been building QueryForge, an open-source Go library that takes a different approach to natural language querying.

Most text-to-SQL systems ask an LLM to generate SQL directly.

The problem I kept running into was that, even with prompts and post-processing, the model could still invent columns, widen filters, or produce queries that were technically valid but not what the user intended.

So I flipped the architecture.

Instead of generating SQL, the LLM only fills in a typed Query AST.

Everything after that is deterministic Go:

Natural Language
        ↓
      LLM
        ↓
   Typed Query AST
        ↓
 AST Validation
        ↓
 SQL / Mongo Compiler

Some of the things this enables:

• Unknown fields become validation errors with suggestions.
• SQL injection isn't sanitized—it simply isn't representable in the AST.
• DELETE/UPDATE operations don't exist in the AST.
• Multi-tenant filters are injected after validation, so the model never even knows the tenant column exists.
• The same AST can target multiple backends (currently PostgreSQL and MongoDB).

The core library uses only the Go standard library and is released under Apache-2.0.

I've also built a live demo where you can:

• type natural language
• inspect the generated AST
• inspect the generated SQL
• try invalid fields
• try prompt injections
• see how validation behaves

Live Demo
https://queryforge-demo.amtry.in

GitHub
https://github.com/awsaman-ai/queryforge