Some backend libraries let you write SQL queries as they are and deliver them to the database. They still handle making the connection, pooling, etc.

ORMs introduce a different API for making SQL queries, with the aim to make it easier. But I find them always subpar to SQL, and often times they miss advanced features (and sometimes not even those advanced).

It also means every time I use a ORM, I have to learn this ORM’s API.

SQL is already a high level language abstracting inner workings of the database. So I find the promise of ease of use not to beat SQL. And I don’t like abstracting an already high level abstraction.

Alright, I admit, there are a few advantages:

  • if I don’t know SQL and don’t plan on learning it, it is easier to learn a ORM
  • if I want better out of the box syntax highlighting (as SQL queries may be interpreted as pure strings)
  • if I want to use structures similar to my programming language (classes, functions, etc).

But ultimately I find these benefits far outweighed by the benefits of pure sql.

  • Lmaydev@programming.dev
    link
    fedilink
    arrow-up
    0
    ·
    1 年前

    The SQL generation is great. It means you can quickly get up and running. If the orm is well designed it should perform well for the majority of queries.

    The other massive bonus is the object mapping. This can be an absolute pain in the ass. Especially between datasets and classes.

    • Cyclohexane@lemmy.mlOP
      link
      fedilink
      arrow-up
      0
      ·
      1 年前

      I find SQL to be easy enough to write without needing generation. It is very well documented, and it is very declarative and English-like. More than any ORM, imo.

      • Lmaydev@programming.dev
        link
        fedilink
        arrow-up
        0
        ·
        1 年前

        I don't c#'s EF is brilliant

        dbContext.Products.Where(p => p.Price < 50).GroupBy(p => p.Category.Id).ToArray()
        
        • JWBananas@startrek.website
          link
          fedilink
          English
          arrow-up
          1
          ·
          1 年前
            p.*
          FROM
            Products p
          WHERE
            p.Price < 50
          GROUP BY
            p.Category_Id```
          
          Meanwhile the ORM is probably generating something stupid and unnecessarily slow like this:
          
          ```SELECT
            p.*, c.*
          FROM
            Products p
          JOIN
            Category c
            USING (Category_Id)
          WHERE
            p.Price < 50
          GROUP BY
            c.Category_Id```
          
          Now stop using goddamn capital letters in your table and field names. And get off my lawn!
  • kSPvhmTOlwvMd7Y7E@programming.dev
    link
    fedilink
    arrow-up
    0
    ·
    1 年前

    You don't even mention the 2 main advantages:

    • ORM lets you to use plain objects over untyped strings. I take typed anything over untyped anything, everyday
    • ORM lets you to use multiple database backends. For ex, you don't need to spawn a local postgres server, then clean/migrate it after each test suit, you can just use in-memory sqlite for that. OK this has some gotchas, but that's a massive improvement in productivity
    • Swiggles@lemmy.blahaj.zone
      link
      fedilink
      arrow-up
      0
      ·
      1 年前

      I was about to write the same thing. Really the object thing is the whole reason to use ORMs.

      Using plain SQL is a compatibility and migration nightmare in medium and bigger sized projects. If anything using plain SQL is just bad software design at least in an OOP context.

    • winky88@startrek.website
      link
      fedilink
      English
      arrow-up
      0
      arrow-down
      1
      ·
      1 年前

      There seems to be a trend of new (old) developers who find that strong typing is nothing more than a nuisance.

      History repeating itself in the IT world. I don't wanna be around to support the systems that inherit these guys.