Method track_seen

src/sql/src/func.rs:1415–1458

Determines the desired type of polymorphic compatibility, as well as the values to determine a polymorphic solution.

(&mut self, param: &ParamType, seen: CoercibleScalarType)

    /// Determines the desired type of polymorphic compatibility, as well as the
    /// values to determine a polymorphic solution.
    fn track_seen(&mut self, param: &ParamType, seen: CoercibleScalarType) {
        use ParamType::*;

        self.seen.push(match param {
            // These represent the keys of their respective compatibility classes.
            AnyElement | AnyCompatible | ListAnyCompatible | MapAnyCompatible | NonVecAny
            | RecordAny => seen,
            MapAny => seen.map_coerced(|array| array.unwrap_map_value_type().clone()),
            ListAny => seen.map_coerced(|array| array.unwrap_list_element_type().clone()),
            ArrayAny | ArrayAnyCompatible => {
                seen.map_coerced(|array| array.unwrap_array_element_type().clone())
            }
            RangeAny | RangeAnyCompatible => {
                seen.map_coerced(|range| range.unwrap_range_element_type().clone())
            }
            ListElementAnyCompatible => seen.map_coerced(|el| SqlScalarType::List {
                custom_id: None,
                element_type: Box::new(el),
            }),
            o => {
                assert!(
                    !o.is_polymorphic(),
                    "polymorphic parameters must track types they \
                     encounter to determine polymorphic solution"
                );
                return;
            }
        });

        let compat_class = param
            .try_into()
            .expect("already returned for non-polymorphic params");

        match &self.compat {
            None => self.compat = Some(compat_class),
            Some(c) => {
                assert_eq!(
                    c, &compat_class,
                    "do not know how to correlate polymorphic classes {:?} and {:?}",
                    c, &compat_class,
                )
            }
        };
    }

    /// Attempt to resolve all polymorphic types to a single "key" type. For
    /// `target_for_param_type` to be useful, this must have already been