mz_repr/

scalar.rs

// Copyright Materialize, Inc. and contributors. All rights reserved.
//
// Use of this software is governed by the Business Source License
// included in the LICENSE file.
//
// As of the Change Date specified in that file, in accordance with
// the Business Source License, use of this software will be governed
// by the Apache License, Version 2.0.

use std::borrow::Cow;
use std::cmp::Ordering;
use std::collections::BTreeMap;
use std::fmt::{self, Debug};
use std::hash::Hash;
use std::iter;
#[cfg(any(test, feature = "proptest"))]
use std::ops::Add;
use std::sync::LazyLock;

use anyhow::bail;
#[cfg(any(test, feature = "proptest"))]
use chrono::TimeZone;
use chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime, Utc};
use dec::OrderedDecimal;
use enum_kinds::EnumKind;
use itertools::Itertools;
use mz_ore::Overflowing;
#[cfg(any(test, feature = "proptest"))]
use mz_ore::cast::CastFrom;
use mz_ore::str::{StrExt, separated};
use mz_proto::{IntoRustIfSome, ProtoType, RustType, TryFromProtoError};
use ordered_float::OrderedFloat;
#[cfg(any(test, feature = "proptest"))]
use proptest::prelude::*;
#[cfg(any(test, feature = "proptest"))]
use proptest::strategy::Union;
use serde::{Deserialize, Serialize};
use uuid::Uuid;

use crate::adt::array::{Array, ArrayDimension};
use crate::adt::char::{Char, CharLength};
use crate::adt::date::Date;
use crate::adt::interval::Interval;
use crate::adt::jsonb::{Jsonb, JsonbRef};
use crate::adt::mz_acl_item::{AclItem, AclMode, MzAclItem};
use crate::adt::numeric::{Numeric, NumericMaxScale};
use crate::adt::pg_legacy_name::PgLegacyName;
use crate::adt::range::Range;
#[cfg(any(test, feature = "proptest"))]
use crate::adt::range::{RangeLowerBound, RangeUpperBound};
use crate::adt::system::{Oid, PgLegacyChar, RegClass, RegProc, RegType};
use crate::adt::timestamp::{CheckedTimestamp, TimestampError, TimestampPrecision};
#[cfg(any(test, feature = "proptest"))]
use crate::adt::timestamp::{HIGH_DATE, LOW_DATE};
use crate::adt::varchar::{VarChar, VarCharMaxLength};
use crate::relation::ReprColumnType;
pub use crate::relation_and_scalar::ProtoScalarType;
pub use crate::relation_and_scalar::proto_scalar_type::ProtoRecordField;
use crate::role_id::RoleId;
use crate::row::DatumNested;
use crate::{CatalogItemId, ColumnName, DatumList, DatumMap, Row, RowArena, SqlColumnType};

/// A single value.
///
/// # Notes
///
/// ## Equality
/// `Datum` must always derive [`Eq`] to enforce equality with `repr::Row`.
///
/// ## `Datum`-containing types
/// Because Rust disallows recursive enums, complex types which need to contain
/// other `Datum`s instead store bytes representing that data in other structs,
/// usually prefixed with `Datum` (e.g. `DatumList`). These types perform a form
/// of ad-hoc deserialization of their inner bytes to `Datum`s via
/// `crate::row::read_datum`.
///
/// To create a new instance of a `Datum`-referencing `Datum`, you need to store
/// the inner `Datum`'s bytes in a row (so you can in turn borrow those bytes in
/// the outer `Datum`). The idiom we've devised for this is a series of
/// functions on `repr::row::RowPacker` prefixed with `push_`.
///
#[derive(Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, EnumKind)]
#[enum_kind(DatumKind, derive(Hash))]
pub enum Datum<'a> {
    /// The `false` boolean value.
    False,
    /// The `true` boolean value.
    True,
    /// A 16-bit signed integer.
    Int16(i16),
    /// A 32-bit signed integer.
    Int32(i32),
    /// A 64-bit signed integer.
    Int64(i64),
    /// An 8-bit unsigned integer.
    UInt8(u8),
    /// An 16-bit unsigned integer.
    UInt16(u16),
    /// A 32-bit unsigned integer.
    UInt32(u32),
    /// A 64-bit unsigned integer.
    UInt64(u64),
    /// A 32-bit floating point number.
    Float32(OrderedFloat<f32>),
    /// A 64-bit floating point number.
    Float64(OrderedFloat<f64>),
    /// A date.
    Date(Date),
    /// A time.
    Time(NaiveTime),
    /// A date and time, without a timezone.
    /// Note that this is not [`crate::Timestamp`]! That's in [`Datum::MzTimestamp`].
    Timestamp(CheckedTimestamp<NaiveDateTime>),
    /// A date and time, with a timezone.
    TimestampTz(CheckedTimestamp<DateTime<Utc>>),
    /// A span of time.
    Interval(Interval),
    /// A sequence of untyped bytes.
    Bytes(&'a [u8]),
    /// A sequence of Unicode codepoints encoded as UTF-8.
    String(&'a str),
    /// Unlike [`Datum::List`], arrays are like tensors and are not permitted to
    /// be ragged.
    Array(Array<'a>),
    /// A sequence of `Datum`s.
    ///
    /// Unlike [`Datum::Array`], lists are permitted to be ragged.
    List(DatumList<'a>),
    /// A mapping from string keys to `Datum`s.
    Map(DatumMap<'a>),
    /// An exact decimal number, possibly with a fractional component, with up
    /// to 39 digits of precision.
    Numeric(OrderedDecimal<Numeric>),
    /// An unknown value within a JSON-typed `Datum`.
    ///
    /// This variant is distinct from [`Datum::Null`] as a null datum is
    /// distinct from a non-null datum that contains the JSON value `null`.
    JsonNull,
    /// A universally unique identifier.
    Uuid(Uuid),
    MzTimestamp(crate::Timestamp),
    /// A range of values, e.g. [-1, 1).
    Range(Range<DatumNested<'a>>),
    /// A list of privileges granted to a user, that uses [`RoleId`]s for role
    /// references.
    MzAclItem(MzAclItem),
    /// A list of privileges granted to a user that uses [`Oid`]s for role references.
    /// This type is used primarily for compatibility with PostgreSQL.
    AclItem(AclItem),
    /// A placeholder value.
    ///
    /// Dummy values are never meant to be observed. Many operations on `Datum`
    /// panic if called on this variant.
    ///
    /// Dummies are useful as placeholders in e.g. a `Vec<Datum>`, where it is
    /// known that a certain element of the vector is never observed and
    /// therefore needn't be computed, but where *some* `Datum` must still be
    /// provided to maintain the shape of the vector. While any valid datum
    /// could be used for this purpose, having a dedicated variant makes it
    /// obvious when these optimizations have gone awry. If we used e.g.
    /// `Datum::Null`, an unexpected `Datum::Null` could indicate any number of
    /// problems: bad user data, bad function metadata, or a bad optimization.
    ///
    // TODO(benesch): get rid of this variant. With a more capable optimizer, I
    // don't think there would be any need for dummy datums.
    Dummy,
    // Keep `Null` last so that calling `<` on Datums sorts nulls last, to
    // match the default in PostgreSQL. Note that this doesn't have an effect
    // on ORDER BY, because that is handled by compare_columns. The only
    // situation it has an effect is array comparisons, e.g.,
    // `SELECT ARRAY[1] < ARRAY[NULL]::int[]`. In such a situation, we end up
    // calling `<` on Datums (see `fn lt` in scalar/func.rs).
    /// An unknown value.
    Null,
    // WARNING! DON'T PLACE NEW DATUM VARIANTS HERE!
    //
    // This order of variants of this enum determines how nulls sort. We
    // have decided that nulls should sort last in Materialize, so all
    // other datum variants should appear before `Null`.
}

impl Debug for Datum<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use mz_ore::str::*;
        match self {
            Datum::False => write!(f, "False"),
            Datum::True => write!(f, "True"),
            Datum::Int16(x) => f.debug_tuple("Int16").field(&redact(x)).finish(),
            Datum::Int32(x) => f.debug_tuple("Int32").field(&redact(x)).finish(),
            Datum::Int64(x) => f.debug_tuple("Int64").field(&redact(x)).finish(),
            Datum::UInt8(x) => f.debug_tuple("UInt8").field(&redact(x)).finish(),
            Datum::UInt16(x) => f.debug_tuple("UInt16").field(&redact(x)).finish(),
            Datum::UInt32(x) => f.debug_tuple("UInt32").field(&redact(x)).finish(),
            Datum::UInt64(x) => f.debug_tuple("UInt64").field(&redact(x)).finish(),
            Datum::Float32(x) => f.debug_tuple("Float32").field(&redact(x)).finish(),
            Datum::Float64(x) => f.debug_tuple("Float64").field(&redact(x)).finish(),
            Datum::Date(x) => f.debug_tuple("Date").field(&redact(x)).finish(),
            Datum::Time(x) => f.debug_tuple("Time").field(&redact(x)).finish(),
            Datum::Timestamp(x) => f
                .debug_tuple("Timestamp")
                .field(&redact(x.to_naive()))
                .finish(),
            Datum::TimestampTz(x) => f
                .debug_tuple("TimestampTz")
                .field(&redact(<DateTime<Utc>>::from(*x)))
                .finish(),
            Datum::Interval(x) => f.debug_tuple("Interval").field(&redact(x)).finish(),
            Datum::Bytes(x) => f.debug_tuple("Bytes").field(&redact(x)).finish(),
            Datum::String(x) => f.debug_tuple("String").field(&redact(x)).finish(),
            Datum::Array(x) => f.debug_tuple("Array").field(x).finish(),
            Datum::List(x) => f.debug_tuple("List").field(x).finish(),
            Datum::Map(x) => f.debug_tuple("Map").field(x).finish(),
            Datum::Numeric(x) => f.debug_tuple("Numeric").field(&redact(&x.0)).finish(),
            Datum::JsonNull => f.debug_tuple("JsonNull").finish(),
            Datum::Uuid(x) => f.debug_tuple("Uuid").field(&redact(x)).finish(),
            Datum::MzTimestamp(x) => f.debug_tuple("MzTimestamp").field(&redact(x)).finish(),
            Datum::Range(x) => f.debug_tuple("Range").field(&redact(x)).finish(),
            Datum::MzAclItem(x) => f.debug_tuple("MzAclItem").field(&redact(x)).finish(),
            Datum::AclItem(x) => f.debug_tuple("AclItem").field(&redact(x)).finish(),
            Datum::Dummy => f.debug_tuple("Dummy").finish(),
            Datum::Null => f.debug_tuple("Null").finish(),
        }
    }
}

impl TryFrom<Datum<'_>> for bool {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::False => Ok(false),
            Datum::True => Ok(true),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<bool> {
    type Error = ();

    #[inline]
    fn try_from(datum: Datum<'_>) -> Result<Self, Self::Error> {
        match datum {
            Datum::Null => Ok(None),
            Datum::False => Ok(Some(false)),
            Datum::True => Ok(Some(true)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for f32 {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Float32(f) => Ok(*f),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<f32> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Float32(f) => Ok(Some(*f)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for OrderedFloat<f32> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Float32(f) => Ok(f),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<OrderedFloat<f32>> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Float32(f) => Ok(Some(f)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for f64 {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Float64(f) => Ok(*f),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<f64> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Float64(f) => Ok(Some(*f)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for OrderedFloat<f64> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Float64(f) => Ok(f),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<OrderedFloat<f64>> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Float64(f) => Ok(Some(f)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for i16 {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Int16(i) => Ok(i),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<i16> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Int16(i) => Ok(Some(i)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for i32 {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Int32(i) => Ok(i),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<i32> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Int32(i) => Ok(Some(i)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for i64 {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Int64(i) => Ok(i),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<i64> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Int64(i) => Ok(Some(i)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for u16 {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::UInt16(u) => Ok(u),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<u16> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::UInt16(u) => Ok(Some(u)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for u32 {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::UInt32(u) => Ok(u),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<u32> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::UInt32(u) => Ok(Some(u)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for u64 {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::UInt64(u) => Ok(u),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<u64> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::UInt64(u) => Ok(Some(u)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for CheckedTimestamp<NaiveDateTime> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Timestamp(dt) => Ok(dt),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for CheckedTimestamp<DateTime<Utc>> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::TimestampTz(dt_tz) => Ok(dt_tz),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Date {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Date(d) => Ok(d),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for OrderedDecimal<Numeric> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Numeric(n) => Ok(n),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<OrderedDecimal<Numeric>> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Numeric(n) => Ok(Some(n)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for crate::Timestamp {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::MzTimestamp(n) => Ok(n),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<crate::Timestamp> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::MzTimestamp(n) => Ok(Some(n)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Interval {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Interval(i) => Ok(i),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<Interval> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Interval(i) => Ok(Some(i)),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for NaiveTime {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Time(t) => Ok(t),
            _ => Err(()),
        }
    }
}

impl TryFrom<Datum<'_>> for Option<NaiveTime> {
    type Error = ();

    #[inline]
    fn try_from(from: Datum<'_>) -> Result<Self, Self::Error> {
        match from {
            Datum::Null => Ok(None),
            Datum::Time(t) => Ok(Some(t)),
            _ => Err(()),
        }
    }
}

impl<'a> Datum<'a> {
    /// Reports whether this datum is null (i.e., is [`Datum::Null`]).
    pub fn is_null(&self) -> bool {
        matches!(self, Datum::Null)
    }

    /// Unwraps the boolean value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::False`] or [`Datum::True`].
    #[track_caller]
    pub fn unwrap_bool(&self) -> bool {
        match self {
            Datum::False => false,
            Datum::True => true,
            _ => panic!("Datum::unwrap_bool called on {:?}", self),
        }
    }

    /// Unwraps the 16-bit integer value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Int16`].
    #[track_caller]
    pub fn unwrap_int16(&self) -> i16 {
        match self {
            Datum::Int16(i) => *i,
            _ => panic!("Datum::unwrap_int16 called on {:?}", self),
        }
    }

    /// Unwraps the 32-bit integer value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Int32`].
    #[track_caller]
    pub fn unwrap_int32(&self) -> i32 {
        match self {
            Datum::Int32(i) => *i,
            _ => panic!("Datum::unwrap_int32 called on {:?}", self),
        }
    }

    /// Unwraps the 64-bit integer value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Int64`].
    #[track_caller]
    pub fn unwrap_int64(&self) -> i64 {
        match self {
            Datum::Int64(i) => *i,
            _ => panic!("Datum::unwrap_int64 called on {:?}", self),
        }
    }

    /// Unwraps the 8-bit unsigned integer value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::UInt8`].
    #[track_caller]
    pub fn unwrap_uint8(&self) -> u8 {
        match self {
            Datum::UInt8(u) => *u,
            _ => panic!("Datum::unwrap_uint8 called on {:?}", self),
        }
    }

    /// Unwraps the 16-bit unsigned integer value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::UInt16`].
    #[track_caller]
    pub fn unwrap_uint16(&self) -> u16 {
        match self {
            Datum::UInt16(u) => *u,
            _ => panic!("Datum::unwrap_uint16 called on {:?}", self),
        }
    }

    /// Unwraps the 32-bit unsigned integer value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::UInt32`].
    #[track_caller]
    pub fn unwrap_uint32(&self) -> u32 {
        match self {
            Datum::UInt32(u) => *u,
            _ => panic!("Datum::unwrap_uint32 called on {:?}", self),
        }
    }

    /// Unwraps the 64-bit unsigned integer value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::UInt64`].
    #[track_caller]
    pub fn unwrap_uint64(&self) -> u64 {
        match self {
            Datum::UInt64(u) => *u,
            _ => panic!("Datum::unwrap_uint64 called on {:?}", self),
        }
    }

    #[track_caller]
    pub fn unwrap_ordered_float32(&self) -> OrderedFloat<f32> {
        match self {
            Datum::Float32(f) => *f,
            _ => panic!("Datum::unwrap_ordered_float32 called on {:?}", self),
        }
    }

    #[track_caller]
    pub fn unwrap_ordered_float64(&self) -> OrderedFloat<f64> {
        match self {
            Datum::Float64(f) => *f,
            _ => panic!("Datum::unwrap_ordered_float64 called on {:?}", self),
        }
    }

    /// Unwraps the 32-bit floating-point value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Float32`].
    #[track_caller]
    pub fn unwrap_float32(&self) -> f32 {
        match self {
            Datum::Float32(f) => f.into_inner(),
            _ => panic!("Datum::unwrap_float32 called on {:?}", self),
        }
    }

    /// Unwraps the 64-bit floating-point value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Float64`].
    #[track_caller]
    pub fn unwrap_float64(&self) -> f64 {
        match self {
            Datum::Float64(f) => f.into_inner(),
            _ => panic!("Datum::unwrap_float64 called on {:?}", self),
        }
    }

    /// Unwraps the date value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Date`].
    #[track_caller]
    pub fn unwrap_date(&self) -> Date {
        match self {
            Datum::Date(d) => *d,
            _ => panic!("Datum::unwrap_date called on {:?}", self),
        }
    }

    /// Unwraps the time vaqlue within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Time`].
    #[track_caller]
    pub fn unwrap_time(&self) -> chrono::NaiveTime {
        match self {
            Datum::Time(t) => *t,
            _ => panic!("Datum::unwrap_time called on {:?}", self),
        }
    }

    /// Unwraps the timestamp value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Timestamp`].
    #[track_caller]
    pub fn unwrap_timestamp(&self) -> CheckedTimestamp<chrono::NaiveDateTime> {
        match self {
            Datum::Timestamp(ts) => *ts,
            _ => panic!("Datum::unwrap_timestamp called on {:?}", self),
        }
    }

    /// Unwraps the timestamptz value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::TimestampTz`].
    #[track_caller]
    pub fn unwrap_timestamptz(&self) -> CheckedTimestamp<chrono::DateTime<Utc>> {
        match self {
            Datum::TimestampTz(ts) => *ts,
            _ => panic!("Datum::unwrap_timestamptz called on {:?}", self),
        }
    }

    /// Unwraps the interval value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Interval`].
    #[track_caller]
    pub fn unwrap_interval(&self) -> Interval {
        match self {
            Datum::Interval(iv) => *iv,
            _ => panic!("Datum::unwrap_interval called on {:?}", self),
        }
    }

    /// Unwraps the string value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::String`].
    #[track_caller]
    pub fn unwrap_str(&self) -> &'a str {
        match self {
            Datum::String(s) => s,
            _ => panic!("Datum::unwrap_string called on {:?}", self),
        }
    }

    /// Unwraps the bytes value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Bytes`].
    #[track_caller]
    pub fn unwrap_bytes(&self) -> &'a [u8] {
        match self {
            Datum::Bytes(b) => b,
            _ => panic!("Datum::unwrap_bytes called on {:?}", self),
        }
    }

    /// Unwraps the uuid value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Uuid`].
    #[track_caller]
    pub fn unwrap_uuid(&self) -> Uuid {
        match self {
            Datum::Uuid(u) => *u,
            _ => panic!("Datum::unwrap_uuid called on {:?}", self),
        }
    }

    /// Unwraps the array value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Array`].
    #[track_caller]
    pub fn unwrap_array(&self) -> Array<'a> {
        match self {
            Datum::Array(array) => *array,
            _ => panic!("Datum::unwrap_array called on {:?}", self),
        }
    }

    /// Unwraps the list value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::List`].
    #[track_caller]
    pub fn unwrap_list(&self) -> DatumList<'a> {
        match self {
            Datum::List(list) => *list,
            _ => panic!("Datum::unwrap_list called on {:?}", self),
        }
    }

    /// Unwraps the map value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Map`].
    #[track_caller]
    pub fn unwrap_map(&self) -> DatumMap<'a> {
        match self {
            Datum::Map(dict) => *dict,
            _ => panic!("Datum::unwrap_dict called on {:?}", self),
        }
    }

    /// Unwraps the numeric value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Numeric`].
    #[track_caller]
    pub fn unwrap_numeric(&self) -> OrderedDecimal<Numeric> {
        match self {
            Datum::Numeric(n) => *n,
            _ => panic!("Datum::unwrap_numeric called on {:?}", self),
        }
    }

    /// Unwraps the mz_repr::Timestamp value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::MzTimestamp`].
    #[track_caller]
    pub fn unwrap_mz_timestamp(&self) -> crate::Timestamp {
        match self {
            Datum::MzTimestamp(t) => *t,
            _ => panic!("Datum::unwrap_mz_timestamp called on {:?}", self),
        }
    }

    /// Unwraps the range value within this datum.
    ///
    /// Note that the return type is a range generic over `Datum`, which is
    /// convenient to work with. However, the type stored in the datum is
    /// generic over `DatumNested`, which is necessary to avoid needless boxing
    /// of the inner `Datum`.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::Range`].
    #[track_caller]
    pub fn unwrap_range(&self) -> Range<Datum<'a>> {
        match self {
            Datum::Range(range) => range.into_bounds(|b| b.datum()),
            _ => panic!("Datum::unwrap_range called on {:?}", self),
        }
    }

    /// Unwraps the mz_acl_item value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::MzAclItem`].
    #[track_caller]
    pub fn unwrap_mz_acl_item(&self) -> MzAclItem {
        match self {
            Datum::MzAclItem(mz_acl_item) => *mz_acl_item,
            _ => panic!("Datum::unwrap_mz_acl_item called on {:?}", self),
        }
    }

    /// Unwraps the acl_item value within this datum.
    ///
    /// # Panics
    ///
    /// Panics if the datum is not [`Datum::AclItem`].
    #[track_caller]
    pub fn unwrap_acl_item(&self) -> AclItem {
        match self {
            Datum::AclItem(acl_item) => *acl_item,
            _ => panic!("Datum::unwrap_acl_item called on {:?}", self),
        }
    }

    /// Reports whether this datum is an instance of the specified (representation) column type.
    ///
    /// See [`Datum<'a>::is_instance_of_sql`] for comparing `Datum`s to `SqlColumnType`s.
    pub fn is_instance_of(self, column_type: &ReprColumnType) -> bool {
        fn is_instance_of_scalar(datum: Datum, scalar_type: &ReprScalarType) -> bool {
            if let ReprScalarType::Jsonb = scalar_type {
                // json type checking
                match datum {
                    Datum::Dummy => false,
                    Datum::JsonNull
                    | Datum::False
                    | Datum::True
                    | Datum::Numeric(_)
                    | Datum::String(_) => true,
                    Datum::List(list) => list
                        .iter()
                        .all(|elem| is_instance_of_scalar(elem, scalar_type)),
                    Datum::Map(dict) => dict
                        .iter()
                        .all(|(_key, val)| is_instance_of_scalar(val, scalar_type)),
                    _ => false,
                }
            } else {
                // general scalar repr type checking
                match (datum, scalar_type) {
                    (Datum::Dummy, _) => false,
                    (Datum::Null, _) => false,
                    (Datum::False, ReprScalarType::Bool) => true,
                    (Datum::False, _) => false,
                    (Datum::True, ReprScalarType::Bool) => true,
                    (Datum::True, _) => false,
                    (Datum::Int16(_), ReprScalarType::Int16) => true,
                    (Datum::Int16(_), _) => false,
                    (Datum::Int32(_), ReprScalarType::Int32) => true,
                    (Datum::Int32(_), _) => false,
                    (Datum::Int64(_), ReprScalarType::Int64) => true,
                    (Datum::Int64(_), _) => false,
                    (Datum::UInt8(_), ReprScalarType::UInt8) => true,
                    (Datum::UInt8(_), _) => false,
                    (Datum::UInt16(_), ReprScalarType::UInt16) => true,
                    (Datum::UInt16(_), _) => false,
                    (Datum::UInt32(_), ReprScalarType::UInt32) => true,
                    (Datum::UInt32(_), _) => false,
                    (Datum::UInt64(_), ReprScalarType::UInt64) => true,
                    (Datum::UInt64(_), _) => false,
                    (Datum::Float32(_), ReprScalarType::Float32) => true,
                    (Datum::Float32(_), _) => false,
                    (Datum::Float64(_), ReprScalarType::Float64) => true,
                    (Datum::Float64(_), _) => false,
                    (Datum::Date(_), ReprScalarType::Date) => true,
                    (Datum::Date(_), _) => false,
                    (Datum::Time(_), ReprScalarType::Time) => true,
                    (Datum::Time(_), _) => false,
                    (Datum::Timestamp(_), ReprScalarType::Timestamp { .. }) => true,
                    (Datum::Timestamp(_), _) => false,
                    (Datum::TimestampTz(_), ReprScalarType::TimestampTz { .. }) => true,
                    (Datum::TimestampTz(_), _) => false,
                    (Datum::Interval(_), ReprScalarType::Interval) => true,
                    (Datum::Interval(_), _) => false,
                    (Datum::Bytes(_), ReprScalarType::Bytes) => true,
                    (Datum::Bytes(_), _) => false,
                    (Datum::String(_), ReprScalarType::String) => true,
                    (Datum::String(_), _) => false,
                    (Datum::Uuid(_), ReprScalarType::Uuid) => true,
                    (Datum::Uuid(_), _) => false,
                    (Datum::Array(array), ReprScalarType::Array(t)) => {
                        array.elements.iter().all(|e| match e {
                            Datum::Null => true,
                            _ => is_instance_of_scalar(e, t),
                        })
                    }
                    (Datum::Array(array), ReprScalarType::Int2Vector) => {
                        array.has_int2vector_dims()
                            && array
                                .elements
                                .iter()
                                .all(|e| is_instance_of_scalar(e, &ReprScalarType::Int16))
                    }
                    (Datum::Array(_), _) => false,
                    (Datum::List(list), ReprScalarType::List { element_type, .. }) => list
                        .iter()
                        .all(|e| e.is_null() || is_instance_of_scalar(e, element_type)),
                    (Datum::List(list), ReprScalarType::Record { fields, .. }) => {
                        if list.iter().count() != fields.len() {
                            return false;
                        }

                        list.iter().zip_eq(fields).all(|(e, t)| {
                            (e.is_null() && t.nullable) || is_instance_of_scalar(e, &t.scalar_type)
                        })
                    }
                    (Datum::List(_), _) => false,
                    (Datum::Map(map), ReprScalarType::Map { value_type, .. }) => map
                        .iter()
                        .all(|(_k, v)| v.is_null() || is_instance_of_scalar(v, value_type)),
                    (Datum::Map(_), _) => false,
                    (Datum::JsonNull, _) => false,
                    (Datum::Numeric(_), ReprScalarType::Numeric) => true,
                    (Datum::Numeric(_), _) => false,
                    (Datum::MzTimestamp(_), ReprScalarType::MzTimestamp) => true,
                    (Datum::MzTimestamp(_), _) => false,
                    (Datum::Range(Range { inner }), ReprScalarType::Range { element_type }) => {
                        match inner {
                            None => true,
                            Some(inner) => {
                                true && match inner.lower.bound {
                                    None => true,
                                    Some(b) => is_instance_of_scalar(b.datum(), element_type),
                                } && match inner.upper.bound {
                                    None => true,
                                    Some(b) => is_instance_of_scalar(b.datum(), element_type),
                                }
                            }
                        }
                    }
                    (Datum::Range(_), _) => false,
                    (Datum::MzAclItem(_), ReprScalarType::MzAclItem) => true,
                    (Datum::MzAclItem(_), _) => false,
                    (Datum::AclItem(_), ReprScalarType::AclItem) => true,
                    (Datum::AclItem(_), _) => false,
                }
            }
        }
        if column_type.nullable {
            if let Datum::Null = self {
                return true;
            }
        }
        is_instance_of_scalar(self, &column_type.scalar_type)
    }

    /// Reports whether this datum is an instance of the specified (SQL) column type.
    ///
    /// See [`Datum<'a>::is_instance_of`] for comparing `Datum`s to `ReprColumnType`s.
    pub fn is_instance_of_sql(self, column_type: &SqlColumnType) -> bool {
        fn is_instance_of_scalar(datum: Datum, scalar_type: &SqlScalarType) -> bool {
            if let SqlScalarType::Jsonb = scalar_type {
                // json type checking
                match datum {
                    Datum::Dummy => false,
                    Datum::JsonNull
                    | Datum::False
                    | Datum::True
                    | Datum::Numeric(_)
                    | Datum::String(_) => true,
                    Datum::List(list) => list
                        .iter()
                        .all(|elem| is_instance_of_scalar(elem, scalar_type)),
                    Datum::Map(dict) => dict
                        .iter()
                        .all(|(_key, val)| is_instance_of_scalar(val, scalar_type)),
                    _ => false,
                }
            } else {
                // sql type checking
                match (datum, scalar_type) {
                    (Datum::Dummy, _) => false,
                    (Datum::Null, _) => false,
                    (Datum::False, SqlScalarType::Bool) => true,
                    (Datum::False, _) => false,
                    (Datum::True, SqlScalarType::Bool) => true,
                    (Datum::True, _) => false,
                    (Datum::Int16(_), SqlScalarType::Int16) => true,
                    (Datum::Int16(_), _) => false,
                    (Datum::Int32(_), SqlScalarType::Int32) => true,
                    (Datum::Int32(_), _) => false,
                    (Datum::Int64(_), SqlScalarType::Int64) => true,
                    (Datum::Int64(_), _) => false,
                    (Datum::UInt8(_), SqlScalarType::PgLegacyChar) => true,
                    (Datum::UInt8(_), _) => false,
                    (Datum::UInt16(_), SqlScalarType::UInt16) => true,
                    (Datum::UInt16(_), _) => false,
                    (Datum::UInt32(_), SqlScalarType::Oid) => true,
                    (Datum::UInt32(_), SqlScalarType::RegClass) => true,
                    (Datum::UInt32(_), SqlScalarType::RegProc) => true,
                    (Datum::UInt32(_), SqlScalarType::RegType) => true,
                    (Datum::UInt32(_), SqlScalarType::UInt32) => true,
                    (Datum::UInt32(_), _) => false,
                    (Datum::UInt64(_), SqlScalarType::UInt64) => true,
                    (Datum::UInt64(_), _) => false,
                    (Datum::Float32(_), SqlScalarType::Float32) => true,
                    (Datum::Float32(_), _) => false,
                    (Datum::Float64(_), SqlScalarType::Float64) => true,
                    (Datum::Float64(_), _) => false,
                    (Datum::Date(_), SqlScalarType::Date) => true,
                    (Datum::Date(_), _) => false,
                    (Datum::Time(_), SqlScalarType::Time) => true,
                    (Datum::Time(_), _) => false,
                    (Datum::Timestamp(_), SqlScalarType::Timestamp { .. }) => true,
                    (Datum::Timestamp(_), _) => false,
                    (Datum::TimestampTz(_), SqlScalarType::TimestampTz { .. }) => true,
                    (Datum::TimestampTz(_), _) => false,
                    (Datum::Interval(_), SqlScalarType::Interval) => true,
                    (Datum::Interval(_), _) => false,
                    (Datum::Bytes(_), SqlScalarType::Bytes) => true,
                    (Datum::Bytes(_), _) => false,
                    (Datum::String(_), SqlScalarType::String)
                    | (Datum::String(_), SqlScalarType::VarChar { .. })
                    | (Datum::String(_), SqlScalarType::Char { .. })
                    | (Datum::String(_), SqlScalarType::PgLegacyName) => true,
                    (Datum::String(_), _) => false,
                    (Datum::Uuid(_), SqlScalarType::Uuid) => true,
                    (Datum::Uuid(_), _) => false,
                    (Datum::Array(array), SqlScalarType::Array(t)) => {
                        array.elements.iter().all(|e| match e {
                            Datum::Null => true,
                            _ => is_instance_of_scalar(e, t),
                        })
                    }
                    (Datum::Array(array), SqlScalarType::Int2Vector) => {
                        array.has_int2vector_dims()
                            && array
                                .elements
                                .iter()
                                .all(|e| is_instance_of_scalar(e, &SqlScalarType::Int16))
                    }
                    (Datum::Array(_), _) => false,
                    (Datum::List(list), SqlScalarType::List { element_type, .. }) => list
                        .iter()
                        .all(|e| e.is_null() || is_instance_of_scalar(e, element_type)),
                    (Datum::List(list), SqlScalarType::Record { fields, .. }) => {
                        if list.iter().count() != fields.len() {
                            return false;
                        }

                        list.iter().zip_eq(fields).all(|(e, (_, t))| {
                            (e.is_null() && t.nullable) || is_instance_of_scalar(e, &t.scalar_type)
                        })
                    }
                    (Datum::List(_), _) => false,
                    (Datum::Map(map), SqlScalarType::Map { value_type, .. }) => map
                        .iter()
                        .all(|(_k, v)| v.is_null() || is_instance_of_scalar(v, value_type)),
                    (Datum::Map(_), _) => false,
                    (Datum::JsonNull, _) => false,
                    (Datum::Numeric(_), SqlScalarType::Numeric { .. }) => true,
                    (Datum::Numeric(_), _) => false,
                    (Datum::MzTimestamp(_), SqlScalarType::MzTimestamp) => true,
                    (Datum::MzTimestamp(_), _) => false,
                    (Datum::Range(Range { inner }), SqlScalarType::Range { element_type }) => {
                        match inner {
                            None => true,
                            Some(inner) => {
                                true && match inner.lower.bound {
                                    None => true,
                                    Some(b) => is_instance_of_scalar(b.datum(), element_type),
                                } && match inner.upper.bound {
                                    None => true,
                                    Some(b) => is_instance_of_scalar(b.datum(), element_type),
                                }
                            }
                        }
                    }
                    (Datum::Range(_), _) => false,
                    (Datum::MzAclItem(_), SqlScalarType::MzAclItem) => true,
                    (Datum::MzAclItem(_), _) => false,
                    (Datum::AclItem(_), SqlScalarType::AclItem) => true,
                    (Datum::AclItem(_), _) => false,
                }
            }
        }
        if column_type.nullable {
            if let Datum::Null = self {
                return true;
            }
        }
        is_instance_of_scalar(self, &column_type.scalar_type)
    }
}

impl<'a> From<bool> for Datum<'a> {
    #[inline]
    fn from(b: bool) -> Datum<'a> {
        if b { Datum::True } else { Datum::False }
    }
}

// TODO: Reconsider whether we want this blanket impl or have precise control
//   over the types.
impl<'a, T> From<Overflowing<T>> for Datum<'a>
where
    Datum<'a>: From<T>,
{
    #[inline]
    fn from(i: Overflowing<T>) -> Datum<'a> {
        Datum::from(i.into_inner())
    }
}

impl<'a> From<i16> for Datum<'a> {
    #[inline]
    fn from(i: i16) -> Datum<'a> {
        Datum::Int16(i)
    }
}

impl<'a> From<i32> for Datum<'a> {
    #[inline]
    fn from(i: i32) -> Datum<'a> {
        Datum::Int32(i)
    }
}

impl<'a> From<i64> for Datum<'a> {
    #[inline]
    fn from(i: i64) -> Datum<'a> {
        Datum::Int64(i)
    }
}

impl<'a> From<u8> for Datum<'a> {
    #[inline]
    fn from(u: u8) -> Datum<'a> {
        Datum::UInt8(u)
    }
}

impl<'a> From<u16> for Datum<'a> {
    #[inline]
    fn from(u: u16) -> Datum<'a> {
        Datum::UInt16(u)
    }
}

impl<'a> From<u32> for Datum<'a> {
    #[inline]
    fn from(u: u32) -> Datum<'a> {
        Datum::UInt32(u)
    }
}

impl<'a> From<u64> for Datum<'a> {
    #[inline]
    fn from(u: u64) -> Datum<'a> {
        Datum::UInt64(u)
    }
}

impl<'a> From<OrderedFloat<f32>> for Datum<'a> {
    #[inline]
    fn from(f: OrderedFloat<f32>) -> Datum<'a> {
        Datum::Float32(f)
    }
}

impl<'a> From<OrderedFloat<f64>> for Datum<'a> {
    #[inline]
    fn from(f: OrderedFloat<f64>) -> Datum<'a> {
        Datum::Float64(f)
    }
}

impl<'a> From<f32> for Datum<'a> {
    #[inline]
    fn from(f: f32) -> Datum<'a> {
        Datum::Float32(OrderedFloat(f))
    }
}

impl<'a> From<f64> for Datum<'a> {
    #[inline]
    fn from(f: f64) -> Datum<'a> {
        Datum::Float64(OrderedFloat(f))
    }
}

impl<'a> From<i128> for Datum<'a> {
    #[inline]
    fn from(d: i128) -> Datum<'a> {
        Datum::Numeric(OrderedDecimal(Numeric::try_from(d).unwrap()))
    }
}

impl<'a> From<u128> for Datum<'a> {
    #[inline]
    fn from(d: u128) -> Datum<'a> {
        Datum::Numeric(OrderedDecimal(Numeric::try_from(d).unwrap()))
    }
}

impl<'a> From<Numeric> for Datum<'a> {
    #[inline]
    fn from(n: Numeric) -> Datum<'a> {
        Datum::Numeric(OrderedDecimal(n))
    }
}

impl<'a> From<OrderedDecimal<Numeric>> for Datum<'a> {
    #[inline]
    fn from(n: OrderedDecimal<Numeric>) -> Datum<'a> {
        Datum::Numeric(n)
    }
}

impl<'a> From<chrono::Duration> for Datum<'a> {
    #[inline]
    fn from(duration: chrono::Duration) -> Datum<'a> {
        let micros = duration.num_microseconds().unwrap_or(0);
        Datum::Interval(Interval::new(0, 0, micros))
    }
}

impl<'a> From<Interval> for Datum<'a> {
    #[inline]
    fn from(other: Interval) -> Datum<'a> {
        Datum::Interval(other)
    }
}

impl<'a> From<&'a str> for Datum<'a> {
    #[inline]
    fn from(s: &'a str) -> Datum<'a> {
        Datum::String(s)
    }
}

impl<'a> From<&'a [u8]> for Datum<'a> {
    #[inline]
    fn from(b: &'a [u8]) -> Datum<'a> {
        Datum::Bytes(b)
    }
}

impl<'a, const N: usize> From<&'a [u8; N]> for Datum<'a> {
    #[inline]
    fn from(b: &'a [u8; N]) -> Datum<'a> {
        Datum::Bytes(b.as_slice())
    }
}

impl<'a> From<Date> for Datum<'a> {
    #[inline]
    fn from(d: Date) -> Datum<'a> {
        Datum::Date(d)
    }
}

impl<'a> From<NaiveTime> for Datum<'a> {
    #[inline]
    fn from(t: NaiveTime) -> Datum<'a> {
        Datum::Time(t)
    }
}

