awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
pgcentralfoundation avatar

pgcentralfoundation/pgrx

0
View on GitHub↗

Pgrx

pgrx is a framework for building and packaging custom PostgreSQL extensions using Rust. It serves as a foreign function interface bridge that maps Rust types and functions to the internal server programming interface of the database.

The project provides a specialized toolchain for cross-compilation across different operating systems and target architectures using custom sysroots. It includes a schema generator that automatically translates high-level language structures into SQL definitions and binary protocol mappings.

The framework manages memory safety by wrapping database memory contexts and translating runtime panics into database-level errors to prevent server crashes. It further supports the definition of custom native database types and the implementation of functions and triggers.

A command line interface is provided to manage the extension lifecycle, including building, testing, and packaging across multiple database versions.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Rust Extension Frameworks - Provides a framework for building and packaging custom PostgreSQL extensions entirely in Rust.
  • Rust Frameworks - Serves as the primary Rust framework for building and packaging custom PostgreSQL extensions with memory safety.
  • PostgreSQL Custom Type Derivation - Derives PostgreSQL types, enums, and composites directly from Rust structs and enums with automatic serialization.
  • PostgreSQL - Derives PostgreSQL types from Rust structs and enums with automatic binary protocol support.
  • Server Programming Interfaces - Executes SQL queries safely from within extensions using a managed Server Programming Interface.
  • Build Toolchains - Provides a complete cargo-based toolchain for cross-compiling, testing, and packaging PostgreSQL extensions.
  • Custom Type Derivation - Derives PostgreSQL types from Rust structs and enums with automatic serialization and binary protocol support.
  • Custom Type Implementations - Creates native PostgreSQL data types from Rust structs and enums with automatic serialization and binary protocol support.
  • Safe Internal Access - Provides safe wrappers for PostgreSQL memory contexts and internals with panic-to-error safety guarantees.
  • Safe Internal Access Wrappers - Provides safe wrappers for PostgreSQL memory contexts and pointers with panic-to-error translation.
  • Rust - Converts between PostgreSQL and Rust types automatically, including zero-copy for text and bytea.
  • User-Defined Functions - Exposes Rust functions as PostgreSQL user-defined functions via declarative attribute macros.
  • Rust User-Defined Functions - Annotates Rust functions to register them as PostgreSQL user-defined functions and triggers.
  • PostgreSQL UDF Development Toolkits - Provides a complete toolkit for defining PostgreSQL user-defined functions, triggers, and custom types in Rust.
  • PostgreSQL User-Defined Functions - Defines user-defined functions and triggers in PostgreSQL using Rust code with automatic SQL schema generation.
  • Extension Development Environments - Provides a cargo subcommand to scaffold, test, and package extensions across multiple PostgreSQL versions.
  • SQL Schema Generators - Automatically derives SQL type definitions and binary protocol mappings from Rust structs and enums.
  • Database Memory Context Wrappers - Wraps PostgreSQL memory contexts in Rust's ownership model for automatic allocation management.
  • PostgreSQL Memory Context Wrappers - Wraps PostgreSQL memory contexts in Rust's ownership model and converts panics to database-level errors.
  • PostgreSQL FFI Bridges - Maps Rust types and functions to PostgreSQL's internal server programming interface through a foreign function bridge.
  • Attribute-Macro Code Generators - Translates annotated Rust functions into PostgreSQL-compatible C entry points using procedural macros.
  • PostgreSQL Internal Safe Wrappers - Provides safe wrappers for PostgreSQL pointers and memory contexts, with optional direct unsafe access to internals.
  • PostgreSQL Memory Context Safety - Handles PostgreSQL memory contexts with Rust's drop semantics, preventing leaks even during panics or errors.
  • Cross-Language Panic Mapping - Converts Rust panics into PostgreSQL errors that abort only the current transaction.
  • Server Programming Interfaces - Provides safe Rust bindings to PostgreSQL's Server Programming Interface for executing queries within extensions.
  • Panic Recovery - Translates Rust panics into PostgreSQL errors that abort the transaction without crashing the server process.
  • Database - Translates Rust panics into PostgreSQL errors that abort only the current transaction, preventing server crashes.
  • Extension Cross-Compilation - Compiles and packages PostgreSQL extensions for multiple operating systems and database versions.
  • Sysroot Toolchains - Provides custom sysroots and build scripts to compile Rust extensions for multiple platforms.
  • Zero-Copy Mappings - Maps PostgreSQL text and bytea types to Rust slices without copying data using pointer aliasing.
  • Extension Testing Environments - Launches a PostgreSQL instance with the extension loaded and opens an interactive psql session.
  • Extension Scaffolders - Generates a new PostgreSQL extension project with a single command providing a ready-to-use structure.
  • Extension Packaging Tools - Creates installation packages for the extension ready for deployment to other systems.
  • Version Target Controls - Supports building and testing extensions against PostgreSQL versions 13 through 18 from a single codebase.
  • Database Version Compatibility - Runs extension unit tests against multiple installed PostgreSQL versions from a single command.
  • Cross-Version Testing - Runs extension unit tests against multiple installed PostgreSQL versions from a single command.
  • Database Version Compatibility - Runs unit tests against multiple installed PostgreSQL versions to ensure cross-version compatibility.
  • SQL Schema Generators - Produces SQL schema files automatically from Rust extension code or custom SQL includes.
