leftzero,

Of course not… where’s the damn <From> tag…?

cupcakezealot,
@cupcakezealot@lemmy.blahaj.zone avatar

please kindly send all javascript into the sun and explode it

db2,

That’s XML though… not that I’m disagreeing.

huginn,

Not XML. JSX. It’s javascript’s answer to markup.

db2,

Gross.

dukk,

The worst of both worlds…

karmiclychee,

It’s like a weaponized grade of whatever they made CSS in JS out of

dan,
@dan@upvote.au avatar

deleted_by_author

    •
    huginn,

    If you put it into an XML parser it will throw an error, so it’s no longer XML.

    Sure it was based on it, but it’s not xml.

    namelivia, (edited )

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

    kpw,

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

    MostlyHarmless,

    It’s JSX. It’s used to embed markup into javascript

    sndrtj,

    It’s to embed Javascript into embedded markup in Javascript

    ABC123itsEASY,

    It’s a react component and that would be the proper way to give a numerical value in jsx

    Huschke,

    JSX has grown beyond react, so without further context it doesn’t have to be react.

    Primarily0617,

    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

    cupcakezealot, (edited )
    @cupcakezealot@lemmy.blahaj.zone avatar

    but sql doesn’t need to be structured that’s what abstraction layers and models are for

    Lem453,

    SQL is literally structured query language

    expr,

    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

    Solemarc,

    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.

    GBU_28,

    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.

    Primarily0617,

    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

    GBU_28,

    Disagree, the difference between “week structured” and needing to know the rules of the verbs is pretty big, to me.

    QuazarOmega, (edited )

    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:

    
<span style="color:#323232;">const MAX_AMOUNT = 42, MIN_BATCHES = 2
</span><span style="color:#323232;">
</span><span style="color:#323232;">database
</span><span style="color:#323232;">    .from(table)
</span><span style="color:#323232;">    .where(
</span><span style="color:#323232;">        (amount) => amount < MAX_AMOUNT,
</span><span style="color:#323232;">        table.field3
</span><span style="color:#323232;">    )
</span><span style="color:#323232;">    .select(table.field1, table.field3)
</span><span style="color:#323232;">    .group_by(table.field1)
</span><span style="color:#323232;">    .having(
</span><span style="color:#323232;">        (id) => count(id) >MIN_BATCHES
</span><span style="color:#323232;">        table.field0
</span><span style="color:#323232;">    )
</span>

    (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?

    rubythulhu,

    most languages have some first or third party lib that implements a query builder

    xep,

    Check out Spark: https://github.com/apache/spark/blob/master/examples/src/main/python/sql/basic.py

    QuazarOmega, (edited )

    Thanks for the suggestion! It looks interesting, not quite what I expected looking at that file*, but that may very well be better

    Edit: other examples seem a bit more similar to mine, cool!

    marcos,

    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?

    physicswizard,

    Boy then are you going to hate QUALIFY

    marcos,

    Yes, I do. It’s a lot of effort and hidden functionality to try to paper over the fact that the statements do not compose.

    QuazarOmega,

    Well, if you lose the OOPism of those dots, we can talk.

    That’s a good point, I didn’t even think about it, maybe a more functional style would make more sense?

    rubythulhu,

    having is less annoying way of not doing needless/bug-prone repetition. if you select someCalculatedValue(someInput) as lol you can add having lol > 42 in mysql, whereas without (ie in pgsql) you’d need to do where someCalculatedValue(someInput) > 42, and make sure changes to that call stay in sync despite how far apart they are in a complex sql statement.

    docAvid,

    Postgres has the having clause. If it didn’t, that wouldn’t work, as you can’t use aggregates in a where. If you have to make do without having, for some reason, you can use a subquery, something like select * from (select someCalculatedValue(someInput) as lol) as stuff where lol > 42, which is very verbose, but doesn’t cause the sync problem.

    Also, I don’t think they were saying the capability having gives is bad, but that a new query language should be designed such that you get that capability without it.

    expr, (edited )

    Because you never learned SQL properly, from the sound of it.

    Also, ORMs produce trash queries and are never expressive enough.

    emptyother,

    ORMs produce good queries if you know what you do. Which requires proper knowledge of SQL, unfortunately.

    QuazarOmega, (edited )

    Because you never learned SQL properly, from the sound of it.

    You might be right, though, to be fair, I also keep forgetting syntax of stuff when I don’t use it very often (read SQL (._.`))

    Also, ORMa produce trash queries and are never expressive enough.

    I meant to say that I would like the raw SQL syntax to be more similar to other programming languages to avoid needing to switch between thinking about different flows of logic

    drathvedro,

    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?

    istoff,

    Is that select * ?

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

    adamth0,

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

    JoYo,
    @JoYo@lemmy.ml avatar

    still more readable than sqlalchemy exceptions

    cmdrkeen,

    Honestly not the worst thing I’ve seen.

    xmunk,

    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?

    cmdrkeen,

    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.

    Primarily0617,

    sql syntax doesn't support even itself correctly i fail to see your point

    RustyNova,

    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.

    TheFerrango,

    Sharepoint queries are written in something very similar 🤢

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

    Witchfire, (edited )
    @Witchfire@lemmy.world avatar

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

    reimufumo,
    @reimufumo@lemmy.ca avatar

    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)

    bahbah23, (edited )

    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?

    doidera,

    Yes

    somePotato, (edited )

    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.

    blackbrook,

    Check out JOOQ.

    shotgun_crab,

    JOOQ made me realize that most ORMs suck

    leftzero,

    it’s a readable query returning a sane JSON object.

    No it’s not. What table is the data supposed to be coming from…?

    cmdrkeen,

    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.

    jflorez,

    It is so readable that you missed the fact it doesn’t have the FROM clause

  • All
  • Subscribed
  • Moderated
  • Favorites
  • •
  • programmer_humor@programming.dev
  • localhost
  • All magazines
    •
    Loading…
    Loading the web debug toolbar…
    Attempt #