pg_graphql VS pgx

Hi, I'm the author of Supabase GraphQL (pg_graphql)

One of the restrictions of composite types is that they can not contain an instance of themselves. So unfortunately, this is not currently possible.

I had this issue when trying to implement an AST type for pg_graphql[1] back when it was written in SQL [2]. In the end we used a JSON type which was much less constrained. That might be solvable using pg_jsonschema [3] if you really wanted to have a good time though

[1] https://github.com/supabase/pg_graphql

It’s something that’ll come in future, but nothing available yet: https://github.com/supabase/pg_graphql/issues/17

But... If you're looking for Graphql/Postgres, maybe look at https://github.com/supabase/pg_graphql which popped onto my radar yesterday, but I have no experience with it.

Check out some of the generated queries this extension [1] pumps out and you might have an answer.

[1] https://github.com/supabase/pg_graphql

hey HN, supabase ceo here. I'm really excited about this release.

Our GraphQL implementation is built on top of pg_graphql[0], a PostgreSQL extension we open-sourced a few months ago. The implementation works with a lot of native PG functionality (like Row Level Security). You can also do a some neat things with PG GRANTS, enabling/disabling access to different tables/columns to effectively serve a different GraphQL API depending who is "logged in".

On Supabase, the extension is served via PostgREST[1] using the public PostgreSQL function exposed by pg_graphql. PostgREST exposes PG functions as RPC routes (in our case we also map /rest/v1/rpc/graphql => /graphql/v1)

I'll ping the main dev (@oli_rice) and make sure he is here to answer any technical questions. This is just one of the exciting features we're launching this week. Stay tuned for one of our most-requested features later this week.

[0] pg_graphql: https://github.com/supabase/pg_graphql

[1] PostgREST: https://postgrest.org/

It uses pgx (https://github.com/tcdi/pgx) which is our more generalized framework for developing Postgres extensions with Rust.

It's a great question, considering I've been using Rust for a number of years now, and I generally advocate its use for its rich ecosystem, safety and tooling. I actively contribute to pgx, a library for building Postgres extensions in Rust. Yet, Omnigres appears to be all done in C.

Our release today is a framework which extends this functionality to other databases/systems. If you’re familiar with Multicorn[1] or Steampipe[2], then it’s very similar. The framework is written in Rust, using the excellent pgx[3].

We have developed FDWs for Stripe, Firebase, BigQuery, Clickhouse, and Airtable (all in various “pre-release” states). The plan is to focus on the tools we’re using internally while we stabalize the framework.

There’s a lot in the blog post into our goals for this release. It’s early, but one of the things I’m most excited about.

[0] Postgres FDW: [https://www.postgresql.org/docs/current/sql-createforeigndat...

[1] Multicorn: https://multicorn.org/

[2] Steampipe: https://steampipe.io/

[2] pgx: [https://github.com/tcdi/pgx](https://github.com/tcdi/pgx)

BTW one nice easter egg is that with pgx there is actually no reason that we can't build even better search solutions inside the database itself.

> That thread led me to a project/product idea where you take an existing Postgres instance used for normal products or whatever, replicate it to various read only clusters with a custom search extension loaded and some orchestrator sitting on top (I’ve written most of one in rust that uses 0mq to communicate with it’s nodes) and create drop in search from existing databases with a nice guided web gui for automatic tuning suitable for most business use cases.

Very interesting idea -- just want to add one thing, write it in rust (with pgx?[0]) :)

[0]: https://github.com/tcdi/pgx

Hey HN,

It turns out choosing a good database-optimized UUID (and deciding whether to use serial, etc) isn't quite so simple, and I finally got a chance to do some exploration, write about it[0].

One of the reasons Postgres is the best open source database out there is it's extensibility -- so I hacked up a small extension for generating some of the more exotic (but crucially, lexicograhically sortable) UUID generation mechanisms:

https://github.com/t3hmrman/pg_idkit

This idea has been bumbling around my head for a while, but I finally got a chance to build it while working with Supabase on a post about IDs[0]!

Most of the heavy lifting is done by pgx[1] which is an amazing framework for building Postgres extensions in Rust. I think we are very early to the trend of amazing postgres extensions built in Rust, and it's yet another reason that it's an exciting time to be all-in on Postgres.

[0]: https://supabase.com/blog/choosing-a-postgres-primary-key

[1]: https://github.com/tcdi/pgx

[0]: https://supabase.com/blog/choosing-a-postgres-primary-key

The extension is still WIP but for those of ya'll that like Rust it's built on pgx which has excellent DX. The rust involved isn't complicated -- I'm basically laundering the functionality from other crates that are listed in the README.md.

Seems to be using this: https://github.com/tcdi/pgx

- https://github.com/furstenheim/is_jsonb_valid

pgx[0] is going to be pretty revolutionary for the postgres ecosystem I think -- there is so much functionality that can be utilized at the database level and I can't think of a language I want to do it with more than Rust.

[0]: https://github.com/tcdi/pgx