pgx
Build Postgres Extensions with Rust!
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Check it deeper on your machine
It has changed since its scan on 11 Nov 2026.
As a Claude Code plugin, install it and then ask Claude Code:
/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/pgcentralfoundation/pgrx with scanskillsafety
Or from a terminal, clone it and run it:
git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/pgcentralfoundation/pgrx'
It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.
Badge for your README
Markdown
[](/listings/tcdi--pgx)HTML
<a href="/listings/tcdi--pgx"><img src="/api/listings/tcdi--pgx/badge.svg" alt="findsafeskills safety rating" /></a>Install
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
README.md · README · 461 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.
- 
- # `pgrx`
- > Build Postgres Extensions with Rust!
- 
- [](https://crates.io/crates/pgrx)
- [](https://docs.rs/pgrx)
- [](https://twitter.com/pgrx_rs)
- [][Discord]
- `pgrx` is a framework for developing PostgreSQL extensions in Rust and strives to be as idiomatic and safe as possible.
- `pgrx` supports Postgres 15 through Postgres 18, plus Postgres 19rc2.
- ## Want to chat with us or get a question answered?
- + **Please join our [Discord Server][Discord].**
- + **We are also in need of financial [sponsorship](https://checkout.square.site/merchant/MLHG5M9GAXQPV/checkout/2OW2SULDQBSZ2JLHSLRZQLZH).**
- ## Key Features
- - **A fully managed development environment with [`cargo-pgrx`](cargo-pgrx/README.md)**
- + `cargo pgrx new`: Create new extensions quickly
- + `cargo pgrx init`: Install new (or register existing) PostgreSQL installs
- + `cargo pgrx run`: Run your extension and interactively test it in `psql` (or `pgcli`)
- + `cargo pgrx test`: Unit-test your extension across multiple PostgreSQL versions
- + `cargo pgrx regress`: Run SQL regression tests and compare their output with expected files
- + `cargo pgrx package`: Create installation packages for your extension, including RPM and DEB packages on Linux
- + `cargo pgrx migrate`: Optionally build upgrade scripts from one small SQL file per change
- + More in the [`README.md`](cargo-pgrx/README.md)!
- - **Target Multiple Postgres Versions**
- + Support from Postgres 15 to Postgres 19 from the same codebase
- + Use Rust feature gating to use version-specific APIs
- + Seamlessly test against all versions
- - **Automatic Schema Generation**
- + Implement extensions entirely in Rust
- + [Automatic mapping for many Rust types into PostgreSQL](#mapping-of-postgres-types-to-rust)
- + SQL schemas generated automatically (or manually via `cargo pgrx schema`)
- + Include custom SQL with `extension_sql!` & `extension_sql_file!`
- - **Automatic PostgreSQL C Macro Translation**
- + During binding generation, pgrx transpiles nearly all of PostgreSQL's function-style C `#define` macros into Rust `macro_rules!` macros
- + Call them through `pgrx::` with their original C names and `!`, such as `pgrx::VARSIZE_ANY!(ptr)`
- + Their behavior follows the selected PostgreSQL installation, compiler flags, and target
- + See [Using PostgreSQL C macros](docs/src/extension/c-macros.md) for extension examples and the [transpiler architecture](pgrx-c-macros/ARCHITECTURE.md) for implementation details
- - **Safety First**
- + Translates Rust `panic!`s into Postgres `ERROR`s that abort the transaction, not the process
- + Memory Management follows Rust's drop semantics, even in the face of `panic!` and `elog(ERROR)`
- + `#[pg_guard]` procedural macro to ensure the above
- + Postgres `Datum`s are `Option<T> where T: FromDatum`
- - `NULL` Datums are safely represented as `Option::<T>::None`
- - **First-class UDF support**
- + Annotate functions with `#[pg_extern]` to expose them to Postgres
- + Return `pgrx::iter::SetOfIterator<'a, T>` for `RETURNS SETOF`
- + Return `pgrx::iter::TableIterator<'a, T>` for `RETURNS TABLE (...)`
- + Create trigger functions with `#[pg_trigger]`
- - **Easy Custom Types**
- + `#[derive(PostgresType)]` to use a Rust struct as a Postgres type
- - By default, represented as a CBOR-encoded object in-memory/on-disk, and JSON as human-readable
- - Supports `#[pg_binary_protocol]` to generate binary protocol send/recv functions
- - Provide custom in-memory/on-disk/human-readable representations
- + `#[derive(PostgresEnum)]` to use a Rust enum as a Postgres enum
- + Composite types supported with the `pgrx::composite_type!("Sample")` macro
- - **Server Programming Interface (SPI)**
- + Safe access into SPI
- + Transparently return owned Datums from an SPI context
- - **Advanced Features**
- + Safe access to Postgres' `MemoryContext` system via `pgrx::PgMemoryContexts`
- + Executor/planner/transaction/subtransaction hooks
- + Safely use Postgres-provided pointers with `pgrx::PgBox<T>` (akin to `alloc::boxed::Box<T>`)
- + `#[pg_guard]` proc-macro for guarding `extern "C-unwind"` Rust functions that need to be passed into Postgres
- + Access Postgres' logging system through `eprintln!`-like macros
- + Direct `unsafe` access to large parts of Postgres internals via the `pgrx::pg_sys` module
- + New features added regularly!
- ## System Requirements
- PGRX has been tested to work on x86_64 Linux, aarch64 Linux, aarch64 macOS, and x86_64 Windows targets⹋.
- It is currently expected to work on other "Unix" OS with possible small changes, but those remain untested.
- The generated C macros need a target whose C data model the compiler can verify
- as LP64, LLP64, or ILP32, and whose Rust architecture, OS, and ABI pgrx
- recognizes. See
- [target limits](docs/src/extension/c-macros.md#understand-refusals-and-runtime-limits).
- A cross build has further requirements; see [Cross-compiling](#cross-compiling).
- - A Rust toolchain: `rustc`, `cargo`, and `rustfmt`. The recommended way to get these is from https://rustup.rs †
- - `git`
- - `libclang` 11 or greater, plus a `clang` driver and LLVM archiver from the same LLVM release
- - Debian-likes: `apt install clang llvm libclang-dev`
- - RHEL-likes: `yum install clang llvm`
- - Windows: download installers from https://github.com/llvm/llvm-project/releases
- - On Linux, pgrx's CI generates the C macros with every Clang major from 14 through 23, on x86_64 and aarch64, and requires those versions to generate the same macros. Other Clang versions are not tested on Linux.
- - `pgrx-pg-sys` uses the driver to find the target's system headers, to check the C macro profile against the PostgreSQL headers and to compile its native support archive, including the `cshim` feature. Its major version must match `libclang`. pgrx uses `CLANG_PATH` when it is set; otherwise it uses the first match among the `CLANG` recorded in a `pg_config` program's `--configure` output, the `clang` installed with `libclang`, and `clang-<major>` or `clang` on `PATH`.
- - The archiver is `llvm-ar` from the driver's LLVM release, or `llvm-lib` for Windows targets. pgrx looks for `llvm-ar-<major>` beside a `clang-<major>` driver, then `llvm-ar` beside the driver or beside its resolved path, such as Debian's `/usr/lib/llvm-<major>/bin/llvm-ar`. Without one, builds for Unix targets use the system `ar`, which works for native builds but may not index objects built for another target.
- - A failure to generate the C macros stops the build with an error that names the cause.
- - A driver that loads a default configuration file, as Gentoo's Clang does, is refused. Set `CLANG_NO_DEFAULT_CONFIG=1` to build without it.
- - C compiler
- - Linux and macOS: a host C compiler, which builds the generator's SHA-256 backend
- - Windows: MSVC, which Rust's MSVC targets need for linking
- - [PostgreSQL's build dependencies](https://wiki.postgresql.org/wiki/Compile_and_Install_from_source_code) ‡
- - Debian-likes: `sudo apt-get install build-essential libreadline-dev zlib1g-dev flex bison libxml2-dev libxslt-dev libssl-dev libxml2-utils xsltproc ccache pkg-config libicu-dev`
- - RHEL-likes: `sudo yum install -y bison-devel readline-devel zlib-devel openssl-devel wget ccache && sudo yum groupinstall -y 'Development Tools'`
- † PGRX has no MSRV policy, thus may require the latest stable version of Rust, available via Rustup
- ‡ A local PostgreSQL server installation is not required. On Linux and MacOS, `cargo pgrx` can download and compile PostgreSQL versions on its own. On Windows, `cargo pgrx` downloads precompiled PostgreSQL versions from EnterpriseDB.
- ⹋ PGRX has not been tested on 32-bit targets. The generated macro runtime's
- verified ILP32 model and the library's 32-bit Datum conversion code do not
- establish a supported 32-bit backend build. Official support would require
- ongoing technical and financial contributions.
- ### macOS
- Running PGRX on a Mac requires some additional setup.
- The Mac C compiler (clang) and related tools are bundled with [Xcode](https://developer.apple.com/xcode/).
- Xcode can be installed from the Mac App Store.
- For additional C libraries, it's easiest to use [Homebrew](https://brew.sh/). In particular,
- you will probably need these if you don't have them already:
- ```zsh
- brew install git icu4c pkg-config
- ```
- Postgres 16 and later build with ICU by default, and their config script does not automatically
- detect the Homebrew install directory. (Postgres 15 builds without ICU unless asked, so it does
- not have this problem.) You may see this error:
- ```configure: error: ICU library not found```
- To fix it, run
- ```
- export PKG_CONFIG_PATH=/opt/homebrew/opt/icu4c/lib/pkgconfig
- ```
- on the command line before you run ```cargo pgrx init```
- #### Troubleshooting
- 1. Every once in a while, Xcode will update itself and move the directory that contains
- the C compiler. When the Postgres ./config process runs during the build, it grabs the current directory
- and stores it, which means that there will be build errors if you do a full rebuild of your
- project and the old directory has disappeared. The solution is re-run `cargo pgrx init` so the
- Postgres installs get rebuilt.
- 2. If a build fails with errors like `unknown type name: uint8_t`:
- You may be using too-old Xcode. This often happens with an Apple Clang version below 15.
- This can be fixed by updating Xcode and the command-line tools. You may require an OS update
- if the Xcode version you must update to does not support your current macOS version.
- ### Windows
- Running PGRX on Windows requires MSVC prerequisites.
- On Windows, please follow https://rust-lang.github.io/rustup/installation/windows-msvc.html to set it up.
- ## Getting Started
- Before anything else, install the [system dependencies](#system-requirements).
- Now install the `cargo-pgrx` sub-command.
- ```bash
- cargo install --locked cargo-pgrx
- ```
- Once `cargo-pgrx` is ready you can initialize the "PGRX Home" directory:
- ```bash
- cargo pgrx init
- ```
- The `init` command downloads all currently supported PostgreSQL versions, compiles them
- to `${PGRX_HOME}`, and runs `initdb`.
- It's also possible to use an existing (user-writable) PostgreSQL install, or install a subset of versions, see the [`README.md` of `cargo-pgrx` for details](cargo-pgrx/README.md#first-time-initialization).
- Now you can begin work on a specific pgrx extension:
- ```bash
- cargo pgrx new my_extension
- cd my_extension
- ```
- This will create a new directory for the extension crate.
- ```
- $ tree
- .
- ├── Cargo.toml
- ├── my_extension.control
- ├── sql
- └── src
- └── lib.rs
- 2 directories, 3 files
- ```
- The new extension includes an example, so you can go ahead and run it right away.
- ```bash
- cargo pgrx run
- ```
- This compiles the extension to a shared library, copies it to the specified Postgres installation, starts that Postgres instance and connects you to a database named the same as the extension.
- Once `cargo-pgrx` drops us into `psql` we can [load the extension](https://www.postgresql.org/docs/15/sql-createextension.html) and do a SELECT on the example function.
- ```sql
- my_extension=# CREATE EXTENSION my_extension;
- CREATE EXTENSION
- my_extension=# SELECT hello_my_extension();
- hello_my_extension
- ---------------------
- Hello, my_extension
- (1 row)
- ```
- For more details on how to manage pgrx extensions see [Managing pgrx extensions](cargo-pgrx/README.md).
- ## Cross-compiling
- Cross-compiling builds an extension on one machine for another platform. pgrx
- does it from a *target bundle*, one file made from the target's PostgreSQL:
- 1) On the target platform, run [`tools/pgrx-collect-partial-bundle.sh`](tools/pgrx-collect-partial-bundle.sh).
- It needs only a POSIX shell, `tar` and PostgreSQL's server headers, and writes a *partial bundle*
- such as `pgrx-pg18-aarch64-unknown-linux-gnu.partial.tar.gz`. It can also take what `pg_config`
- reports from a file or from arguments, for headers in a sysroot whose `pg_config` cannot run.
- 2) Copy that file to the build host.
- 3) On the build host, run `cargo pgrx package --bundle <file>`. This needs a Rust toolchain that can link
- for the target, Clang, and the target's system headers, and no PostgreSQL, `pg_config` or `cargo pgrx init`.
- A partial bundle holds nothing generated, so it serves every pgrx version. To need only a linker on
- the build host, generate a *full bundle* instead with `cargo pgrx package --bundle-generate` in your
- extension's directory on the target. That needs Rust and Clang there, and has to be done again after
- each pgrx upgrade, since a full bundle is valid for one Rust target, PostgreSQL major version, pgrx
- version and `cshim` setting.
- The bundle comes from the target because the bindings, C macros and native
- support that pgrx builds from PostgreSQL's headers depend on how that PostgreSQL
- was built. The target platform can be a container or a CI runner. The
- [cross-compilation guide](docs/src/extension/build/cross-compile.md)
- describes both kinds of bundle, what pgrx verifies, and cross toolchains.
- Library names, package layout, and RPM/DEB generation follow the bundle's
- target. Cargo's `build.target`, `CARGO_BUILD_TARGET`, forwarded Cargo flags, and
- custom JSON target specifications do not select a target for cargo-pgrx.
- `cargo pgrx run` will not work.
- ## Upgrading
- To move an extension to a new `pgrx` release, install the matching `cargo-pgrx`, then update
- your crate's `pgrx` dependencies:
- ```bash
- cargo install cargo-pgrx --version <VERSION> --locked
- ```
- ```bash
- cargo pgrx upgrade
- ```
- A release that needs code or build changes has a migration guide in the top level of this
- repository, such as the [v0.20.0 Migration Guide](v0.20.0-MIGRATION.md).
- As new Postgres versions are supported by `pgrx`, you can re-run `cargo pgrx init` to download and compile them:
- ```bash
- cargo pgrx init
- ```
- ## Mapping of Postgres types to Rust
- | Postgres Type | Rust Type (as `Option<T>`) |
- |----------------------------|---------------------------------------------------------|
- | `bytea` | `Vec<u8>`, `&[u8]` (zero-copy in), or `pgrx::Bytea<'_>` (zero-copy in/out) |
- | `text` | `String` or `&str` (zero-copy) |
- | `varchar` | `String` or `&str` (zero-copy) or `char` |
- | `"char"` | `i8` |
- | `smallint` | `i16` |
- | `integer` | `i32` |
- | `bigint` | `i64` |
- | `oid` | `pgrx::pg_sys::Oid` |
- | `real` | `f32` |
- | `double precision` | `f64` |
- | `bool` | `bool` |
- | `json` | `pgrx::Json(serde_json::Value)` |
- | `jsonb` | `pgrx::JsonB(serde_json::Value)` |
- | `date` | `pgrx::Date` |
- | `time` | `pgrx::Time` |
- | `timestamp` | `pgrx::Timestamp` |
- | `time with time zone` | `pgrx::TimeWithTimeZone` |
- | `timestamp with time zone` | `pgrx::TimestampWithTimeZone` |
- | `anyarray` | `pgrx::AnyArray` |
- | `anyelement` | `pgrx::AnyElement` |
- | `box` | `pgrx::geo::Box` |
- | `circle` | `pgrx::geo::Circle` |
- | `line` | `pgrx::geo::Line` |
- | `lseg` | `pgrx::geo::LineSegment` |
- | `path` | `pgrx::geo::Path` |
- | `point` | `pgrx::geo::Point` |
- | `polygon` | `pgrx::geo::Polygon` |
- | `tid` | `pgrx::pg_sys::ItemPointerData` |
- | `cstring` | `&core::ffi::CStr` |
- | `inet` | `pgrx::Inet(String)` -- TODO: needs better support |
- | `numeric` | `pgrx::Numeric<P, S> or pgrx::AnyNumeric` |
- | `void` | `()` |
- | `ARRAY[]::<type>` | `Vec<Option<T>>` or `pgrx::Array<T>` (zero-copy) |
- | `int4range` | `pgrx::Range<i32>` |
- | `int8range` | `pgrx::Range<i64>` |
- | `numrange` | `pgrx::Range<Numeric<P, S>>` or `pgrx::Range<AnyRange>` |
- | `daterange` | `pgrx::Range<pgrx::Date>` |
- | `tsrange` | `pgrx::Range<pgrx::Timestamp>` |
- | `tstzrange` | `pgrx::Range<pgrx::TimestampWithTimeZone>` |
- | `NULL` | `Option::None` |
- | `internal` | `pgrx::Internal` |
- | `uuid` | `pgrx::Uuid([u8; 16])` |
- | `tsvector` | `&pgrx::TsVector` or `pgrx::TsVectorBuf` |
- | `tsquery` | `&pgrx::TsQuery` or `pgrx::TsQueryBuf` |
- There are also `IntoDatum` and `FromDatum` traits for implementing additional type conversions,
- along with `#[derive(PostgresType)]` and `#[derive(PostgresEnum)]` for automatic conversion of
- custom types.
- Note that `text` and `varchar` are converted to `&str` or `String`, so PGRX
- assumes any Postgres database you use it with has UTF-8-compatible encoding.
- Currently, PGRX will panic if it detects this is incorrect, to inform you, the
- programmer, that you were wrong. However, it is best to not rely on this
- behavior, as UTF-8 validation can be a performance hazard. This problem was
- previously assumed to simply not happen, and PGRX may decide to change the
- details of how it does UTF-8 validation checks in the future in order to
- mitigate performance hazards.
- The default Postgres server encoding is `SQL_ASCII`, and it guarantees neither
- ASCII nor UTF-8 (as Postgres will then accept but ignore non-ASCII bytes).
- For best results, always use PGRX with UTF-8, and set database encodings
- explicitly upon database creation.
- ## Digging Deeper
- - [cargo-pgrx sub-command](cargo-pgrx/)
- - [Custom Types](pgrx-examples/custom_types/)
- - [Postgres Operator Functions and Operator Classes/Families](pgrx-examples/operators/)
- - [Shared Memory Support](pgrx-examples/shmem/)
- - [various examples](pgrx-examples/)
- ## Caveats & Known Issues
- There are probably more issues than the ones listed here, but the primary ones of note are:
- - Threading is not really supported. Postgres is strictly single-threaded. As such, if you do venture into using threads, those threads **MUST NOT** call *any* internal Postgres function, or otherwise use any Postgres-provided pointer. There's also a potential problem with Postgres' use of `sigprocmask`. This was being discussed on the -hackers list, even with a patch provided, but the conversation seems to have stalled (https://www.postgresql.org/message-id/flat/5EF20168.2040508%40anastigmatix.net#4533edb74194d30adfa04a6a2ce635ba).
- - How to correctly interact with Postgres in an `async` context remains unexplored.
- - `pgrx` wraps a lot of `unsafe` code, some of which has poorly-defined safety conditions. It may be easy to induce illogical and undesirable behaviors even from safe code with `pgrx`, and some of these wrappers may be fundamentally unsound. Please report any issues that may arise.
- - Not all of Postgres' internals are included or even wrapped. This isn't due to it not being possible, it's simply due to it being an incredibly large task. If you identify internal Postgres APIs you need, open an issue and we'll get them exposed, at least through the `pgrx::pg_sys` module.
- - Sessions started before `ALTER EXTENSION my_extension UPDATE;` will continue to see the old version of `my_extension`. New sessions will see the updated version of the extension.
- - `pgrx` is used by many "in production", but it is not "1.0.0" or above, despite that being recommended by SemVer for production-quality software. This is because there are many unresolved soundness and ergonomics questions that will likely require breaking changes to resolve, in some cases requiring cutting-edge Rust features to be able to expose sound interfaces. While a 1.0.0 release is intended at some point, it seems prudent to wait until it seems like a 2.0.0 release would not be needed the next week and the remaining questions can be deferred.
- ## TODO
- There are a few things on our immediate TODO list
- - Automatic extension schema upgrade scripts (today, `cargo pgrx migrate` assembles them from hand-written SQL fragments)
- - Improved unit testing framework
- - Better/Safer API for Datum management
- - Improved generated bindings organization
- - Safely wrap more Postgres internal APIs
- - More examples -- especially around memory management and the various derive macros `#[derive(PostgresType/Enum)]`
- ## Feature Flags
- PGRX has optional feature flags for Rust code that do not involve configuring the version of Postgres used,
- but rather extend additional support for other kinds of Rust code. These are not included by default.
- ### "unsafe-postgres": Allow compilation for Postgres forks that have a different ABI
- As of Postgres 15, forks are allowed to specify they use a different ABI than canonical Postgres.
- Since pgrx makes countless assumptions about Postgres' internal ABI it is not possible for it to
- guarantee that a compiled pgrx extension will probably execute within such a Postgres fork. You,
- dear compiler runner, can make this guarantee for yourself by specifying the `unsafe-postgres`
- feature flag. Otherwise, a pgrx extension will fail to compile with an error similar to:
- ```
- error[E0080]: evaluation of constant value failed
- --> pgrx/src/lib.rs:151:5
- |
- 151 | / assert!(
- 152 | | same_slice(pg_sys::FMGR_ABI_EXTRA, b"xPostgreSQL\0"),
- 153 | | "Unsupported Postgres ABI. Perhaps you need `--features unsafe-postgres`?",
- 154 | | );
- | |_____^ the evaluated program panicked at 'Unsupported Postgres ABI. Perhaps you need `--features unsafe-postgres`?', pgrx/src/lib.rs:151:5
- |
- ```
- ### "no_thread_check_in_release": Skip the backend thread check in release builds
- Postgres may only be called from the backend's own thread. pgrx remembers the first thread that
- calls into Postgres and panics when another one does. That check runs on every call through
- pgrx's FFI guard, and several safe pgrx functions rely on it for their soundness.
- With the `no_thread_check_in_release` feature, a build without `debug_assertions`, which is what
- `cargo pgrx install --release` and `cargo pgrx package` make by default, compiles the check as a
- `const fn` that does nothing. Calling Postgres from another thread is then undefined behavior that
- nothing reports, including through pgrx's safe functions. A build with `debug_assertions`, such as
- the one `cargo pgrx test` makes by default, keeps the check.
- Cargo unifies features, so one crate that sets this one removes the check from every crate of the
- build that uses pgrx. Only set it in an extension whose every dependency keeps Postgres calls on
- the backend thread.
- `pgrx::assert_active_thread()` is the same check as a function you can call yourself. It runs in
- every build, whatever this feature says. A build without pgrx's own checks has no active thread
- until the first call, so make that call on the backend thread.
- ## Contributing
- We are most definitely open to contributions of any kind. Bug Reports, Feature Requests, and Documentation.
- If you'd like to contribute code via a Pull Request, please make it against our `develop` branch. The `master` branch is no longer used.
- Providing wrappers for Postgres' internals is not a straightforward task, and completely wrapping it is going
- to take quite a bit of time. `pgrx` is generally ready for use now, and it will continue to be developed as
- time goes on. Your feedback about what you'd like to be able to do with `pgrx` is greatly appreciated.
- ## Hacking
- When you run tests in this repository, the `#[pg_test]` harness builds and runs the checkout's
- `cargo-pgrx` with `cargo run`, so tests always use the revision you're working on. Set
- `CARGO_PGRX` to the path of a `cargo-pgrx` binary to use a different one.
- Other commands, such as `cargo pgrx init`, also need a `cargo-pgrx` from the same revision.
- Install one from the checkout as described in
- [Contributing](docs/src/contributing.md#dev-environment-setup), or run it without installing,
- as in `cargo run -p cargo-pgrx -- pgrx init`.
- Extensions can pin a matching `cargo-pgrx` with
- [cargo-local-install](https://github.com/MaulingMonkey/cargo-local-install). This repository's
- `Cargo.toml` has a `[workspace.metadata.local-install]` entry for it as an example: `cargo local-install`
- installs that `cargo-pgrx` into `./bin`, which you then prepend to your `PATH`.
- ## License
- ```
- Portions Copyright 2019-2021 ZomboDB, LLC.
- Portions Copyright 2021-2023 Technology Concepts & Design, Inc.
- Portions Copyright 2023 PgCentral Foundation, Inc.
- All rights reserved.
- Use of this source code is governed by the MIT license that can be found in the LICENSE file.
- ```
- [Discord]: https://discord.gg/PMrpdJsqcJ
- [timecrate]: https://crates.io/crates/time
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.