News for hackers. Stuff that matters.
Re:What ORMs have taught me: just learn SQL (2014) by 725686 on Friday September 20, 2019 @05:38PM (#21031566)
Each time I see someone complain about ORMs I remember Greenspun's tenth rule[1], which adapted to ORM would be:

"Any sufficiently complicated program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of a decent ORM."

ORMs are hard for a reason. Using an ORM doesn't mean you can't or shouldn't use plain SQL where the situation calls for it. You can mix and match perfectly fine.

[1] https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule Edit: typo.

Re:What ORMs have taught me: just learn SQL (2014) by geodel on Friday September 20, 2019 @05:59PM (#21031748)
To me it is more of as Ted Neward describes "ORM is Vietnam of Computer Science"[1]

"Although it may seem trite to say it, Object/Relational Mapping is the Vietnam of Computer Science. It represents a quagmire which starts well, gets more complicated as time passes, and before long entraps its users in a commitment that has no clear demarcation point, no clear win conditions, and no clear exit strategy."

[1] http://blogs.tedneward.com/post/the-vietnam-of-computer-scie...

Re:What ORMs have taught me: just learn SQL (2014) by mapgrep on Friday September 20, 2019 @07:47PM (#21032441)
Ya I’ve heard this one a lot. It’s kind of funny to say and does humorously underline the complexity of the problem but people take it seriously. So to take it seriously for a second:

There was no good reason to be in Vietnam; even taking the stated rationale as a given, which many people did not, it was a concern many levels removed from the actual safety or functioning of American society.

ORMs in contrast achieve much more proximate goals — they solve a real problem and can measurably reduce the amount of code you have to write. It is tedious to write the same sort of SQL query over and over. Even if you prefer to use literal sql for the complex stuff (as I do), ORMs tend to be a significant win (in fewer LOC to write) on abstracting out basic queries.

Re:What ORMs have taught me: just learn SQL (2014) by setr on Friday September 20, 2019 @08:36PM (#21032676)
Tbh you could easily claim that the explicit goal, mapping to objects, is incorrect.

The real value is to reduce the damage of the SQL language itself — the unnecessarily ordered clauses, the arbitrary inconsistencies in syntax, the worthless parser errors, the lack of any static typechecking — which cause so much code bloat and debug headaches.

There are two reasons to use the ORM: to not learn SQL, and to generate SQL.

The first reason is the commonly provides one, and what leads us into vietnam. The latter is why people try to avoid ORMs, yet find themselves back in vietnam.

What we really need is a less shitty version of SQL.

Re:What ORMs have taught me: just learn SQL (2014) by bitexploder on Saturday September 21, 2019 @12:29AM (#21033526)
I have found the best ORMs don’t hide their SQLness much. SQLAlchemy is pretty great, but you don’t get full use out of it unless you have your arms around SQL itself. When you use an ORM to cut down on chores it’s great. When you use an ORM to avoid your datastore and it’s idiosyncrasies it is worth taking a long hard look at why :)

Most of the ORM interactions are well formatted code that don’t hide the datastore much. As long as you let the ORM map in objects and it’s performant, life is alright. When the ORM starts running the show there may be no coming back.

Re:What ORMs have taught me: just learn SQL (2014) by mapgrep on Saturday September 21, 2019 @11:11AM (#21035818)
I enjoyed this comment because I only I only recently tried Sqla for a project and agree fully that it embraces sql, in large part by NOT renaming/rethinking things at the oop level - methods very much tend to be named after sql verbs. I really liked this.

What I liked less was all the setup/config ceremony. Compared to ActiveRecord (the Ruby lib not necessarily the orm concept) I was using more LOC before I got to the part where I started saving time on simple queries. I realize this is because sqla uses the datamapper model. But for me thif sweet spot would be auto setup like AR with sql-like syntax of sqla.

Re:What ORMs have taught me: just learn SQL (2014) by bitexploder on Saturday September 21, 2019 @09:49PM (#21039125)
Yeah. When you get good at composing SQLa code it is really nice. You can functionally build your queries and DB interactions. It just fit well with my way of coding. ActiveRecord had a lot of magic to my taste, but you could still drop down with it. Agree SQLa can be tedious at first. No tool is perfect :)
Re:What ORMs have taught me: just learn SQL (2014) by cturner on Saturday September 21, 2019 @05:15AM (#21034297)

    > What we really need is a less shitty version of SQL.
My view is the opposite. The power of SQL perpetuates a low-quality software culture. The root issue is a dev culture that can't see past databases.

A lot of software design runs like this: (1) translate business patterns into a relational schema; (2) build interactions with that schema; and (3) as that gets harder, use SQL arcana and ORMs and views and stored procedures to squeeze out flexibility.

I worked like this for the first decade of my career. My systems got some use, and struggled along, but they are failed projects.

Repeatedly I had this feeling: the project is almost done, but there are some concurrency issues where I would not even know how to start addressing them.

The database-centric design made it impossible to work past that.

After much searching, I came to this: Stored State is a brittle and unwieldy thing, and you want as little of it in your life as possible. The more you have, the harder you have to work to get anything done. Databases are an institution of Stored State.

As an alternative, you can derive state from messages.

Re:What ORMs have taught me: just learn SQL (2014) by wwweston on Saturday September 21, 2019 @05:57PM (#21038156)
What kind of concurrency issues were you running into with a RDBMS that has atomic transactions?

Are we talking about distributed store situations where CAP theorem limits apply, or something else?

Re:What ORMs have taught me: just learn SQL (2014) by collyw on Saturday September 21, 2019 @08:17AM (#21034868)
I see the same problems but it usually caused by a reluctance to modify the database schema. Once you get comfortable doing that and keep your schema matching the requirements then it solves a lot of the problems.
Re:What ORMs have taught me: just learn SQL (2014) by inimino on Saturday September 21, 2019 @07:47AM (#21034743)
> As an alternative, you can derive state from messages.

Bingo!

Unfortunately, if people won't even listen to Alan Kay on this stuff, who will they listen to?

Re:What ORMs have taught me: just learn SQL (2014) by dsego on Saturday September 21, 2019 @07:59AM (#21034780)
What is the solution then? Are you talking about event sourcing or something different?
Re:What ORMs have taught me: just learn SQL (2014) by mst on Friday September 20, 2019 @09:20PM (#21032852)
An ORMish thing that considers its primary purpose to enable metaprogramming SQL is actually useful.

In http://p3rl.org/DBIx::Class perl has had such a thing for over a decade now.

It makes me cry that nobody's ever adequately cloned it into other languages. Eventually I'll probably do so myself.

Re:What ORMs have taught me: just learn SQL (2014) by weberc2 on Friday September 20, 2019 @09:58PM (#21033001)
Isn’t that just a query builder? I’m not familiar with Perl or your library, so maybe you could tell me where I’m wrong?
Re:What ORMs have taught me: just learn SQL (2014) by mst on Saturday September 21, 2019 @09:30AM (#21035264)
What I was trying (and evidently failing) to say is that a sufficiently powerful query generation system that's designed for people who actually like their database to be able to generate the exact SQL they would've written by hand is essential to the 'mapper' part of the equation being able to smooth out any impedence mismatches between the appropriate object model and the appropriate database schema.

Hopefully that longer answer is a bit clearer than my first attempt.

Re:What ORMs have taught me: just learn SQL (2014) by misterdoubt on Friday September 20, 2019 @10:20PM (#21033090)
I guess I don't know enough Perl to understand how this differs dramatically from something like SQLAlchemy in Python.
Re:What ORMs have taught me: just learn SQL (2014) by mst on Saturday September 21, 2019 @09:26AM (#21035235)
SQLAlchemy is pretty close. Been quite a few years since I've had a chance to get drunk with the authors and compare notes though, so I'm not going to try and get into details because I'm pretty much guaranteed to get some of them wrong.
Re:What ORMs have taught me: just learn SQL (2014) by noisem4ker on Friday September 20, 2019 @08:43PM (#21032705)
Something like jOOQ?

https://www.jooq.org

Re:What ORMs have taught me: just learn SQL (2014) by Too on Saturday September 21, 2019 @03:41AM (#21034037)
That looks fantastic. No magic mumbo jumbo mapping, just a simple type safe sql. Both syntax safety (no need to remember which of WHERE and HAVING comes first) and type safety on all fields. It's not advertised in the examples on the front page but i also take for granted sql injections are completely impossible since all data goes into functions and are not string formatted, without the mess of having to remember the order of arguments as with prepared statements.

Anyone got tips on similar frameworks for other languages than java and for other dbs.

Re:What ORMs have taught me: just learn SQL (2014) by xadoc on Saturday September 21, 2019 @06:26AM (#21034504)
Dapper for C# made by StackOverflow team

https://github.com/StackExchange/Dapper

Re:What ORMs have taught me: just learn SQL (2014) by Noumenon72 on Friday September 20, 2019 @10:35PM (#21033141)
Ye. Static typechecking is the only thing in his list that I really care about, since you can "git gud" at SQL and not be bothered by the syntax/ordering/parser concerns. jOOQ is exactly what I want to bridge the gap between Java and the DB.
Re:What ORMs have taught me: just learn SQL (2014) by setr on Saturday September 21, 2019 @12:33AM (#21033542)
The ordering is always a problem, because your logic may not follow it. Eg if your set of conditions apply to multiple queries, then you might know your where conditions before you know your select/from clauses.

So instead of building up your sql string in a straightforward fashion, you need to have at minimum an abstraction that delays construction.

You get lead into vietnam as almost a direct result of SQL’s context-sensitive clauses.

Re:What ORMs have taught me: just learn SQL (2014) by spion on Saturday September 21, 2019 @02:46AM (#21033900)
Or you could go with LINQ's approach from (x) where (y) select (z).

Honestly, I think LINQ and entity framework successfully solved most ORM concerns

Re:What ORMs have taught me: just learn SQL (2014) by mamcx on Friday September 20, 2019 @10:45PM (#21033166)
> What we really need is a less shitty version of SQL.

I think the same. In my spared time I building a relational language (http://tablam.org ..accept more help!) starting even lower: Without a rdbms.

I work in the past with FoxPro, and was possible to build a full app with UI and reports and all stuff you can imagine with a database-oriented language. You code the UI on fox, query with fox, make triggers with fox, etc...

I'm looking in capture the same essence.

Re:What ORMs have taught me: just learn SQL (2014) by dragonwriter on Saturday September 21, 2019 @12:55AM (#21033587)
> What we really need is a less shitty version of SQL.

Any of the D (Date and Darwen's, not Digital Mars’s) family of relational languages might fit the bill.

Re:What ORMs have taught me: just learn SQL (2014) by SomeOldThrow on Saturday September 21, 2019 @02:20PM (#21036972)
> ORMs in contrast achieve much more proximate goals — they solve a real problem and can measurably reduce the amount of code you have to write.

Why would you optimize for LOC rather than expressing the behavior you want well? In some situations sure—rapid prototyping—but that’s an odd assumption in a general case.

Re:What ORMs have taught me: just learn SQL (2014) by jacques_chester on Friday September 20, 2019 @08:35PM (#21032673)
If you haven't read that post, it's worth reading in its entirety. The title is not the entire argument.
Re:What ORMs have taught me: just learn SQL (2014) by yawaramin on Friday September 20, 2019 @06:09PM (#21031838)
> ORMs are hard for a reason.

Yes, the object-relational impedance mismatch. It's the classic case of having a hammer (OOP) and trying to make everything look like a nail.

Re:What ORMs have taught me: just learn SQL (2014) by delusional on Friday September 20, 2019 @07:09PM (#21032213)
I would actually let OOP off the hook here. I think what did the harm in this case was the java generation. The generation of programmers that were told that in the future they would only have to write the "business logic", and everthing else would just happen. They were taught javabeans, orms, gigantic frameworks. They completely forgot that their code actually needed to execute, and no one cared about their "business logic" if the application didn't do what it was supposed to do.

This generation has only ever used ORM's, and so to them those tools must solve some hard problem, they are so complex after all. SQL must be hard.

It turns out that SQL is actually much simpler than ORM's. The failure modes are much simpler, and the implementations more robust. Sure, writing the code can be tedious, but tedeious is not hard. Writing brainless code every once in a while gives you time to reflect on the design of your system, and think about the larger context.

Re:What ORMs have taught me: just learn SQL (2014) by revscat on Friday September 20, 2019 @11:27PM (#21033299)
This is the polar opposite of my experience. Not to mention that you undercut your own argument by admitting SQL’s tediousness: tedious code tends to lead to more tedious code, as subsequent developers fear breaking something, so they just add a layer on top of it, rather than addressing root causes. So that SQL view you had now has 10 inner joins in it, a union, and is being used by five other views now, each with their own similar levels of complexity. Trying to do any refactoring on this is almost humanly impossible, because you can’t keep all of it in your head.

And this is an extremely common situation to find yourself in. Code bases which are of middle- to large-sized, and which are inevitably touched by various hands of various skill levels, tends towards complexity.

SQL is the worst source of unmaintainable and difficult to refactor code. It’s difficult to unit test. Error messages are more often than not inscrutable. (I’m looking at you, Oracle.) There is no idiomatic way to break up complex SQL into functions or classes. There’s no type checking. You don’t have the equivalent of Ruby Gems, Python’s pip, or Swift’s CocoaPods. IDE support is limited to syntax highlighting Compare this with something like Eclipse or IntelliJ where you can just Ctrl-click on something and go to the definition. Want to rename a public method in a statically typed language? Pretty easy. Want to rename a column in SQL? Yeah, good luck. Not impossible, but you don’t have any guarantees that something won’t break until runtime.

So yeah. ORM has its place, and modern ones work very well at abstracting away SQL’s weaknesses.

Re:What ORMs have taught me: just learn SQL (2014) by scarface74 on Friday September 20, 2019 @10:31PM (#21033127)
I seriously don’t think I have worked with a single developer in 20+ years that didn’t at least know simple sql and joins
Re:What ORMs have taught me: just learn SQL (2014) by goatlover on Friday September 20, 2019 @09:01PM (#21032797)
> It turns out that SQL is actually much simpler than ORM's.

Are they simpler when it comes to matching the data to the application's data structures? One advantage of ORMs is that they encourage this setup from the start.

Re:What ORMs have taught me: just learn SQL (2014) by dragonwriter on Saturday September 21, 2019 @04:32AM (#21034181)
> Are they simpler when it comes to matching the data to the application's data structures?

That depends on the modelling approaches taken by the application developer and DB developer.

Re:What ORMs have taught me: just learn SQL (2014) by mumblemumble on Friday September 20, 2019 @08:10PM (#21032560)
I think that this is true if you're writing your application in a way that requires object-relational mapping in the first place.

And that's only necessary when you're trying to manage your data in the application in an object-oriented way. And managing your data in an object-oriented way implies more than just the simple fact of defining classes to serve as data records. Those classes can be entirely equivalent to a struct in a procedural language or a record in a functional one. And I can't remember ever suffering from object/relational impedance mismatch when working in a procedural or functional language. Implying that the spot where you really start getting into trouble is when you trot out some distinctive feature of an object-oriented data model.

I submit that the original sin is treating instances of those data classes as if they are discrete entities that can serve as an application-side proxy for some other discrete entity that exists in the database, almost as if ODBC were just a more REST-flavored alternative to CORBA. Which is a thing that I've often been tempted to do in an object-oriented language, but never in a procedural or functional one.

Which isn't to say that I don't use anything to help with talking to databases in those other styles of language. It's just that I retain SQL as my query language (there are plenty of reasons to do it, none of which I'll bother to repeat here) and rely on a more Dapper-style library to handle unpacking the results into data structures. And I don't really consider those to be ORMs; they're just a special class of data mapping utility library.

So, in conclusion, I think that a more accurate stab would be "Any sufficiently hastily built, object-oriented, database-driven non-ORM program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of a decent ORM."

Re:What ORMs have taught me: just learn SQL (2014) by moring on Saturday September 21, 2019 @03:02AM (#21033944)
Two counter-points:

(1) While treating a single SQL table as a distinct entity is a sin by your argument, I would argue that treating a set of tables as a distinct entity is not. I'm referring to what DDD calls an aggregate, e.g. a customer (address + email history + scoring + whatever tables), or an order (line items, shipping info, payment info, ...) Reading the comments here, I'm starting to wonder if some kind of holy grail or at least useful approach lies in there.

(2) The impedance mismatch has two ends, and one might as well argue that the problem is not mapping tabular data to objects, but mapping objects to tables. This might be an underrated benefit of what is usually called "NoSQL", dwarfed by the whole discussion around "schemaless". Unfortunately, I don't have any experience in that area, but it's something I have long planned on trying. Note that I'm not trying to say that NoSQL "solves the impedance mismatch" but rather that, in DDD's approach to solve persistence, NoSQL might actually be able to do what DDD wants (e.g. with respect to defining a "unit of consistency"), unlike tabular data.

Re:What ORMs have taught me: just learn SQL (2014) by mumblemumble on Saturday September 21, 2019 @12:52PM (#21036404)
A distinction that may seem like pedantry, but I think is actually the crux of the issue I've had with with ORM:

The problem is not in treating entities in the database as entities. It's in treating instances of classes in the application's memory space as local proxies for those entities.

You're on much firmer ground if you understand them as simple pieces of information derived from the state of those entities as of some point in time. Both in terms of ending up with a more internally consistent and robust approach to data (by virtue of removing some temptation to preserve an illusion that this data can be presumed to always be complete and up-to-date), and in terms of not artificially cutting yourself off from most of the power of the relational model.

You're right that this tension is somewhat resolved by just switching to using an object store of some sort. (NoSQL is far too diverse of a subject to treat as a single unit.) But it's a very particular sort of resolution, because it's a sort of least common denominator approach where you just drag the data store down to the level of the programming model. It strikes me as akin to resolving the difficulties in maintaining complex software in Perl by resolving to never let anyone write anything more powerful than a shell or CGI script rather than by looking for a language that will better support you for the long haul. It can certainly be a fine and reasonable choice. The problem comes in when people don't fully realize that that's the choice they're making.

Re:What ORMs have taught me: just learn SQL (2014) by ryangittins on Friday September 20, 2019 @09:44PM (#21032956)
> You can mix and match perfectly fine.

Thank you!

This seems like one of those topics where people often feel the need to pick a side for some reason. I've often heard criticism to the effect of, "people only use ORMs because they don't know SQL. Learn SQL!" It's seemingly impossible to convince these people that ORMs are fantastic for reducing boilerplate code and they can coexist right next to raw SQL for problems gnarlier than "select all foo where bar equals baz."

Re:What ORMs have taught me: just learn SQL (2014) by revscat on Saturday September 21, 2019 @12:21AM (#21033498)
This.

Earlier in my career I made a point to deep dive into SQL. Long story short: I realized that there are a lot of very good reasons to limit the amount of raw SQL in your application that have nothing to do with familiarity.

SQL is just a bad language, and it’s unfortunate that we’re still stuck with it, basically unchanged, decades after its introduction.

For me, it’s almost as anachronistic as COBOL.

Re:What ORMs have taught me: just learn SQL (2014) by kimi on Saturday September 21, 2019 @12:06PM (#21036132)
YMMV, but for me it feels like magic every time I use it. I can get things done in declarative way that would take a while in any programming language I know (and I'm a Clojure guy, so I value simplicity and conciseness).
Re:What ORMs have taught me: just learn SQL (2014) by perl4ever on Saturday September 21, 2019 @07:43PM (#21038640)
The only issue I really have with SQL is the lack of control over how a query is executed can really be an impediment. It's like how people were talking in another thread about getting frustrated with garbage collection.

I spent a lot of time working in a department that wrote a lot of ad hoc Oracle SQL, for updates to a production system, and complex reports, and there was one guy that was ten times faster than everyone else, and also more likely to get his code correct, and so I paid attention to what he did.

He would break down a complex set of operations into simple individual queries generating temporary tables; he just wouldn't bother fighting with the optimizer, or trying to predict what it would do. So he not only wrote queries that ran quickly, but he wrote them quickly, and he got them correct quickly.

I would read Tom Kyte, exhorting people to use the full complexity of the language and the Oracle optimizer, but from my experience, it just was not the way to go. I wrote many page (or more) long queries that were things of beauty and then found that breaking them down into simple ones actually was usually much faster.

One fundamental thing that I don't think gurus understand, is that for the average grunt in a typical corporation, there is a separation of duties, such that you can't just go and change the things that a system administrator controls. So saying "your database is configured wrong" doesn't address normal life.

Although the pure relational model may be nice to think about, I find it really convenient to have a certain amount of sequential context, and PL/SQL always seemed to me to have a disgruntled relationship with SQL, so I've gradually tended towards Microsoft alternatives.

Re:What ORMs have taught me: just learn SQL (2014) by james_s_tayler on Friday September 20, 2019 @06:42PM (#21032041)
The best ORM (outside of ActiveRecord) I've seen was a proprietary hand-rolled one that solved the impedance mismatch.

It had a canonical XML format that entities were defined in and code generation for data access layers, domain models, view models etc.

It actually worked better than I've seen the abuse I've seen developers put EF through. I found it nicer and simpler than times I've worked with Hibernate.

I'm not going to say it was perfect, but every time I think back on it it makes me want to revisit the idea of leveraging a bit of code generation or metaprogramming to be able to have a canonical definition of an entity transformed into concerns that deal with the given entity at different points in the application.

That part of it just really hit the sweet spot for me.

Re:What ORMs have taught me: just learn SQL (2014) by taffer on Friday September 20, 2019 @07:45PM (#21032434)
Have you checked out MyBatis or JOOQ? They sound pretty much like what you're describing.
Re:What ORMs have taught me: just learn SQL (2014) by james_s_tayler on Friday September 20, 2019 @08:57PM (#21032768)
MyBatis has _some_ similarities, notably the defining entities in xml part. But it diverges after that.

Think about it more like MyBatis meets Spring Data JPA. Define that entity in XML the run a code gen which gives you the CrudRepository class but also generates a controller that exposes an API with pretty good good ability to specify adhoc queries. Plus view models.

I think it worked because it both reasonably well designed and hyper opinionated.

Re:What ORMs have taught me: just learn SQL (2014) by tomtomtom777 on Friday September 20, 2019 @08:12PM (#21032569)
What you are saying exactly highlights what the author is missing: That if your application has some logic, you will eventually have to map your database rows to your in memory typed structures.

It sucks. Sometimes it sucks less if you map your queries as well, sometimes it sucks less if you stick to SQL and only map your results, sometimes it sucks so much you're better off with a no-sql solution.

But when using a relational database, ORM isn't optional.

Re:What ORMs have taught me: just learn SQL (2014) by Avamander on Friday September 20, 2019 @10:17PM (#21033081)
Um, PL/PGSQL and et al for stored procedures exist, OOP is optional.
Re:What ORMs have taught me: just learn SQL (2014) by mannykannot on Saturday September 21, 2019 @10:03AM (#21035434)
OOP is optional, but if your program has any concept of structured data, then, regardless of whether that structure can be expressed syntactically within the programming language, you will necessarily have a mapping between that and the database. It might be as simple as a 1:1 mapping between relations and ADTs, with collections of references being used within the program to represent the keyed relationships that exist within the database scheme.
Re:What ORMs have taught me: just learn SQL (2014) by revscat on Saturday September 21, 2019 @12:14AM (#21033473)
So? Stored procedures suck. There are good reasons they have never seen serious traction and are infrequently used to the point of being irrelevant.
Re:What ORMs have taught me: just learn SQL (2014) by jevgeni on Saturday September 21, 2019 @01:40AM (#21033707)
Major international banks have entire payment systems implemented in PL/SQL. I’m talking 2-3kloc procedures and thousands of them.
Re:What ORMs have taught me: just learn SQL (2014) by Avamander on Saturday September 21, 2019 @10:10AM (#21035470)
That's what you think not having any knowledge of them. Many of the best and huge systems I've seen have been implemented in stored procedures.
Re:What ORMs have taught me: just learn SQL (2014) by nqzero on Friday September 20, 2019 @06:42PM (#21032043)
Db4j is an async transactional database engine that uses java as the query language. It doesn't eliminate the O/R impedance mismatch entirely (it's not a graph or object database), but it does simplify it greatly since everything is java

https://github.com/db4j/db4j

I love the idea and it's been fun for me to make demos with, but I've gotten almost zero feedback on the API, and what I have gotten is "can you add a SQL frontend". And yet neither ORM nor SQL are loved

So the question (and I'm not suggesting that Db4j is the answer) is: "what's the API that would be most natural ?"

Re:What ORMs have taught me: just learn SQL (2014) by didibus on Saturday September 21, 2019 @02:30AM (#21033851)
Unless you don't have objects... then no need for an Object-relational mapping, not a well maintained one, and not an ad-hoc one. All you need is a DB connection pooling library, some helpers or libs to help you build dynamic SQL queries and that's all.
Re:What ORMs have taught me: just learn SQL (2014) by j88439h84 on Friday September 20, 2019 @05:43PM (#21031616)
Very good point. I'll need to remember this.
Re:What ORMs have taught me: just learn SQL (2014) by SomeOldThrow on Saturday September 21, 2019 @03:16AM (#21033982)
What is a decent ORM under this definition? I don’t think I’ve ever seen one sufficient for business logic.