no.. just no

Honestly more readable than a lot of SQL I've read. It even has hierarchical grouping.

I was disgusted by the XML at first, but it's a readable query returning a sane JSON object.

Meanwhile, I'm mantaining Java code where the SQL is a perfectly square wall of text, and some insane mofo decided the way to read the resulting list of Object[] 🤮 is getting each column by index... so I'd switch to SQXMLL in a heartbeat.
- React basically figured out how to make XML work.
  
  Remember, XML was actually designed for use cases like this, that’s why it came with XPath and XSLT, which let you make it executable in a sense by performing arbitrary transformations on an XML tree.
  
  Back in the day, at my first coding job, we had an entire program that had a massive data model encoded in XML, and we used a bunch of XSL to programmatically convert that into Java objects, SQL queries, and HTML forms. Actually worked fairly well, except of course that XSL was an awful language to do that all in.
  
  React simply figured out how to use JavaScript as the transformation language instead.
- it's a readable query returning a sane JSON object.
  
  No it's not. What table is the data supposed to be coming from..?
- Check out JOOQ.
true, but having it look like a component might get annoying. since this is likely to stay at the top, having an island of non components between two components might make it hard to see where functions start and end. and if this isn't used directly inside a component it'll just look dumb and inefficient (this also looks like it'll take way more to edit once you change something)
- I think I agree with you both. I'm not a Node developer; could you keep your SQL objects/components in a separate file so that they don't clutter up other logic?
It is so readable that you missed the fact it doesn’t have the FROM clause

Honestly not the worst thing I’ve seen.

I'd like you to think for a moment about CTEs, the HAVING clause, window functions and every other funky and useful thing you can do in SQL ... Now just think, do you think that this syntax supports all those correctly?
- sql syntax doesn't support even itself correctly i fail to see your point
- Probably no better or worse than any other ORM written in a more traditional language. Worst comes to worst, you can always escape to plain SQL.
- You'd certainly have to have a CTE to even entertain the thought of using this syntax in the real world.

Ah yes. That's what the kids call "sqlx" right?

NGL, if it has real time code completion and compile time SQL checks, this is fine.

I actually like this. This would allow reuse of all the infrastructure we have around XML. No more SQL injection and dealing with query parameters? Sign me up!

Assuming it's built well. As someone else pointed out, it doesn't look quite right here.
So you mean like parameterized queries, which exist?
- Better than parameterized queries. Yes, we have stuff like query("INSERT INTO table(status, name) VALUES ($1, $2);").bind(ent.status).bind(ent.name).execute..., but that's kind of awful isn't it? With XML queries, we could use any of the XML libraries we have to create and manipulate XML queries without risking 'XML injection'. e.g we could convert ordinary structs/classes into column values automatically without having to use any ORM.

Not only is this really gross, it's also straight up wrong. It's missing a from clause, and it makes no sense for a where clause to be nested under the select. The select list selects columns from rows that have already been filtered by the where clause. Same for the limit.

Also just gonna go ahead and assume the JSX parser will happily allow SQL injection attacks...

I like the format, though.
- Clearly you've not had to write and maintain much XML.
Booooo

I want to hate this. I really do. But the problem is… I think I like it.

But how do I know if the WHERE clause is AND or OR?
- We can say default is and and add an Or node for or. Similar to SoP notation, you only write +.
- Fair. The constraint nodes should probably exist under an And or Or node.
This needs a bit of work but it could be interesting

When you are assigned to write database queries at work and your academical background is that online react bootcamp

if you don't believe that adding more structure to the absolute maniacal catastrophe that is sql is a good thing then i'm going to start to have doubts about your authenticity as a human being

If you think this is more structured than traditional SQL, I really disagree. Is this a select * query, it's ambiguous. Also what table is being queried here there's no from or other table identifier.
Me trying to remember on whose output data having, count, sum, etc. work

Once you know functions you would have no reason to go back.
I propose we make SQL into this:

const MAX_AMOUNT = 42, MIN_BATCHES = 2 database .from(table) .where( (amount) => amount < MAX_AMOUNT, table.field3 ) .select(table.field1, table.field3) .group_by(table.field1) .having( (id) => count(id) >MIN_BATCHES table.field0 )

(Sorry for any glaring mistakes, I'm too lazy right now to know what I'm doing)

..and I bet I just reinvented the wheel, maybe some JavaScript ORM?
- Because you never learned SQL properly, from the sound of it.
  
  Also, ORMs produce trash queries and are never expressive enough.
- Well, if you lose the OOPism of those dots, we can talk.
  
  Anyway, I'm really against the "having" tag. You need another keyword so that you can apply your filter after the group by?
- Check out Spark: https://github.com/apache/spark/blob/master/examples/src/main/python/sql/basic.py
- most languages have some first or third party lib that implements a query builder
- No. The arrow function in where eliminates any possibility of using indexes. And how do you propose to deal with logical expressions without resorting to shit like .orWhereNot() and callback hell? And, most importantly, what about joins?
Huh? Sql is one of the most powerful, action packed (as in you can move lots of shit with few commands) languages out there.

It's transferable and ubiquitous.
- powerful isn't the same as well-structured
  
  it was written to be a language that anybody could read or write as well as english, which just like every other time that's been tried, results in a language that's exactly as anal about grammar as C or Python except now it's impossible to remember what that structure is because adding anything to the language to make that easier is forbidden
  
  when you write a language where its designers were so keen for it to remain human readable that they made deleting all rows in a table the default action, i don't think "well structured" can be used to describe it
but sql doesn't need to be structured that's what abstraction layers and models are for
- SQL is literally structured query language
- SQL is incredibly structured. It's also a very good language, and developers need to stop piling on junk on top of it and producing terrible queries. Learn the damn language. It's not that hard

Remember kids, JSX is just function calls. It can't hurt you.

Oh it can and it did.

The most offensive thing here is the amount={5} attribute. What is it? It's not XML.

It's a react component and that would be the proper way to give a numerical value in jsx
- JSX has grown beyond react, so without further context it doesn't have to be react.
It's JSX. It's used to embed markup into javascript
- It's to embed Javascript into embedded markup in Javascript

please kindly send all javascript into the sun and explode it

That's XML though.. not that I'm disagreeing.
- Not XML. JSX. It's javascript's answer to markup.

still more readable than sqlalchemy exceptions

This idea is bad and whoever came up with it should feel bad.

It never ceases to amaze me how far idiots will go to avoid learning the most simple things. SQL isn't hard, people's difficulty with it says a lot more about them than it does SQL.
- People think in different ways. What might seem logical to you might look alien to another. I know SQL well enough to optimize queries, but I find it a lot easier to think about and write queries as LINQ methods. A lot more cleaner and logical to my brain.
- Neither is sending form data to the server without any JS. It's more robust too. Yet almost no form on the web works without JS.

I haven't been this pissed off since LINQ started allowing syntax switches in random-ass places.

Omg that's terrible! Link?

"HTTP and the Web is a totally reliable and easy to use internet protocol"

Is that select * ?

I expect it looks more cumbersome with joins and multiple columns from different tables.

That's what I was wondering. It's doing a SELECT, but not saying exactly which columns it wants to retrieve.

Joins must be a pain in the ass with hooks

Of course not... where's the damn tag..?

got no clue abot sql. what is wrong and how is it supposed to look like?

this basically xml being made to look like SQL. It's gross and that's why it's funny
SQL is run on the server to communicate with a database. The screenshot is jsx, which is a front-end, UI templating language. Writing SQL this way is cursed
- It could be querying the in-browser database (that's commonly used, such as with WhatsApp web), which would be seeded by a different part of the application
SQL is supposed to look like this: SELECT status, name FROM some_table LIMIT 5
Different language

Sharepoint queries are written in something very similar 🤢

I still have nightmares from the one time I had to use that.

I kind of like it. I can understand where it start and end.

It's kind of like graphQl you could make a compiler that would work with this.

but why

Needs JSON embedded in the elements because JSON is best practice.