Method parse_complex

avro/src/schema/parser.rs:251–475

Parse a `serde_json::Value` representing a complex Avro type into a `Schema`. Avro supports "recursive" definition of types. e.g: `{"type": {"type": "string"}}`

(
        &mut self,
        complex: &Map<String, Value>,
        enclosing_namespace: NamespaceRef,
    )

            parser: &mut Parser,
            enclosing_namespace: NamespaceRef,
        ) -> AvroResult<Schema> {
            match complex.remove("type") {
                Some(value) => match value {
                    Value::String(s) if s == "fixed" => {
                        parser.parse_fixed(complex, enclosing_namespace)
                    }
                    _ => parser.parse(value, enclosing_namespace),
                },
                None => Err(Details::GetLogicalTypeField.into()),
            }
        }

        // This crate supports some logical types natively, and this function tries to convert
        // a native complex type with a logical type attribute to these logical types.
        // This function:
        // 1. Checks whether the native complex type is in the supported kinds.
        // 2. If it is, using the convert function to convert the native complex type to
        // a logical type.
        fn try_convert_to_logical_type<F>(
            logical_type: &str,
            schema: Schema,
            supported_schema_kinds: &[SchemaKind],
            convert: F,
        ) -> AvroResult<Schema>
        where
            F: Fn(Schema) -> AvroResult<Schema>,
        {
            let kind = SchemaKind::from(schema.clone());
            if supported_schema_kinds.contains(&kind) {
                convert(schema)
            } else {
                warn!(
                    "Ignoring unknown logical type '{logical_type}' for schema of type: {schema:?}!"
                );
                Ok(schema)
            }
        }

        match complex.remove_entry("logicalType") {
            Some((key, Value::String(t))) => match t.as_str() {
                "decimal" => {
                    return try_convert_to_logical_type(
                        "decimal",
                        // TODO: See if we can avoid this clone, although if this really is a decimal
                        //       the clone is cheap enough not to be a problem
                        parse_as_native_complex(complex.clone(), self, enclosing_namespace)?,
                        &[SchemaKind::Fixed, SchemaKind::Bytes],
                        |inner| -> AvroResult<Schema> {
                            match self.parse_precision_and_scale(&complex) {
                                Ok((precision, scale)) => Ok(Schema::Decimal(DecimalSchema {
                                    precision,
                                    scale,
                                    inner: inner.try_into()?,
                                })),
                                Err(err) => {
                                    warn!("Ignoring invalid decimal logical type: {err}");
                                    Ok(inner)
                                }