zetasql VS libpg_query

Compare zetasql vs libpg_query and see what are their differences.

zetasql

ZetaSQL - Analyzer Framework for SQL (by google)

libpg_query

C library for accessing the PostgreSQL parser outside of the server environment (by pganalyze)
Our great sponsors
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • WorkOS - The modern identity platform for B2B SaaS
  • SaaSHub - Software Alternatives and Reviews
zetasql libpg_query
15 13
2,122 1,050
2.2% 2.4%
0.0 8.9
25 days ago about 1 month ago
C++ C
Apache License 2.0 BSD 3-clause "New" or "Revised" License
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

zetasql

Posts with mentions or reviews of zetasql. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2022-11-26.

libpg_query

Posts with mentions or reviews of libpg_query. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-03-18.
  • Transpile Any SQL to PostgreSQL Dialect
    7 projects | news.ycombinator.com | 18 Mar 2024
    This in combination with [pg_query](https://github.com/pganalyze/libpg_query) could be a very powerful combination that allows writing generic static analyzers.
  • Postgres: The Next Generation
    4 projects | news.ycombinator.com | 10 Oct 2023
    It's true that the core PG code isn't written in a modular way that's friendly to integration piecemeal in other projects (outside of libpq).

    For THIS PARTICULAR case, the pganalyze team has actually extracted out the parser of PG for including in your own projects:

    https://github.com/pganalyze/libpg_query

  • SQLedge: Replicate Postgres to SQLite on the Edge
    9 projects | news.ycombinator.com | 9 Aug 2023
    #. SQLite WAL mode

    From https://www.sqlite.org/isolation.html https://news.ycombinator.com/item?id=32247085 :

    > [sqlite] WAL mode permits simultaneous readers and writers. It can do this because changes do not overwrite the original database file, but rather go into the separate write-ahead log file. That means that readers can continue to read the old, original, unaltered content from the original database file at the same time that the writer is appending to the write-ahead log

    #. superfly/litefs: aFUSE-based file system for replicating SQLite https://github.com/superfly/litefs

    #. sqldiff: https://www.sqlite.org/sqldiff.html https://news.ycombinator.com/item?id=31265005

    #. dolthub/dolt: https://github.com/dolthub/dolt

    > Dolt can be set up as a replica of your existing MySQL or MariaDB database using standard MySQL binlog replication. Every write becomes a Dolt commit. This is a great way to get the version control benefits of Dolt and keep an existing MySQL or MariaDB database.

    #. pganalyze/libpg_query: https://github.com/pganalyze/libpg_query :

    > C library for accessing the PostgreSQL parser outside of the server environment

    #. Ibis + Substrait [ + DuckDB ]

    > ibis strives to provide a consistent interface for interacting with a multitude of different analytical execution engines, most of which (but not all) speak some dialect of SQL.

    > Today, Ibis accomplishes this with a lot of help from `sqlalchemy` and `sqlglot` to handle differences in dialect, or we interact directly with available Python bindings (for instance with the pandas, datafusion, and polars backends).

    > [...] `Substrait` is a new cross-language serialization format for communicating (among other things) query plans. It's still in its early days, but there is already nascent support for Substrait in Apache Arrow, DuckDB, and Velox.

    #. benbjohnson/postlite: https://github.com/benbjohnson/postlite

    > postlite is a network proxy to allow access to remote SQLite databases over the Postgres wire protocol. This allows GUI tools to be used on remote SQLite databases which can make administration easier.

    > The proxy works by translating Postgres frontend wire messages into SQLite transactions and converting results back into Postgres response wire messages. Many Postgres clients also inspect the pg_catalog to determine system information so Postlite mirrors this catalog by using an attached in-memory database with virtual tables. The proxy also performs minor rewriting on these system queries to convert them to usable SQLite syntax.

    > Note: This software is in alpha. Please report bugs. Postlite doesn't alter your database unless you issue INSERT, UPDATE, DELETE commands so it's probably safe. If anything, the Postlite process may die but it shouldn't affect your database.

    #. > "Hosting SQLite Databases on GitHub Pages" (2021) re: sql.js-httpvfs, DuckDB https://news.ycombinator.com/item?id=28021766

    #. awesome-db-tools https://github.com/mgramin/awesome-db-tools

  • Show HN: Postgres Language Server
    21 projects | news.ycombinator.com | 6 Aug 2023
    Can't you just give some love to the issue https://github.com/pganalyze/libpg_query/issues/44 instead ? As I said before this would be very helpful for the community because there are a lot of libraries that use libpg_query and cannot be used on windows (f.e see https://github.com/lelit/pglast/issues/7).

    It seems that the only problem for fixing the problem is:

    > Thanks for the offer, but the problem is our team being time limited / having an engineer with a Windows machine ready to take this on, not that we wouldn't want to pay someone to work on it :)

    (https://github.com/pganalyze/libpg_query/issues/44#issuecomm...)

    Hosting the LSP elsewhere is really needed since if people wanted to go that way they could use Remote ssh (https://code.visualstudio.com/docs/remote/ssh) to host the whole dev environment on linux and connect to it.

    Thank you

    21 projects | news.ycombinator.com | 6 Aug 2023
    Excited to see this - and excellent use case for libpg_query (I'm the original author and still help maintain it together with the rest of the team) and appreciate the shout out to pganalyze!

    If anyone else has a use case for using the Postgres parser outside the server, we have a healthy ecosystem of libraries that build on the core C library (we maintain bindings for Ruby, Go and Rust ourselves), as well as various projects using it (e.g. sqlc uses it for a type-safe way for using hand-written SQL in Go): https://github.com/pganalyze/libpg_query#resources

    21 projects | news.ycombinator.com | 6 Aug 2023
    Generally I agree that this would be great to have, and Postgres does have a set of libraries it already maintains as part of the main source tree (i.e. libpq, etc), and there is a shared set of code between the backend and the "frontend" (https://github.com/postgres/postgres/tree/master/src/common). So theoretically you could imagine the parser moving into that shared code portion, sharing code but not necessarily requiring linking to a library from the backend.

    However, the challenge from what I've understood from past conversations with some folks working on Postgres core is that the parser is currently heavily tied into the backend - note the parser isn't just the scan.l/gram.y file, but also the raw parse node structs that it outputs. You can see how many files we pull in from the main tree that are prefixed with "src_backend": https://github.com/pganalyze/libpg_query/tree/15-latest/src/...

    Further, there isn't a canonical way to output node trees into a text format today in core, besides the rather hard to work with output of debug_print_parse - there have been discussions on -hackers to potentially utilize JSON here, which may make this a bit easier. Note that in libpg_query we currently use Protobuf (but used to use JSON), which does have the benefit of getting auto-generated structs in the language bindings - but Protobuf is not used in core Postgres at all today.

    All in all, I think there is some upstream interest, but its not clear that this is a good idea from a maintainability perspective.

    21 projects | news.ycombinator.com | 6 Aug 2023
    it leverages your code-base, rather than connecting to your database. it uses to [libpg_query](https://github.com/pganalyze/libpg_query) to construct the syntax tree which can then be used to for the LSP features
    21 projects | news.ycombinator.com | 6 Aug 2023
    The libpg query library has a very important problem: It does not work on windows https://github.com/pganalyze/libpg_query/issues/44

    I'd recommend starting with fixing that instead. It would be much more helpful for the community.

  • Show HN: PRQL – A Proposal for a Better SQL
    15 projects | news.ycombinator.com | 24 Jan 2022
    I like that everyone is trying to make something like SQL that reads more naturally to them. More alternatives is good! SQL is a widely accepted standard, and has strictly defined and super broadly accepted semantics.

    As someone who has written quite a few half-baked-for-general-use but fit-for-purpose SQL generator utilities over the years, I'll suggest that if you intend for a novel syntax to be a general SQL replacement then being isomorphic to SQL would massively increase usefulness and uptake:

    1. novel syntax to SQL; check! Now novel syntax works with all the databases!

    2. any valid SQL to novel syntax; a bit harder, but I'd start by using a SQL parser like https://github.com/pganalyze/libpg_query and translating the resulting AST into the novel syntax.

    3. novel syntax to SQL back to novel syntax is idempotent; a nice side effect is a validator/formatter for "novel syntax"

    4. SQL to novel syntax back to SQL is idempotent; a nice side effect is a validator/formatter for SQL, which would be awesome. (See also https://go.dev/blog/gofmt, which is where I learned this "round trip as formatter" trick.)

    I don't mean for this to sound negative, and I know that 2, 3, and 4 are kind of hard. Thank you for building prql!

  • Go PL/SQL parser using ANTLRv4
    2 projects | /r/databasedevelopment | 10 Jan 2022
    I feel like https://github.com/pganalyze/libpg_query should be the default choice for anything that needs a SQL parser. PL/SQL parsing is included there.

What are some alternatives?

When comparing zetasql and libpg_query you can also consider the following projects:

sqlparse - A non-validating SQL parser module for Python

Apache Calcite - Apache Calcite

JSqlParser - JSqlParser parses an SQL statement and translate it into a hierarchy of Java classes. The generated hierarchy can be navigated using the Visitor Pattern

ANTLR - ANTLR (ANother Tool for Language Recognition) is a powerful parser generator for reading, processing, executing, or translating structured text or binary files.

pgsql-parser - PostgreSQL Query Parser for Node.js

sqlite-parser - JavaScript implentation of SQLite 3 query parser

sqlglot - Python SQL Parser and Transpiler

alasql - AlaSQL.js - JavaScript SQL database for browser and Node.js. Handles both traditional relational tables and nested JSON data (NoSQL). Export, store, and import data from localStorage, IndexedDB, or Excel.

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

Presto - The official home of the Presto distributed SQL query engine for big data