impl<'a> From<CheckedTimestamp<NaiveDateTime>> for Datum<'a> {
    #[inline]
    fn from(dt: CheckedTimestamp<NaiveDateTime>) -> Datum<'a> {
        Datum::Timestamp(dt)
    }
}

impl<'a> From<CheckedTimestamp<DateTime<Utc>>> for Datum<'a> {
    #[inline]
    fn from(dt: CheckedTimestamp<DateTime<Utc>>) -> Datum<'a> {
        Datum::TimestampTz(dt)
    }
}

impl<'a> TryInto<Datum<'a>> for NaiveDateTime {
    type Error = TimestampError;

    #[inline]
    fn try_into(self) -> Result<Datum<'a>, Self::Error> {
        let t = CheckedTimestamp::from_timestamplike(self)?;
        Ok(t.into())
    }
}

impl<'a> TryInto<Datum<'a>> for DateTime<Utc> {
    type Error = TimestampError;

    #[inline]
    fn try_into(self) -> Result<Datum<'a>, Self::Error> {
        let t = CheckedTimestamp::from_timestamplike(self)?;
        Ok(t.into())
    }
}

impl<'a> From<Uuid> for Datum<'a> {
    #[inline]
    fn from(uuid: Uuid) -> Datum<'a> {
        Datum::Uuid(uuid)
    }
}
impl<'a> From<crate::Timestamp> for Datum<'a> {
    #[inline]
    fn from(ts: crate::Timestamp) -> Datum<'a> {
        Datum::MzTimestamp(ts)
    }
}

impl<'a> From<MzAclItem> for Datum<'a> {
    #[inline]
    fn from(mz_acl_item: MzAclItem) -> Self {
        Datum::MzAclItem(mz_acl_item)
    }
}

impl<'a, T> From<Option<T>> for Datum<'a>
where
    Datum<'a>: From<T>,
{
    fn from(o: Option<T>) -> Datum<'a> {
        match o {
            Some(d) => d.into(),
            None => Datum::Null,
        }
    }
}

fn write_delimited<T, TS, F>(
    f: &mut fmt::Formatter,
    delimiter: &str,
    things: TS,
    write: F,
) -> fmt::Result
where
    TS: IntoIterator<Item = T>,
    F: Fn(&mut fmt::Formatter, T) -> fmt::Result,
{
    let mut iter = things.into_iter().peekable();
    while let Some(thing) = iter.next() {
        write(f, thing)?;
        if iter.peek().is_some() {
            f.write_str(delimiter)?;
        }
    }
    Ok(())
}

impl fmt::Display for Datum<'_> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Datum::Null => f.write_str("null"),
            Datum::True => f.write_str("true"),
            Datum::False => f.write_str("false"),
            Datum::Int16(num) => write!(f, "{}", num),
            Datum::Int32(num) => write!(f, "{}", num),
            Datum::Int64(num) => write!(f, "{}", num),
            Datum::UInt8(num) => write!(f, "{}", num),
            Datum::UInt16(num) => write!(f, "{}", num),
            Datum::UInt32(num) => write!(f, "{}", num),
            Datum::UInt64(num) => write!(f, "{}", num),
            Datum::Float32(num) => write!(f, "{}", num),
            Datum::Float64(num) => write!(f, "{}", num),
            Datum::Date(d) => write!(f, "{}", d),
            Datum::Time(t) => write!(f, "{}", t),
            Datum::Timestamp(t) => write!(f, "{}", t),
            Datum::TimestampTz(t) => write!(f, "{}", t),
            Datum::Interval(iv) => write!(f, "{}", iv),
            Datum::Bytes(dat) => {
                f.write_str("0x")?;
                for b in dat.iter() {
                    write!(f, "{:02x}", b)?;
                }
                Ok(())
            }
            Datum::String(s) => {
                write!(f, "{}", s.escaped())
            }
            Datum::Uuid(u) => write!(f, "{}", u),
            Datum::Array(array) => {
                if array.dims().into_iter().any(|dim| dim.lower_bound != 1) {
                    write_delimited(f, "", array.dims(), |f, e| {
                        let (lower, upper) = e.dimension_bounds();
                        write!(f, "[{}:{}]", lower, upper)
                    })?;
                    f.write_str("=")?;
                }
                f.write_str("{")?;
                write_delimited(f, ", ", array.elements, |f, e| write!(f, "{}", e))?;
                f.write_str("}")
            }
            Datum::List(list) => {
                f.write_str("[")?;
                write_delimited(f, ", ", *list, |f, e| write!(f, "{}", e))?;
                f.write_str("]")
            }
            Datum::Map(dict) => {
                f.write_str("{")?;
                write_delimited(f, ", ", dict, |f, (k, v)| write!(f, "{}: {}", k, v))?;
                f.write_str("}")
            }
            Datum::Numeric(n) => write!(f, "{}", n.0.to_standard_notation_string()),
            Datum::MzTimestamp(t) => write!(f, "{}", t),
            Datum::JsonNull => f.write_str("json_null"),
            Datum::Dummy => f.write_str("dummy"),
            Datum::Range(i) => write!(f, "{}", i),
            Datum::MzAclItem(mz_acl_item) => write!(f, "{mz_acl_item}"),
            Datum::AclItem(acl_item) => write!(f, "{acl_item}"),
        }
    }
}

