pgrx 0.18.0

pgrx: A Rust framework for creating Postgres extensions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//LICENSE Portions Copyright 2019-2021 ZomboDB, LLC.
//LICENSE
//LICENSE Portions Copyright 2021-2023 Technology Concepts & Design, Inc.
//LICENSE
//LICENSE Portions Copyright 2023-2023 PgCentral Foundation, Inc. <contact@pgcentral.org>
//LICENSE
//LICENSE All rights reserved.
//LICENSE
//LICENSE Use of this source code is governed by the MIT license that can be found in the LICENSE file.
use super::ArrayIntoIterator;
use crate::{AnyElement, Array, FromDatum, IntoDatum, pg_sys};
use pgrx_sql_entity_graph::metadata::{
    ArgumentError, ReturnsError, ReturnsRef, SqlMappingRef, SqlTranslatable,
};
use std::iter::FusedIterator;

/// The [`anyarray` polymorphic pseudo-type][anyarray].
///
// rustdoc doesn't directly support a warning block: https://github.com/rust-lang/rust/issues/73935
/// **Warning**: Calling [`FromDatum::from_datum`] with this type will unconditionally panic. Call
/// [`FromDatum::from_polymorphic_datum`] with a type ID instead.
///
/// [anyarray]: https://www.postgresql.org/docs/current/extend-type-system.html#EXTEND-TYPES-POLYMORPHIC
#[derive(Debug, Clone, Copy)]
pub struct AnyArray {
    datum: pg_sys::Datum,
    typoid: pg_sys::Oid,
}

impl AnyArray {
    pub fn datum(&self) -> pg_sys::Datum {
        self.datum
    }

    pub fn oid(&self) -> pg_sys::Oid {
        self.typoid
    }

    #[inline]
    pub fn into<T: FromDatum>(&self) -> Option<T> {
        unsafe { T::from_polymorphic_datum(self.datum(), false, self.oid()) }
    }
}

impl FromDatum for AnyArray {
    const GET_TYPOID: bool = true;

    /// You should **never** call this function to make this type; it will unconditionally panic.
    /// For polymorphic types such as this one, you must use [`FromDatum::from_polymorphic_datum`]
    /// and pass a type ID.
    #[inline]
    unsafe fn from_datum(_datum: pg_sys::Datum, _is_null: bool) -> Option<AnyArray> {
        panic!(
            "Can't create a polymorphic type using from_datum, call FromDatum::from_polymorphic_datum instead"
        )
    }

    #[inline]
    unsafe fn from_polymorphic_datum(
        datum: pg_sys::Datum,
        is_null: bool,
        typoid: pg_sys::Oid,
    ) -> Option<AnyArray> {
        if is_null { None } else { Some(AnyArray { datum, typoid }) }
    }
}

impl IntoDatum for AnyArray {
    #[inline]
    fn into_datum(self) -> Option<pg_sys::Datum> {
        Some(self.datum)
    }

    fn type_oid() -> pg_sys::Oid {
        pg_sys::ANYARRAYOID
    }
}

unsafe impl SqlTranslatable for AnyArray {
    const TYPE_IDENT: &'static str = crate::pgrx_resolved_type!(AnyArray);
    const TYPE_ORIGIN: pgrx_sql_entity_graph::metadata::TypeOrigin =
        pgrx_sql_entity_graph::metadata::TypeOrigin::External;
    const ARGUMENT_SQL: Result<SqlMappingRef, ArgumentError> =
        Ok(SqlMappingRef::literal("anyarray"));
    const RETURN_SQL: Result<ReturnsRef, ReturnsError> =
        Ok(ReturnsRef::One(SqlMappingRef::literal("anyarray")));
}

impl<'a> IntoIterator for &'a AnyArray
where
    Self: 'a,
{
    type Item = Option<AnyElement>;
    type IntoIter = AnyArrayIterator<'a>;

    fn into_iter(self) -> Self::IntoIter {
        unsafe {
            AnyArrayIterator {
                inner: Array::<pg_sys::Datum>::from_polymorphic_datum(
                    self.datum(),
                    false,
                    self.oid(),
                )
                .map(|a| a.into_iter()),
                typelem: pg_sys::get_element_type(self.oid()),
            }
        }
    }
}

pub struct AnyArrayIterator<'a> {
    inner: Option<ArrayIntoIterator<'a, pg_sys::Datum>>,
    typelem: pg_sys::Oid,
}

impl<'a> Iterator for AnyArrayIterator<'a> {
    type Item = Option<AnyElement>;

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.as_mut().and_then(|i| {
            i.next().map(|d| match d {
                Some(d) => unsafe { AnyElement::from_polymorphic_datum(d, false, self.typelem) },
                None => None,
            })
        })
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        match &self.inner {
            Some(inner) => inner.size_hint(),
            None => (0, Some(0)),
        }
    }
}

impl<'a> ExactSizeIterator for AnyArrayIterator<'a> {}
impl<'a> FusedIterator for AnyArrayIterator<'a> {}