SQL Has Problems. We Can Fix Them: Pipe Syntax In SQL

I find LINQ query syntax less readable than SQL. I like LINQ method syntax for simple, linear queries.

The linear method syntax is somewhat like the idea of piping SQL operations.

I just threw up in my mouth a little. Do we have content warnings here? We should get content warnings here. It's been three blessed years since I thought about the pile of crap that is LINQ. Here's to three more!

It's used that way in Elixir. I don't find it a problem.

In Clojure, -> is used for inserting the piped argument at the head position in the arguments of whatever it is passed to, while ->> is used for inserting it at the tail. This approach is great for working with immutable data in a series of approachable transformations, which I believe is one reason why so many Domain-Specific Languages for generative programming are written in that language, aside from its interactive REPL. Additionally, there is no need to worry about excessive copying, as this is generally well optimized.

This can be particularly useful with HoneySQL, which is more of a DSL for SQL rather than a typical ORM tool. For example:

(defn apply-filters [query filters]
"applies WHERE clauses to a query"
  (reduce (fn [q [column value]]
            (helpers/where q [:= column value]))
          query
          filters))

(defn build-dynamic-query [{:keys [table columns filters sort-by limit]}]
  (-> {}
      (helpers/select columns)
      (helpers/from table)
      (apply-filters filters)
      (helpers/order-by sort-by)
      (helpers/limit limit)
      sql/format))

;; Result - a super readable function call that resembles a natural language 
(build-dynamic-query 
  {:table :products 
   :columns [:id :name :price] 
   :filters {:category "electronics" :in-stock true}
   :sort-by [:price :desc]
   :limit 20})

CTRL+ALT+<, SHIFT+<

🙃🤡

What about respecting the reader of the diff when there's a change in the middle?

Stored Procedures have been a thing for literally decades. But they're an absolute pain.

What would really improve the usefulness of databases are autoindexes and generally more "let me handle that for you". I'd argue 90% of business apps essentially need a way to store objects and their relationships, but doing that in an efficient manner is really hard (at least if you've got a few more rows to handle).

SQL has pretty powerful conditional support support already and lateral joins are essentially loops if you're unfamiliar with them.

2 different words.

https://www.merriam-webster.com/dictionary/delineated

Delineated is a word and makes sense here