[HN Gopher] Show HN: Trilogy - A Reusable, Composable SQL Experi...
___________________________________________________________________
Show HN: Trilogy - A Reusable, Composable SQL Experiment
Recipe: Add a semantic layer to SQL; use it drop the requirement
for joins/group_by; add in type-checking and a lightweight python-
esque import syntax to enable reuse and hierarchical querying.
Trilogy is intended to provide an accessible but deep alternative
to raw SQL. It offers a new-but-inspired-by-SQL syntax that
compiles to various dialects of SQL (with DuckDB as the default).
The target audience is people that really like SQL for analytics
and data engineering, but want less boilerplate and sharp edges and
looser coupling to the DB. Semantic models can be easily shared,
composed and iterated on in an interactive session, preserving the
adhoc workflows that make SQL so powerful. The "higher level" of
the language vis-a-vis SQL makes it straightforward to extend into
ETL (an experimental basic DBT integration is available), offering
potential to optimize a processing graph across intermediate
staging nodes automatically. This higher level of abstraction also
offers some nice opportunities for more reliable text to SQL for
LLMs. A similarly basic integration is available to demonstrate
this, as is a very basic VsCode extension and electron-based IDE.
Tech stack is primarily Python. Open source, MIT license. Github is
linked from demo page. Thoughts, feedback, contributions all
welcome! Note: renamed from PreQL (see prior show
https://news.ycombinator.com/item?id=40728938) to avoid confusion
with the many PreQLs of the world. The `SQL pun` naming space is
unfortunately well-explored. Other SQL replacements (all great,
all worth a look!): PRQL (pipelined SQL alternative, all new
syntax) https://news.ycombinator.com/item?id=36866861 Malloy (all
new syntax, semantic focus)
https://news.ycombinator.com/item?id=30053860 preql (much more
ambitious, all new syntax)
https://news.ycombinator.com/item?id=26447070
Author : efromvt
Score : 53 points
Date : 2024-11-24 22:53 UTC (1 days ago)
(HTM) web link (trilogydata.dev)
(TXT) w3m dump (trilogydata.dev)
| tluyben2 wrote:
| This is great; I have been thinking about this for a long time. I
| like reading about past and current implementations that try to
| better sql; from a programming and a data science and performance
| perspective. I am aware of the ones you linked and some others
| like 'Real' (shakti.com) sql and some enhancements from papers.
|
| Anyway; nice one! Will try.
| mritchie712 wrote:
| Not a SQL replacement, but if you're looking for an open source
| semantic layer, Cube is the way to go [0]
|
| 0 - https://github.com/cube-js/cube
| knowitnone wrote:
| always appreciate links to good tools
| hobofan wrote:
| One thing that I am always looking for in a new "reusable",
| "composable" SQL tool is reuse of the same analytical queries
| across different source tables.
|
| My litmus test:
|
| I have a table "people" with the columns "people.firstname",
| "people.lastname", and a table "persons" with the columns
| "persons.firstname", "persons.lastname". I now want to create a
| query that gives me the "fullname" (".firstname" + " " +
| ".lastname") of all rows of both tables. If I have to spell out
| the logic for how to calculate the fullname in the query twice,
| the test is failed.
|
| (Taking the shortcut of creating the union of both tables first
| is not allowed, but I can't think of a simple example that
| enforces that restriction).
|
| For some reason, all of the solutions (PRQL, Malloy, dbt) that
| try to make SQL more reusable don't really consider this kind of
| reuse, and with that ultimately fall flat for the use-cases I
| would typically have for them. Sadly, Trilogy doesn't seem to be
| any better on that front.
| friendly_deer wrote:
| This is something I've never thought about before, and haven't
| had a use case for, so I'm genuinely interested in learning a
| little more about your use cases if you can elaborate a little
| futher.
| default-kramer wrote:
| Sometimes you want to be able to do something like "run some
| SQL, but instead of using the normal tables use these temp
| tables I just created."
|
| In particular, I wanted to do this in SQLite recently. I
| wanted to have one write process which would always remain
| unblocked. And I also wanted to be able to run certain tasks
| which would do some temporary/discardable DB manipulations as
| part of producing an output file. These tasks could open the
| SQLite DB in read-only mode; load relevant data into temp
| tables, manipulate that data, and write the output file.
| Everything would have worked great if only SQL were a more
| composable language.
| hn_throwaway_99 wrote:
| TBH, I don't think your test is very useful in real world
| environments. That is, you have 2 independent tables, and
| you're wanting the solution to depend on the fact that there
| are columns that are named the same across both tables.
|
| IMO these kinds of "shortcuts based on column naming across
| tables" usually end in disaster down the road. For example,
| I've been bitten in the past by "natural joins" when we've
| wanted to refactor something later.
|
| I definitely agree that I don't want to have to repeat logic
| _within_ a single table, but the kind of syntactic sugar that
| is your litmus test is a big foot gun IMO.
| default-kramer wrote:
| > IMO these kinds of "shortcuts based on column naming across
| tables" usually end in disaster down the road.
|
| But sometimes this decision has been made years ago and it's
| not realistic to change it now. I've wanted to do this many
| times, and I've never been the person who created said
| tables.
|
| Also, certain use cases perform much better if you create
| temp tables with small subsets of data from the main tables.
| It sure would be nice to be able to reuse fragments of SQL
| written against the main tables... if only SQL were better.
| hobofan wrote:
| Oh, I 100% agree with you.
|
| > IMO these kinds of "shortcuts based on column naming across
| tables" usually end in disaster down the road.
|
| I can see that point, and that was not what I wanted to
| express with my litmus test. It's only supposed to be a
| litmus test after all. In a proper solution there would be
| additional things I would be looking for, but so far
| everything I've seen already fails that "trivial" test.
|
| One could easily re-formulate it, so that in the one tabel
| the column is named ".firstname", and in the other one it is
| named ".first_part_of_the_name".
|
| The core point is more that no matter the relational logic
| you layer on top of a table/view, that logic should be
| paramterizable by table/view/column names, to be properly
| relocatable. I'd be happy about suggestions for better
| examples! Some solutions (I think dbt) do have some
| relocateability across schemas, but usually in a more
| singleton-like manner rather than being able to instantiate
| the logic multiple times.
|
| I can just tell you that I interact with queries that would
| benefit from such kind of reuse on a daily basis. One common
| thing would also be mechanisms that you want to reuse across
| many different tables in your schema. E.g. soft-deletes or
| historic/snapshot tables. Nowadays those kinds of solutions
| usually end up being expressed in the ORM/query builder of a
| programming language (and thus highly fragmented across
| programming language ecosystems), instead of living on an
| SQL-like level and being able to mature better.
| fooododododo wrote:
| Curious what your opinion on plpgsql functions is? Could
| easily solve your initial problem (if I follow). They don't
| seem to come up much though
| hobofan wrote:
| I do like PL\pgSQL functions, and I think they can to
| some extent be used to solve this problem, though I think
| they are limited in how their internal structure is
| parameterizable.
|
| I am rarely in a position at my client projects where I
| can employ PL\pgSQL though, so I opt more for out-of-
| database solutions for composing my queries, as that
| usually is easier to debug.
| jasonpbecker wrote:
| This feels like a case for a function.
| hobofan wrote:
| See my reply to hn_throwaway_99. The example is overly
| trivialized and should expand to more complex relational
| logic as well.
| snthpy wrote:
| Hi,
|
| Having this sort of "table polymorphism" is something we've
| thought a lot about for PRQL and is definitely something we
| want to get right. That said it's not straightforward but you
| can do a lot of it already. You can try the following examples
| for yourself in the PRQL Playground (https://prql-
| lang.org/playground/).
|
| First a simple example using functions as they are documented:
|
| ```prql
|
| let fullname = func firstname lastname -> f"{firstname}
| {lastname}"
|
| from customers
|
| select full_name=(fullname first_name last_name)
|
| ```
|
| Now the example above isn't quite what you're looking for
| because you still have to specify the columns as function
| arguments and there really isn't much gained here. It serves to
| illustrate the principle though as the `fullname` function
| could be doing something more complicated.
|
| What you want is:
|
| ```prql
|
| let add_full_name = func tbl<relation> -> (
| from tbl derive full_name = f"{first_name}
| {last_name}" )
|
| from customers
|
| add_full_name
|
| select full_name
|
| ```
|
| Now this requires the `<relation>` type annotation which hasn't
| been documented because it's still quite experimental. However
| this works right now and can be applied to different tables or
| relations, for example you could use the same function in the
| following:
|
| ```prql
|
| from i=invoices
|
| join c=customers (==customer_id)
|
| select {c.first_name, c.last_name, i.total}
|
| sort {-total}
|
| add_full_name
|
| select {full_name, total}
|
| ```
|
| I'll add some more examples in child comments.
|
| Disclaimer: I'm a PRQL contributor.
| snthpy wrote:
| Here's a function to normalize values relative to the column
| range:
|
| ```prql
|
| let normalize = func x -> ((x - min x)/((max x) - (min x)) |
| math.round 2)
|
| from tracks
|
| take 5
|
| derive {ms_norm=(normalize milliseconds),
| bytes_norm=(normalize bytes)}
|
| select {track_id, ms=milliseconds, ms_norm, bytes,
| bytes_norm}
|
| ```
|
| which produces the following SQL:
|
| ```sql
|
| WITH table_0 AS ( SELECT track_id,
| bytes, milliseconds FROM tracks
| LIMIT 5
|
| )
|
| SELECT track_id, milliseconds AS ms,
| ROUND( (milliseconds - MIN(milliseconds) OVER ()) / (
| MAX(milliseconds) OVER () - MIN(milliseconds) OVER ()
| ), 2 ) AS ms_norm, bytes,
| ROUND( (bytes - MIN(bytes) OVER ()) / (MAX(bytes)
| OVER () - MIN(bytes) OVER ()), 2 ) AS
| bytes_norm
|
| FROM table_0
|
| -- Generated by PRQL compiler version:0.13.2 (https://prql-
| lang.org)
|
| ```
| hobofan wrote:
| Thanks for the thorough reply! Really glad to see at least
| one of the solutions working towards it, and I'll definitely
| check PRQL out again in more depth!
| carlineng wrote:
| I agree 100% that this needs to be more of a thing. For data
| engineers building data pipelines, queries are like functions,
| and table schemas are like types. There needs to be a way to
| write a query that runs on an abstract interface, rather than
| an actual table. To do this, most folks rely on string
| templating in Python or Jinja, which makes the development
| process really cumbersome. As a result, most teams end up in
| scenarios where data pipelines are always a big mess of
| spaghetti SQL, or they are stuck maintaining complex frameworks
| that abstract away common logic, but are inscrutable to the
| average user.
|
| I wrote a longer blog post about this recently:
| https://carlineng.com/?postid=holy-grail-data-engineering#bl...
| fooododododo wrote:
| Do they ever write plpgsql? If not why not?
| hobofan wrote:
| I think your blog post frames the problem very well!
|
| Seeing that both someone working on PRQL and Malloy replied
| and to both of you it's an understood pain makes me feel a
| lot better about the future of these tools! When talking
| about that with people that are not that deep into the
| problem it is often hard to transport the difference between
| this kind of composability vs. the composability that the
| tools are offering today, and the implications that come with
| that.
|
| At a past startup I had the fortune to be able to work on a
| similar system to what I am looking for: Packageable,
| reusable relation algebra inspired by Substrait. It had the
| downside though that it was quite tied to RDF and SPARQL in
| its implementation, and now I'm chasing something similar in
| the SQL world :D
| thesz wrote:
| > There needs to be a way to write a query that runs on an
| abstract interface, rather than an actual table.
|
| Proper use of SQL inverts control. Instead of parameterizing
| query by table, you write a query and at the actual use site
| you join it on the table you need by fields your query
| provides. VIEWs allows you to not repeat yourself too often.
|
| Best thing is that you do not need to even mention that
| "abstract interface table" as a parameter at all.
| hobofan wrote:
| > VIEWs allows you to not repeat yourself too often.
|
| No they don't. They only offer a solution to the problem
| "many different predicates for a few tables", but don't
| offer a solution to the problem "a few similar predicates
| for many different tables", as views as per their
| declaration are already tied to a single table.
| munk-a wrote:
| I have used CTEs with dynamic query stitching to solve this
| problem (specifically my business operates over two very
| similar but distinct domains which we keep in separate
| buckets). If you build the majority of your logic into a CTE
| that processes named columns coming out of a prior chunk you
| can swap out what actual columns in the DB are mapped into
| the columns coming out of that earlier CTE with its
| definition. It may be possible to make this more magical
| using pl/pgsql but I've found that dynamic query stitching at
| the CTE resolution is a level of fiddly-ness I'm comfortable
| building into resilient products.
|
| I work with complex data models and keeping all that
| structure in my brain takes enough effort that I want to keep
| my queries as simple as possible because when it's time to
| debug one there's no way I'm carrying over _any_ memory from
| when I originally wrote it.
| totalhack wrote:
| If I'm understanding your intent correctly, I think you could
| do that with Zillion.
|
| https://github.com/totalhack/zillion
|
| Disclaimer: been sidetracked by an acquisition at my day job
| this year, intend to put more time into this project soon, but
| I use it in production to great effect.
| hobofan wrote:
| Sure, I could do that in Zillion the same way I'm currently
| composing queries in Python at runtime with PyPika.
|
| I'm looking for a more programming language agnostic solution
| that tools like this (e.g. also PRQL, Malloy) usually offer.
| efromvt wrote:
| Hmm - in Trilogy, if both tables had firstname and lastname as
| concepts bound to them, and you created full name that was the
| concat of those concepts, you'd only need to define fullname
| once and the calculation would work against both without any
| direct binding to either. The unioning is actually the
| unsupported part right now, though it's planned to be
| implemented!
| efromvt wrote:
| To expand on previous answer, right now this would be
| represented as:
|
| key firstname string; key lastname string;
|
| auto full_name <- concat(firstname, ' ', lastname);
|
| datasource people ( firstname:firstname, lastname:lastname )
| address people;
|
| datasource persons ( firstname: firstname, last_name:lastname )
| address persons;
|
| And a select full_name;
|
| Could resolve from either table.
|
| The missing bit if you're trying to define a universe across
| both is actually the union construct; right now a concept is
| assumed to have one cardinality space.
|
| Something like: auto all_first_names <- union(first_name1,
| first_name2);
|
| There's a coupling between the concept definition both as a
| function input and as a semantic value. They could be
| decomposed, but you'd still need to recompose them at some
| point before running a query.
| snthpy wrote:
| Cool project!
|
| Will take a proper look when I get a chance.
|
| In the meantime, I just wanted to say: nice name! ;-)
| totalhack wrote:
| Congrats on the launch. I made a tool that has some similar
| objectives but doesn't present as SQL itself like Trilogy seems
| to. I'll take a deeper look at Trilogy soon, always interested to
| see the variety of approaches to this.
|
| https://github.com/totalhack/zillion
___________________________________________________________________
(page generated 2024-11-25 23:00 UTC)