Method parse_record

avro/src/schema/parser.rs:540–595

Parse a `serde_json::Value` representing an Avro record type into a `Schema`.

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

        enclosing_namespace: NamespaceRef,
    ) -> AvroResult<Schema> {
        let fields_opt = complex.remove("fields");

        if fields_opt.is_none()
            && let Some(seen) = self.get_already_seen_schema(&complex, enclosing_namespace)
        {
            return Ok(seen.clone());
        }

        let fully_qualified_name = Name::parse(&mut complex, enclosing_namespace)?;
        let aliases =
            self.fix_aliases_namespace(complex.aliases()?, fully_qualified_name.namespace())?;

        let mut lookup = BTreeMap::new();

        self.register_resolving_schema(&fully_qualified_name, &aliases);

        debug!("Going to parse record schema: {fully_qualified_name:?}");

        let fields = match fields_opt {
            Some(Value::Array(array)) => array
                .into_iter()
                .map(|v| match v {
                    Value::Object(o) => RecordField::parse(o, self, &fully_qualified_name),
                    _ => Err(Details::GetRecordFieldsArrayInvalidType(v.description()).into()),
                })
                .collect::<Result<Vec<_>, _>>()?,
            Some(value) => {
                return Err(Details::GetRecordFieldsInvalidType(value.description()).into());
            }
            None => return Err(Details::GetRecordFieldsJson.into()),
        };

        for (position, field) in fields.iter().enumerate() {
            if let Some(_old) = lookup.insert(field.name.clone(), position) {
                return Err(Details::FieldNameDuplicate(field.name.clone()).into());
            }

            for alias in &field.aliases {
                lookup.insert(alias.clone(), position);
            }
        }

        let schema = Schema::Record(RecordSchema {
            name: fully_qualified_name.clone(),
            aliases: aliases.clone(),
            doc: complex.doc()?,
            fields,
            lookup,
            attributes: self.get_custom_attributes(complex),
        });

        self.register_parsed_schema(&fully_qualified_name, &schema, &aliases);
        Ok(schema)
    }

    fn get_custom_attributes(&self, complex: Map<String, Value>) -> BTreeMap<String, Value> {
        complex.into_iter().collect()
    }