4,720 stars·326 forks·Rust·21 views

Star history

Star history chart for pgcentralfoundation/pgrxStar history chart for pgcentralfoundation/pgrx

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does pgcentralfoundation/pgrx do?

pgrx is a framework for building and packaging custom PostgreSQL extensions using Rust. It serves as a foreign function interface bridge that maps Rust types and functions to the internal server programming interface of the database.

What are the main features of pgcentralfoundation/pgrx?

The main features of pgcentralfoundation/pgrx are: Rust Extension Frameworks, Rust Frameworks, PostgreSQL Custom Type Derivation, PostgreSQL, Server Programming Interfaces, Build Toolchains, Custom Type Derivation, Custom Type Implementations.

Which projects share features with pgcentralfoundation/pgrx?

Projects with overlapping indexed features include: tcdi/pgx — pgx is a framework and suite of tools for developing high-performance PostgreSQL extensions using the Rust programming… neon-bindings/neon — Neon is a framework for writing high-performance native Node.js modules using the Rust programming language. It serves… tealdeer-rs/tealdeer — A very fast implementation of tldr in Rust. holistics/dbml — DBML is a domain-specific language and schema definition language used for documenting database architecture and… palantir/pyspark-style-guide — The project establishes consistent naming conventions, readability standards, and structural best practices across… grpc-ecosystem/go-grpc-middleware — go-grpc-middleware is a gRPC middleware framework for Go designed to handle cross-cutting concerns, reliability, and…

Projects sharing features with Pgrx

These projects share indexed features with Pgrx. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • tcdi/pgxtcdi avatar

    tcdi/pgx

    4,716View on GitHub↗

    pgx is a framework and suite of tools for developing high-performance PostgreSQL extensions using the Rust programming language. It provides a low-level API wrapper to interact with internal database memory contexts, logging systems, and core execution APIs, enabling the implementation of custom database functionality and logic directly within the database engine. The project distinguishes itself through a dedicated build tool and command line interface that manages the extension development lifecycle, from environment initialization to binary packaging. It includes a type mapper that transla

    Rust
    View on GitHub↗4,716
  • neon-bindings/neonneon-bindings avatar

    neon-bindings/neon

    8,426View on GitHub↗

    Neon is a framework for writing high-performance native Node.js modules using the Rust programming language. It serves as a foreign function interface bridge and a toolchain for bootstrapping, compiling, and managing Rust-based extensions. The project provides a cross-language memory manager that handles buffers and object borrowing to ensure safe memory access between Rust and JavaScript. It enables the mapping of data types and function calls across the language boundary, allowing Rust functions to be exported to the script environment and JavaScript functions to be called from Rust. The f

    Rust
    View on GitHub↗8,426
  • tealdeer-rs/tealdeertealdeer-rs avatar

    tealdeer-rs/tealdeer

    6,651View on GitHub↗

    A very fast implementation of tldr in Rust.

    Rusthacktoberfestrusttldr
    View on GitHub↗6,651
  • holistics/dbmlholistics avatar

    holistics/dbml

    3,520View on GitHub↗

    DBML is a domain-specific language and schema definition language used for documenting database architecture and design. It provides a human-readable text format for defining database tables, columns, and relationships in a standardized way. The project functions as a relational schema parser and SQL schema generator. It transforms declarative design specifications into an abstract syntax tree for programmatic manipulation and converts these definitions into executable SQL statements across various database dialects. The system covers relational data modeling, database schema design, and arc

    JavaScriptdatabase-schemadbmldbx
    View on GitHub↗3,520
  • Compare all 30 related projects→