That particular post ends with a wish-list of items so it's the most similar to the OP. But there are others on the site that I quite enjoy (click on the home icon and search "SQL" on the page).
My personal take is that SQL will continue to reign for a long time because of the how monumental the task of replacing it is due to the inherent complexity of databases. LLMs make this worse because they're really good at translating prose to SQL. Now that it matters less how annoying SQL is to programmers, SQL will become more like assembly over time: something mostly computers write because it's complicated for humans to deal with directly. This is deeply ironic given that SQL was ostensibly designed to read like prose, i.e. to be easy for humans.
Rendello 3 hours ago [-]
The end of that article ends with a pertinent quote [1] by Michael Stonebraker [2]. I've included more of the original quote here:
> My biggest complaint about System R is that the team never stopped to clean up SQL. [...] All the annoying features of the language have endured to this day. SQL will be the COBOL of 2020, a language we are stuck with that everybody will complain about.
> My second biggest complaint is that System R used a subroutine call interface (now ODBC) to couple a client application to the DBMS. I consider ODBC among the worst interfaces on the planet. To issue a single query, one has to open a data base, open a cursor, bind it to a query and then issue individual fetches for data records. It takes a page of fairly inscrutable code just to run one query. [...] Only recently with the advent of Linq and Ruby on Rails are we seeing a resurgence of cleaner language-specific enbeddings (sic).
I was with him until he mentioned Ruby on Rails, is he talking about something other than the fairly ugly activerecord pattern?
2 hours ago [-]
ljm 12 hours ago [-]
Rawdogging SQL when you're not a seasoned DB administrator basically makes an arcane art look occult.
Most people reach out towards an ORM or query building engine and otherwise don't really go far beyond the basic CRUD, joins, and some simple aggregations with groups. Since they try to be DB agnostic you'll rarely get an adaptor over CTEs or window functions or partitioning.
An LLM is great at exposing what a database is capable of doing with SQL and might even manage to navigate the most poorly designed of schemas. And it might even manage to design one to an acceptable standard if it has enough domain knowledge in its context.
sgarland 3 hours ago [-]
> Rawdogging SQL when you're not a seasoned DB administrator basically makes an arcane art look occult.
Isn't that true of most languages? SQL has pretty simple syntax; I think the only reason it's sometimes seen as arcane is that fewer and fewer people bother to learn it.
alliao 41 minutes ago [-]
dba here and I really don't get why SQL is so feared... I get that it requires very different way to think about data but it is quite simple in terms of you tell it what to do, and if it does it badly you probably told it wrong so just try something different...
vjvjvjvjghv 11 hours ago [-]
The problem in my view is that there aren't good tools to debug advanced SQL stuff within the context of the whole system which is usually written in a higher level language. I just spent a few weeks modifying some code where the original dev put a lot of logic into stored procedures. That's in principle fine but it's really hard to figure the actual business logic when it's spread out over C# and then also SQL. It doesn't help that the SQL code looks like FORTRAN code from 1985.
Personally I think we need ORMs that allow expressing advanced SQL stuff with other high level languages. Or even better: The ORM detects where advanced SQL makes sense and uses it.
ljm 9 hours ago [-]
If I had to pick, I'd try to make the ORM redundant by making 'lower level' SQL easier to deploy rather than depending on sending strings of SQL queries and mutations over the wire.
I haven't worked in a single setup where raw SQL has been encouraged, because it always requires DB migrations and not all of them are safe. Nobody dares touch the DB server's resources by setting up stored procedures, materialised views, etc. etc. and instead people are blowing money on Redis instances and caching and shit.
I don't have an answer to this but I've hit a lot of issues in my career where I think, "this could have been solved months ago by pivoting a couple of tables or creating a new function." You have been able to 'script' the DB for decades but you lose a lot of what you gain from the traditional SDLC at the app layer.
bruce511 17 minutes ago [-]
For me, one of the primary benefits of ORMs is that they can parameterize requests which then prevents SQL injection attacks.
Passing raw SQL to the database needs very careful attention to the dynamic parts, and it's too easy for user-generated data to be included.
Yes, it's possible to pass user generated text through a sanitizer but now you just have an arms race between the sanitizer and "clever" users.
grebc 6 hours ago [-]
Dapper in .net is fantastic to deal with raw sql, to the point I think I’m delusional because it’s so damn simple to send outrageous queries to the database and have those multiple mixed results turned into objects very simply.
I’ve never had an issue of raw SQL requiring migrations? Unless you’re talking of changing database engine? In which case I think it’s a bit of folly to imagine changing the database engine will not mean changes to your stack higher up the chain.
catlifeonmars 1 hours ago [-]
> Rawdogging SQL when you're not a seasoned DB administrator basically makes an arcane art look occult.
This is kind of a hot take. Most devs I know know PostGreSQL well. They know how to write complex queries with CTAS, joins, etc, know how to create indexes, views, and add user defined functions.
reitzensteinm 12 hours ago [-]
LLMs are also very good at writing code for newly invented languages, especially if they can execute it and iterate. I strongly believe the barrier to switch languages is lowered in a post LLM world.
Ten years ago I was at a startup where we used Datomic, and it was okay, but six months in the sales team was like “ok how do I run SQL queries so I can triage leads”. We had no answer of course.
Today it would simply be: type what you want in natural language and we’ll generate the query with Claude.
I just tried one representative query from that startup against a hypothetical datalog query tool in Rust and it did just fine.
marcus_holmes 1 hours ago [-]
I did this with our team: I created a schema.md document with an LLM-friendly explanation of the schema, and walked the whole team through how to create a Grafana query using an LLM and this document.
Within a couple of weeks we have totally non-technical folks with very sophisticated queries in their dashboards. It works fine.
It was very cut-and-paste, though, and I'm working (when I get the chance) on doing this via a chat interface where the LLM can interact directly with the database and Grafana to make it smoother.
So I think the answer is not necessarily new languages, just better integration with the final interface. In an ideal world we should be able to ask in chat "what were the sales numbers for last quarter for APAC excluding the three largest customers?" and get an answer near-instantly, and then we don't really need to deal with queries or languages at all.
alliao 39 minutes ago [-]
did you use llm to create the llm-friendly schema.md? This sounds like a brilliant idea I might need to steal it... thanks!
huahaiy 2 hours ago [-]
Agree. Especially when Datalog queries are simpler to write and faster to run than SQL, there is a strong reason to at least try it.
scythmic_waves 8 hours ago [-]
I agree that an LLM could also generate the code for a new query language. But my point is that fewer people will attempt to author a new query language in the first place because an LLM will be writing the queries either way. So the effort would be less impactful.
reitzensteinm 8 hours ago [-]
You're right, I was talking past you.
I have an implicit belief that SQL isn't the most effective low level language we could have and LLMs will free us up to explore that space, similar to asm.js -> WASM. But I'm open to being wrong about that.
alliao 38 minutes ago [-]
I think it strikes a good balance between still human-readable and low-ish.. any lower I suspect you'd need to dedicate a lot more documentation else where..
huahaiy 2 hours ago [-]
Datalog exists and there are so many implementations.
First paragraph of preface: “SQL has been the default language of application databases for half a century. That default is now holding application state back. Datalevin is a database built to replace SQL databases at the center of application systems: it stores data as small facts and queries those facts with Datalog”
The implementations are not high performance, but if you can fit everything in memory or you can organize your data and integrate it through external queries, you should get something workable for a lot of use cases.
I did not set out to replace SQL, and while I don't mind adoption, that is not why I am sharing it here. The open sourcing was motivated by making datalog more widely known. I did some research and found out that I needed a datalog implementation with particular characteristics, I for sure knew I didn't want to use SQL for what I needed.
There are structured types and recursion and being able to name predicates and compose queries... Mangle has some users and there is a few application that take advantage of the queries-as-logic-programming approach.
I think an insight one can draw in this discussion that a query language and the system (DBMS implementation) that it is part of can hardly be separated when it comes to the inevitable performance requirements one has.
AlotOfReading 3 hours ago [-]
That's a pretty cool pair of repos. I've been working on a C++ Datalog myself [0] for embedded queries over in-memory datasets. It's been surprisingly useful for a bunch of different usecases (e.g. build graphs). My implementation is faster than Souffle on all the benchmarks I've tried, but apparently I still have some work to do optimizing startup time on small graphs.
As a meta comment, I can handle code blocks without syntax highlighting, and I can handle code blocks that wrap. But both together with long comments just turn into line noise. There's no longer any useful visual signal for how to read them. On my phone the code blocks are simply impossible to meaningfully parse.
froh 8 hours ago [-]
landscape it is not good but okay-ish on my phone display. hth.
Sounds a lot like Spark before it became so enterprise-focused. Back in my day we wrote scala to run our queries, and once we figured out how to get our compiler and runtime set up, we liked it!
I’ve been getting into Postgres recently and I was very surprised how easy it is to introduce new types/operators/etc through C code. I’m not talking about domains. Just write some C and you can have whatever type you want. It really demystified “extensions” for me, I actually think that is an actively harmful name (it sounds clunky, gross, based on my experience dealing with “extension” and “plugins” elsewhere) for what is essentially just custom types/functions. More people should try writing their own postgres extensions. It’s not very difficult at all!
I’ve been cooking in this space for quite a while (HDFS/spark, Apache Pinot, proprietary stuff, an experimental functional ORM over SQLite). The biggest problem, I think, is the interface between the management/admin, application, and “query” layers. I think something like grpc/protoc (or indeed the way Spark used the JVM) is needed to provide non-leaky abstractions and more programmatic/structured interfaces from the DB to its clients. Happy to share more, but basically, the database needs to become capable of general (meta-)parsing with a reflective type system, I think.
mikewarot 9 hours ago [-]
My ask is 15 years old[1], a live SQL extension. Allow a query to be a subscription to a database, so any updates get streamed as deltas to a listening client. There were a ton of times in my time using SQL where the same query is run over and over, just to get/handle that delta.
Wouldn't it be a lot more efficient to just work that way in the first place?
You can get callbacks from the driver as query results change, or have notifications be sent to stored procedures, or posted to a message queue (and from there turned into web hooks etc). The notification comes with info about the deltas.
The main issue with it is that the queries it can monitor live are a subset of all queries. It's really more like using SQL to select database cells to watch, than propagating changes through arbitrary query plans. For example, it can't handle a SELECT COUNT(*) FROM statement. Obviously you can use it as a trigger for re-running more advanced queries though.
DenisM 7 hours ago [-]
Snowflake has STREAM which can be crated on a view. It also has Dynamic Tables, from which you read a delta using STREAM or using row timestamp.
SQL server has Query Notification.
You can also read from debezium or other cdc, but thats more like table change than query result change.
grebc 6 hours ago [-]
Sounds like you want to read the log file to be honest.
convolvatron 7 hours ago [-]
pg logical replication is close to this. but ideally you want incremental query updates, which I believe Materialize provides.
but yes, I agree this is quite often what one wants, and would remove a lot of grot from the client
nylonstrung 9 hours ago [-]
PRQL is one of the best attempts at a new query language IMO
I've been working on a Lean4-based query lang that compiles to substrait, I think the power it has wrt to types and functional programming could improve on SQL ergonomics a good deal
3eb7988a1663 13 hours ago [-]
Can someone explain to me why SQL error messages are so bad? I routinely have some monster query where the message is effectively, "Illegal syntax somewhere, dufus".
bawolff 13 hours ago [-]
I'd guess people just haven't put much effort into it. Lots of programming language compilers have absolutely terrible error messages. In SQL its usually just one line, so "somewhere" isn't that big a place.
klysm 13 hours ago [-]
This sounds like a proper of the parser, rather than of the language
derriz 13 hours ago [-]
A long time ago, I had to write SQL parsers (for 3 of the most popular DBs at the time). It is a surprisingly difficult language to parse and disambiguate - particularly when having to deal with the warts of its variants. Sure it's not quite C++ but it's was easily the most annoying parser work I ever had to do. And in my experience, the trickier it is to parse a particular language, the more difficult it is to provide feedback to users in the form of helpful parse errors.
appplication 12 hours ago [-]
This is true, but the observation is still salient. There does seem to be some correspondence between languages with inherent friction and parsers that aren’t interested in being helpful. E.g. sometimes a user base just collectively decides they’re ok with some level of pain.
YuechenLi 12 hours ago [-]
SQL is what it is today because it is battle tested and has to handles a very hard problem of handling arbitrary concurrent reads/writes, so the likely scenario is that trying to replace general SQL wholesale will just end up making a worse, less tested version of SQL that developers are less familiar with. So, I think the best query language is probably whatever query feature that's already in your backend language, LINQ for C# for example. The only room for an SQL replacement in my opinion is if you are willing to trade flexibility for speed a la TigerBeetle.
The good thing about having built your own programming language via LLM nowadays is that you don't really have to speculate about a theoretical language when you can just have Codex/Claude implement it and try it out for yourself. I did it yesterday when I wanted to try out this theoretical high-performance database architecture that I had in mind and just added query functionalities to the language I already have.
If anyone is interested about the results, the default naive mode for this new database is ~0.2x the speed of concurrent durable mutation workloads, but if you specialize it to the particular application, you can get ridiculous 50-100x performance increases on filters and maps at the cost of flexibility and more upfront design. Experimental results are promising, definitely not production ready though.
calvinmorrison 12 hours ago [-]
doesnt meant the syntax isnt a pile of dog farts
YuechenLi 11 hours ago [-]
I agree, yeah, SQL syntax is awful. But the easier solution is what pretty much what backend has converged on, have something in your backend programming language that lowers to SQL so you never have to write any raw SQL at all except as a low-level escape hatch, so that in most instances SQL just becomes an IR that nobody really needs to think about in normal application code.
drfloyd51 11 hours ago [-]
Are we really this devolved as coders? We can’t handle different syntaxes? We need LLMs to write queries? What the heck is going on with our industry?
Old man rant off.
3eb7988a1663 11 hours ago [-]
I don't take it as too-much-syntax in the brain[0], but all of the problems bad syntax causes. We could still be writing code in assembly, but we have found that different languages make things easier or safer to construct.
I can trivially handle having to repeatedly bounce to the top-then-to-the-bottom of a query I am writing because I want to change the group-by or sorting order, but that is annoying friction. Since the language does not compose well, you need to keep most of the query in your head and cannot build it up piecemeal as easily as something like PRQL (https://prql-lang.org/)
[0] Although, it would be incredible if I could write timestamp formatting without having to look up the bespoke vendor incantation every time I switch dialects.
DenisM 7 hours ago [-]
Does CTE not allow composability?
zbentley 9 hours ago [-]
The difficulties that even experienced programmers have with SQL are far more than just the syntax. And, given what most people need the database for, that difficulty is pretty disproportionate to the complexity of the task.
I think the “it’s just syntax bro, learn it!” critique is about as ill-fitting as the claim that embedding a scripting language in a larger program is pointless because “assembly/C89 is just syntax bro, learn it!”
grebc 7 hours ago [-]
I take what you’re saying about difficulty being disproportionate to the task as an indicator of ability.
It’s literally so damn simple to knock out a database & some crud functions either as a desktop app or a website that the complaints in this thread are hilarious.
zbentley 5 hours ago [-]
That comes across as arrogant and rude. Assuming you actually want to engage, I discussed some of the reasons that this can be hard here: https://news.ycombinator.com/item?id=49411927
Particularly relevant is the part of that link which discusses having to pervasively refactor queries to add even a simple synthetic join or computed column. That’s a pain in the ass even for experienced DBAs, and is fundamentally not time well spent for row-at-a-time cases that are often, as you said, simple CRUD.
Are you sure you aren’t overfitting based on working on only one small, simple subset of the things people commonly use SQL for?
grebc 3 hours ago [-]
The example of pervasive refactor is a bit of a contrived example to be honest. Get the id of the record you're discussing with your pre-conditions and then retrieve the data you're after.
At least in SQL Server select x2 from foo group by x+1 as x2 you'd use select x+1 as x2 from foo group by x.
I've read your article and it's written well enough, I'm just not sure that's as big a hit piece as you think it is nor do I think here is the place to post a full rebuttal.
>Are you sure you aren’t overfitting based on working on only one small, simple subset of the things people commonly use SQL for?
I think on the contrary that esoteric features not used as commonly utilised deserve to be esoteric to use. The common path should be the easiest. That SQL is used by different professions and not just IT related ones is testament to a good language. You won't find BA's using C to write reports for instance. There's A LOT of value in that.
goatlover 9 hours ago [-]
Not even an old man rant SQL isn't that hard to learn. I never had a problem with the syntax. Not everything needs to look like C. Remember when every complained about Python's whitespace indenting? Seems like everyone got over it.
g-b-r 11 hours ago [-]
Syntax affects readability and writing speed a lot
g-b-r 11 hours ago [-]
No, SQL is what it is today because it was crappy in the beginning and no one managed to replace it.
It was only a partial implementation of the relational model, we could have been so much better had it not become the standard
YuechenLi 11 hours ago [-]
The sad reality is that having something that works, even if badly, is better than having a theoretically elegant architecture that is not implemented. See JS or Linux vs Hurd for other examples.
Ask yourself this question, supposedly somebody made the full implementation of the relationship model into a database engine tomorrow, will you use it yourself, and can you convince your company to use it in place of SQL? Again, I wish this wasn't the case, but I'm not sure if there is anything we can do about the adoption problem.
veqq 7 hours ago [-]
...but we've had full implementations of the relational model for decades, with great performance etc. It's just a query language. A DB can use whatever query language it implements. Just like JS, there were schemes before JS (including the working browser one before management made Eich redo it into JS), there were other languages used in the browser even!
grebc 7 hours ago [-]
It’s a fine tool for most data storage/retrieval jobs.
Crying about some theoretical relational model doesn’t do anything to further your point.
g-b-r 4 hours ago [-]
No one cries about theoretical things
gonzalohm 9 hours ago [-]
Nothing around better error handling or schema updates? After working with SQL for 10+ years those are definitely the things I miss.
For error handling I mean things like deprecating a column and allowing a custom error message when someone queries it.
And for schema updates I mean allowing table versions. Same table name but allowing querying an older version of the schema
grebc 7 hours ago [-]
I like the idea of deprecating a column and getting a warning so much. Also versioned data built-in I would love.
tmoertel 13 hours ago [-]
The problem with alternative query languages is that the people who have the most knowledge about creating queries and of the relational domains underlying their businesses are all experts in SQL. Introducing something else, then, means your most natural user base must migrate away from something they understand how to use well, and that's a hard sell.
So, until the ultimate query language is developed, I'll take SQL with pipes. It's an easy sell and good enough to eliminate 90% of my gripes about SQL.
taybin 13 hours ago [-]
This is exactly the same problem facing people trying to develop new music notations. In order to grasp the domain enough, they have to be experts in the existing music notation, and once you're an expert in it, the motivation to create something new goes away. From what I've seen, the people who want a new music notation are mostly people uncomfortable with sight reading.
AlotOfReading 12 hours ago [-]
Experts have been criticizing SQL since it was a proprietary IBM language. Take this typewritten rant from 1983 [0] as an example. And we've had better query languages for just as long, e.g. datalog. People really love SQL though, which I can only assume is because the vast majority of usecases are slight variations on SELECT * FROM table.
They might love the relational model concepts that manage to seep through it
likium 12 hours ago [-]
Exactly, we all know the merits of Esperanto, but few have switched away from English.
smitty1e 13 hours ago [-]
For example, Elastic.
Much extra learning curve for little obvious gain.
I like to say, with zero research basis, that the New Shiny has to be an order of magnitude better than the Old Thing for people to say "Oh yeah, I gotta have that."
brianolson 9 hours ago [-]
SQL is the worst way to access a database, except for all of the others that have been tried from time to time
UltraSane 9 hours ago [-]
Cypher is pretty nice.
Southclaws 12 hours ago [-]
this is exactly why i built Rad: a relational db with an IR as its public interface, so you can experiment with interesting query languages against a solid foundation and a real planner without needing to compile-up to sql (radengine.dev)
crabmusket 3 hours ago [-]
Oh this is awesome. This is exactly what I've been too lazy to build for years now.
We don't need a new syntax. SQL, PRQL or whatever else should compile down to the database's machine readable interface, same as language-integrated query builders or libraries like your generated clients.
Did you come across Substrait when working on this? Any thoughts?
This also sounds like what Turso imagine doing with their VDBE:
> Like SQLite, it compiles SQL into bytecode for that machine, the VDBE, and then runs the bytecode. That design is what lets one engine host more than one SQL dialect. SQLite is the first and primary frontend that compiles to it, and Postgres is now a frontend of its own, with its own dialect and wire protocol. More will follow. Our goal is to be for databases what LLVM is to compilers, with one modern and reliable core, and many frontends compiled down onto it.
dzonga 8 hours ago [-]
for most 'application' like workloads not analytics - standardizing or improving on mongo-query language (MQL) would be welcome.
the drawback is your query patterns have to be known before hand when designing your application. which isn't really a drawback since you're doing it before building the application. & hence not as flexible as SQL.
speedstyle 11 hours ago [-]
I don't want a query language. I want to call and profile typed functions like normal data structures, and which use (low-level/non-declarative) RPC where needed
zbentley 9 hours ago [-]
I don’t think that extreme is compatible with the reporting/analytics use case of SQL DBs. Even though entire roles/companies may never touch that kind of SQL, there’s a massive quantity of it out there.
I once worked on a medical records system (with a pretty well designed but necessarily complex schema) where the primary “patient” data object used by most code was fetched by a query that, depending on what associated data you needed, had between 106 and more than 400 relations (across dozens to hundreds of tables) joined together.
And that was CRUDy data-path code. The OLAP/reporting side added zeros to those numbers. Query texts were often hundreds of kilobytes.
speedstyle 6 hours ago [-]
Could the same queries be 'planned', compiled down to pipelined KV operations, by the requester? I don't see that this is inherently less capable. You could even use an existing ORM – though I think you can do better when not compiling to something declarative, maybe more like polars.
I feel like databases effectively (/literally) add a JIT, which can mostly figure out what to do, even has accurate heuristics on the distribution of the data, but in exchange you get a less deterministic system, and less intuition for how to query or structure things. It's like, you know when to use a list/map/queue, but you want to focus on the business logic, so just use a smart collections which guess at runtime.
I think you can get this with FoundationDB, I should experiment rather than hypothesizing, but it feels like it would be nicer
zbentley 5 hours ago [-]
It’s theoretically possible to do that kind of planning on the client, but difficult and not worth it compared to letting the database do it. Especially for reporting, there’s another disadvantage: many query planners use runtime statistics from the database to build the plan; synchronizing those onto the client would be difficult and error-prone.
But why bother? If I have a thousand clients that all want to run a query, why compile the plan a thousand times (and build/distribute the local planner to all of the different clients’ platforms) when I could send a query and have the database plan and cache the query once?
speedstyle 4 hours ago [-]
For most cases I mean compiled into the client, not planned at runtime. And yes, explicitly trading away access to the live latencies and data distribution (except maybe for interactive analysts) – if you want a better query you profile and edit the client, like with any other service. Or in the JIT analogy, writing Go/Rust over JS/Java, using experience and profile-guided optimization but not realtime heuristics. Certainly this would make it easier to improve on bad plans, but that's survivorship bias, maybe I don't understand how many currently-good executions a more naive abstraction wouldn't produce.
a2ff6eeb0 13 hours ago [-]
This would have been interesting about a decade ago, but today AIs all know SQL, and I haven't written it myself in a while.
Since it seems like the quantity of training data dominates AI performance, and AI doesn't yet internalize experience with new tools, it seems like a bad idea to stray from the training set.
Without repeatable benchmarks, it feels like obsessing over a language's syntax and semantics feels a little like debating whether you write assembly using AT&T or Intel syntax.
ModernMech 13 hours ago [-]
AIs would benefit from better query languages for the same reasons people would.
a2ff6eeb0 12 hours ago [-]
The difference is that the bulk of what an AI knows is baked in when it's trained, at least for now. There's no way for it to learn a language and improve with it.
ModernMech 10 hours ago [-]
That's not quite true in my experience; AI can pick up new languages very quickly and are able to adapt to novel syntax and semantics with just a description and a few examples. What's also baked into the AI are decades of PL research and it can quickly deploy esoteric PL concepts not found in 99% of languages.
In my experience it's rather people who have the most trouble with new languages, as the difference between the PL frontier and languages that most people use is quite extreme.
Conversely, AI is adept at staking out a point in the PL design space and developing a grammar and vocabulary around it. Then it writes a parser and interpreter to execute whatever semantics, writes a standard library to support writing programs, and finally writes the compiler in itself.
Because it's so good at doing this you can do a lot of exploration whereas before it would take years now it takes months.
a2ff6eeb0 8 hours ago [-]
It'll do something, but with a higher error rate and far more iterations needed.
ModernMech 8 hours ago [-]
Again it's just not been my experience through testing so I'm curious what kind of measurements you're citing here.
Thanks, yeah I remember when that made the rounds a couple weeks ago. Although what I'm proposing is a little different than what's covered there: the AI designing a language for a particular task, writing the runtime to implement the language, and then solving the task in the language it designed. The blog rather is about how an AI performs with languages designed by people for general purposes.
a2ff6eeb0 7 hours ago [-]
What evals did you use to compare that to using an existing language with a large corpus of training data?
What benchmarks did they use? It seems like on larger tasks, having the LLM be familiar with the language through a large volume of training data will compactness and tenseness.
I think part of the issue is that SQL is nice for some things (do some aggregation on a row-filtered subset of columns) but perhaps not as much for other things (a query where later rows depend on earlier rows in complex ways). I think being able to compile a procedural programming language to SQL would be pretty nice for the latter.
NetMageSCW 10 hours ago [-]
See LINQ?
mrkeen 8 hours ago [-]
I love LINQ's syntax and monadic API, but that's about it.
It speed-runs juniors into thinking they are writing transactional code when they aren't.
And for seniors who are more aware of footguns and try to be careful, they're met with an inability to do so (e.g. upserts).
I wan't easier ways to work with nested structures, like relationships. All this flat table structure is a pain.
convolvatron 10 hours ago [-]
the only real differences between a query language and a normal language are quantification and unification. quantification is something that seems pretty easy to paper over (i.e by just having functions that operate on Set types).
SPJ is/was working on a lanauge Verse which provides a procedural looking language that is actually either fully unification or region-based under the hood. trivially this is just allowing relations (tables or functions) to implement only a subset of input/output signatures
so yes, I think its a great idea to just smoosh the two together, particularly if its in a host language with sufficient meta programming facilities to extract out the relational parts and evaluate them as streams
zoolo 13 hours ago [-]
Check out CodeQL, it's a modern relational query language based on Datalog.
esafak 13 hours ago [-]
Database engineers have to be the change they want to see and add support for newer query languages.
flir 12 hours ago [-]
The early-2ks crop of NoSQL solutions have all got SQL baked in now, haven't they?
Maybe when they've achieved wide adoption for a better language than SQL, they can work on getting rid of qwerty keyboards...
convolvatron 12 hours ago [-]
that is a pretty difficult place to apply leverage. if you don't support SQL you're at a big competitive disadvantage. because its a weird design with lots of sharp edges that's going to take a lot of your time - customers are going to be unhappy that you don't support the knobs and frills from their existing environment.
so you can certainly float an alternate QL on top of the same base, but its going to be hard to drive uptake. you can translate SQL to your internal variant, but oddities like group by are going to twist your internal model.
at this point I think its more interesting to start to deconstruct these large software systems like OSes and databases and move the composition of systems down a step.
https://www.scattered-thoughts.net/writing/against-sql
That particular post ends with a wish-list of items so it's the most similar to the OP. But there are others on the site that I quite enjoy (click on the home icon and search "SQL" on the page).
My personal take is that SQL will continue to reign for a long time because of the how monumental the task of replacing it is due to the inherent complexity of databases. LLMs make this worse because they're really good at translating prose to SQL. Now that it matters less how annoying SQL is to programmers, SQL will become more like assembly over time: something mostly computers write because it's complicated for humans to deal with directly. This is deeply ironic given that SQL was ostensibly designed to read like prose, i.e. to be easy for humans.
> My biggest complaint about System R is that the team never stopped to clean up SQL. [...] All the annoying features of the language have endured to this day. SQL will be the COBOL of 2020, a language we are stuck with that everybody will complain about.
> My second biggest complaint is that System R used a subroutine call interface (now ODBC) to couple a client application to the DBMS. I consider ODBC among the worst interfaces on the planet. To issue a single query, one has to open a data base, open a cursor, bind it to a query and then issue individual fetches for data records. It takes a page of fairly inscrutable code just to run one query. [...] Only recently with the advent of Linq and Ruby on Rails are we seeing a resurgence of cleaner language-specific enbeddings (sic).
1. http://www.redbook.io/ch2-importantdbms.html
2. https://en.wikipedia.org/wiki/Michael_Stonebraker
Most people reach out towards an ORM or query building engine and otherwise don't really go far beyond the basic CRUD, joins, and some simple aggregations with groups. Since they try to be DB agnostic you'll rarely get an adaptor over CTEs or window functions or partitioning.
An LLM is great at exposing what a database is capable of doing with SQL and might even manage to navigate the most poorly designed of schemas. And it might even manage to design one to an acceptable standard if it has enough domain knowledge in its context.
Isn't that true of most languages? SQL has pretty simple syntax; I think the only reason it's sometimes seen as arcane is that fewer and fewer people bother to learn it.
Personally I think we need ORMs that allow expressing advanced SQL stuff with other high level languages. Or even better: The ORM detects where advanced SQL makes sense and uses it.
I haven't worked in a single setup where raw SQL has been encouraged, because it always requires DB migrations and not all of them are safe. Nobody dares touch the DB server's resources by setting up stored procedures, materialised views, etc. etc. and instead people are blowing money on Redis instances and caching and shit.
I don't have an answer to this but I've hit a lot of issues in my career where I think, "this could have been solved months ago by pivoting a couple of tables or creating a new function." You have been able to 'script' the DB for decades but you lose a lot of what you gain from the traditional SDLC at the app layer.
Passing raw SQL to the database needs very careful attention to the dynamic parts, and it's too easy for user-generated data to be included.
Yes, it's possible to pass user generated text through a sanitizer but now you just have an arms race between the sanitizer and "clever" users.
I’ve never had an issue of raw SQL requiring migrations? Unless you’re talking of changing database engine? In which case I think it’s a bit of folly to imagine changing the database engine will not mean changes to your stack higher up the chain.
This is kind of a hot take. Most devs I know know PostGreSQL well. They know how to write complex queries with CTAS, joins, etc, know how to create indexes, views, and add user defined functions.
Ten years ago I was at a startup where we used Datomic, and it was okay, but six months in the sales team was like “ok how do I run SQL queries so I can triage leads”. We had no answer of course.
Today it would simply be: type what you want in natural language and we’ll generate the query with Claude.
I just tried one representative query from that startup against a hypothetical datalog query tool in Rust and it did just fine.
Within a couple of weeks we have totally non-technical folks with very sophisticated queries in their dashboards. It works fine.
It was very cut-and-paste, though, and I'm working (when I get the chance) on doing this via a chat interface where the LLM can interact directly with the database and Grafana to make it smoother.
So I think the answer is not necessarily new languages, just better integration with the final interface. In an ideal world we should be able to ask in chat "what were the sales numbers for last quarter for APAC excluding the three largest customers?" and get an answer near-instantly, and then we don't really need to deal with queries or languages at all.
I have an implicit belief that SQL isn't the most effective low level language we could have and LLMs will free us up to explore that space, similar to asm.js -> WASM. But I'm open to being wrong about that.
First paragraph of preface: “SQL has been the default language of application databases for half a century. That default is now holding application state back. Datalevin is a database built to replace SQL databases at the center of application systems: it stores data as small facts and queries those facts with Datalog”
The implementations are not high performance, but if you can fit everything in memory or you can organize your data and integrate it through external queries, you should get something workable for a lot of use cases.
I did not set out to replace SQL, and while I don't mind adoption, that is not why I am sharing it here. The open sourcing was motivated by making datalog more widely known. I did some research and found out that I needed a datalog implementation with particular characteristics, I for sure knew I didn't want to use SQL for what I needed.
There are structured types and recursion and being able to name predicates and compose queries... Mangle has some users and there is a few application that take advantage of the queries-as-logic-programming approach.
I think an insight one can draw in this discussion that a query language and the system (DBMS implementation) that it is part of can hardly be separated when it comes to the inevitable performance requirements one has.
[0] https://github.com/J-Montgomery/dartfrog
(https://news.ycombinator.com/item?id=24106608, https://news.ycombinator.com/item?id=19871051)
I’ve been getting into Postgres recently and I was very surprised how easy it is to introduce new types/operators/etc through C code. I’m not talking about domains. Just write some C and you can have whatever type you want. It really demystified “extensions” for me, I actually think that is an actively harmful name (it sounds clunky, gross, based on my experience dealing with “extension” and “plugins” elsewhere) for what is essentially just custom types/functions. More people should try writing their own postgres extensions. It’s not very difficult at all!
I’ve been cooking in this space for quite a while (HDFS/spark, Apache Pinot, proprietary stuff, an experimental functional ORM over SQLite). The biggest problem, I think, is the interface between the management/admin, application, and “query” layers. I think something like grpc/protoc (or indeed the way Spark used the JVM) is needed to provide non-leaky abstractions and more programmatic/structured interfaces from the DB to its clients. Happy to share more, but basically, the database needs to become capable of general (meta-)parsing with a reflective type system, I think.
Wouldn't it be a lot more efficient to just work that way in the first place?
[1] http://livesql.org/ <--- just a few paragraphs of text from 2011
https://docs.oracle.com/en/database/oracle/oracle-database/2...
You can get callbacks from the driver as query results change, or have notifications be sent to stored procedures, or posted to a message queue (and from there turned into web hooks etc). The notification comes with info about the deltas.
The main issue with it is that the queries it can monitor live are a subset of all queries. It's really more like using SQL to select database cells to watch, than propagating changes through arbitrary query plans. For example, it can't handle a SELECT COUNT(*) FROM statement. Obviously you can use it as a trigger for re-running more advanced queries though.
SQL server has Query Notification.
You can also read from debezium or other cdc, but thats more like table change than query result change.
but yes, I agree this is quite often what one wants, and would remove a lot of grot from the client
I've been working on a Lean4-based query lang that compiles to substrait, I think the power it has wrt to types and functional programming could improve on SQL ergonomics a good deal
The good thing about having built your own programming language via LLM nowadays is that you don't really have to speculate about a theoretical language when you can just have Codex/Claude implement it and try it out for yourself. I did it yesterday when I wanted to try out this theoretical high-performance database architecture that I had in mind and just added query functionalities to the language I already have.
If anyone is interested about the results, the default naive mode for this new database is ~0.2x the speed of concurrent durable mutation workloads, but if you specialize it to the particular application, you can get ridiculous 50-100x performance increases on filters and maps at the cost of flexibility and more upfront design. Experimental results are promising, definitely not production ready though.
Old man rant off.
I can trivially handle having to repeatedly bounce to the top-then-to-the-bottom of a query I am writing because I want to change the group-by or sorting order, but that is annoying friction. Since the language does not compose well, you need to keep most of the query in your head and cannot build it up piecemeal as easily as something like PRQL (https://prql-lang.org/)
[0] Although, it would be incredible if I could write timestamp formatting without having to look up the bespoke vendor incantation every time I switch dialects.
I think the “it’s just syntax bro, learn it!” critique is about as ill-fitting as the claim that embedding a scripting language in a larger program is pointless because “assembly/C89 is just syntax bro, learn it!”
It’s literally so damn simple to knock out a database & some crud functions either as a desktop app or a website that the complaints in this thread are hilarious.
The link in the top comment further expands on the cognitive overhead: https://www.scattered-thoughts.net/writing/against-sql
Particularly relevant is the part of that link which discusses having to pervasively refactor queries to add even a simple synthetic join or computed column. That’s a pain in the ass even for experienced DBAs, and is fundamentally not time well spent for row-at-a-time cases that are often, as you said, simple CRUD.
Are you sure you aren’t overfitting based on working on only one small, simple subset of the things people commonly use SQL for?
At least in SQL Server select x2 from foo group by x+1 as x2 you'd use select x+1 as x2 from foo group by x.
I've read your article and it's written well enough, I'm just not sure that's as big a hit piece as you think it is nor do I think here is the place to post a full rebuttal.
>Are you sure you aren’t overfitting based on working on only one small, simple subset of the things people commonly use SQL for?
I think on the contrary that esoteric features not used as commonly utilised deserve to be esoteric to use. The common path should be the easiest. That SQL is used by different professions and not just IT related ones is testament to a good language. You won't find BA's using C to write reports for instance. There's A LOT of value in that.
It was only a partial implementation of the relational model, we could have been so much better had it not become the standard
Ask yourself this question, supposedly somebody made the full implementation of the relationship model into a database engine tomorrow, will you use it yourself, and can you convince your company to use it in place of SQL? Again, I wish this wasn't the case, but I'm not sure if there is anything we can do about the adoption problem.
Crying about some theoretical relational model doesn’t do anything to further your point.
For error handling I mean things like deprecating a column and allowing a custom error message when someone queries it.
And for schema updates I mean allowing table versions. Same table name but allowing querying an older version of the schema
So, until the ultimate query language is developed, I'll take SQL with pipes. It's an easy sell and good enough to eliminate 90% of my gripes about SQL.
[0] https://courses.cs.duke.edu/spring03/cps216/papers/date-1983...
They might love the relational model concepts that manage to seep through it
I like to say, with zero research basis, that the New Shiny has to be an order of magnitude better than the Old Thing for people to say "Oh yeah, I gotta have that."
We don't need a new syntax. SQL, PRQL or whatever else should compile down to the database's machine readable interface, same as language-integrated query builders or libraries like your generated clients.
Did you come across Substrait when working on this? Any thoughts?
This also sounds like what Turso imagine doing with their VDBE:
> Like SQLite, it compiles SQL into bytecode for that machine, the VDBE, and then runs the bytecode. That design is what lets one engine host more than one SQL dialect. SQLite is the first and primary frontend that compiles to it, and Postgres is now a frontend of its own, with its own dialect and wire protocol. More will follow. Our goal is to be for databases what LLVM is to compilers, with one modern and reliable core, and many frontends compiled down onto it.
the drawback is your query patterns have to be known before hand when designing your application. which isn't really a drawback since you're doing it before building the application. & hence not as flexible as SQL.
I once worked on a medical records system (with a pretty well designed but necessarily complex schema) where the primary “patient” data object used by most code was fetched by a query that, depending on what associated data you needed, had between 106 and more than 400 relations (across dozens to hundreds of tables) joined together.
And that was CRUDy data-path code. The OLAP/reporting side added zeros to those numbers. Query texts were often hundreds of kilobytes.
I feel like databases effectively (/literally) add a JIT, which can mostly figure out what to do, even has accurate heuristics on the distribution of the data, but in exchange you get a less deterministic system, and less intuition for how to query or structure things. It's like, you know when to use a list/map/queue, but you want to focus on the business logic, so just use a smart collections which guess at runtime.
I think you can get this with FoundationDB, I should experiment rather than hypothesizing, but it feels like it would be nicer
But why bother? If I have a thousand clients that all want to run a query, why compile the plan a thousand times (and build/distribute the local planner to all of the different clients’ platforms) when I could send a query and have the database plan and cache the query once?
Since it seems like the quantity of training data dominates AI performance, and AI doesn't yet internalize experience with new tools, it seems like a bad idea to stray from the training set.
Without repeatable benchmarks, it feels like obsessing over a language's syntax and semantics feels a little like debating whether you write assembly using AT&T or Intel syntax.
In my experience it's rather people who have the most trouble with new languages, as the difference between the PL frontier and languages that most people use is quite extreme.
Conversely, AI is adept at staking out a point in the PL design space and developing a grammar and vocabulary around it. Then it writes a parser and interpreter to execute whatever semantics, writes a standard library to support writing programs, and finally writes the compiler in itself.
Because it's so good at doing this you can do a lot of exploration whereas before it would take years now it takes months.
See https://danluu.com/pl-tokens/
It speed-runs juniors into thinking they are writing transactional code when they aren't.
And for seniors who are more aware of footguns and try to be careful, they're met with an inability to do so (e.g. upserts).
SPJ is/was working on a lanauge Verse which provides a procedural looking language that is actually either fully unification or region-based under the hood. trivially this is just allowing relations (tables or functions) to implement only a subset of input/output signatures
so yes, I think its a great idea to just smoosh the two together, particularly if its in a host language with sufficient meta programming facilities to extract out the relational parts and evaluate them as streams
Maybe when they've achieved wide adoption for a better language than SQL, they can work on getting rid of qwerty keyboards...
so you can certainly float an alternate QL on top of the same base, but its going to be hard to drive uptake. you can translate SQL to your internal variant, but oddities like group by are going to twist your internal model.
at this point I think its more interesting to start to deconstruct these large software systems like OSes and databases and move the composition of systems down a step.