/// The type of a [`Datum`].
///
/// There is a direct correspondence between `Datum` variants and `SqlScalarType`
/// variants.
///
/// Each variant maps to a variant of [`ReprScalarType`], with some overlap.
///
/// There is an indirect correspondence between `Datum` variants and `SqlScalarType`
/// variants: every `Datum` variant belongs to one or more `SqlScalarType` variants.
#[derive(
    Clone,
    Debug,
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    Ord,
    PartialOrd,
    Hash,
    EnumKind
)]
#[enum_kind(SqlScalarBaseType, derive(PartialOrd, Ord, Hash))]
pub enum SqlScalarType {
    /// The type of [`Datum::True`] and [`Datum::False`].
    Bool,
    /// The type of [`Datum::Int16`].
    Int16,
    /// The type of [`Datum::Int32`].
    Int32,
    /// The type of [`Datum::Int64`].
    Int64,
    /// The type of [`Datum::UInt16`].
    UInt16,
    /// The type of [`Datum::UInt32`].
    UInt32,
    /// The type of [`Datum::UInt64`].
    UInt64,
    /// The type of [`Datum::Float32`].
    Float32,
    /// The type of [`Datum::Float64`].
    Float64,
    /// The type of [`Datum::Numeric`].
    ///
    /// `Numeric` values cannot exceed [`NUMERIC_DATUM_MAX_PRECISION`] digits of
    /// precision.
    ///
    /// This type additionally specifies the maximum scale of the decimal. The
    /// scale specifies the number of digits after the decimal point.
    ///
    /// [`NUMERIC_DATUM_MAX_PRECISION`]: crate::adt::numeric::NUMERIC_DATUM_MAX_PRECISION
    Numeric {
        max_scale: Option<NumericMaxScale>,
    },
    /// The type of [`Datum::Date`].
    Date,
    /// The type of [`Datum::Time`].
    Time,
    /// The type of [`Datum::Timestamp`].
    Timestamp {
        precision: Option<TimestampPrecision>,
    },
    /// The type of [`Datum::TimestampTz`].
    TimestampTz {
        precision: Option<TimestampPrecision>,
    },
    /// The type of [`Datum::Interval`].
    Interval,
    /// A single byte character type backed by a [`Datum::UInt8`].
    ///
    /// PostgreSQL calls this type `"char"`. Note the quotes, which distinguish
    /// it from the type `SqlScalarType::Char`.
    PgLegacyChar,
    /// A character type for storing identifiers of no more than 64 characters
    /// in length.
    ///
    /// PostgreSQL uses this type to represent the names of objects in the
    /// system catalog.
    PgLegacyName,
    /// The type of [`Datum::Bytes`].
    Bytes,
    /// The type of [`Datum::String`].
    String,
    /// Stored as [`Datum::String`], but expresses a fixed-width, blank-padded
    /// string.
    ///
    /// Note that a `length` of `None` is used in special cases, such as
    /// creating lists.
    Char {
        length: Option<CharLength>,
    },
    /// Stored as [`Datum::String`], but can optionally express a limit on the
    /// string's length.
    VarChar {
        max_length: Option<VarCharMaxLength>,
    },
    /// The type of a datum that may represent any valid JSON value.
    ///
    /// Valid datum variants for this type are:
    ///
    ///   * [`Datum::JsonNull`]
    ///   * [`Datum::False`]
    ///   * [`Datum::True`]
    ///   * [`Datum::String`]
    ///   * [`Datum::Numeric`]
    ///   * [`Datum::List`]
    ///   * [`Datum::Map`]
    Jsonb,
    /// The type of [`Datum::Uuid`].
    Uuid,
    /// The type of [`Datum::Array`].
    ///
    /// Elements within the array are of the specified type. It is illegal for
    /// the element type to be itself an array type. Array elements may always
    /// be [`Datum::Null`].
    Array(Box<SqlScalarType>),
    /// The type of [`Datum::List`].
    ///
    /// Elements within the list are of the specified type. List elements may
    /// always be [`Datum::Null`].
    List {
        element_type: Box<SqlScalarType>,
        custom_id: Option<CatalogItemId>,
    },
    /// An ordered and named sequence of datums.
    Record {
        /// The names and types of the fields of the record, in order from left
        /// to right.
        ///
        /// Boxed slice to reduce the size of the enum variant.
        fields: Box<[(ColumnName, SqlColumnType)]>,
        custom_id: Option<CatalogItemId>,
    },
    /// A PostgreSQL object identifier.
    Oid,
    /// The type of [`Datum::Map`]
    ///
    /// Keys within the map are always of type [`SqlScalarType::String`].
    /// Values within the map are of the specified type. Values may always
    /// be [`Datum::Null`].
    Map {
        value_type: Box<SqlScalarType>,
        custom_id: Option<CatalogItemId>,
    },
    /// A PostgreSQL function name.
    RegProc,
    /// A PostgreSQL type name.
    RegType,
    /// A PostgreSQL class name.
    RegClass,
    /// A vector on small ints; this is a legacy type in PG used primarily in
    /// the catalog.
    Int2Vector,
    /// A Materialize timestamp. The type of [`Datum::MzTimestamp`].
    MzTimestamp,
    Range {
        element_type: Box<SqlScalarType>,
    },
    /// The type of [`Datum::MzAclItem`]
    MzAclItem,
    /// The type of [`Datum::AclItem`]
    AclItem,
}

impl RustType<ProtoRecordField> for (ColumnName, SqlColumnType) {
    fn into_proto(&self) -> ProtoRecordField {
        ProtoRecordField {
            column_name: Some(self.0.into_proto()),
            column_type: Some(self.1.into_proto()),
        }
    }

    fn from_proto(proto: ProtoRecordField) -> Result<Self, TryFromProtoError> {
        Ok((
            proto
                .column_name
                .into_rust_if_some("ProtoRecordField::column_name")?,
            proto
                .column_type
                .into_rust_if_some("ProtoRecordField::column_type")?,
        ))
    }
}

impl RustType<ProtoScalarType> for SqlScalarType {
    fn into_proto(&self) -> ProtoScalarType {
        use crate::relation_and_scalar::proto_scalar_type::Kind::*;
        use crate::relation_and_scalar::proto_scalar_type::*;

        ProtoScalarType {
            kind: Some(match self {
                SqlScalarType::Bool => Bool(()),
                SqlScalarType::Int16 => Int16(()),
                SqlScalarType::Int32 => Int32(()),
                SqlScalarType::Int64 => Int64(()),
                SqlScalarType::UInt16 => UInt16(()),
                SqlScalarType::UInt32 => UInt32(()),
                SqlScalarType::UInt64 => UInt64(()),
                SqlScalarType::Float32 => Float32(()),
                SqlScalarType::Float64 => Float64(()),
                SqlScalarType::Date => Date(()),
                SqlScalarType::Time => Time(()),
                SqlScalarType::Timestamp { precision } => Timestamp(ProtoTimestamp {
                    precision: precision.into_proto(),
                }),
                SqlScalarType::TimestampTz { precision } => TimestampTz(ProtoTimestampTz {
                    precision: precision.into_proto(),
                }),
                SqlScalarType::Interval => Interval(()),
                SqlScalarType::PgLegacyChar => PgLegacyChar(()),
                SqlScalarType::PgLegacyName => PgLegacyName(()),
                SqlScalarType::Bytes => Bytes(()),
                SqlScalarType::String => String(()),
                SqlScalarType::Jsonb => Jsonb(()),
                SqlScalarType::Uuid => Uuid(()),
                SqlScalarType::Oid => Oid(()),
                SqlScalarType::RegProc => RegProc(()),
                SqlScalarType::RegType => RegType(()),
                SqlScalarType::RegClass => RegClass(()),
                SqlScalarType::Int2Vector => Int2Vector(()),

                SqlScalarType::Numeric { max_scale } => Numeric(max_scale.into_proto()),
                SqlScalarType::Char { length } => Char(ProtoChar {
                    length: length.into_proto(),
                }),
                SqlScalarType::VarChar { max_length } => VarChar(ProtoVarChar {
                    max_length: max_length.into_proto(),
                }),

                SqlScalarType::List {
                    element_type,
                    custom_id,
                } => List(Box::new(ProtoList {
                    element_type: Some(element_type.into_proto()),
                    custom_id: custom_id.map(|id| id.into_proto()),
                })),
                SqlScalarType::Record { custom_id, fields } => Record(ProtoRecord {
                    custom_id: custom_id.map(|id| id.into_proto()),
                    fields: fields.into_proto(),
                }),
                SqlScalarType::Array(typ) => Array(typ.into_proto()),
                SqlScalarType::Map {
                    value_type,
                    custom_id,
                } => Map(Box::new(ProtoMap {
                    value_type: Some(value_type.into_proto()),
                    custom_id: custom_id.map(|id| id.into_proto()),
                })),
                SqlScalarType::MzTimestamp => MzTimestamp(()),
                SqlScalarType::Range { element_type } => Range(Box::new(ProtoRange {
                    element_type: Some(element_type.into_proto()),
                })),
                SqlScalarType::MzAclItem => MzAclItem(()),
                SqlScalarType::AclItem => AclItem(()),
            }),
        }
    }

    fn from_proto(proto: ProtoScalarType) -> Result<Self, TryFromProtoError> {
        use crate::relation_and_scalar::proto_scalar_type::Kind::*;

        let kind = proto
            .kind
            .ok_or_else(|| TryFromProtoError::missing_field("ProtoScalarType::Kind"))?;

        match kind {
            Bool(()) => Ok(SqlScalarType::Bool),
            Int16(()) => Ok(SqlScalarType::Int16),
            Int32(()) => Ok(SqlScalarType::Int32),
            Int64(()) => Ok(SqlScalarType::Int64),
            UInt16(()) => Ok(SqlScalarType::UInt16),
            UInt32(()) => Ok(SqlScalarType::UInt32),
            UInt64(()) => Ok(SqlScalarType::UInt64),
            Float32(()) => Ok(SqlScalarType::Float32),
            Float64(()) => Ok(SqlScalarType::Float64),
            Date(()) => Ok(SqlScalarType::Date),
            Time(()) => Ok(SqlScalarType::Time),
            Timestamp(x) => Ok(SqlScalarType::Timestamp {
                precision: x.precision.into_rust()?,
            }),
            TimestampTz(x) => Ok(SqlScalarType::TimestampTz {
                precision: x.precision.into_rust()?,
            }),
            Interval(()) => Ok(SqlScalarType::Interval),
            PgLegacyChar(()) => Ok(SqlScalarType::PgLegacyChar),
            PgLegacyName(()) => Ok(SqlScalarType::PgLegacyName),
            Bytes(()) => Ok(SqlScalarType::Bytes),
            String(()) => Ok(SqlScalarType::String),
            Jsonb(()) => Ok(SqlScalarType::Jsonb),
            Uuid(()) => Ok(SqlScalarType::Uuid),
            Oid(()) => Ok(SqlScalarType::Oid),
            RegProc(()) => Ok(SqlScalarType::RegProc),
            RegType(()) => Ok(SqlScalarType::RegType),
            RegClass(()) => Ok(SqlScalarType::RegClass),
            Int2Vector(()) => Ok(SqlScalarType::Int2Vector),

            Numeric(x) => Ok(SqlScalarType::Numeric {
                max_scale: x.into_rust()?,
            }),
            Char(x) => Ok(SqlScalarType::Char {
                length: x.length.into_rust()?,
            }),

            VarChar(x) => Ok(SqlScalarType::VarChar {
                max_length: x.max_length.into_rust()?,
            }),
            Array(x) => Ok(SqlScalarType::Array({
                let st: SqlScalarType = (*x).into_rust()?;
                st.into()
            })),
            List(x) => Ok(SqlScalarType::List {
                element_type: Box::new(
                    x.element_type
                        .map(|x| *x)
                        .into_rust_if_some("ProtoList::element_type")?,
                ),
                custom_id: x.custom_id.map(|id| id.into_rust()).transpose()?,
            }),
            Record(x) => Ok(SqlScalarType::Record {
                custom_id: x.custom_id.map(|id| id.into_rust()).transpose()?,
                fields: x.fields.into_rust()?,
            }),
            Map(x) => Ok(SqlScalarType::Map {
                value_type: Box::new(
                    x.value_type
                        .map(|x| *x)
                        .into_rust_if_some("ProtoMap::value_type")?,
                ),
                custom_id: x.custom_id.map(|id| id.into_rust()).transpose()?,
            }),
            MzTimestamp(()) => Ok(SqlScalarType::MzTimestamp),
            Range(x) => Ok(SqlScalarType::Range {
                element_type: Box::new(
                    x.element_type
                        .map(|x| *x)
                        .into_rust_if_some("ProtoRange::element_type")?,
                ),
            }),
            MzAclItem(()) => Ok(SqlScalarType::MzAclItem),
            AclItem(()) => Ok(SqlScalarType::AclItem),
        }
    }
}

/// Trait for SQL container types whose element/value type can be extracted
/// from or wrapped into a [`SqlScalarType`].
///
/// Implemented by [`DatumList`], [`Array`], [`DatumMap`], and [`Range`].
/// The `#[sqlfunc]` proc macro emits calls to these associated functions so
/// that Rust's type system resolves the correct unwrap/wrap behavior at compile
/// time, instead of relying on string-matching type names in the AST.
///
/// The methods are deliberately associated functions (no `&self`) because they
/// operate on [`SqlScalarType`] metadata, not on container values.
pub trait SqlContainerType {
    /// Extract the element type from a container scalar type.
    fn unwrap_element_type(container: &SqlScalarType) -> &SqlScalarType;
    /// Construct a container scalar type from an element type.
    fn wrap_element_type(element: SqlScalarType) -> SqlScalarType;
}

/// Types that implement this trait can be stored in an SQL column with the specified SqlColumnType
pub trait AsColumnType {
    /// The SQL column type of this Rust type
    fn as_column_type() -> SqlColumnType;
}

/// A bridge between native Rust types and SQL runtime types represented in Datums
pub trait InputDatumType<'a, E>: Sized {
    /// Whether this Rust type can represent NULL values
    fn nullable() -> bool;

    /// Whether ALL components of this input accept NULL values.
    ///
    /// For single-element types this equals `nullable()`. For tuples, this is
    /// the AND of all components' `nullable()` values. Used by `output_type` to
    /// detect implicit null propagation from non-nullable parameter positions.
    fn all_nullable() -> bool {
        Self::nullable()
    }

    /// Try to convert a Result whose Ok variant is a Datum into this native Rust type (Self). If
    /// it fails the error variant will contain the original result.
    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>>;

    /// Try to convert a number of datums to a Result whose Ok variant is a native Rust type (Self)
    /// representing a number of datums obtained from the iterator.
    fn try_from_iter(
        iter: &mut impl Iterator<Item = Result<Datum<'a>, E>>,
    ) -> Result<Self, Result<Option<Datum<'a>>, E>> {
        // TODO: Consider removing default implementation, only relevant for single-element datum
        //   types.
        match iter.next() {
            Some(next) => Self::try_from_result(next).map_err(|e| e.map(Some)),
            None => Err(Ok(None)),
        }
    }
}

/// A bridge between native Rust types and SQL runtime types represented in Datums
pub trait OutputDatumType<'a, E>: Sized {
    /// Whether this Rust type can represent NULL values
    fn nullable() -> bool;

    /// Whether this Rust type can represent errors
    fn fallible() -> bool;

    /// Convert this Rust type into a Result containing a Datum, or an error
    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E>;
}

/// A new type that wraps a [`Vec`] that is used to differentiate the target [`Datum`] between
/// Arrays and Lists. The target of this type is Array.
#[derive(Debug)]
pub struct ArrayRustType<T>(pub Vec<T>);

impl<T> From<Vec<T>> for ArrayRustType<T> {
    fn from(v: Vec<T>) -> Self {
        Self(v)
    }
}

// We define `AsColumnType` in terms of the owned type of `B`.
impl<B: ToOwned<Owned: AsColumnType> + ?Sized> AsColumnType for Cow<'_, B> {
    fn as_column_type() -> SqlColumnType {
        <B::Owned>::as_column_type()
    }
}

impl<'a, E, B: ToOwned + ?Sized> InputDatumType<'a, E> for Cow<'a, B>
where
    for<'b> B::Owned: InputDatumType<'b, E>,
    for<'b> &'b B: InputDatumType<'b, E>,
{
    fn nullable() -> bool {
        B::Owned::nullable()
    }
    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        <&B>::try_from_result(res).map(|b| Cow::Borrowed(b))
    }
}

impl<'a, E, B: ToOwned + ?Sized> OutputDatumType<'a, E> for Cow<'a, B>
where
    for<'b> B::Owned: OutputDatumType<'b, E>,
    for<'b> &'b B: OutputDatumType<'b, E>,
{
    fn nullable() -> bool {
        B::Owned::nullable()
    }
    fn fallible() -> bool {
        B::Owned::fallible()
    }
    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        match self {
            Cow::Owned(b) => b.into_result(temp_storage),
            Cow::Borrowed(b) => b.into_result(temp_storage),
        }
    }
}

impl<B: AsColumnType> AsColumnType for Option<B> {
    fn as_column_type() -> SqlColumnType {
        B::as_column_type().nullable(true)
    }
}

impl<'a, E, B: InputDatumType<'a, E>> InputDatumType<'a, E> for Option<B> {
    fn nullable() -> bool {
        true
    }
    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Null) => Ok(None),
            Ok(datum) => B::try_from_result(Ok(datum)).map(Some),
            _ => Err(res),
        }
    }
}

impl<'a, E, B: OutputDatumType<'a, E>> OutputDatumType<'a, E> for Option<B> {
    fn nullable() -> bool {
        true
    }
    fn fallible() -> bool {
        false
    }
    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        match self {
            Some(inner) => inner.into_result(temp_storage),
            None => Ok(Datum::Null),
        }
    }
}

impl<E, B: AsColumnType> AsColumnType for Result<B, E> {
    fn as_column_type() -> SqlColumnType {
        B::as_column_type()
    }
}

impl<'a, E, B: InputDatumType<'a, E>> InputDatumType<'a, E> for Result<B, E> {
    fn nullable() -> bool {
        B::nullable()
    }
    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        B::try_from_result(res).map(Ok)
    }
    fn try_from_iter(
        iter: &mut impl Iterator<Item = Result<Datum<'a>, E>>,
    ) -> Result<Self, Result<Option<Datum<'a>>, E>> {
        B::try_from_iter(iter).map(Ok)
    }
}

impl<'a, E, B: OutputDatumType<'a, E>> OutputDatumType<'a, E> for Result<B, E> {
    fn nullable() -> bool {
        B::nullable()
    }
    fn fallible() -> bool {
        true
    }
    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        self.and_then(|inner| inner.into_result(temp_storage))
    }
}

macro_rules! impl_tuple_input_datum_type {
    ($($T:ident),+) => {
        #[allow(non_snake_case)]
        impl<'a, E, $($T: InputDatumType<'a, E>),+> InputDatumType<'a, E> for ($($T,)+) {
            fn try_from_result(_res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
                unimplemented!("Not possible")
            }
            fn try_from_iter(
                iter: &mut impl Iterator<Item = Result<Datum<'a>, E>>,
            ) -> Result<Self, Result<Option<Datum<'a>>, E>> {
                // Eagerly evaluate all arguments before checking for errors.
                // Each `$T` repetition expands to a separate variable, so we
                // first collect all results and then unpack them in priority
                // order: internal errors, then eval errors, then null
                // propagation. Doing it in one pass per `$T` would short-
                // circuit on the first error and skip evaluating later args.
                $(
                    let $T = <$T>::try_from_iter(iter);
                )+
                // Handle internal errors
                $(
                    let $T = match $T {
                        Err(Ok(None)) => return Err(Ok(None)),
                        Err(Ok(Some(datum))) if !datum.is_null() => return Err(Ok(Some(datum))),
                        els => els,
                    };
                )+
                // Handle eval errors
                $(
                    let $T = match $T {
                        Err(Err(err)) => return Err(Err(err)),
                        els => els,
                    };
                )+
                // Handle null propagation
                $(
                    let $T = $T?;
                )+
                Ok(($($T,)+))
            }
            fn nullable() -> bool {
                // OR: the tuple "accepts NULL" if any component does.
                // Used by the default `propagates_nulls` (`!nullable()`): when
                // every component rejects NULL, the function propagates nulls
                // for ALL inputs — safe for the optimizer to replace with NULL.
                $( <$T>::nullable() )||+
            }
            fn all_nullable() -> bool {
                // AND: true only when every component accepts NULL. When false,
                // at least one parameter position rejects NULL at runtime
                // (via `try_from_iter`), making the output potentially nullable
                // even if `propagates_nulls` is false.
                $( <$T>::nullable() )&&+
            }
        }
    }
}

impl_tuple_input_datum_type!(T0);
impl_tuple_input_datum_type!(T0, T1);
impl_tuple_input_datum_type!(T0, T1, T2);
impl_tuple_input_datum_type!(T0, T1, T2, T3);
impl_tuple_input_datum_type!(T0, T1, T2, T3, T4);
impl_tuple_input_datum_type!(T0, T1, T2, T3, T4, T5);

/// A wrapper type for variadic arguments that consumes the remaining iterator.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Variadic<T>(pub Vec<T>);

impl<T> From<Vec<T>> for Variadic<T> {
    #[inline(always)]
    fn from(v: Vec<T>) -> Self {
        Self(v)
    }
}

impl<T> std::ops::Deref for Variadic<T> {
    type Target = Vec<T>;

    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> IntoIterator for Variadic<T> {
    type Item = T;
    type IntoIter = std::vec::IntoIter<T>;

    #[inline(always)]
    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

impl<'a, T> IntoIterator for &'a Variadic<T> {
    type Item = &'a T;
    type IntoIter = std::slice::Iter<'a, T>;

    #[inline(always)]
    fn into_iter(self) -> Self::IntoIter {
        (&self.0).into_iter()
    }
}

impl<'a, E, T: InputDatumType<'a, E>> InputDatumType<'a, E> for Variadic<T> {
    fn nullable() -> bool {
        T::nullable()
    }
    #[inline]
    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        Ok(vec![T::try_from_result(res)?].into())
    }
    #[inline]
    fn try_from_iter(
        iter: &mut impl Iterator<Item = Result<Datum<'a>, E>>,
    ) -> Result<Self, Result<Option<Datum<'a>>, E>> {
        let mut res = Vec::with_capacity(iter.size_hint().0);
        loop {
            match T::try_from_iter(iter) {
                Ok(t) => res.push(t),
                Err(Ok(None)) => break,
                Err(err) => return Err(err),
            }
        }
        Ok(Self(res))
    }
}

/// Wrapper to distinguish "argument may not be present" from `Option<T>` (nullable).
#[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct OptionalArg<T>(pub Option<T>);

impl<T> std::ops::Deref for OptionalArg<T> {
    type Target = Option<T>;

    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> From<Option<T>> for OptionalArg<T> {
    #[inline(always)]
    fn from(opt: Option<T>) -> Self {
        Self(opt)
    }
}

impl<'a, E, T: InputDatumType<'a, E>> InputDatumType<'a, E> for OptionalArg<T> {
    fn nullable() -> bool {
        T::nullable()
    }
    #[inline]
    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        Ok(Some(T::try_from_result(res)?).into())
    }
    #[inline]
    fn try_from_iter(
        iter: &mut impl Iterator<Item = Result<Datum<'a>, E>>,
    ) -> Result<Self, Result<Option<Datum<'a>>, E>> {
        match iter.next() {
            Some(datum) => {
                let val = T::try_from_result(datum).map_err(|r| r.map(Some))?;
                Ok(Some(val).into())
            }
            None => Ok(None.into()),
        }
    }
}

/// A wrapper type that excludes `NULL` values, even if `B` allows them.
///
/// The wrapper allows for using types that can represent `NULL` values in contexts where
/// `NULL` values are not allowed, enforcing the non-null constraint at the type level.
/// For example, functions that propagate `NULL` values can use this type to ensure that
/// their inputs are non-null, even if the type could represent `NULL` values.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct ExcludeNull<B>(B);

impl<B: AsColumnType> AsColumnType for ExcludeNull<B> {
    fn as_column_type() -> SqlColumnType {
        B::as_column_type().nullable(false)
    }
}

impl<'a, E, B: InputDatumType<'a, E>> InputDatumType<'a, E> for ExcludeNull<B> {
    fn nullable() -> bool {
        false
    }
    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Null) => Err(Ok(Datum::Null)),
            _ => B::try_from_result(res).map(ExcludeNull),
        }
    }
}

impl<'a, E, B: OutputDatumType<'a, E>> OutputDatumType<'a, E> for ExcludeNull<B> {
    fn nullable() -> bool {
        false
    }
    fn fallible() -> bool {
        B::fallible()
    }
    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        self.0.into_result(temp_storage)
    }
}

