Expand description
pgx is a framework for creating Postgres extensions in 100% Rust
Example
use pgx::*;
// Convert the input string to lowercase and return
#[pg_extern]
fn my_to_lowercase(input: &'static str) -> String {
input.to_lowercase()
}
Re-exports
pub use aggregate::*;pub use atomics::*;pub use callbacks::*;pub use datum::*;pub use enum_helper::*;pub use fcinfo::*;pub use guc::*;pub use hooks::*;pub use htup::*;pub use inoutfuncs::*;pub use itemptr::*;pub use list::*;pub use log::*;pub use lwlock::*;pub use memcxt::*;pub use namespace::*;pub use nodes::*;pub use pgbox::*;pub use rel::*;pub use shmem::*;pub use spi::*;pub use stringinfo::*;pub use trigger_support::*;pub use tupdesc::*;pub use varlena::*;pub use wrappers::*;pub use xid::*;pub use pgx_pg_sys as pg_sys;pub use cstr_core;pub use pgx_utils as utils;Modules
Safely create Postgres Background Workers, including with full SPI support
Provides safe wrappers around Postgres’ “Transaction” and “Sub Transaction” hook system
Handing for easily converting Postgres Datum types into their corresponding Rust types and converting Rust types into their corresponding Postgres types
Helper functions for working with Postgres enum types
Helper macros and functions for creating Postgres UDFs.
Provides a safe interface into Postgres’ Configuration System (GUC)
A trait and registration system for hooking Postgres internal operations such as its planner and executor
Utility functions for working with pg_sys::HeapTuple and pg_sys::HeapTupleHeader structs
Helper trait for the #[derive(PostgresType)] proc macro for overriding custom Postgres type
input/output functions.
Helper functions for working with Postgres ItemPointerData (tid) type
A safe wrapper around Postgres’ internal List structure.
Access to Postgres’ logging system
Provides interfacing into Postgres’ MemoryContext system.
A helper struct for creating a Postgres List of Strings to qualify an object name
Helper functions and such for Postgres’ various query tree Nodes
Provides a safe wrapper around Postgres’ pg_sys::RelationData struct
Safe access to Postgres’ Server Programming Interface (SPI).
A safe wrapper around Postgres StringInfo structure
Helper functions for working with custom Rust trigger functions
Provides a safe wrapper around Postgres’ pg_sys::TupleDescData struct
Helper functions to work with Postgres varlena * structures
Provides safe wrapper functions around some of Postgres’ useful functions.
Macros
Log to Postgres’ fatal log level. This will abort the current Postgres backend connection processs.
Log to Postgres’ panic log level. This will cause the entire Postgres cluster to crash.
If an interrupt is pending (perhaps a user-initiated “cancel query” message to this backend), this will safely abort the current transaction
Log to Postgres’ debug1 log level.
Log to Postgres’ debug2 log level.
Log to Postgres’ debug3 log level.
Log to Postgres’ debug4 log level.
Log to Postgres’ debug5 log level.
A macro for specifying default argument values so they get propery translated to SQL in
CREATE FUNCTION statements
Log to Postgres’ error log level. This will abort the current Postgres transaction.
Declare SQL to be included in generated extension script.
Declare SQL (from a file) to be included in generated extension script.
Log to Postgres’ info log level.
Log to Postgres’ log log level.
A macro for providing SQL names for the returned fields for functions that return a Rust tuple,
especially those that return a std::iter::Iterator<Item=(f1, f2, f3)>
Log to Postgres’ notice log level.
Create the Pg_magic_func required by PGX in extensions.
A macro for marking a library compatible with pgx.
In order to store a type in Postgres Shared Memory, it must be passed to
pg_shmem_init!() during _PG_init().
Create neccessary extension-local internal marker for use with SQL generation.
Log to Postgres’ warning log level.
Structs
A std::result::Result-type value returned from pg_try() that allows for performing cleanup
work after a closure raised an error and before it is possibly rethrown
Enums
Statics
The default lookup for TypeIds to both Rust and SQL types via a RustSqlMapping.
Functions
Guard a closure such that Rust Panics are properly converted into Postgres ERRORs
Initialize the extension with Postgres
Converts a pg_sys::NameData struct into a &str.
Similar to guard, but allows the caller to unwrap the result in various ways, possibly
performing cleanup work before the caught error is rethrown
Attribute Macros
Used with #[pg_operator]. 1 value which is the function name
Used with #[pg_operator]. no values
Associated macro for #[pg_test] to provide context back to your test framework to indicate
that the test system is being initialized
Used with #[pg_operator]. 1 value which is the function name
Used with #[pg_operator]. no values
Used with #[pg_operator]. 1 value which is the function name
Used with #[pg_operator]. 1 value which is the operator name itself
Declare a pgx::Aggregate implentation on a type as able to used by Postgres as an aggregate.
Declare a function as #[pg_extern] to indicate that it can be used by Postgres as a UDF.
Declare a function as #[pg_guard] to indicate that it is called from a Postgres extern "C"
function so that Rust panic!()s (and Postgres elog(ERROR)s) will be properly handled by pgx
Declare a function as #[pg_operator] to indicate that it represents a Postgres operator
cargo pgx schema will automatically generate the underlying SQL
Declare a Rust module and its contents to be in a schema.
#[pg_test] functions are test functions (akin to #[test]), but they run in-process inside
Postgres during cargo pgx test.
A helper attribute for various contexts.
Used with #[pg_operator]. 1 value which is the function name
Associated macro for #[pg_extern] or #[macro@pg_operator]. Used to set the SEARCH_PATH option
on the CREATE FUNCTION statement.
Derive Macros
Generate necessary bindings for using the enum with PostgreSQL.
Generate necessary code using the type in operators like == and !=.
Generate necessary code for stable hashing the type so it can be used with USING hash indexes.
Generate necessary code using the type in operators like >, <, <=, and >=.
Generate necessary bindings for using the type with PostgreSQL.