Module pgx::prelude

source ·
Expand description

The PGX prelude includes necessary imports to make extensions work.

Re-exports

Macros

  • FATAL
    Log to Postgres’ fatal log level. This will abort the current Postgres backend connection process.
  • PANIC
    Log to Postgres’ panic log level. This will cause the entire Postgres cluster to crash.
  • check_for_interrupts
    If an interrupt is pending (perhaps a user-initiated “cancel query” message to this backend), this will safely abort the current transaction
  • debug1
    Log to Postgres’ debug1 log level.
  • debug2
    Log to Postgres’ debug2 log level.
  • debug3
    Log to Postgres’ debug3 log level.
  • debug4
    Log to Postgres’ debug4 log level.
  • debug5
    Log to Postgres’ debug5 log level.
  • default
    A macro for specifying default argument values so they get properly translated to SQL in CREATE FUNCTION statements
  • ereport
    Sends some kind of message to Postgres, and if it’s a PgLogLevel::ERROR or greater, Postgres’ error handling takes over and, in the case of PgLogLevel::ERROR, aborts the current transaction.
  • error
    Log to Postgres’ error log level. This will abort the current Postgres transaction.
  • extension_sql
    Declare SQL to be included in generated extension script.
  • extension_sql_file
    Declare SQL (from a file) to be included in generated extension script.
  • function_name
    This macro returns the name of the enclosing function. As the internal implementation is based on the std::any::type_name, this macro derives all the limitations of this function.
  • info
    Log to Postgres’ info log level.
  • log
    Log to Postgres’ log log level.
  • name
    A macro for providing SQL names for the returned fields for functions that return a Rust tuple, especially those that return a TableIterator.
  • notice
    Log to Postgres’ notice log level.
  • pg_module_magic
    A macro for marking a library compatible with pgx.
  • warning
    Log to Postgres’ warning log level.

Structs

  • Array
    An array of some type (eg. TEXT[], int[])
  • Date
  • Interval
    From the PG docs https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-INTERVAL-INPUT Internally interval values are stored as months, days, and microseconds. This is done because the number of days in a month varies, and a day can have 23 or 25hours if a daylight savings time adjustment is involved. The months and days fields are integers while the microseconds field can store fractional seconds. Because intervals are usually created from constant strings or timestamp subtraction, this storage method works well in most cases…
  • PgTryBuilder
    PgTryBuilder is a mechanism to mimic Postgres C macros PG_TRY and PG_CATCH.
  • PgVarlena
    Wraps a Postgres varlena *, presenting it as if it’s a Rust type of a fixed size.
  • Range
    A safe deconstruction of a Postgres pg_sys::RangeType struct.
  • Time
  • TimeWithTimeZone
  • Timestamp
  • TimestampWithTimeZone
  • VariadicArray

Enums

Constants

Traits

  • FromDatum
    Convert a (pg_sys::Datum, is_null:bool pair into a Rust type
  • IntoDatum
    Convert a Rust type into a pg_sys::Datum.
  • RangeSubType
    This trait allows a struct to be a valid subtype for a RangeType

Functions

Type Definitions

Attribute Macros

  • commutator
    Used with #[pg_operator]. 1 value which is the function name
  • hashes
    Used with #[pg_operator]. no values
  • initialize
    Associated macro for #[pg_test] to provide context back to your test framework to indicate that the test system is being initialized
  • join
    Used with #[pg_operator]. 1 value which is the function name
  • merges
    Used with #[pg_operator]. no values
  • negator
    Used with #[pg_operator]. 1 value which is the function name
  • opname
    Used with #[pg_operator]. 1 value which is the operator name itself
  • pg_aggregate
    Declare a pgx::Aggregate implementation on a type as able to used by Postgres as an aggregate.
  • pg_extern
    Declare a function as #[pg_extern] to indicate that it can be used by Postgres as a UDF.
  • pg_guard
    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
  • pg_operator
    Declare a function as #[pg_operator] to indicate that it represents a Postgres operator cargo pgx schema will automatically generate the underlying SQL
  • pg_schema
    Declare a Rust module and its contents to be in a schema.
  • pg_test
    #[pg_test] functions are test functions (akin to #[test]), but they run in-process inside Postgres during cargo pgx test.
  • pg_trigger
    Create a PostgreSQL trigger function
  • pgx
    A helper attribute for various contexts.
  • restrict
    Used with #[pg_operator]. 1 value which is the function name
  • search_path
    Associated macro for #[pg_extern] or #[macro@pg_operator]. Used to set the SEARCH_PATH option on the CREATE FUNCTION statement.

Derive Macros

  • PostgresEnum
    Generate necessary bindings for using the enum with PostgreSQL.
  • PostgresEq
    Generate necessary code using the type in operators like == and !=.
  • PostgresGucEnum
    Derives the GucEnum trait, so that normal Rust enums can be used as a GUC.
  • PostgresHash
    Generate necessary code for stable hashing the type so it can be used with USING hash indexes.
  • PostgresOrd
    Generate necessary code using the type in operators like >, <, <=, and >=.
  • PostgresType
    Generate necessary bindings for using the type with PostgreSQL.