impl<B> std::ops::Deref for ExcludeNull<B> {
    type Target = B;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// Macro to derive InputDatumType and OutputDatumType for all Datum variants that are simple Copy types
macro_rules! impl_datum_type_copy {
    ($lt:lifetime, $native:ty, $variant:ident) => {
        #[allow(unused_lifetimes)]
        impl<$lt> AsColumnType for $native {
            fn as_column_type() -> SqlColumnType {
                SqlScalarType::$variant.nullable(false)
            }
        }

        impl<$lt, E> InputDatumType<$lt, E> for $native {
            fn nullable() -> bool {
                false
            }

            fn try_from_result(res: Result<Datum<$lt>, E>) -> Result<Self, Result<Datum<$lt>, E>> {
                match res {
                    Ok(Datum::$variant(f)) => Ok(f.into()),
                    _ => Err(res),
                }
            }
        }

        impl<$lt, E> OutputDatumType<$lt, E> for $native {
            fn nullable() -> bool {
                false
            }

            fn fallible() -> bool {
                false
            }

            fn into_result(self, _temp_storage: &$lt RowArena) -> Result<Datum<$lt>, E> {
                Ok(Datum::$variant(self.into()))
            }
        }
    };
    ($native:ty, $variant:ident) => {
        impl_datum_type_copy!('a, $native, $variant);
    };
}

impl_datum_type_copy!(f32, Float32);
impl_datum_type_copy!(f64, Float64);
impl_datum_type_copy!(i16, Int16);
impl_datum_type_copy!(i32, Int32);
impl_datum_type_copy!(i64, Int64);
impl_datum_type_copy!(u16, UInt16);
impl_datum_type_copy!(u32, UInt32);
impl_datum_type_copy!(u64, UInt64);
impl_datum_type_copy!(Interval, Interval);
impl_datum_type_copy!(Date, Date);
impl_datum_type_copy!(NaiveTime, Time);
impl_datum_type_copy!(Uuid, Uuid);
impl_datum_type_copy!('a, &'a str, String);
impl_datum_type_copy!('a, &'a [u8], Bytes);
impl_datum_type_copy!(crate::Timestamp, MzTimestamp);

impl<'a, E> InputDatumType<'a, E> for Datum<'a> {
    fn nullable() -> bool {
        true
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(datum) => Ok(datum),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Datum<'a> {
    fn nullable() -> bool {
        true
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(self)
    }
}

impl<'a, E> InputDatumType<'a, E> for DatumList<'a> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::List(list)) => Ok(list),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for DatumList<'a> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::List(self))
    }
}

impl<'a, E> InputDatumType<'a, E> for Array<'a> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Array(array)) => Ok(array),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Array<'a> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::Array(self))
    }
}

/// PostgreSQL's `int2vector` type: a thin wrapper over a 1-dimensional
/// [`Array`] of `int2`, kept distinct from a regular `int2[]` array because
/// it forbids `NULL` elements.
///
/// All elements are non-nullable `int2`s. This is reflected in
/// [`Int2Vector`]'s [`AsColumnType`] impl (always `nullable(false)`) and in
/// the text I/O grammar: the legacy whitespace-separated vector syntax used
/// by `int2vector` (see [`crate::strconv::parse_legacy_vector_inner`]) has
/// no notation for `NULL`, unlike the curly-brace array syntax (see
/// [`crate::strconv::parse_array`]).
///
/// The 1-dimensional restriction is enforced by
/// [`Array::has_int2vector_dims`] (which also permits the empty array);
/// regular arrays may be multi-dimensional. (The single dimension's lower
/// bound is 0, matching PostgreSQL's `int2vector` convention, whereas
/// regular arrays in Materialize use a lower bound of 1.)
#[derive(Debug)]
pub struct Int2Vector<'a>(pub Array<'a>);

impl AsColumnType for Int2Vector<'_> {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Int2Vector.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for Int2Vector<'a> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Array(array)) => Ok(Int2Vector(array)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Int2Vector<'a> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::Array(self.0))
    }
}

impl<'a, E> InputDatumType<'a, E> for DatumMap<'a> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Map(map)) => Ok(map),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for DatumMap<'a> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::Map(self))
    }
}

impl<'a, E> InputDatumType<'a, E> for Range<DatumNested<'a>> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Range(range)) => Ok(range),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Range<DatumNested<'a>> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::Range(self))
    }
}

impl<'a, E> InputDatumType<'a, E> for Range<Datum<'a>> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(r @ Datum::Range(..)) => Ok(r.unwrap_range()),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Range<Datum<'a>> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        let d =
            self.into_bounds(|bound| temp_storage.make_datum_nested(|packer| packer.push(bound)));
        Ok(Datum::Range(d))
    }
}

impl AsColumnType for bool {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Bool.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for bool {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::True) => Ok(true),
            Ok(Datum::False) => Ok(false),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for bool {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        if self {
            Ok(Datum::True)
        } else {
            Ok(Datum::False)
        }
    }
}

impl AsColumnType for String {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::String.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for String {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::String(s)) => Ok(s.to_owned()),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for String {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::String(temp_storage.push_string(self)))
    }
}

impl<T: AsColumnType> AsColumnType for ArrayRustType<T> {
    fn as_column_type() -> SqlColumnType {
        let inner = T::as_column_type();
        SqlScalarType::Array(Box::new(inner.scalar_type)).nullable(false)
    }
}

impl<'a, T, E> InputDatumType<'a, E> for ArrayRustType<T>
where
    T: InputDatumType<'a, E>,
{
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        if let Ok(Datum::Array(arr)) = &res {
            let result = arr
                .elements()
                .into_iter()
                .map(|d| T::try_from_result(Ok(d)))
                .collect::<Result<_, _>>();
            if let Ok(elements) = result {
                return Ok(ArrayRustType(elements));
            }
        }

        // The `try_from_result` contract requires we return the original `res` on error.
        Err(res)
    }
}

impl<'a, T, E> OutputDatumType<'a, E> for ArrayRustType<T>
where
    T: OutputDatumType<'a, E>,
{
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        T::fallible()
    }

    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        let dimensions = ArrayDimension {
            lower_bound: 1,
            length: self.0.len(),
        };
        let iter = self
            .0
            .into_iter()
            .map(|elem| elem.into_result(temp_storage));
        temp_storage.try_make_datum(|packer| {
            packer
                .try_push_array_fallible(&[dimensions], iter)
                .expect("self is 1 dimensional, and its length is used for the array length")
        })
    }
}

impl AsColumnType for Vec<u8> {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Bytes.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for Vec<u8> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Bytes(b)) => Ok(b.to_owned()),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Vec<u8> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::Bytes(temp_storage.push_owned_bytes(self)))
    }
}

impl AsColumnType for Numeric {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Numeric { max_scale: None }.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for Numeric {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Numeric(n)) => Ok(n.into_inner()),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Numeric {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::from(self))
    }
}

impl<'a, E> InputDatumType<'a, E> for OrderedDecimal<Numeric> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Numeric(n)) => Ok(n),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for OrderedDecimal<Numeric> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::from(self))
    }
}

impl AsColumnType for PgLegacyChar {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::PgLegacyChar.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for PgLegacyChar {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::UInt8(a)) => Ok(PgLegacyChar(a)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for PgLegacyChar {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::UInt8(self.0))
    }
}

impl<S> AsColumnType for PgLegacyName<S>
where
    S: AsRef<str>,
{
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::PgLegacyName.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for PgLegacyName<&'a str> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::String(a)) => Ok(PgLegacyName(a)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for PgLegacyName<&'a str> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::String(self.0))
    }
}

impl<'a, E> InputDatumType<'a, E> for PgLegacyName<String> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::String(a)) => Ok(PgLegacyName(a.to_owned())),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for PgLegacyName<String> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::String(temp_storage.push_string(self.0)))
    }
}

impl AsColumnType for Oid {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Oid.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for Oid {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::UInt32(a)) => Ok(Oid(a)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Oid {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::UInt32(self.0))
    }
}

impl AsColumnType for RegClass {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::RegClass.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for RegClass {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::UInt32(a)) => Ok(RegClass(a)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for RegClass {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::UInt32(self.0))
    }
}

impl AsColumnType for RegProc {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::RegProc.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for RegProc {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::UInt32(a)) => Ok(RegProc(a)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for RegProc {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::UInt32(self.0))
    }
}

impl AsColumnType for RegType {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::RegType.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for RegType {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::UInt32(a)) => Ok(RegType(a)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for RegType {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::UInt32(self.0))
    }
}

impl<S> AsColumnType for Char<S>
where
    S: AsRef<str>,
{
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Char { length: None }.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for Char<&'a str> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::String(a)) => Ok(Char(a)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Char<&'a str> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::String(self.0))
    }
}

impl<'a, E> InputDatumType<'a, E> for Char<String> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::String(a)) => Ok(Char(a.to_owned())),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for Char<String> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::String(temp_storage.push_string(self.0)))
    }
}

impl<S> AsColumnType for VarChar<S>
where
    S: AsRef<str>,
{
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::VarChar { max_length: None }.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for VarChar<&'a str> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::String(a)) => Ok(VarChar(a)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for VarChar<&'a str> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::String(self.0))
    }
}

impl<'a, E> InputDatumType<'a, E> for VarChar<String> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::String(a)) => Ok(VarChar(a.to_owned())),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for VarChar<String> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::String(temp_storage.push_string(self.0)))
    }
}

impl<'a, E> InputDatumType<'a, E> for Jsonb {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        Ok(JsonbRef::try_from_result(res)?.to_owned())
    }
}

impl<'a, E> OutputDatumType<'a, E> for Jsonb {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(temp_storage.push_unary_row(self.into_row()))
    }
}

impl AsColumnType for Jsonb {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Jsonb.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for JsonbRef<'a> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(
                d @ (Datum::JsonNull
                | Datum::True
                | Datum::False
                | Datum::Numeric(_)
                | Datum::String(_)
                | Datum::List(_)
                | Datum::Map(_)),
            ) => Ok(JsonbRef::from_datum(d)),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for JsonbRef<'a> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(self.into_datum())
    }
}

impl<'a> AsColumnType for JsonbRef<'a> {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Jsonb.nullable(false)
    }
}

impl AsColumnType for MzAclItem {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::MzAclItem.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for MzAclItem {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::MzAclItem(mz_acl_item)) => Ok(mz_acl_item),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for MzAclItem {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::MzAclItem(self))
    }
}

impl AsColumnType for AclItem {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::AclItem.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for AclItem {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::AclItem(acl_item)) => Ok(acl_item),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for AclItem {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::AclItem(self))
    }
}

impl AsColumnType for CheckedTimestamp<NaiveDateTime> {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::Timestamp { precision: None }.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for CheckedTimestamp<NaiveDateTime> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::Timestamp(a)) => Ok(a),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for CheckedTimestamp<NaiveDateTime> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::Timestamp(self))
    }
}

impl AsColumnType for CheckedTimestamp<DateTime<Utc>> {
    fn as_column_type() -> SqlColumnType {
        SqlScalarType::TimestampTz { precision: None }.nullable(false)
    }
}

impl<'a, E> InputDatumType<'a, E> for CheckedTimestamp<DateTime<Utc>> {
    fn nullable() -> bool {
        false
    }

    fn try_from_result(res: Result<Datum<'a>, E>) -> Result<Self, Result<Datum<'a>, E>> {
        match res {
            Ok(Datum::TimestampTz(a)) => Ok(a),
            _ => Err(res),
        }
    }
}

impl<'a, E> OutputDatumType<'a, E> for CheckedTimestamp<DateTime<Utc>> {
    fn nullable() -> bool {
        false
    }

    fn fallible() -> bool {
        false
    }

    fn into_result(self, _temp_storage: &'a RowArena) -> Result<Datum<'a>, E> {
        Ok(Datum::TimestampTz(self))
    }
}

impl SqlScalarType {
    /// Returns the contained numeric maximum scale.
    ///
    /// # Panics
    ///
    /// Panics if the scalar type is not [`SqlScalarType::Numeric`].
    pub fn unwrap_numeric_max_scale(&self) -> Option<NumericMaxScale> {
        match self {
            SqlScalarType::Numeric { max_scale } => *max_scale,
            _ => panic!("SqlScalarType::unwrap_numeric_scale called on {:?}", self),
        }
    }

    /// Returns the contained timestamp precision.
    ///
    /// # Panics
    ///
    /// Panics if the scalar type is not [`SqlScalarType::Timestamp`] or
    /// [`SqlScalarType::TimestampTz`].
    pub fn unwrap_timestamp_precision(&self) -> Option<TimestampPrecision> {
        match self {
            SqlScalarType::Timestamp { precision } | SqlScalarType::TimestampTz { precision } => {
                *precision
            }
            _ => panic!(
                "SqlScalarType::unwrap_timestamp_precision called on {:?}",
                self
            ),
        }
    }

    /// Returns the [`SqlScalarType`] of elements in a [`SqlScalarType::List`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::List`].
    pub fn unwrap_list_element_type(&self) -> &SqlScalarType {
        match self {
            SqlScalarType::List { element_type, .. } => element_type,
            _ => panic!(
                "SqlScalarType::unwrap_list_element_type called on {:?}",
                self
            ),
        }
    }

    /// Returns the [`SqlScalarType`] of elements in the nth layer a
    /// [`SqlScalarType::List`].
    ///
    /// For example, in an `int list list`, the:
    /// - 0th layer is `int list list`
    /// - 1st layer is `int list`
    /// - 2nd layer is `int`
    ///
    /// # Panics
    ///
    /// Panics if the nth-1 layer is anything other than a
    /// [`SqlScalarType::List`].
    pub fn unwrap_list_nth_layer_type(&self, layer: usize) -> &SqlScalarType {
        if layer == 0 {
            return self;
        }
        match self {
            SqlScalarType::List { element_type, .. } => {
                element_type.unwrap_list_nth_layer_type(layer - 1)
            }
            _ => panic!(
                "SqlScalarType::unwrap_list_nth_layer_type called on {:?}",
                self
            ),
        }
    }

    /// Returns a vector of [`SqlScalarType`] elements in a [`SqlScalarType::Record`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::Record`].
    pub fn unwrap_record_element_type(&self) -> Vec<&SqlScalarType> {
        match self {
            SqlScalarType::Record { fields, .. } => {
                fields.iter().map(|(_, t)| &t.scalar_type).collect_vec()
            }
            _ => panic!(
                "SqlScalarType::unwrap_record_element_type called on {:?}",
                self
            ),
        }
    }

    /// Returns vector of [`SqlColumnType`] elements in a [`SqlScalarType::Record`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::Record`].
    pub fn unwrap_record_element_column_type(&self) -> Vec<&SqlColumnType> {
        match self {
            SqlScalarType::Record { fields, .. } => fields.iter().map(|(_, t)| t).collect_vec(),
            _ => panic!(
                "SqlScalarType::unwrap_record_element_column_type called on {:?}",
                self
            ),
        }
    }

    /// Returns number of dimensions/axes (also known as "rank") on a
    /// [`SqlScalarType::List`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::List`].
    pub fn unwrap_list_n_layers(&self) -> usize {
        let mut descender = self.unwrap_list_element_type();
        let mut layers = 1;

        while let SqlScalarType::List { element_type, .. } = descender {
            layers += 1;
            descender = element_type;
        }

        layers
    }

    /// Returns `self` with any type modifiers removed.
    ///
    /// Namely, this should set optional scales or limits to `None`.
    pub fn without_modifiers(&self) -> SqlScalarType {
        use SqlScalarType::*;
        match self {
            List {
                element_type,
                custom_id: None,
            } => List {
                element_type: Box::new(element_type.without_modifiers()),
                custom_id: None,
            },
            Map {
                value_type,
                custom_id: None,
            } => Map {
                value_type: Box::new(value_type.without_modifiers()),
                custom_id: None,
            },
            Record {
                fields,
                custom_id: None,
            } => {
                let fields = fields
                    .iter()
                    .map(|(column_name, column_type)| {
                        (
                            column_name.clone(),
                            SqlColumnType {
                                scalar_type: column_type.scalar_type.without_modifiers(),
                                nullable: column_type.nullable,
                            },
                        )
                    })
                    .collect();
                Record {
                    fields,
                    custom_id: None,
                }
            }
            Array(a) => Array(Box::new(a.without_modifiers())),
            Numeric { .. } => Numeric { max_scale: None },
            // Char's default length should not be `Some(1)`, but instead `None`
            // to support Char values of different lengths in e.g. lists.
            Char { .. } => Char { length: None },
            VarChar { .. } => VarChar { max_length: None },
            Range { element_type } => Range {
                element_type: Box::new(element_type.without_modifiers()),
            },
            v => v.clone(),
        }
    }

    /// Returns the [`SqlScalarType`] of elements in a [`SqlScalarType::Array`] or the
    /// elements of a vector type, e.g. [`SqlScalarType::Int16`] for
    /// [`SqlScalarType::Int2Vector`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::Array`] or
    /// [`SqlScalarType::Int2Vector`].
    pub fn unwrap_array_element_type(&self) -> &SqlScalarType {
        match self {
            SqlScalarType::Array(s) => &**s,
            SqlScalarType::Int2Vector => &SqlScalarType::Int16,
            _ => panic!(
                "SqlScalarType::unwrap_array_element_type called on {:?}",
                self
            ),
        }
    }

    /// Returns the [`SqlScalarType`] of elements in a [`SqlScalarType::Array`],
    /// [`SqlScalarType::Int2Vector`], or [`SqlScalarType::List`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::Array`],
    /// [`SqlScalarType::Int2Vector`], or [`SqlScalarType::List`].
    pub fn unwrap_collection_element_type(&self) -> &SqlScalarType {
        match self {
            SqlScalarType::Array(element_type) => element_type,
            SqlScalarType::Int2Vector => &SqlScalarType::Int16,
            SqlScalarType::List { element_type, .. } => element_type,
            _ => panic!(
                "SqlScalarType::unwrap_collection_element_type called on {:?}",
                self
            ),
        }
    }

    /// Returns the [`SqlScalarType`] of values in a [`SqlScalarType::Map`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::Map`].
    pub fn unwrap_map_value_type(&self) -> &SqlScalarType {
        match self {
            SqlScalarType::Map { value_type, .. } => &**value_type,
            _ => panic!("SqlScalarType::unwrap_map_value_type called on {:?}", self),
        }
    }

    /// Returns the length of a [`SqlScalarType::Char`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::Char`].
    pub fn unwrap_char_length(&self) -> Option<CharLength> {
        match self {
            SqlScalarType::Char { length, .. } => *length,
            _ => panic!("SqlScalarType::unwrap_char_length called on {:?}", self),
        }
    }

    /// Returns the max length of a [`SqlScalarType::VarChar`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::VarChar`].
    pub fn unwrap_varchar_max_length(&self) -> Option<VarCharMaxLength> {
        match self {
            SqlScalarType::VarChar { max_length, .. } => *max_length,
            _ => panic!(
                "SqlScalarType::unwrap_varchar_max_length called on {:?}",
                self
            ),
        }
    }

    /// Returns the [`SqlScalarType`] of elements in a [`SqlScalarType::Range`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`SqlScalarType::Map`].
    pub fn unwrap_range_element_type(&self) -> &SqlScalarType {
        match self {
            SqlScalarType::Range { element_type } => &**element_type,
            _ => panic!(
                "SqlScalarType::unwrap_range_element_type called on {:?}",
                self
            ),
        }
    }

    /// Returns a "near match" of `self`, which are types that are implicitly
    /// castable from `self` and offer a means to leverage Materialize's type
    /// system to achieve more reasonable approaches to unifying types.
    ///
    /// However, it's very important to not blithely accept the `near_match`,
    /// which can be suboptimal/unnecessary, e.g. in the case of an already
    /// homogeneous group.
    ///
    /// The feature is preferrable in MZ, but unnecessary in PG because PG's
    /// type system offers totally linear progression through the complexity of
    /// types. e.g. with numbers, there is a linear progression in the domain
    /// each can represent. However, MZ's support for unsigned integers create a
    /// non-linear type system, i.e. while the magnitude of `Int32` and
    /// `UInt32`'s domains are the same, they are not equal.
    ///
    /// Without this feature, Materialize will:
    /// - Guess that a mixute of the same width of int and uint cannot be
    ///   coerced to a homogeneous type.
    /// - Select the `Float64` based version of common binary functions (e.g.
    ///   `=`), which introduces an unexpected float cast to integer values.
    ///
    /// Note that if adding any near matches besides unsigned ints, consider
    /// extending/generalizing how `guess_best_common_type` uses this function.
    pub fn near_match(&self) -> Option<&'static SqlScalarType> {
        match self {
            SqlScalarType::UInt16 => Some(&SqlScalarType::Int32),
            SqlScalarType::UInt32 => Some(&SqlScalarType::Int64),
            SqlScalarType::UInt64 => Some(&SqlScalarType::Numeric { max_scale: None }),
            _ => None,
        }
    }

    /// Derives a column type from this scalar type with the specified
    /// nullability.
    pub const fn nullable(self, nullable: bool) -> SqlColumnType {
        SqlColumnType {
            nullable,
            scalar_type: self,
        }
    }

    /// Returns whether or not `self` is a vector-like type, i.e.
    /// [`SqlScalarType::Array`], [`SqlScalarType::Int2Vector`], or
    /// [`SqlScalarType::List`], irrespective of its element type.
    pub fn is_vec(&self) -> bool {
        matches!(
            self,
            SqlScalarType::Array(_) | SqlScalarType::Int2Vector | SqlScalarType::List { .. }
        )
    }

    pub fn is_custom_type(&self) -> bool {
        use SqlScalarType::*;
        match self {
            List {
                element_type: t,
                custom_id,
            }
            | Map {
                value_type: t,
                custom_id,
            } => custom_id.is_some() || t.is_custom_type(),
            Record {
                fields, custom_id, ..
            } => {
                custom_id.is_some()
                    || fields
                        .iter()
                        .map(|(_, t)| t)
                        .any(|t| t.scalar_type.is_custom_type())
            }
            _ => false,
        }
    }

    /// Computes the least upper bound of two SQL scalar types, or an error if
    /// they are incompatible. Compatible types are equal, share a base type and
    /// differ only in modifiers (which are then dropped), or are structured
    /// types with pairwise compatible components.
    ///
    /// NOTE: Structured types must recurse rather than fall through to the
    /// `base_eq` arm. `base_eq` ignores record field nullability, so returning
    /// either side verbatim can declare a field non-nullable where the other
    /// side puts a null.
    pub fn sql_union(&self, other: &SqlScalarType) -> Result<SqlScalarType, anyhow::Error> {
        use SqlScalarType::*;
        match (self, other) {
            (scalar_type, other_scalar_type) if scalar_type == other_scalar_type => {
                Ok(scalar_type.clone())
            }
            (
                Record { fields, custom_id },
                Record {
                    fields: other_fields,
                    custom_id: other_custom_id,
                },
            ) if custom_id == other_custom_id && fields.len() == other_fields.len() => {
                let mut union_fields = Vec::with_capacity(fields.len());
                for ((name, typ), (other_name, other_typ)) in
                    fields.iter().zip_eq(other_fields.iter())
                {
                    if name != other_name {
                        bail!("Can't union types: {:?} and {:?}", self, other);
                    }
                    union_fields.push((name.clone(), typ.sql_union(other_typ)?));
                }
                Ok(Record {
                    fields: union_fields.into(),
                    custom_id: *custom_id,
                })
            }
            (
                List {
                    element_type,
                    custom_id,
                },
                List {
                    element_type: other_element_type,
                    custom_id: other_custom_id,
                },
            ) if custom_id == other_custom_id => Ok(List {
                element_type: Box::new(element_type.sql_union(other_element_type)?),
                custom_id: *custom_id,
            }),
            (
                Map {
                    value_type,
                    custom_id,
                },
                Map {
                    value_type: other_value_type,
                    custom_id: other_custom_id,
                },
            ) if custom_id == other_custom_id => Ok(Map {
                value_type: Box::new(value_type.sql_union(other_value_type)?),
                custom_id: *custom_id,
            }),
            (Array(element_type), Array(other_element_type)) => {
                Ok(Array(Box::new(element_type.sql_union(other_element_type)?)))
            }
            (
                Range { element_type },
                Range {
                    element_type: other_element_type,
                },
            ) => Ok(Range {
                element_type: Box::new(element_type.sql_union(other_element_type)?),
            }),
            (scalar_type, other_scalar_type) if scalar_type.base_eq(other_scalar_type) => {
                Ok(scalar_type.without_modifiers())
            }
            _ => bail!("Can't union types: {:?} and {:?}", self, other),
        }
    }

