Show HN: PRQL 0.2 – Releasing a better SQL

1. prql

   1 121 10,045 9.7 Rust

   PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement

   

   Hi everyone — thanks for your interest in PRQL — let us know any questions or feedback!

   We're excited to be releasing 0.2[1], the first version of PRQL you can use in your own projects. It wouldn't exist without the feedback we got from HackerNews when we originally posted the proposal.

   [1]: https://github.com/prql/prql/releases/tag/0.2.0

2. SaaSHub

   www.saashub.com featured

   SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

   

3. dbt-prql

   2 2 101 6.2 Python

   dbt-prql allows writing PRQL in dbt models

   

4. lnav

   3 85 8,260 9.6 C++

   Log file navigator

   I work on a TUI logfile viewer that uses SQLite as a backend for doing analysis on the log messages (https://lnav.org). However, writing SQL interactively is painful since you can't really provide good auto-complete or preview, which is something I try to provide for most other operations.

   The PRQL pipeline syntax would make for a much better experience for lnav since you're able to progressively refine a query without having to jump around. (You've probably noticed that many log services, like Sumologic, already provide a pipeline-style syntax instead of something SQL-like.) The nice thing is that you can simply keep typing to get the results you want and get a preview at each stage. For example, entering "from" and then pressing would make it clear to the program that table-names should be suggested. The program could then show the first few lines of the table. Typing "from syslog_log | filter " and then pressing would make it clear that columns from the syslog_log table should be suggested (along with some other expression stuff). And, then, the preview of the filtered output could be shown.

   In the current implementation, pressing just suggests every possible thing in the universe, whether it's appropriate or not. This leaves the poor with not much help after they've typed "SELECT". I find myself having to lookup docs/source to figure out column names or whatever and I wrote the darn thing. Ultimately, I think the analysis functionality just doesn't get used because interactively writing SQL is so user-hostile.

5. postgres-conn

   4 1 2 0.0 Rust

   I recently started implementing the Postgres protocol in Rust (https://github.com/dmeijboom/postgres-conn). So I guess I’ll be experimenting with creating a Postgres proxy which translates PRQL on-the-fly.

6. wasm-pack

   5 38 6,424 7.3 Rust

   📦✨ your favorite rust -> wasm workflow tool!

   

   That's true - the package is auto-generated using [wasmpak](https://github.com/rustwasm/wasm-pack), that's why TypeScript definitions are clunky. I did the initial prql-js release and I'm actually not sure about the free() issue you are talking about.

   We are currently working on compiling it for both Node.js and the browser target, and would be happy to see some advice if you are familiar with WASM!

7. rfcs

   6 5 37 5.5 Python

   RFCs for major changes to EdgeDB (by edgedb)

   

   Replied on Twitter!

   > I see EdgeDB as primarily focused on transactional queries, whereas PRQL is very focused on analytical queries.

   That's true to an extent currently, but we actually envisioned EdgeQL to be a capable analytical query language too. We'll release EdgeDB 2.0 in a couple of weeks and it will feature a powerful GROUP BY statement (read more about it here [1]) and in 3.0 we might ship window functions (or some equivalent).

   With all that said PRQL looks cool!

   [1] https://github.com/edgedb/rfcs/blob/master/text/1009-group.r...

8. mentat

   7 2 53 0.0 Rust

   A persistent, relational store inspired by Datomic and DataScript. (by qpdb)

   

9. logica

   8 24 1,930 8.8 Jupyter Notebook

   Logica is a logic programming language that compiles to SQL. It runs on DuckDB, Google BigQuery, PostgreSQL and SQLite.

   

10. Puts Debuggerer

    9 3,389 200 4.2 Ruby

    Ruby library for improved puts debugging, automatically displaying bonus useful information such as source line number and source code.

    

    I'm modeling the GP's comment. I think a common case is something like a polymorphic user/organization entity like GitHub: there is some kind of base user that is usable in a lot of places (e.g. https://github.com/) but there's also a load of distinct organization-specific fields and a load of distinct user-specific fields.

11. Franchise

    10 2 2 10.0 JavaScript

    🍟 a notebook sql client. what you get when have a lot of sequels. (by MobilityDB)

    

    If you appreciated that check out "Franchise - a notebook SQL client. What you get when you have a lot of sequels": https://github.com/MobilityDB/Franchise

12. owoof

    11 2 40 0.0 Rust

    A program for querying and modifying information in a datalog-like format backed by SQLite.

13. prosto

    12 9 91 3.6 Python

    Prosto is a data processing toolkit radically changing how data is processed by heavily relying on functions and operations with functions - an alternative to map-reduce and join-groupby

    > Joins are what makes relational modeling interesting!

    It is the central part of RM which is difficult to model using other methods and which requires high expertise in non-trivial use cases. One alternative to how multiple tables can be analyzed without joins is proposed in the concept-oriented model [1] which relies on two equal modeling constructs: sets (like RM) and functions. In particular, it is implemented in the Prosto data processing toolkit [2] and its Column-SQL language. The idea is that links between tables are used instead of joins. A link is formally a function from one set to another set.

    [1] Joins vs. Links or Relational Join Considered Harmful https://www.researchgate.net/publication/301764816_Joins_vs_...

    [2] https://github.com/asavinov/prosto data processing toolkit radically changing how data is processed by heavily relying on functions and operations with functions - an alternative to map-reduce and join-groupby

Suggest a related project