Struct Oid

pub struct Oid(/* private fields */);

An object identifier in Postgres.

This is meant to be understood purely by equality. There is no sensible “order” for Oids.

Notes

Default shall return a sensical Oid, not necessarily a useful one. Currently, this means that it returns the invalid Oid.

Implementations

impl Oid

pub const INVALID: Oid

pub const unsafe fn from_u32_unchecked(id: u32) -> Oid

👎Deprecated since 0.11.2: safely converts via SPI, use pg_sys::Oid::from(u32)

Generate an Oid from an arbitrary u32.

Safety

This allows you to create an Oid that Postgres won’t recognize and throw it into Postgres. Don’t.

You should know what kind of object the identifier would imply before creating it. Postgres may sometimes call very different internal functions based on an Oid input. The extension programming interface of Postgres can reach deep, calling functions that assume the caller should be trusted like Postgres would trust itself. Because it is. Postgres tables can also change at runtime, so if an Oid is not a BuiltinOid, what Postgres does based on an Oid can change dynamically.

The existence of this unsafe requirement to create arbitrary Oids does not, itself, constitute a promise any Oid from Postgres or PGRX is guaranteed to be valid or sensical. There are many existing problems in the way of this, for example:

• Oid includes the guaranteed-wrong values Oid::INVALID
• Postgres may return arbitrary-seeming Oids, like BuiltinOid::UNKNOWNOID
• an Oid can arrive in Rust from a table a non-superuser can write
• PGRX mostly relies on Rust’s type system instead of the dynamic typing of Postgres, thus often deliberately does not bother to remember what OID something had.

So this function is merely a reminder. Even for extensions that work with many Oids, it is not typical to need to create one from an arbitrary u32. Prefer to use a constant, or a BuiltinOid, or to obtain one from querying Postgres, or simply use Oid::INVALID. Marking it as an unsafe fn is an invitation to get an Oid from more trustworthy sources. This includes Oid::INVALID, or BuiltinOid, or by directly calling into Postgres. An unsafe fn is not an officer of the law empowered to indict C programs for felonies, nor cite SQL statements for misdemeanors, nor even truly stop you from foolishness. Even “trustworthy” is meant here in a similar sense to how raw pointers can be “trustworthy”. Often, you should still check if it’s null.

pub const fn from_u32(id: u32) -> Oid

Creates an Oid from an arbitrary u32.

This is the same as the From::from implementation, but available in a const context.

pub const fn from_builtin(id: u32) -> Result<Oid, NotBuiltinOid>

Gets an Oid from a u32 if it is a valid builtin declared by Postgres

pub const fn as_u32(self) -> u32

Trait Implementations

impl<'fcx> ArgAbi<'fcx> for Oid

unsafe fn unbox_arg_unchecked(arg: Arg<'_, 'fcx>) -> Self

Unbox an argument with a matching type.

unsafe fn unbox_nullable_arg(arg: Arg<'_, 'fcx>) -> Nullable<Self>

Unbox a nullable arg

fn is_virtual_arg() -> bool

“Is this a virtual arg?”

impl BorrowDatum for Oid

const PASS: PassBy

The “native” passing convention for this type.

unsafe fn point_from(ptr: NonNull<u8>) -> NonNull<Self>

Cast a pointer to this blob of bytes to a pointer to this type.

unsafe fn point_from_align4(ptr: NonNull<u32>) -> NonNull<Self>

Cast a pointer to aligned varlena headers to this type

unsafe fn borrow_unchecked<'dat>(ptr: NonNull<u8>) -> &'dat Self

Optimization for borrowing the referent

impl BoxRet for Oid

unsafe fn box_into<'fcx>(self, fcinfo: &mut FcInfo<'fcx>) -> Datum<'fcx>

Safety

impl Clone for Oid

fn clone(&self) -> Oid

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Oid

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Oid

fn default() -> Oid

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Oid

fn deserialize<__D>( __deserializer: __D, ) -> Result<Oid, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Enlist for Oid

const LIST_TAG: NodeTag = pg_sys::NodeTag::T_OidList

The appropriate list tag for this type.

impl From<BuiltinOid> for Oid

fn from(builtin: BuiltinOid) -> Oid

Converts to this type from the input type.

impl From<Oid> for Datum

fn from(oid: Oid) -> Datum

Converts to this type from the input type.

impl From<Oid> for PgOid

fn from(oid: Oid) -> PgOid

Converts to this type from the input type.

impl From<u32> for Oid

De facto available via SPI

fn from(word: u32) -> Oid

Converts to this type from the input type.

impl FromDatum for Oid

unsafe fn from_polymorphic_datum( datum: Datum, is_null: bool, _: Oid, ) -> Option<Oid>

Like from_datum for instantiating polymorphic types which require preserving the dynamic type metadata.

const GET_TYPOID: bool = false

Should a type OID be fetched when calling from_datum?

unsafe fn from_datum(datum: Datum, is_null: bool) -> Option<Self>

Safety

unsafe fn from_datum_in_memory_context( memory_context: PgMemoryContexts, datum: Datum, is_null: bool, typoid: Oid, ) -> Option<Self>

Default implementation switched to the specified memory context and then simply calls FromDatum::from_datum(...) from within that context.

unsafe fn try_from_datum( datum: Datum, is_null: bool, type_oid: Oid, ) -> Result<Option<Self>, TryFromDatumError>

where Self: IntoDatum,

try_from_datum is a convenience wrapper around FromDatum::from_datum that returns a a Result around an Option, as a Datum can be null. It’s intended to be used in situations where the caller needs to know whether the type conversion succeeded or failed.

unsafe fn try_from_datum_in_memory_context( memory_context: PgMemoryContexts, datum: Datum, is_null: bool, type_oid: Oid, ) -> Result<Option<Self>, TryFromDatumError>

where Self: IntoDatum,

A version of try_from_datum that switches to the given context to convert from Datum

impl Hash for Oid

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoDatum for Oid

fn into_datum(self) -> Option<Datum>

fn type_oid() -> Oid

fn composite_type_oid(&self) -> Option<Oid>

fn is_compatible_with(other: Oid) -> bool

Is a Datum of this type compatible with another Postgres type?

impl PartialEq for Oid

fn eq(&self, other: &Oid) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Oid

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SqlTranslatable for Oid

fn argument_sql() -> Result<SqlMapping, ArgumentError>

fn return_sql() -> Result<Returns, ReturnsError>

fn type_name() -> &'static str

fn variadic() -> bool

fn optional() -> bool

fn entity() -> FunctionMetadataTypeEntity

impl TryFrom<Oid> for BuiltinOid

type Error = NotBuiltinOid

The type returned in the event of a conversion error.

fn try_from(oid: Oid) -> Result<BuiltinOid, NotBuiltinOid>

Performs the conversion.

impl UnboxDatum for Oid

type As<'src> = Oid

Self with the lifetime 'src

unsafe fn unbox<'src>(datum: Datum<'src>) -> Self::As<'src>

where Self: 'src,

Convert from Datum<'src> to T::As<'src>

impl Copy for Oid

impl Eq for Oid

impl StructuralPartialEq for Oid