    /// Determines equality among scalar types that acknowledges custom OIDs,
    /// but ignores other embedded values.
    ///
    /// In most situations, you want to use `base_eq` rather than `SqlScalarType`'s
    /// implementation of `Eq`. `base_eq` expresses the semantics of direct type
    /// interoperability whereas `Eq` expresses an exact comparison between the
    /// values.
    ///
    /// For instance, `base_eq` signals that e.g. two [`SqlScalarType::Numeric`]
    /// values can be added together, irrespective of their embedded scale. In
    /// contrast, two `Numeric` values with different scales are never `Eq` to
    /// one another.
    pub fn base_eq(&self, other: &SqlScalarType) -> bool {
        self.eq_inner(other, false)
    }

    // Determines equality among scalar types that ignores any custom OIDs or
    // embedded values.
    pub fn structural_eq(&self, other: &SqlScalarType) -> bool {
        self.eq_inner(other, true)
    }

    pub fn eq_inner(&self, other: &SqlScalarType, structure_only: bool) -> bool {
        use SqlScalarType::*;
        match (self, other) {
            (
                List {
                    element_type: l,
                    custom_id: oid_l,
                },
                List {
                    element_type: r,
                    custom_id: oid_r,
                },
            )
            | (
                Map {
                    value_type: l,
                    custom_id: oid_l,
                },
                Map {
                    value_type: r,
                    custom_id: oid_r,
                },
            ) => l.eq_inner(r, structure_only) && (oid_l == oid_r || structure_only),
            (Array(a), Array(b)) | (Range { element_type: a }, Range { element_type: b }) => {
                a.eq_inner(b, structure_only)
            }
            (
                Record {
                    fields: fields_a,
                    custom_id: oid_a,
                },
                Record {
                    fields: fields_b,
                    custom_id: oid_b,
                },
            ) => {
                (oid_a == oid_b || structure_only)
                    && fields_a.len() == fields_b.len()
                    && fields_a
                        .iter()
                        .zip_eq(fields_b)
                        // Ignore nullability.
                        .all(|(a, b)| {
                            (a.0 == b.0 || structure_only)
                                && a.1.scalar_type.eq_inner(&b.1.scalar_type, structure_only)
                        })
            }
            (s, o) => SqlScalarBaseType::from(s) == SqlScalarBaseType::from(o),
        }
    }

    /// Adopts the nullability from another [`SqlScalarType`].
    /// Traverses deeply into structured types.
    pub fn backport_nullability(&mut self, backport_typ: &ReprScalarType) {
        match (self, backport_typ) {
            (
                SqlScalarType::List { element_type, .. },
                ReprScalarType::List {
                    element_type: backport_element_type,
                    ..
                },
            ) => {
                element_type.backport_nullability(backport_element_type);
            }
            (
                SqlScalarType::Map { value_type, .. },
                ReprScalarType::Map {
                    value_type: backport_value_type,
                    ..
                },
            ) => {
                value_type.backport_nullability(backport_value_type);
            }
            (
                SqlScalarType::Record { fields, .. },
                ReprScalarType::Record {
                    fields: backport_fields,
                    ..
                },
            ) => {
                assert_eq!(
                    fields.len(),
                    backport_fields.len(),
                    "HIR and MIR types should have the same number of fields"
                );
                fields
                    .iter_mut()
                    .zip_eq(backport_fields)
                    .for_each(|(field, backport_field)| {
                        field.1.backport_nullability(backport_field);
                    });
            }
            (SqlScalarType::Array(a), ReprScalarType::Array(b)) => {
                a.backport_nullability(b);
            }
            (
                SqlScalarType::Range { element_type },
                ReprScalarType::Range {
                    element_type: backport_element_type,
                },
            ) => {
                element_type.backport_nullability(backport_element_type);
            }
            _ => (),
        }
    }

    /// Returns various interesting datums for a SqlScalarType (max, min, 0 values, etc.).
    pub fn interesting_datums(&self) -> impl Iterator<Item = Datum<'static>> {
        // TODO: Add datums for the types that have an inner Box'd SqlScalarType. It'd be best to
        // re-use this function to dynamically generate interesting datums of the requested type.
        // But the 'static bound makes this either hard or impossible. We might need to remove that
        // and return, say, an owned Row. This would require changing lots of dependent test
        // functions, some of which also hard code a 'static bound.
        static BOOL: LazyLock<Row> =
            LazyLock::new(|| Row::pack_slice(&[Datum::True, Datum::False]));
        static INT16: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Int16(0),
                Datum::Int16(1),
                Datum::Int16(-1),
                Datum::Int16(i16::MIN),
                Datum::Int16(i16::MIN + 1),
                Datum::Int16(i16::MAX),
                // The following datums are
                // around the boundaries introduced by
                // variable-length int encoding
                //
                // TODO[btv]: Add more datums around
                // boundaries in VLE (e.g. negatives) if `test_smoketest_all_builtins` is
                // fixed to be faster.
                Datum::Int16(127),
                Datum::Int16(128),
            ])
        });
        static INT32: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Int32(0),
                Datum::Int32(1),
                Datum::Int32(-1),
                Datum::Int32(i32::MIN),
                Datum::Int32(i32::MIN + 1),
                Datum::Int32(i32::MAX),
                // The following datums are
                // around the boundaries introduced by
                // variable-length int encoding
                Datum::Int32(32767),
                Datum::Int32(32768),
            ])
        });
        static INT64: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Int64(0),
                Datum::Int64(1),
                Datum::Int64(-1),
                Datum::Int64(i64::MIN),
                Datum::Int64(i64::MIN + 1),
                Datum::Int64(i64::MAX),
                // The following datums are
                // around the boundaries introduced by
                // variable-length int encoding
                Datum::Int64(2147483647),
                Datum::Int64(2147483648),
            ])
        });
        static UINT16: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::UInt16(0),
                Datum::UInt16(1),
                Datum::UInt16(u16::MAX),
                // The following datums are
                // around the boundaries introduced by
                // variable-length int encoding
                Datum::UInt16(255),
                Datum::UInt16(256),
            ])
        });
        static UINT32: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::UInt32(0),
                Datum::UInt32(1),
                Datum::UInt32(u32::MAX),
                // The following datums are
                // around the boundaries introduced by
                // variable-length int encoding
                Datum::UInt32(32767),
                Datum::UInt32(32768),
            ])
        });
        static UINT64: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::UInt64(0),
                Datum::UInt64(1),
                Datum::UInt64(u64::MAX),
                // The following datums are
                // around the boundaries introduced by
                // variable-length int encoding
                Datum::UInt64(2147483647),
                Datum::UInt64(2147483648),
            ])
        });
        static FLOAT32: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Float32(OrderedFloat(0.0)),
                Datum::Float32(OrderedFloat(1.0)),
                Datum::Float32(OrderedFloat(-1.0)),
                Datum::Float32(OrderedFloat(f32::MIN)),
                Datum::Float32(OrderedFloat(f32::MIN_POSITIVE)),
                Datum::Float32(OrderedFloat(f32::MAX)),
                Datum::Float32(OrderedFloat(f32::EPSILON)),
                Datum::Float32(OrderedFloat(f32::NAN)),
                // NOTE: -NaN and -0.0 have distinct bit patterns from NaN and
                // 0.0 but compare equal under `OrderedFloat`. Orderings that
                // look at the representation (e.g. arrow's total order, where
                // -NaN < -Infinity) can disagree with `OrderedFloat` on them.
                Datum::Float32(OrderedFloat(-f32::NAN)),
                Datum::Float32(OrderedFloat(-0.0)),
                Datum::Float32(OrderedFloat(f32::INFINITY)),
                Datum::Float32(OrderedFloat(f32::NEG_INFINITY)),
            ])
        });
        static FLOAT64: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Float64(OrderedFloat(0.0)),
                Datum::Float64(OrderedFloat(1.0)),
                Datum::Float64(OrderedFloat(-1.0)),
                Datum::Float64(OrderedFloat(f64::MIN)),
                Datum::Float64(OrderedFloat(f64::MIN_POSITIVE)),
                Datum::Float64(OrderedFloat(f64::MAX)),
                Datum::Float64(OrderedFloat(f64::EPSILON)),
                Datum::Float64(OrderedFloat(f64::NAN)),
                // See the FLOAT32 note on -NaN and -0.0.
                Datum::Float64(OrderedFloat(-f64::NAN)),
                Datum::Float64(OrderedFloat(-0.0)),
                Datum::Float64(OrderedFloat(f64::INFINITY)),
                Datum::Float64(OrderedFloat(f64::NEG_INFINITY)),
            ])
        });
        static NUMERIC: LazyLock<Row> = LazyLock::new(|| {
            cfg_if::cfg_if! {
                // Numerics can't currently be instantiated under Miri
                if #[cfg(miri)] {
                    Row::pack_slice(&[])
                } else {
                    Row::pack_slice(&[
                        Datum::Numeric(OrderedDecimal(Numeric::from(0.0))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(1.0))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(-1.0))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(f64::MIN))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(f64::MIN_POSITIVE))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(f64::MAX))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(f64::EPSILON))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(f64::NAN))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(f64::INFINITY))),
                        Datum::Numeric(OrderedDecimal(Numeric::from(f64::NEG_INFINITY))),
                    ])
                }
            }
        });
        static DATE: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Date(Date::from_pg_epoch(0).unwrap()),
                Datum::Date(Date::from_pg_epoch(Date::LOW_DAYS).unwrap()),
                Datum::Date(Date::from_pg_epoch(Date::HIGH_DAYS).unwrap()),
            ])
        });
        static TIME: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Time(NaiveTime::from_hms_micro_opt(0, 0, 0, 0).unwrap()),
                Datum::Time(NaiveTime::from_hms_micro_opt(23, 59, 59, 999_999).unwrap()),
                // Leap second: chrono represents it as a fractional part of
                // one second or more. `TIME '23:59:60'` is the largest value
                // parsing admits, since fractional leap seconds are rejected,
                // and it encodes to exactly PostgreSQL's 24:00:00 bound. A
                // fractional leap second here would leave the type's
                // PostgreSQL wire domain.
                Datum::Time(NaiveTime::from_hms_micro_opt(23, 59, 59, 1_000_000).unwrap()),
            ])
        });
        static TIMESTAMP: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Timestamp(
                    DateTime::from_timestamp(0, 0)
                        .unwrap()
                        .naive_utc()
                        .try_into()
                        .unwrap(),
                ),
                Datum::Timestamp(
                    crate::adt::timestamp::LOW_DATE
                        .and_hms_opt(0, 0, 0)
                        .unwrap()
                        .try_into()
                        .unwrap(),
                ),
                Datum::Timestamp(
                    crate::adt::timestamp::HIGH_DATE
                        .and_hms_opt(23, 59, 59)
                        .unwrap()
                        .try_into()
                        .unwrap(),
                ),
                // nano seconds
                Datum::Timestamp(
                    DateTime::from_timestamp(0, 123456789)
                        .unwrap()
                        .naive_utc()
                        .try_into()
                        .unwrap(),
                ),
                // Leap second
                Datum::Timestamp(
                    CheckedTimestamp::from_timestamplike(
                        NaiveDate::from_isoywd_opt(2019, 30, chrono::Weekday::Wed)
                            .unwrap()
                            .and_hms_milli_opt(23, 59, 59, 1234)
                            .unwrap(),
                    )
                    .unwrap(),
                ),
            ])
        });
        static TIMESTAMPTZ: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::TimestampTz(DateTime::from_timestamp(0, 0).unwrap().try_into().unwrap()),
                Datum::TimestampTz(
                    DateTime::from_naive_utc_and_offset(
                        crate::adt::timestamp::LOW_DATE
                            .and_hms_opt(0, 0, 0)
                            .unwrap(),
                        Utc,
                    )
                    .try_into()
                    .unwrap(),
                ),
                Datum::TimestampTz(
                    DateTime::from_naive_utc_and_offset(
                        crate::adt::timestamp::HIGH_DATE
                            .and_hms_opt(23, 59, 59)
                            .unwrap(),
                        Utc,
                    )
                    .try_into()
                    .unwrap(),
                ),
                // nano seconds
                Datum::TimestampTz(
                    DateTime::from_timestamp(0, 123456789)
                        .unwrap()
                        .try_into()
                        .unwrap(),
                ),
            ])
        });
        static INTERVAL: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Interval(Interval::new(0, 0, 0)),
                Datum::Interval(Interval::new(1, 1, 1)),
                Datum::Interval(Interval::new(-1, -1, -1)),
                Datum::Interval(Interval::new(1, 0, 0)),
                Datum::Interval(Interval::new(0, 1, 0)),
                Datum::Interval(Interval::new(0, 0, 1)),
                Datum::Interval(Interval::new(-1, 0, 0)),
                Datum::Interval(Interval::new(0, -1, 0)),
                Datum::Interval(Interval::new(0, 0, -1)),
                Datum::Interval(Interval::new(i32::MIN, i32::MIN, i64::MIN)),
                Datum::Interval(Interval::new(i32::MAX, i32::MAX, i64::MAX)),
                Datum::Interval(Interval::new(i32::MIN, 0, 0)),
                Datum::Interval(Interval::new(i32::MAX, 0, 0)),
                Datum::Interval(Interval::new(0, i32::MIN, 0)),
                Datum::Interval(Interval::new(0, i32::MAX, 0)),
                Datum::Interval(Interval::new(0, 0, i64::MIN)),
                Datum::Interval(Interval::new(0, 0, i64::MAX)),
            ])
        });
        static PGLEGACYCHAR: LazyLock<Row> =
            LazyLock::new(|| Row::pack_slice(&[Datum::UInt8(u8::MIN), Datum::UInt8(u8::MAX)]));
        static PGLEGACYNAME: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::String(""),
                Datum::String(" "),
                Datum::String("'"),
                Datum::String("\""),
                Datum::String("."),
                Datum::String(&"x".repeat(64)),
            ])
        });
        static BYTES: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[Datum::Bytes(&[]), Datum::Bytes(&[0]), Datum::Bytes(&[255])])
        });
        static STRING: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::String(""),
                Datum::String(" "),
                Datum::String("'"),
                Datum::String("\""),
                Datum::String("."),
                Datum::String("2015-09-18T23:56:04.123Z"),
                Datum::String(&"x".repeat(100)),
                // Persist stats truncate string bounds to 100 bytes: cover a
                // string past that limit, one whose truncated upper bound
                // cannot be incremented (every char is char::MAX), and one
                // with a multibyte char straddling the truncation boundary.
                Datum::String(&"x".repeat(101)),
                Datum::String(&"\u{10FFFF}".repeat(101)),
                Datum::String(&format!("{}\u{1F600}", "x".repeat(99))),
                // Valid timezone.
                Datum::String("JAPAN"),
                Datum::String("1,2,3"),
                Datum::String("\r\n"),
                Datum::String("\"\""),
            ])
        });
        static CHAR: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::String(" "),
                Datum::String("'"),
                Datum::String("\""),
                Datum::String("."),
                Datum::String(","),
                Datum::String("\t"),
                Datum::String("\n"),
                Datum::String("\r"),
                Datum::String("\\"),
                // Null character.
                Datum::String(std::str::from_utf8(b"\x00").unwrap()),
                // Start of text.
                Datum::String(std::str::from_utf8(b"\x02").unwrap()),
                // End of text.
                Datum::String(std::str::from_utf8(b"\x03").unwrap()),
                // Backspace.
                Datum::String(std::str::from_utf8(b"\x08").unwrap()),
                // Escape.
                Datum::String(std::str::from_utf8(b"\x1B").unwrap()),
                // Delete.
                Datum::String(std::str::from_utf8(b"\x7F").unwrap()),
            ])
        });
        static JSONB: LazyLock<Row> = LazyLock::new(|| {
            let mut datums = vec![Datum::True, Datum::False, Datum::JsonNull];
            datums.extend(STRING.iter());
            datums.extend(NUMERIC.iter().filter(|n| {
                let Datum::Numeric(n) = n else {
                    panic!("expected Numeric, found {n:?}");
                };
                // JSON doesn't support NaN or Infinite numbers.
                !(n.0.is_nan() || n.0.is_infinite())
            }));
            let mut row = Row::default();
            let mut packer = row.packer();
            for datum in datums {
                packer.push(datum);
            }
            // Maps, including ones with disjoint key sets. Persist keeps
            // per-key statistics for JSON maps, so a collection mixing maps
            // where a key is present in one and absent in another exercises
            // the absent-key handling in stats and their consumers.
            packer.push_dict([("x", Datum::String("a"))]);
            packer.push_dict([("y", Datum::String("b"))]);
            packer.push_dict([("x", Datum::True), ("y", Datum::JsonNull)]);
            packer.push_dict(std::iter::empty::<(&str, Datum)>());
            // JSON map keys are not truncated in persist stats, unlike SQL
            // string columns, so cover one past the string truncation limit.
            let long_key = "k".repeat(101);
            packer.push_dict([(long_key.as_str(), Datum::True)]);
            packer.push_dict_with(|packer| {
                packer.push(Datum::String("nested"));
                packer.push_dict([("x", Datum::String("a"))]);
            });
            // Lists, including a heterogeneous one.
            packer.push_list([Datum::True, Datum::JsonNull, Datum::String("a")]);
            packer.push_list(std::iter::empty::<Datum>());
            row
        });
        static UUID: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::Uuid(Uuid::from_u128(u128::MIN)),
                Datum::Uuid(Uuid::from_u128(u128::MAX)),
            ])
        });
        static ARRAY: LazyLock<BTreeMap<&'static SqlScalarType, Row>> = LazyLock::new(|| {
            let generate_row = |inner_type: &SqlScalarType| {
                let datums: Vec<_> = inner_type.interesting_datums().collect();

                let mut row = Row::default();
                row.packer()
                    .try_push_array::<_, Datum<'static>>(
                        &[ArrayDimension {
                            lower_bound: 1,
                            length: 0,
                        }],
                        [],
                    )
                    .expect("failed to push empty array");
                row.packer()
                    .try_push_array(
                        &[ArrayDimension {
                            lower_bound: 1,
                            length: datums.len(),
                        }],
                        datums,
                    )
                    .expect("failed to push array");

                row
            };

            SqlScalarType::enumerate()
                .into_iter()
                .filter(|ty| !matches!(ty, SqlScalarType::Array(_)))
                .map(|ty| (ty, generate_row(ty)))
                .collect()
        });
        static EMPTY_ARRAY: LazyLock<Row> = LazyLock::new(|| {
            let mut row = Row::default();
            row.packer()
                .try_push_array::<_, Datum<'static>>(
                    &[ArrayDimension {
                        lower_bound: 1,
                        length: 0,
                    }],
                    [],
                )
                .expect("failed to push empty array");
            row
        });
        static LIST: LazyLock<Row> = LazyLock::new(|| Row::pack_slice(&[]));
        static RECORD: LazyLock<Row> = LazyLock::new(|| Row::pack_slice(&[]));
        static OID: LazyLock<Row> =
            LazyLock::new(|| Row::pack_slice(&[Datum::UInt32(u32::MIN), Datum::UInt32(u32::MAX)]));
        static MAP: LazyLock<Row> = LazyLock::new(|| Row::pack_slice(&[]));
        static INT2VECTOR: LazyLock<Row> = LazyLock::new(|| Row::pack_slice(&[]));
        static MZTIMESTAMP: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::MzTimestamp(crate::Timestamp::MIN),
                Datum::MzTimestamp(crate::Timestamp::MAX),
            ])
        });
        static RANGE: LazyLock<Row> = LazyLock::new(|| Row::pack_slice(&[]));
        static MZACLITEM: LazyLock<Row> = LazyLock::new(|| {
            Row::pack_slice(&[
                Datum::MzAclItem(MzAclItem {
                    grantee: RoleId::Public,
                    grantor: RoleId::Public,
                    acl_mode: AclMode::empty(),
                }),
                Datum::MzAclItem(MzAclItem {
                    grantee: RoleId::Public,
                    grantor: RoleId::Public,
                    acl_mode: AclMode::all(),
                }),
                Datum::MzAclItem(MzAclItem {
                    grantee: RoleId::User(42),
                    grantor: RoleId::Public,
                    acl_mode: AclMode::empty(),
                }),
                Datum::MzAclItem(MzAclItem {
                    grantee: RoleId::User(42),
                    grantor: RoleId::Public,
                    acl_mode: AclMode::all(),
                }),
                Datum::MzAclItem(MzAclItem {
                    grantee: RoleId::Public,
                    grantor: RoleId::User(42),
                    acl_mode: AclMode::empty(),
                }),
                Datum::MzAclItem(MzAclItem {
                    grantee: RoleId::Public,
                    grantor: RoleId::User(42),
                    acl_mode: AclMode::all(),
                }),
            ])
        });
        // aclitem has no binary encoding so we can't test it here.
        static ACLITEM: LazyLock<Row> = LazyLock::new(|| Row::pack_slice(&[]));

        let iter: Box<dyn Iterator<Item = Datum<'static>>> = match self {
            SqlScalarType::Bool => Box::new((*BOOL).iter()),
            SqlScalarType::Int16 => Box::new((*INT16).iter()),
            SqlScalarType::Int32 => Box::new((*INT32).iter()),
            SqlScalarType::Int64 => Box::new((*INT64).iter()),
            SqlScalarType::UInt16 => Box::new((*UINT16).iter()),
            SqlScalarType::UInt32 => Box::new((*UINT32).iter()),
            SqlScalarType::UInt64 => Box::new((*UINT64).iter()),
            SqlScalarType::Float32 => Box::new((*FLOAT32).iter()),
            SqlScalarType::Float64 => Box::new((*FLOAT64).iter()),
            SqlScalarType::Numeric { .. } => Box::new((*NUMERIC).iter()),
            SqlScalarType::Date => Box::new((*DATE).iter()),
            SqlScalarType::Time => Box::new((*TIME).iter()),
            SqlScalarType::Timestamp { .. } => Box::new((*TIMESTAMP).iter()),
            SqlScalarType::TimestampTz { .. } => Box::new((*TIMESTAMPTZ).iter()),
            SqlScalarType::Interval => Box::new((*INTERVAL).iter()),
            SqlScalarType::PgLegacyChar => Box::new((*PGLEGACYCHAR).iter()),
            SqlScalarType::PgLegacyName => Box::new((*PGLEGACYNAME).iter()),
            SqlScalarType::Bytes => Box::new((*BYTES).iter()),
            SqlScalarType::String => Box::new((*STRING).iter().chain((*CHAR).iter())),
            SqlScalarType::Char { .. } => Box::new((*CHAR).iter()),
            SqlScalarType::VarChar { .. } => Box::new((*STRING).iter().chain((*CHAR).iter())),
            SqlScalarType::Jsonb => Box::new((*JSONB).iter()),
            SqlScalarType::Uuid => Box::new((*UUID).iter()),
            SqlScalarType::Array(inner_type) => {
                if matches!(inner_type.as_ref(), SqlScalarType::Array(_)) {
                    panic!("SqlScalarType::Array cannot have a nested Array");
                }

                Box::new(
                    (*ARRAY)
                        .get(inner_type.as_ref())
                        .unwrap_or(&*EMPTY_ARRAY)
                        .iter(),
                )
            }
            SqlScalarType::List { .. } => Box::new((*LIST).iter()),
            SqlScalarType::Record { .. } => Box::new((*RECORD).iter()),
            SqlScalarType::Oid => Box::new((*OID).iter()),
            SqlScalarType::Map { .. } => Box::new((*MAP).iter()),
            SqlScalarType::RegProc => Box::new((*OID).iter()),
            SqlScalarType::RegType => Box::new((*OID).iter()),
            SqlScalarType::RegClass => Box::new((*OID).iter()),
            SqlScalarType::Int2Vector => Box::new((*INT2VECTOR).iter()),
            SqlScalarType::MzTimestamp => Box::new((*MZTIMESTAMP).iter()),
            SqlScalarType::Range { .. } => Box::new((*RANGE).iter()),
            SqlScalarType::MzAclItem { .. } => Box::new((*MZACLITEM).iter()),
            SqlScalarType::AclItem { .. } => Box::new((*ACLITEM).iter()),
        };

        iter
    }

    /// Returns all non-parameterized types and some versions of some
    /// parameterized types.
    pub fn enumerate() -> &'static [Self] {
        // TODO: Is there a compile-time way to make sure any new
        // non-parameterized types get added here?
        &[
            SqlScalarType::Bool,
            SqlScalarType::Int16,
            SqlScalarType::Int32,
            SqlScalarType::Int64,
            SqlScalarType::UInt16,
            SqlScalarType::UInt32,
            SqlScalarType::UInt64,
            SqlScalarType::Float32,
            SqlScalarType::Float64,
            SqlScalarType::Numeric {
                max_scale: Some(NumericMaxScale(
                    crate::adt::numeric::NUMERIC_DATUM_MAX_PRECISION,
                )),
            },
            SqlScalarType::Date,
            SqlScalarType::Time,
            SqlScalarType::Timestamp {
                precision: Some(TimestampPrecision(crate::adt::timestamp::MAX_PRECISION)),
            },
            SqlScalarType::Timestamp {
                precision: Some(TimestampPrecision(0)),
            },
            SqlScalarType::Timestamp { precision: None },
            SqlScalarType::TimestampTz {
                precision: Some(TimestampPrecision(crate::adt::timestamp::MAX_PRECISION)),
            },
            SqlScalarType::TimestampTz {
                precision: Some(TimestampPrecision(0)),
            },
            SqlScalarType::TimestampTz { precision: None },
            SqlScalarType::Interval,
            SqlScalarType::PgLegacyChar,
            SqlScalarType::Bytes,
            SqlScalarType::String,
            SqlScalarType::Char {
                length: Some(CharLength(1)),
            },
            SqlScalarType::VarChar { max_length: None },
            SqlScalarType::Jsonb,
            SqlScalarType::Uuid,
            SqlScalarType::Oid,
            SqlScalarType::RegProc,
            SqlScalarType::RegType,
            SqlScalarType::RegClass,
            SqlScalarType::Int2Vector,
            SqlScalarType::MzTimestamp,
            SqlScalarType::MzAclItem,
            // TODO: Fill in some variants of these.
            /*
            SqlScalarType::AclItem,
            SqlScalarType::Array(_),
            SqlScalarType::List {
                element_type: todo!(),
                custom_id: todo!(),
            },
            SqlScalarType::Record {
                fields: todo!(),
                custom_id: todo!(),
            },
            SqlScalarType::Map {
                value_type: todo!(),
                custom_id: todo!(),
            },
            SqlScalarType::Range {
                element_type: todo!(),
            }
            */
        ]
    }

    /// Returns the appropriate element type for making a [`SqlScalarType::Array`] whose elements are
    /// of `self`.
    ///
    /// If the type is not compatible with making an array, returns in the error position.
    pub fn array_of_self_elem_type(self) -> Result<SqlScalarType, SqlScalarType> {
        match self {
            t @ (SqlScalarType::AclItem
            | SqlScalarType::Bool
            | SqlScalarType::Int16
            | SqlScalarType::Int32
            | SqlScalarType::Int64
            | SqlScalarType::UInt16
            | SqlScalarType::UInt32
            | SqlScalarType::UInt64
            | SqlScalarType::Float32
            | SqlScalarType::Float64
            | SqlScalarType::Numeric { .. }
            | SqlScalarType::Date
            | SqlScalarType::Time
            | SqlScalarType::Timestamp { .. }
            | SqlScalarType::TimestampTz { .. }
            | SqlScalarType::Interval
            | SqlScalarType::PgLegacyChar
            | SqlScalarType::PgLegacyName
            | SqlScalarType::Bytes
            | SqlScalarType::String
            | SqlScalarType::VarChar { .. }
            | SqlScalarType::Jsonb
            | SqlScalarType::Uuid
            | SqlScalarType::Record { .. }
            | SqlScalarType::Oid
            | SqlScalarType::RegProc
            | SqlScalarType::RegType
            | SqlScalarType::RegClass
            | SqlScalarType::Int2Vector
            | SqlScalarType::MzTimestamp
            | SqlScalarType::Range { .. }
            | SqlScalarType::MzAclItem { .. }) => Ok(t),

            SqlScalarType::Array(elem) => Ok(elem.array_of_self_elem_type()?),

            // https://github.com/MaterializeInc/database-issues/issues/2360
            t @ (SqlScalarType::Char { .. }
            // not sensible to put in arrays
            | SqlScalarType::Map { .. }
            | SqlScalarType::List { .. }) => Err(t),
        }
    }
}

// See the chapter "Generating Recurisve Data" from the proptest book:
// https://altsysrq.github.io/proptest-book/proptest/tutorial/recursive.html
#[cfg(any(test, feature = "proptest"))]
impl Arbitrary for SqlScalarType {
    type Parameters = ();
    type Strategy = BoxedStrategy<SqlScalarType>;

    fn arbitrary_with(_: Self::Parameters) -> Self::Strategy {
        // A strategy for generating the leaf cases of SqlScalarType
        let leaf = Union::new(vec![
            Just(SqlScalarType::Bool).boxed(),
            Just(SqlScalarType::UInt16).boxed(),
            Just(SqlScalarType::UInt32).boxed(),
            Just(SqlScalarType::UInt64).boxed(),
            Just(SqlScalarType::Int16).boxed(),
            Just(SqlScalarType::Int32).boxed(),
            Just(SqlScalarType::Int64).boxed(),
            Just(SqlScalarType::Float32).boxed(),
            Just(SqlScalarType::Float64).boxed(),
            any::<Option<NumericMaxScale>>()
                .prop_map(|max_scale| SqlScalarType::Numeric { max_scale })
                .boxed(),
            Just(SqlScalarType::Date).boxed(),
            Just(SqlScalarType::Time).boxed(),
            any::<Option<TimestampPrecision>>()
                .prop_map(|precision| SqlScalarType::Timestamp { precision })
                .boxed(),
            any::<Option<TimestampPrecision>>()
                .prop_map(|precision| SqlScalarType::TimestampTz { precision })
                .boxed(),
            Just(SqlScalarType::MzTimestamp).boxed(),
            Just(SqlScalarType::Interval).boxed(),
            Just(SqlScalarType::PgLegacyChar).boxed(),
            Just(SqlScalarType::Bytes).boxed(),
            Just(SqlScalarType::String).boxed(),
            any::<Option<CharLength>>()
                .prop_map(|length| SqlScalarType::Char { length })
                .boxed(),
            any::<Option<VarCharMaxLength>>()
                .prop_map(|max_length| SqlScalarType::VarChar { max_length })
                .boxed(),
            Just(SqlScalarType::PgLegacyName).boxed(),
            Just(SqlScalarType::Jsonb).boxed(),
            Just(SqlScalarType::Uuid).boxed(),
            Just(SqlScalarType::AclItem).boxed(),
            Just(SqlScalarType::MzAclItem).boxed(),
            Just(SqlScalarType::Oid).boxed(),
            Just(SqlScalarType::RegProc).boxed(),
            Just(SqlScalarType::RegType).boxed(),
            Just(SqlScalarType::RegClass).boxed(),
            Just(SqlScalarType::Int2Vector).boxed(),
        ])
        // None of the leaf SqlScalarTypes types are really "simpler" than others
        // so don't waste time trying to shrink.
        .no_shrink()
        .boxed();

        // There are a limited set of types we support in ranges.
        let range_leaf = Union::new(vec![
            Just(SqlScalarType::Int32).boxed(),
            Just(SqlScalarType::Int64).boxed(),
            Just(SqlScalarType::Date).boxed(),
            any::<Option<NumericMaxScale>>()
                .prop_map(|max_scale| SqlScalarType::Numeric { max_scale })
                .boxed(),
            any::<Option<TimestampPrecision>>()
                .prop_map(|precision| SqlScalarType::Timestamp { precision })
                .boxed(),
            any::<Option<TimestampPrecision>>()
                .prop_map(|precision| SqlScalarType::TimestampTz { precision })
                .boxed(),
        ]);
        let range = range_leaf
            .prop_map(|inner_type| SqlScalarType::Range {
                element_type: Box::new(inner_type),
            })
            .boxed();

        // The Array type is not recursive, so we define it separately.
        let array = leaf
            .clone()
            .prop_map(|inner_type| SqlScalarType::Array(Box::new(inner_type)))
            .boxed();

        let leaf = Union::new_weighted(vec![(30, leaf), (1, array), (1, range)]);

        leaf.prop_recursive(2, 3, 5, |inner| {
            Union::new(vec![
                // List
                (inner.clone(), any::<Option<CatalogItemId>>())
                    .prop_map(|(x, id)| SqlScalarType::List {
                        element_type: Box::new(x),
                        custom_id: id,
                    })
                    .boxed(),
                // Map
                (inner.clone(), any::<Option<CatalogItemId>>())
                    .prop_map(|(x, id)| SqlScalarType::Map {
                        value_type: Box::new(x),
                        custom_id: id,
                    })
                    .boxed(),
                // Record
                {
                    // Now we have to use `inner` to create a Record type. First we
                    // create strategy that creates SqlColumnType.
                    let column_type_strat =
                        (inner, any::<bool>()).prop_map(|(scalar_type, nullable)| SqlColumnType {
                            scalar_type,
                            nullable,
                        });

                    // Then we use that to create the fields of the record case.
                    // fields has type vec<(ColumnName,SqlColumnType)>
                    let fields_strat =
                        prop::collection::vec((any::<ColumnName>(), column_type_strat), 0..10);

                    // Now we combine it with the default strategies to get Records.
                    (fields_strat, any::<Option<CatalogItemId>>())
                        .prop_map(|(fields, custom_id)| SqlScalarType::Record {
                            fields: fields.into(),
                            custom_id,
                        })
                        .boxed()
                },
            ])
        })
        .boxed()
    }
}

#[cfg(any(test, feature = "proptest"))]
impl Arbitrary for ReprScalarType {
    type Parameters = ();
    type Strategy = BoxedStrategy<ReprScalarType>;

    fn arbitrary_with(_: Self::Parameters) -> Self::Strategy {
        // A strategy for generating the leaf cases of ReprScalarType
        let leaf = Union::new(vec![
            Just(ReprScalarType::Bool).boxed(),
            Just(ReprScalarType::UInt8).boxed(),
            Just(ReprScalarType::UInt16).boxed(),
            Just(ReprScalarType::UInt32).boxed(),
            Just(ReprScalarType::UInt64).boxed(),
            Just(ReprScalarType::Int16).boxed(),
            Just(ReprScalarType::Int32).boxed(),
            Just(ReprScalarType::Int64).boxed(),
            Just(ReprScalarType::Float32).boxed(),
            Just(ReprScalarType::Float64).boxed(),
            Just(ReprScalarType::Numeric).boxed(),
            Just(ReprScalarType::Date).boxed(),
            Just(ReprScalarType::Time).boxed(),
            Just(ReprScalarType::Timestamp).boxed(),
            Just(ReprScalarType::TimestampTz).boxed(),
            Just(ReprScalarType::MzTimestamp).boxed(),
            Just(ReprScalarType::Interval).boxed(),
            Just(ReprScalarType::Bytes).boxed(),
            Just(ReprScalarType::String).boxed(),
            Just(ReprScalarType::Jsonb).boxed(),
            Just(ReprScalarType::Uuid).boxed(),
            Just(ReprScalarType::AclItem).boxed(),
            Just(ReprScalarType::MzAclItem).boxed(),
            Just(ReprScalarType::Int2Vector).boxed(),
        ])
        // None of the leaf ReprScalarTypes types are really "simpler" than others
        // so don't waste time trying to shrink.
        .no_shrink()
        .boxed();

        // There are a limited set of types we support in ranges.
        let range_leaf = Union::new(vec![
            Just(ReprScalarType::Int32).boxed(),
            Just(ReprScalarType::Int64).boxed(),
            Just(ReprScalarType::Date).boxed(),
            Just(ReprScalarType::Numeric).boxed(),
            Just(ReprScalarType::Timestamp).boxed(),
            Just(ReprScalarType::TimestampTz).boxed(),
        ]);
        let range = range_leaf
            .prop_map(|inner_type| ReprScalarType::Range {
                element_type: Box::new(inner_type),
            })
            .boxed();

        // The Array type is not recursive, so we define it separately.
        let array = leaf
            .clone()
            .prop_map(|inner_type| ReprScalarType::Array(Box::new(inner_type)))
            .boxed();

        let leaf = Union::new_weighted(vec![(30, leaf), (1, array), (1, range)]);

        leaf.prop_recursive(2, 3, 5, |inner| {
            Union::new(vec![
                // List
                inner
                    .clone()
                    .prop_map(|x| ReprScalarType::List {
                        element_type: Box::new(x),
                    })
                    .boxed(),
                // Map
                inner
                    .clone()
                    .prop_map(|x| ReprScalarType::Map {
                        value_type: Box::new(x),
                    })
                    .boxed(),
                // Record
                {
                    // Now we have to use `inner` to create a Record type. First we
                    // create strategy that creates SqlColumnType.
                    let column_type_strat =
                        (inner.clone(), any::<bool>()).prop_map(|(scalar_type, nullable)| {
                            ReprColumnType {
                                scalar_type,
                                nullable,
                            }
                        });

                    // Then we use that to create the fields of the record case.
                    // fields has type vec<(ColumnName,SqlColumnType)>
                    let fields_strat = prop::collection::vec(column_type_strat, 0..10);

                    // Now we combine it with the default strategies to get Records.
                    fields_strat
                        .prop_map(|fields| ReprScalarType::Record {
                            fields: fields.into_boxed_slice(),
                        })
                        .boxed()
                },
            ])
        })
        .boxed()
    }
}

/// The type of a [`Datum`] as it is represented.
///
/// Each variant here corresponds to one or more variants of [`SqlScalarType`].
///
/// There is a direct correspondence between `Datum` variants and `ReprScalarType`
/// variants: every `Datum` variant corresponds to exactly one `ReprScalarType` variant
/// (with an exception for `Datum::Array`, which could be both an `Int2Vector` and an `Array`).
///
/// It is important that any new variants for this enum be added to the `Arbitrary` instance
/// and the `union` method.
#[derive(Clone, Debug, EnumKind, Serialize, Deserialize)]
#[enum_kind(ReprScalarBaseType, derive(PartialOrd, Ord, Hash))]
pub enum ReprScalarType {
    Bool,
    Int16,
    Int32,
    Int64,
    UInt8, // also includes SqlScalarType::PgLegacyChar
    UInt16,
    UInt32, // also includes SqlScalarType::{Oid,RegClass,RegProc,RegType}
    UInt64,
    Float32,
    Float64,
    Numeric,
    Date,
    Time,
    Timestamp,
    TimestampTz,
    MzTimestamp,
    Interval,
    Bytes,
    Jsonb,
    String, // also includes SqlScalarType::{VarChar,Char,PgLegacyName}
    Uuid,
    Array(Box<ReprScalarType>),
    Int2Vector, // See [`Int2Vector`] for why this is separate from `Array`.
    List { element_type: Box<ReprScalarType> },
    Record { fields: Box<[ReprColumnType]> },
    Map { value_type: Box<ReprScalarType> },
    Range { element_type: Box<ReprScalarType> },
    MzAclItem,
    AclItem,
}

impl PartialEq for ReprScalarType {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (ReprScalarType::Array(a), ReprScalarType::Array(b)) => a.eq(b),
            (
                ReprScalarType::List { element_type: a },
                ReprScalarType::List { element_type: b },
            ) => a.eq(b),
            (ReprScalarType::Record { fields: a }, ReprScalarType::Record { fields: b }) => {
                a.len() == b.len()
                    && a.iter()
                        .zip_eq(b.iter())
                        .all(|(af, bf)| af.scalar_type.eq(&bf.scalar_type))
            }
            (ReprScalarType::Map { value_type: a }, ReprScalarType::Map { value_type: b }) => {
                a.eq(b)
            }
            (
                ReprScalarType::Range { element_type: a },
                ReprScalarType::Range { element_type: b },
            ) => a.eq(b),
            _ => ReprScalarBaseType::from(self) == ReprScalarBaseType::from(other),
        }
    }
}
impl Eq for ReprScalarType {}

impl Hash for ReprScalarType {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        match self {
            ReprScalarType::Array(a) => a.hash(state),
            ReprScalarType::List { element_type: a } => a.hash(state),
            ReprScalarType::Record { fields: a } => {
                for field in a {
                    field.scalar_type.hash(state);
                }
            }
            ReprScalarType::Map { value_type: a } => a.hash(state),
            ReprScalarType::Range { element_type: a } => a.hash(state),
            _ => ReprScalarBaseType::from(self).hash(state),
        }
    }
}

impl PartialOrd for ReprScalarType {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for ReprScalarType {
    fn cmp(&self, other: &Self) -> Ordering {
        match (self, other) {
            (ReprScalarType::Array(a), ReprScalarType::Array(b)) => a.cmp(b),
            (
                ReprScalarType::List { element_type: a },
                ReprScalarType::List { element_type: b },
            ) => a.cmp(b),
            (ReprScalarType::Record { fields: a }, ReprScalarType::Record { fields: b }) => {
                let len_ordering = a.len().cmp(&b.len());
                if len_ordering != Ordering::Equal {
                    return len_ordering;
                }

                // NB ignoring nullability
                for (af, bf) in a.iter().zip_eq(b.iter()) {
                    let scalar_type_ordering = af.scalar_type.cmp(&bf.scalar_type);
                    if scalar_type_ordering != Ordering::Equal {
                        return scalar_type_ordering;
                    }
                }

                Ordering::Equal
            }
            (ReprScalarType::Map { value_type: a }, ReprScalarType::Map { value_type: b }) => {
                a.cmp(b)
            }
            (
                ReprScalarType::Range { element_type: a },
                ReprScalarType::Range { element_type: b },
            ) => a.cmp(b),
            _ => ReprScalarBaseType::from(self).cmp(&ReprScalarBaseType::from(other)),
        }
    }
}

impl std::fmt::Display for ReprScalarType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ReprScalarType::Bool => write!(f, "r_bool"),
            ReprScalarType::Int16 => write!(f, "r_int16"),
            ReprScalarType::Int32 => write!(f, "r_int32"),
            ReprScalarType::Int64 => write!(f, "r_int64"),
            ReprScalarType::UInt8 => write!(f, "r_uint8"),
            ReprScalarType::UInt16 => write!(f, "r_uint16"),
            ReprScalarType::UInt32 => write!(f, "r_uint32"),
            ReprScalarType::UInt64 => write!(f, "r_uint64"),
            ReprScalarType::Float32 => write!(f, "r_float32"),
            ReprScalarType::Float64 => write!(f, "r_float64"),
            ReprScalarType::Numeric => write!(f, "r_numeric"),
            ReprScalarType::Date => write!(f, "r_date"),
            ReprScalarType::Time => write!(f, "r_time"),
            ReprScalarType::Timestamp => write!(f, "r_timestamp"),
            ReprScalarType::TimestampTz => write!(f, "r_timestamptz"),
            ReprScalarType::MzTimestamp => write!(f, "r_mz_timestamp"),
            ReprScalarType::Interval => write!(f, "r_interval"),
            ReprScalarType::Bytes => write!(f, "r_bytes"),
            ReprScalarType::Jsonb => write!(f, "r_jsonb"),
            ReprScalarType::String => write!(f, "r_string"),
            ReprScalarType::Uuid => write!(f, "r_uuid"),
            ReprScalarType::Array(element_type) => write!(f, "r_array({element_type})"),
            ReprScalarType::Int2Vector => write!(f, "r_int2vector"),
            ReprScalarType::List { element_type } => write!(f, "r_list({element_type})"),
            ReprScalarType::Record { fields } => {
                let fields = separated(", ", fields.iter());
                write!(f, "r_record({fields})")
            }
            ReprScalarType::Map { value_type } => write!(f, "r_map({value_type})"),
            ReprScalarType::Range { element_type } => write!(f, "r_range({element_type})"),
            ReprScalarType::MzAclItem => write!(f, "r_mz_acl_item"),
            ReprScalarType::AclItem => write!(f, "r_acl_item"),
        }
    }
}

impl ReprScalarType {
    /// Returns a [`ReprColumnType`] with the given nullability.
    pub fn nullable(self, nullable: bool) -> ReprColumnType {
        ReprColumnType {
            scalar_type: self,
            nullable,
        }
    }

    /// Returns the union of two `ReprScalarType` or an error.
    ///
    /// Errors can only occur if the two types are built somewhere using different constructors.
    /// Note that `ReprScalarType::Record` holds a `ReprColumnType`, and so nullability information
    /// is unioned.
    pub fn union(&self, scalar_type: &ReprScalarType) -> Result<Self, anyhow::Error> {
        match (self, scalar_type) {
            (ReprScalarType::Bool, ReprScalarType::Bool) => Ok(ReprScalarType::Bool),
            (ReprScalarType::Int16, ReprScalarType::Int16) => Ok(ReprScalarType::Int16),
            (ReprScalarType::Int32, ReprScalarType::Int32) => Ok(ReprScalarType::Int32),
            (ReprScalarType::Int64, ReprScalarType::Int64) => Ok(ReprScalarType::Int64),
            (ReprScalarType::UInt8, ReprScalarType::UInt8) => Ok(ReprScalarType::UInt8),
            (ReprScalarType::UInt16, ReprScalarType::UInt16) => Ok(ReprScalarType::UInt16),
            (ReprScalarType::UInt32, ReprScalarType::UInt32) => Ok(ReprScalarType::UInt32),
            (ReprScalarType::UInt64, ReprScalarType::UInt64) => Ok(ReprScalarType::UInt64),
            (ReprScalarType::Float32, ReprScalarType::Float32) => Ok(ReprScalarType::Float32),
            (ReprScalarType::Float64, ReprScalarType::Float64) => Ok(ReprScalarType::Float64),
            (ReprScalarType::Numeric, ReprScalarType::Numeric) => Ok(ReprScalarType::Numeric),
            (ReprScalarType::Date, ReprScalarType::Date) => Ok(ReprScalarType::Date),
            (ReprScalarType::Time, ReprScalarType::Time) => Ok(ReprScalarType::Time),
            (ReprScalarType::Timestamp, ReprScalarType::Timestamp) => Ok(ReprScalarType::Timestamp),
            (ReprScalarType::TimestampTz, ReprScalarType::TimestampTz) => {
                Ok(ReprScalarType::TimestampTz)
            }
            (ReprScalarType::MzTimestamp, ReprScalarType::MzTimestamp) => {
                Ok(ReprScalarType::MzTimestamp)
            }
            (ReprScalarType::AclItem, ReprScalarType::AclItem) => Ok(ReprScalarType::AclItem),
            (ReprScalarType::MzAclItem, ReprScalarType::MzAclItem) => Ok(ReprScalarType::MzAclItem),
            (ReprScalarType::Interval, ReprScalarType::Interval) => Ok(ReprScalarType::Interval),
            (ReprScalarType::Bytes, ReprScalarType::Bytes) => Ok(ReprScalarType::Bytes),
            (ReprScalarType::Jsonb, ReprScalarType::Jsonb) => Ok(ReprScalarType::Jsonb),
            (ReprScalarType::String, ReprScalarType::String) => Ok(ReprScalarType::String),
            (ReprScalarType::Uuid, ReprScalarType::Uuid) => Ok(ReprScalarType::Uuid),
            (ReprScalarType::Array(element_type), ReprScalarType::Array(other_element_type)) => Ok(
                ReprScalarType::Array(Box::new(element_type.union(other_element_type)?)),
            ),
            (ReprScalarType::Int2Vector, ReprScalarType::Int2Vector) => {
                Ok(ReprScalarType::Int2Vector)
            }
            (
                ReprScalarType::List { element_type },
                ReprScalarType::List {
                    element_type: other_element_type,
                },
            ) => Ok(ReprScalarType::List {
                element_type: Box::new(element_type.union(other_element_type)?),
            }),
            (
                ReprScalarType::Record { fields },
                ReprScalarType::Record {
                    fields: other_fields,
                },
            ) => {
                if fields.len() != other_fields.len() {
                    bail!("Can't union record types: {:?} and {:?}", self, scalar_type);
                }

                let mut union_fields = Vec::with_capacity(fields.len());
                for (field, other_field) in fields.iter().zip_eq(other_fields.iter()) {
                    union_fields.push(field.union(other_field)?);
                }
                Ok(ReprScalarType::Record {
                    fields: union_fields.into_boxed_slice(),
                })
            }
            (
                ReprScalarType::Map { value_type },
                ReprScalarType::Map {
                    value_type: other_value_type,
                },
            ) => Ok(ReprScalarType::Map {
                value_type: Box::new(value_type.union(other_value_type)?),
            }),
            (
                ReprScalarType::Range { element_type },
                ReprScalarType::Range {
                    element_type: other_element_type,
                },
            ) => Ok(ReprScalarType::Range {
                element_type: Box::new(element_type.union(other_element_type)?),
            }),
            (_, _) => bail!("Can't union scalar types: {:?} and {:?}", self, scalar_type),
        }
    }

    /// Returns the [`ReprScalarType`] of elements in a [`ReprScalarType::List`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`ReprScalarType::List`].
    pub fn unwrap_list_element_type(&self) -> &ReprScalarType {
        match self {
            ReprScalarType::List { element_type, .. } => element_type,
            _ => panic!(
                "ReprScalarType::unwrap_list_element_type called on {:?}",
                self
            ),
        }
    }

    /// Returns a vector of [`ReprScalarType`] elements in a [`ReprScalarType::Record`].
    ///
    /// # Panics
    ///
    /// Panics if called on anything other than a [`ReprScalarType::Record`].
    pub fn unwrap_record_element_type(&self) -> Vec<&ReprScalarType> {
        match self {
            ReprScalarType::Record { fields, .. } => {
                fields.iter().map(|t| &t.scalar_type).collect_vec()
            }
            _ => panic!(
                "SqlScalarType::unwrap_record_element_type called on {:?}",
                self
            ),
        }
    }
}

impl From<&SqlScalarType> for ReprScalarType {
    fn from(typ: &SqlScalarType) -> Self {
        match typ {
            SqlScalarType::Bool => ReprScalarType::Bool,
            SqlScalarType::Int16 => ReprScalarType::Int16,
            SqlScalarType::Int32 => ReprScalarType::Int32,
            SqlScalarType::Int64 => ReprScalarType::Int64,
            SqlScalarType::UInt16 => ReprScalarType::UInt16,
            SqlScalarType::UInt32 => ReprScalarType::UInt32,
            SqlScalarType::UInt64 => ReprScalarType::UInt64,
            SqlScalarType::Float32 => ReprScalarType::Float32,
            SqlScalarType::Float64 => ReprScalarType::Float64,
            SqlScalarType::Numeric { max_scale: _ } => ReprScalarType::Numeric,
            SqlScalarType::Date => ReprScalarType::Date,
            SqlScalarType::Time => ReprScalarType::Time,
            SqlScalarType::Timestamp { precision: _ } => ReprScalarType::Timestamp,
            SqlScalarType::TimestampTz { precision: _ } => ReprScalarType::TimestampTz,
            SqlScalarType::Interval => ReprScalarType::Interval,
            SqlScalarType::PgLegacyChar => ReprScalarType::UInt8,
            SqlScalarType::PgLegacyName => ReprScalarType::String,
            SqlScalarType::Bytes => ReprScalarType::Bytes,
            SqlScalarType::String => ReprScalarType::String,
            SqlScalarType::Char { length: _ } => ReprScalarType::String,
            SqlScalarType::VarChar { max_length: _ } => ReprScalarType::String,
            SqlScalarType::Jsonb => ReprScalarType::Jsonb,
            SqlScalarType::Uuid => ReprScalarType::Uuid,
            SqlScalarType::Array(element_type) => {
                ReprScalarType::Array(Box::new(element_type.as_ref().into()))
            }
            SqlScalarType::List {
                element_type,
                custom_id: _,
            } => ReprScalarType::List {
                element_type: Box::new(element_type.as_ref().into()),
            },
            SqlScalarType::Record {
                fields,
                custom_id: _,
            } => ReprScalarType::Record {
                fields: fields.into_iter().map(|(_, typ)| typ.into()).collect(),
            },
            SqlScalarType::Oid => ReprScalarType::UInt32,
            SqlScalarType::Map {
                value_type,
                custom_id: _,
            } => ReprScalarType::Map {
                value_type: Box::new(value_type.as_ref().into()),
            },
            SqlScalarType::RegProc => ReprScalarType::UInt32,
            SqlScalarType::RegType => ReprScalarType::UInt32,
            SqlScalarType::RegClass => ReprScalarType::UInt32,
            SqlScalarType::Int2Vector => ReprScalarType::Int2Vector,
            SqlScalarType::MzTimestamp => ReprScalarType::MzTimestamp,
            SqlScalarType::Range { element_type } => ReprScalarType::Range {
                element_type: Box::new(element_type.as_ref().into()),
            },
            SqlScalarType::MzAclItem => ReprScalarType::MzAclItem,
            SqlScalarType::AclItem => ReprScalarType::AclItem,
        }
    }
}

impl SqlScalarType {
    /// Lossily translates a [`ReprScalarType`] back to a [`SqlScalarType`].
    ///
    /// NB that `ReprScalarType::from` is a left inverse of this function, but
    /// not a right inverse.
    ///
    /// Here is an example: `SqlScalarType::VarChar` maps to `ReprScalarType::String`,
    /// which maps back to `SqlScalarType::String`.
    ///
    /// ```
    /// use mz_repr::{ReprScalarType, SqlScalarType};
    ///
    /// let sql = SqlScalarType::VarChar { max_length: None };
    /// let repr = ReprScalarType::from(&sql);
    /// assert_eq!(repr, ReprScalarType::String);
    ///
    /// let sql_rt = SqlScalarType::from_repr(&repr);
    /// assert_ne!(sql_rt, sql);
    /// assert_eq!(sql_rt, SqlScalarType::String);
    /// ```
    pub fn from_repr(repr: &ReprScalarType) -> Self {
        match repr {
            ReprScalarType::Bool => SqlScalarType::Bool,
            ReprScalarType::Int16 => SqlScalarType::Int16,
            ReprScalarType::Int32 => SqlScalarType::Int32,
            ReprScalarType::Int64 => SqlScalarType::Int64,
            ReprScalarType::UInt8 => SqlScalarType::PgLegacyChar,
            ReprScalarType::UInt16 => SqlScalarType::UInt16,
            ReprScalarType::UInt32 => SqlScalarType::UInt32,
            ReprScalarType::UInt64 => SqlScalarType::UInt64,
            ReprScalarType::Float32 => SqlScalarType::Float32,
            ReprScalarType::Float64 => SqlScalarType::Float64,
            ReprScalarType::Numeric => SqlScalarType::Numeric { max_scale: None },
            ReprScalarType::Date => SqlScalarType::Date,
            ReprScalarType::Time => SqlScalarType::Time,
            ReprScalarType::Timestamp => SqlScalarType::Timestamp { precision: None },
            ReprScalarType::TimestampTz => SqlScalarType::TimestampTz { precision: None },
            ReprScalarType::MzTimestamp => SqlScalarType::MzTimestamp,
            ReprScalarType::Interval => SqlScalarType::Interval,
            ReprScalarType::Bytes => SqlScalarType::Bytes,
            ReprScalarType::Jsonb => SqlScalarType::Jsonb,
            ReprScalarType::String => SqlScalarType::String,
            ReprScalarType::Uuid => SqlScalarType::Uuid,
            ReprScalarType::Array(element_type) => {
                SqlScalarType::Array(Box::new(SqlScalarType::from_repr(element_type)))
            }
            ReprScalarType::Int2Vector => SqlScalarType::Int2Vector,
            ReprScalarType::List { element_type } => SqlScalarType::List {
                element_type: Box::new(SqlScalarType::from_repr(element_type)),
                custom_id: None,
            },
            ReprScalarType::Record { fields } => SqlScalarType::Record {
                fields: fields
                    .iter()
                    .enumerate()
                    .map(|typ| {
                        (
                            ColumnName::from(format!("field_{}", typ.0)),
                            SqlColumnType::from_repr(typ.1),
                        )
                    })
                    .collect::<Vec<_>>()
                    .into_boxed_slice(),
                custom_id: None,
            },
            ReprScalarType::Map { value_type } => SqlScalarType::Map {
                value_type: Box::new(SqlScalarType::from_repr(value_type)),
                custom_id: None,
            },
            ReprScalarType::Range { element_type } => SqlScalarType::Range {
                element_type: Box::new(SqlScalarType::from_repr(element_type)),
            },
            ReprScalarType::MzAclItem => SqlScalarType::MzAclItem,
            ReprScalarType::AclItem => SqlScalarType::AclItem,
        }
    }
}

static EMPTY_ARRAY_ROW: LazyLock<Row> = LazyLock::new(|| {
    let mut row = Row::default();
    row.packer()
        .try_push_array(&[], iter::empty::<Datum>())
        .expect("array known to be valid");
    row
});

static EMPTY_LIST_ROW: LazyLock<Row> = LazyLock::new(|| {
    let mut row = Row::default();
    row.packer().push_list(iter::empty::<Datum>());
    row
});

static EMPTY_MAP_ROW: LazyLock<Row> = LazyLock::new(|| {
    let mut row = Row::default();
    row.packer().push_dict(iter::empty::<(_, Datum)>());
    row
});

impl Datum<'_> {
    pub fn empty_array() -> Datum<'static> {
        EMPTY_ARRAY_ROW.unpack_first()
    }

    pub fn empty_list() -> Datum<'static> {
        EMPTY_LIST_ROW.unpack_first()
    }

    pub fn empty_map() -> Datum<'static> {
        EMPTY_MAP_ROW.unpack_first()
    }

    pub fn contains_dummy(&self) -> bool {
        match self {
            Datum::Dummy => true,
            Datum::List(list) => list.iter().any(|d| d.contains_dummy()),
            Datum::Map(map) => map.iter().any(|(_, d)| d.contains_dummy()),
            Datum::Array(array) => array.elements().iter().any(|d| d.contains_dummy()),
            Datum::Range(range) => range.inner.map_or(false, |range| {
                range
                    .lower
                    .bound
                    .map_or(false, |d| d.datum().contains_dummy())
                    || range
                        .upper
                        .bound
                        .map_or(false, |d| d.datum().contains_dummy())
            }),
            _ => false,
        }
    }
}

/// A mirror type for [`Datum`] that can be proptest-generated.
#[derive(Debug, PartialEq, Clone)]
#[cfg(any(test, feature = "proptest"))]
pub enum PropDatum {
    Null,
    Bool(bool),
    Int16(i16),
    Int32(i32),
    Int64(i64),
    UInt8(u8),
    UInt16(u16),
    UInt32(u32),
    UInt64(u64),
    Float32(f32),
    Float64(f64),

    Date(Date),
    Time(chrono::NaiveTime),
    Timestamp(CheckedTimestamp<chrono::NaiveDateTime>),
    TimestampTz(CheckedTimestamp<chrono::DateTime<chrono::Utc>>),
    MzTimestamp(u64),

    Interval(Interval),
    Numeric(Numeric),

    Bytes(Vec<u8>),
    String(String),

    Array(PropArray),
    List(PropList),
    Map(PropDict),
    Record(PropDict),
    Range(PropRange),

    AclItem(AclItem),
    MzAclItem(MzAclItem),

    JsonNull,
    Uuid(Uuid),
    Dummy,
}

#[cfg(any(test, feature = "proptest"))]
impl std::cmp::Eq for PropDatum {}

#[cfg(any(test, feature = "proptest"))]
impl PartialOrd for PropDatum {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

#[cfg(any(test, feature = "proptest"))]
impl Ord for PropDatum {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        Datum::from(self).cmp(&Datum::from(other))
    }
}

/// Generate an arbitrary [`PropDatum`].
#[cfg(any(test, feature = "proptest"))]
pub fn arb_datum(allow_dummy: bool) -> BoxedStrategy<PropDatum> {
    let mut leaf_options = vec![
        any::<bool>().prop_map(PropDatum::Bool).boxed(),
        any::<i16>().prop_map(PropDatum::Int16).boxed(),
        any::<i32>().prop_map(PropDatum::Int32).boxed(),
        any::<i64>().prop_map(PropDatum::Int64).boxed(),
        any::<u16>().prop_map(PropDatum::UInt16).boxed(),
        any::<u32>().prop_map(PropDatum::UInt32).boxed(),
        any::<u64>().prop_map(PropDatum::UInt64).boxed(),
        any::<f32>().prop_map(PropDatum::Float32).boxed(),
        any::<f64>().prop_map(PropDatum::Float64).boxed(),
        arb_date().prop_map(PropDatum::Date).boxed(),
        add_arb_duration(chrono::NaiveTime::from_hms_opt(0, 0, 0).unwrap())
            .prop_map(PropDatum::Time)
            .boxed(),
        arb_naive_date_time()
            .prop_map(|t| PropDatum::Timestamp(CheckedTimestamp::from_timestamplike(t).unwrap()))
            .boxed(),
        arb_utc_date_time()
            .prop_map(|t| PropDatum::TimestampTz(CheckedTimestamp::from_timestamplike(t).unwrap()))
            .boxed(),
        any::<Interval>().prop_map(PropDatum::Interval).boxed(),
        arb_numeric().prop_map(PropDatum::Numeric).boxed(),
        prop::collection::vec(any::<u8>(), 1024)
            .prop_map(PropDatum::Bytes)
            .boxed(),
        ".*".prop_map(PropDatum::String).boxed(),
        Just(PropDatum::JsonNull).boxed(),
        any::<[u8; 16]>()
            .prop_map(|x| PropDatum::Uuid(Uuid::from_bytes(x)))
            .boxed(),
        arb_range(arb_range_data())
            .prop_map(PropDatum::Range)
            .boxed(),
    ];

    if allow_dummy {
        leaf_options.push(Just(PropDatum::Dummy).boxed());
    }
    let leaf = Union::new(leaf_options);

    leaf.prop_recursive(3, 8, 16, |inner| {
        Union::new(vec![
            arb_array(inner.clone()).prop_map(PropDatum::Array).boxed(),
            arb_list(inner.clone()).prop_map(PropDatum::List).boxed(),
            arb_dict(inner).prop_map(PropDatum::Map).boxed(),
        ])
    })
    .boxed()
}

/// Generates an arbitrary [`PropDatum`] for the provided [`SqlColumnType`].
#[cfg(any(test, feature = "proptest"))]
pub fn arb_datum_for_column(column_type: SqlColumnType) -> impl Strategy<Value = PropDatum> {
    let strat = arb_datum_for_scalar(column_type.scalar_type);

    if column_type.nullable {
        Union::new_weighted(vec![(1, Just(PropDatum::Null).boxed()), (5, strat.boxed())]).boxed()
    } else {
        strat.boxed()
    }
}

/// Generates an arbitrary [`PropDatum`] for the provided [`SqlScalarType`].
#[cfg(any(test, feature = "proptest"))]
pub fn arb_datum_for_scalar(scalar_type: SqlScalarType) -> impl Strategy<Value = PropDatum> {
    match scalar_type {
        SqlScalarType::Bool => any::<bool>().prop_map(PropDatum::Bool).boxed(),
        SqlScalarType::Int16 => any::<i16>().prop_map(PropDatum::Int16).boxed(),
        SqlScalarType::Int32 => any::<i32>().prop_map(PropDatum::Int32).boxed(),
        SqlScalarType::Int64 => any::<i64>().prop_map(PropDatum::Int64).boxed(),
        SqlScalarType::PgLegacyChar => any::<u8>().prop_map(PropDatum::UInt8).boxed(),
        SqlScalarType::UInt16 => any::<u16>().prop_map(PropDatum::UInt16).boxed(),
        SqlScalarType::UInt32
        | SqlScalarType::Oid
        | SqlScalarType::RegClass
        | SqlScalarType::RegProc
        | SqlScalarType::RegType => any::<u32>().prop_map(PropDatum::UInt32).boxed(),
        SqlScalarType::UInt64 => any::<u64>().prop_map(PropDatum::UInt64).boxed(),
        SqlScalarType::Float32 => any::<f32>().prop_map(PropDatum::Float32).boxed(),
        SqlScalarType::Float64 => any::<f64>().prop_map(PropDatum::Float64).boxed(),
        SqlScalarType::Numeric { .. } => arb_numeric().prop_map(PropDatum::Numeric).boxed(),
        SqlScalarType::String
        | SqlScalarType::PgLegacyName
        | SqlScalarType::Char { length: None }
        | SqlScalarType::VarChar { max_length: None } => ".*".prop_map(PropDatum::String).boxed(),
        SqlScalarType::Char {
            length: Some(length),
        } => {
            let max_len = usize::cast_from(length.into_u32()).max(1);
            prop::collection::vec(any::<char>(), 0..max_len)
                .prop_map(move |chars| {
                    // `Char`s are fixed sized strings padded with blanks.
                    let num_blanks = max_len - chars.len();
                    let s = chars
                        .into_iter()
                        .chain(std::iter::repeat(' ').take(num_blanks))
                        .collect();
                    PropDatum::String(s)
                })
                .boxed()
        }
        SqlScalarType::VarChar {
            max_length: Some(length),
        } => {
            let max_len = usize::cast_from(length.into_u32()).max(1);
            prop::collection::vec(any::<char>(), 0..max_len)
                .prop_map(|chars| PropDatum::String(chars.into_iter().collect()))
                .boxed()
        }
        SqlScalarType::Bytes => prop::collection::vec(any::<u8>(), 300)
            .prop_map(PropDatum::Bytes)
            .boxed(),
        SqlScalarType::Date => arb_date().prop_map(PropDatum::Date).boxed(),
        SqlScalarType::Time => add_arb_duration(chrono::NaiveTime::from_hms_opt(0, 0, 0).unwrap())
            .prop_map(PropDatum::Time)
            .boxed(),
        SqlScalarType::Timestamp { .. } => arb_naive_date_time()
            .prop_map(|t| PropDatum::Timestamp(CheckedTimestamp::from_timestamplike(t).unwrap()))
            .boxed(),
        SqlScalarType::TimestampTz { .. } => arb_utc_date_time()
            .prop_map(|t| PropDatum::TimestampTz(CheckedTimestamp::from_timestamplike(t).unwrap()))
            .boxed(),
        SqlScalarType::MzTimestamp => any::<u64>().prop_map(PropDatum::MzTimestamp).boxed(),
        SqlScalarType::Interval => any::<Interval>().prop_map(PropDatum::Interval).boxed(),
        SqlScalarType::Uuid => any::<[u8; 16]>()
            .prop_map(|x| PropDatum::Uuid(Uuid::from_bytes(x)))
            .boxed(),
        SqlScalarType::AclItem => any::<AclItem>().prop_map(PropDatum::AclItem).boxed(),
        SqlScalarType::MzAclItem => any::<MzAclItem>().prop_map(PropDatum::MzAclItem).boxed(),
        SqlScalarType::Range { element_type } => {
            let data_strat = (
                arb_datum_for_scalar(*element_type.clone()),
                arb_datum_for_scalar(*element_type),
            );
            arb_range(data_strat).prop_map(PropDatum::Range).boxed()
        }
        SqlScalarType::List { element_type, .. } => arb_list(arb_datum_for_scalar(*element_type))
            .prop_map(PropDatum::List)
            .boxed(),
        SqlScalarType::Array(element_type) => arb_array(arb_datum_for_scalar(*element_type))
            .prop_map(PropDatum::Array)
            .boxed(),
        SqlScalarType::Int2Vector => {
            // `int2vector` is, by definition, a 1-dimensional array of `int2`
            // values (matching PostgreSQL's `int2vector` and Materialize's
            // `Value::from_datum`, which asserts on multi-dimensional arrays).
            // The generic `arb_array` strategy can produce multi-dimensional
            // arrays, so we hand-roll a 1-D variant here.
            let element_strategy = any::<i16>().prop_map(PropDatum::Int16).boxed();
            prop::collection::vec(element_strategy, 0..16)
                .prop_map(|elements| {
                    let dims = [ArrayDimension {
                        lower_bound: 1,
                        length: elements.len(),
                    }];
                    let element_datums: Vec<Datum<'_>> =
                        elements.iter().map(|pd| pd.into()).collect();
                    let mut row = Row::default();
                    row.packer().try_push_array(&dims, element_datums).unwrap();
                    PropDatum::Array(PropArray(row, elements))
                })
                .boxed()
        }
        SqlScalarType::Map { value_type, .. } => arb_dict(arb_datum_for_scalar(*value_type))
            .prop_map(PropDatum::Map)
            .boxed(),
        SqlScalarType::Record { fields, .. } => {
            let field_strats = fields.iter().map(|(name, ty)| {
                (
                    name.to_string(),
                    arb_datum_for_scalar(ty.scalar_type.clone()),
                )
            });
            arb_record(field_strats).prop_map(PropDatum::Record).boxed()
        }
        SqlScalarType::Jsonb => {
            let int_value = any::<i128>()
                .prop_map(|v| Numeric::try_from(v).unwrap())
                .boxed();
            // Numerics only support up to 39 digits.
            let float_value = (1e-39f64..1e39)
                .prop_map(|v| Numeric::try_from(v).unwrap())
                .boxed();
            // JSON does not support NaN or Infinite numbers, so we can't use
            // the normal `arb_numeric` strategy.
            let json_number = Union::new(vec![int_value, float_value]);

            let json_leaf = Union::new(vec![
                any::<()>().prop_map(|_| PropDatum::JsonNull).boxed(),
                any::<bool>().prop_map(PropDatum::Bool).boxed(),
                json_number.prop_map(PropDatum::Numeric).boxed(),
                ".*".prop_map(PropDatum::String).boxed(),
            ]);
            json_leaf
                .prop_recursive(4, 32, 8, |element| {
                    Union::new(vec![
                        prop::collection::vec(element.clone(), 0..16)
                            .prop_map(|elements| {
                                let datums: Vec<_> = elements.iter().map(|pd| pd.into()).collect();
                                let mut row = Row::default();
                                row.packer().push_list(datums.iter());
                                PropDatum::List(PropList(row, elements))
                            })
                            .boxed(),
                        prop::collection::hash_map(".*", element, 0..16)
                            .prop_map(|elements| {
                                let mut elements: Vec<_> = elements.into_iter().collect();
                                elements.sort_by_key(|(k, _)| k.clone());
                                elements.dedup_by_key(|(k, _)| k.clone());
                                let mut row = Row::default();
                                let entry_iter =
                                    elements.iter().map(|(k, v)| (k.as_str(), Datum::from(v)));
                                row.packer().push_dict(entry_iter);
                                PropDatum::Map(PropDict(row, elements))
                            })
                            .boxed(),
                    ])
                })
                .boxed()
        }
    }
}

/// Generates an arbitrary [`NaiveDateTime`].
#[cfg(any(test, feature = "proptest"))]
pub fn arb_naive_date_time() -> impl Strategy<Value = NaiveDateTime> {
    add_arb_duration(chrono::DateTime::from_timestamp(0, 0).unwrap().naive_utc())
}

/// Generates an arbitrary [`DateTime`] in [`Utc`].
#[cfg(any(test, feature = "proptest"))]
pub fn arb_utc_date_time() -> impl Strategy<Value = DateTime<Utc>> {
    add_arb_duration(chrono::Utc.timestamp_opt(0, 0).unwrap())
}

#[cfg(any(test, feature = "proptest"))]
fn arb_array_dimension() -> BoxedStrategy<ArrayDimension> {
    (1..4_usize)
        .prop_map(|length| ArrayDimension {
            lower_bound: 1,
            length,
        })
        .boxed()
}

#[derive(Debug, PartialEq, Clone)]
#[cfg(any(test, feature = "proptest"))]
pub struct PropArray(Row, Vec<PropDatum>);

#[cfg(any(test, feature = "proptest"))]
fn arb_array(element_strategy: BoxedStrategy<PropDatum>) -> BoxedStrategy<PropArray> {
    // Elements in Arrays can always be Null.
    let element_strategy = Union::new_weighted(vec![
        (20, element_strategy),
        (1, Just(PropDatum::Null).boxed()),
    ]);

    prop::collection::vec(
        arb_array_dimension(),
        1..usize::from(crate::adt::array::MAX_ARRAY_DIMENSIONS),
    )
    .prop_flat_map(move |dimensions| {
        let n_elts: usize = dimensions.iter().map(|d| d.length).product();
        (
            Just(dimensions),
            prop::collection::vec(element_strategy.clone(), n_elts),
        )
    })
    .prop_map(|(dimensions, elements)| {
        let element_datums: Vec<Datum<'_>> = elements.iter().map(|pd| pd.into()).collect();
        let mut row = Row::default();
        row.packer()
            .try_push_array(&dimensions, element_datums)
            .unwrap();
        PropArray(row, elements)
    })
    .boxed()
}

#[derive(Debug, PartialEq, Clone)]
#[cfg(any(test, feature = "proptest"))]
pub struct PropList(Row, Vec<PropDatum>);

#[cfg(any(test, feature = "proptest"))]
fn arb_list(element_strategy: BoxedStrategy<PropDatum>) -> BoxedStrategy<PropList> {
    // Elements in Lists can always be Null.
    let element_strategy = Union::new_weighted(vec![
        (20, element_strategy),
        (1, Just(PropDatum::Null).boxed()),
    ]);

    prop::collection::vec(element_strategy, 1..50)
        .prop_map(|elements| {
            let element_datums: Vec<Datum<'_>> = elements.iter().map(|pd| pd.into()).collect();
            let mut row = Row::default();
            row.packer().push_list(element_datums.iter());
            PropList(row, elements)
        })
        .boxed()
}

#[derive(Debug, PartialEq, Clone)]
#[cfg(any(test, feature = "proptest"))]
pub struct PropRange(
    Row,
    Option<(
        (Option<Box<PropDatum>>, bool),
        (Option<Box<PropDatum>>, bool),
    )>,
);

#[cfg(any(test, feature = "proptest"))]
pub fn arb_range_type() -> Union<BoxedStrategy<SqlScalarType>> {
    Union::new(vec![
        Just(SqlScalarType::Int32).boxed(),
        Just(SqlScalarType::Int64).boxed(),
        Just(SqlScalarType::Date).boxed(),
    ])
}

#[cfg(any(test, feature = "proptest"))]
fn arb_range_data() -> Union<BoxedStrategy<(PropDatum, PropDatum)>> {
    Union::new(vec![
        (
            any::<i32>().prop_map(PropDatum::Int32),
            any::<i32>().prop_map(PropDatum::Int32),
        )
            .boxed(),
        (
            any::<i64>().prop_map(PropDatum::Int64),
            any::<i64>().prop_map(PropDatum::Int64),
        )
            .boxed(),
        (
            arb_date().prop_map(PropDatum::Date),
            arb_date().prop_map(PropDatum::Date),
        )
            .boxed(),
    ])
}

#[cfg(any(test, feature = "proptest"))]
fn arb_range(
    data: impl Strategy<Value = (PropDatum, PropDatum)> + 'static,
) -> BoxedStrategy<PropRange> {
    (
        any::<u16>(),
        any::<bool>(),
        any::<bool>(),
        any::<bool>(),
        any::<bool>(),
        data,
    )
        .prop_map(
            |(split, lower_inf, lower_inc, upper_inf, upper_inc, (a, b))| {
                let mut row = Row::default();
                let mut packer = row.packer();
                let r = if split % 32 == 0 {
                    packer
                        .push_range(Range::new(None))
                        .expect("pushing empty ranges never fails");
                    None
                } else {
                    let b_is_lower = Datum::from(&b) < Datum::from(&a);

                    let (lower, upper) = if b_is_lower { (b, a) } else { (a, b) };
                    let mut range = Range::new(Some((
                        RangeLowerBound {
                            inclusive: lower_inc,
                            bound: if lower_inf {
                                None
                            } else {
                                Some(Datum::from(&lower))
                            },
                        },
                        RangeUpperBound {
                            inclusive: upper_inc,
                            bound: if upper_inf {
                                None
                            } else {
                                Some(Datum::from(&upper))
                            },
                        },
                    )));

                    range.canonicalize().unwrap();

                    // Extract canonicalized state; pretend the range was empty
                    // if the bounds are rewritten.
                    let (empty, lower_inf, lower_inc, upper_inf, upper_inc) = match range.inner {
                        None => (true, false, false, false, false),
                        Some(inner) => (
                            false
                                || match inner.lower.bound {
                                    Some(b) => b != Datum::from(&lower),
                                    None => !lower_inf,
                                }
                                || match inner.upper.bound {
                                    Some(b) => b != Datum::from(&upper),
                                    None => !upper_inf,
                                },
                            inner.lower.bound.is_none(),
                            inner.lower.inclusive,
                            inner.upper.bound.is_none(),
                            inner.upper.inclusive,
                        ),
                    };

                    if empty {
                        packer.push_range(Range { inner: None }).unwrap();
                        None
                    } else {
                        packer.push_range(range).unwrap();
                        Some((
                            (
                                if lower_inf {
                                    None
                                } else {
                                    Some(Box::new(lower))
                                },
                                lower_inc,
                            ),
                            (
                                if upper_inf {
                                    None
                                } else {
                                    Some(Box::new(upper))
                                },
                                upper_inc,
                            ),
                        ))
                    }
                };

                PropRange(row, r)
            },
        )
        .boxed()
}

#[derive(Debug, PartialEq, Clone)]
#[cfg(any(test, feature = "proptest"))]
pub struct PropDict(Row, Vec<(String, PropDatum)>);

#[cfg(any(test, feature = "proptest"))]
fn arb_dict(element_strategy: BoxedStrategy<PropDatum>) -> BoxedStrategy<PropDict> {
    // Elements in Maps can always be Null.
    let element_strategy = Union::new_weighted(vec![
        (20, element_strategy),
        (1, Just(PropDatum::Null).boxed()),
    ]);

    prop::collection::vec((".*", element_strategy), 1..50)
        .prop_map(|mut entries| {
            entries.sort_by_key(|(k, _)| k.clone());
            entries.dedup_by_key(|(k, _)| k.clone());
            let mut row = Row::default();
            let entry_iter = entries.iter().map(|(k, v)| (k.as_str(), Datum::from(v)));
            row.packer().push_dict(entry_iter);
            PropDict(row, entries)
        })
        .boxed()
}

#[cfg(any(test, feature = "proptest"))]
fn arb_record(
    fields: impl Iterator<Item = (String, BoxedStrategy<PropDatum>)>,
) -> BoxedStrategy<PropDict> {
    let (names, strategies): (Vec<_>, Vec<_>) = fields.unzip();

    strategies
        .prop_map(move |x| {
            let mut row = Row::default();
            row.packer().push_list(x.iter().map(Datum::from));
            let entries: Vec<_> = names.clone().into_iter().zip_eq(x).collect();
            PropDict(row, entries)
        })
        .boxed()
}

#[cfg(any(test, feature = "proptest"))]
fn arb_date() -> BoxedStrategy<Date> {
    (Date::LOW_DAYS..Date::HIGH_DAYS)
        .prop_map(move |days| Date::from_pg_epoch(days).unwrap())
        .boxed()
}

#[cfg(any(test, feature = "proptest"))]
pub fn add_arb_duration<T: 'static + Copy + Add<chrono::Duration> + std::fmt::Debug>(
    to: T,
) -> BoxedStrategy<T::Output>
where
    T::Output: std::fmt::Debug,
{
    let lower = LOW_DATE
        .and_hms_opt(0, 0, 0)
        .unwrap()
        .and_utc()
        .timestamp_micros();
    let upper = HIGH_DATE
        .and_hms_opt(0, 0, 0)
        .unwrap()
        .and_utc()
        .timestamp_micros();
    (lower..upper)
        .prop_map(move |v| to + chrono::Duration::microseconds(v))
        .boxed()
}

#[cfg(any(test, feature = "proptest"))]
pub(crate) fn arb_numeric() -> BoxedStrategy<Numeric> {
    let int_value = any::<i128>()
        .prop_map(|v| Numeric::try_from(v).unwrap())
        .boxed();
    let float_value = (-1e39f64..1e39)
        .prop_map(|v| Numeric::try_from(v).unwrap())
        .boxed();

    // While these strategies are subsets of the ones above, including them
    // helps us generate a more realistic set of values.
    let tiny_floats = ((-10.0..10.0), (1u32..10))
        .prop_map(|(v, num_digits)| {
            // Truncate to a small number of digits.
            let num_digits: f64 = 10u32.pow(num_digits).try_into().unwrap();
            let trunc = f64::trunc(v * num_digits) / num_digits;
            Numeric::try_from(trunc).unwrap()
        })
        .boxed();
    let small_ints = (-1_000_000..1_000_000)
        .prop_map(|v| Numeric::try_from(v).unwrap())
        .boxed();
    let small_floats = (-1_000_000.0..1_000_000.0)
        .prop_map(|v| Numeric::try_from(v).unwrap())
        .boxed();

    Union::new_weighted(vec![
        (20, tiny_floats),
        (20, small_ints),
        (20, small_floats),
        (10, int_value),
        (10, float_value),
        (1, Just(Numeric::infinity()).boxed()),
        (1, Just(-Numeric::infinity()).boxed()),
        (1, Just(Numeric::nan()).boxed()),
        (1, Just(Numeric::zero()).boxed()),
    ])
    .boxed()
}

#[cfg(any(test, feature = "proptest"))]
impl<'a> From<&'a PropDatum> for Datum<'a> {
    #[inline]
    fn from(pd: &'a PropDatum) -> Self {
        use PropDatum::*;
        match pd {
            Null => Datum::Null,
            Bool(b) => Datum::from(*b),
            Int16(i) => Datum::from(*i),
            Int32(i) => Datum::from(*i),
            Int64(i) => Datum::from(*i),
            UInt8(u) => Datum::from(*u),
            UInt16(u) => Datum::from(*u),
            UInt32(u) => Datum::from(*u),
            UInt64(u) => Datum::from(*u),
            Float32(f) => Datum::from(*f),
            Float64(f) => Datum::from(*f),
            Date(d) => Datum::from(*d),
            Time(t) => Datum::from(*t),
            Timestamp(t) => Datum::from(*t),
            TimestampTz(t) => Datum::from(*t),
            MzTimestamp(t) => Datum::MzTimestamp((*t).into()),
            Interval(i) => Datum::from(*i),
            Numeric(s) => Datum::from(*s),
            Bytes(b) => Datum::from(&b[..]),
            String(s) => Datum::from(s.as_str()),
            Array(PropArray(row, _)) => {
                let array = row.unpack_first().unwrap_array();
                Datum::Array(array)
            }
            List(PropList(row, _)) => {
                let list = row.unpack_first().unwrap_list();
                Datum::List(list)
            }
            Map(PropDict(row, _)) => {
                let map = row.unpack_first().unwrap_map();
                Datum::Map(map)
            }
            Record(PropDict(row, _)) => {
                let list = row.unpack_first().unwrap_list();
                Datum::List(list)
            }
            Range(PropRange(row, _)) => {
                let d = row.unpack_first();
                assert!(matches!(d, Datum::Range(_)));
                d
            }
            AclItem(i) => Datum::AclItem(*i),
            MzAclItem(i) => Datum::MzAclItem(*i),
            JsonNull => Datum::JsonNull,
            Uuid(u) => Datum::from(*u),
            Dummy => Datum::Dummy,
        }
    }
}

#[mz_ore::test]
fn verify_base_eq_record_nullability() {
    let s1 = SqlScalarType::Record {
        fields: [(
            "c".into(),
            SqlColumnType {
                scalar_type: SqlScalarType::Bool,
                nullable: true,
            },
        )]
        .into(),
        custom_id: None,
    };
    let s2 = SqlScalarType::Record {
        fields: [(
            "c".into(),
            SqlColumnType {
                scalar_type: SqlScalarType::Bool,
                nullable: false,
            },
        )]
        .into(),
        custom_id: None,
    };
    let s3 = SqlScalarType::Record {
        fields: [].into(),
        custom_id: None,
    };
    assert!(s1.base_eq(&s2));
    assert!(!s1.base_eq(&s3));
}

#[cfg(test)]
mod tests {
    use mz_ore::assert_ok;
    use mz_proto::protobuf_roundtrip;

    use super::*;

    proptest! {
       #[mz_ore::test]
       #[cfg_attr(miri, ignore)] // too slow
        fn scalar_type_protobuf_roundtrip(expect in any::<SqlScalarType>() ) {
            let actual = protobuf_roundtrip::<_, ProtoScalarType>(&expect);
            assert_ok!(actual);
            assert_eq!(actual.unwrap(), expect);
        }
    }

    proptest! {
        #[mz_ore::test]
        #[cfg_attr(miri, ignore)]
        fn sql_repr_types_agree_on_valid_data(
            (src, datum) in any::<SqlColumnType>()
                .prop_flat_map(|src| {
                    let datum = arb_datum_for_column(src.clone());
                    (Just(src), datum)
                }),
        ) {
            let tgt = ReprColumnType::from(&src);
            let datum = Datum::from(&datum);
            assert_eq!(
                datum.is_instance_of_sql(&src),
                datum.is_instance_of(&tgt),
                "translated to repr type {tgt:#?}",
            );
        }
    }

    proptest! {
        // We run many cases because the data are _random_, and we want to be sure
        // that we have covered sufficient cases.
        #![proptest_config(ProptestConfig::with_cases(10000))]
        #[mz_ore::test]
        #[cfg_attr(miri, ignore)]
        fn sql_repr_types_agree_on_random_data(
            src in any::<SqlColumnType>(),
            datum in arb_datum(true),
        ) {
            let tgt = ReprColumnType::from(&src);
            let datum = Datum::from(&datum);

            assert_eq!(
                datum.is_instance_of_sql(&src),
                datum.is_instance_of(&tgt),
                "translated to repr type {tgt:#?}",
            );
        }
    }

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(10000))]
        #[mz_ore::test]
        #[cfg_attr(miri, ignore)]
        fn repr_type_to_sql_type_roundtrip(repr_type in any::<ReprScalarType>()) {
            // ReprScalarType::from is a left inverse of SqlScalarType::from.
            //
            // It is _not_ a right inverse, because SqlScalarType::from is lossy.
            // For example, many SqlScalarType variants map to ReprScalarType::String.
            let sql_type = SqlScalarType::from_repr(&repr_type);
            assert_eq!(repr_type, ReprScalarType::from(&sql_type));
        }
    }

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(10000))]
        #[mz_ore::test]
        #[cfg_attr(miri, ignore)]
        fn sql_type_base_eq_implies_repr_type_eq(
            sql_type1 in any::<SqlScalarType>(),
            sql_type2 in any::<SqlScalarType>(),
        ) {
            let repr_type1 = ReprScalarType::from(&sql_type1);
            let repr_type2 = ReprScalarType::from(&sql_type2);
            if sql_type1.base_eq(&sql_type2) {
                assert_eq!(repr_type1, repr_type2);
            }
        }
    }

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(10000))]
        #[mz_ore::test]
        #[cfg_attr(miri, ignore)]
        fn repr_type_self_union(repr_type in any::<ReprScalarType>()) {
            let union = repr_type.union(&repr_type);
            assert_ok!(
                union,
                "every type should self-union \
                 (update ReprScalarType::union to handle this)",
            );
            assert_eq!(
                union.unwrap(), repr_type,
                "every type should self-union to itself",
            );
        }
    }

    proptest! {
        #[mz_ore::test]
        #[cfg_attr(miri, ignore)] // can't call foreign function `decContextDefault`
        fn array_packing_unpacks_correctly(array in arb_array(arb_datum(true))) {
            let PropArray(row, elts) = array;
            let datums: Vec<Datum<'_>> = elts.iter().map(|e| e.into()).collect();
            let unpacked_datums: Vec<Datum<'_>> = row
                .unpack_first().unwrap_array().elements().iter().collect();
            assert_eq!(unpacked_datums, datums);
        }

        #[mz_ore::test]
        #[cfg_attr(miri, ignore)] // can't call foreign function `decContextDefault`
        fn list_packing_unpacks_correctly(array in arb_list(arb_datum(true))) {
            let PropList(row, elts) = array;
            let datums: Vec<Datum<'_>> = elts.iter().map(|e| e.into()).collect();
            let unpacked_datums: Vec<Datum<'_>> = row
                .unpack_first().unwrap_list().iter().collect();
            assert_eq!(unpacked_datums, datums);
        }

        #[mz_ore::test]
        #[cfg_attr(miri, ignore)] // too slow
        fn dict_packing_unpacks_correctly(array in arb_dict(arb_datum(true))) {
            let PropDict(row, elts) = array;
            let datums: Vec<(&str, Datum<'_>)> = elts.iter()
                .map(|(k, e)| (k.as_str(), e.into())).collect();
            let unpacked_datums: Vec<(&str, Datum<'_>)> = row
                .unpack_first().unwrap_map().iter().collect();
            assert_eq!(unpacked_datums, datums);
        }

        #[mz_ore::test]
        #[cfg_attr(miri, ignore)] // too slow
        fn row_packing_roundtrips_single_valued(
            prop_datums in prop::collection::vec(arb_datum(true), 1..100),
        ) {
            let datums: Vec<Datum<'_>> = prop_datums.iter().map(|pd| pd.into()).collect();
            let row = Row::pack(&datums);
            let unpacked = row.unpack();
            assert_eq!(datums, unpacked);
        }

        #[mz_ore::test]
        #[cfg_attr(miri, ignore)] // too slow
        fn range_packing_unpacks_correctly(range in arb_range(arb_range_data())) {
            let PropRange(row, prop_range) = range;
            let row = row.unpack_first();
            let d = row.unwrap_range();

            let (
                ((prop_lower, prop_lower_inc), (prop_upper, prop_upper_inc)),
                crate::adt::range::RangeInner { lower, upper },
            ) = match (prop_range, d.inner) {
                (Some(prop_values), Some(inner_range)) => (prop_values, inner_range),
                (None, None) => return Ok(()),
                _ => panic!("inequivalent row packing"),
            };

            for (prop_bound, prop_bound_inc, inner_bound, inner_bound_inc) in [
                (prop_lower, prop_lower_inc, lower.bound, lower.inclusive),
                (prop_upper, prop_upper_inc, upper.bound, upper.inclusive),
            ] {
                assert_eq!(prop_bound_inc, inner_bound_inc);
                match (prop_bound, inner_bound) {
                    (None, None) => continue,
                    (Some(p), Some(b)) => {
                        assert_eq!(Datum::from(&*p), b);
                    }
                    _ => panic!("inequivalent row packing"),
                }
            }
        }
    }
}