Method parse_avro_schema

src/sql-parser/src/parser.rs:2204–2259

(&mut self)

    }

    fn parse_avro_schema(&mut self) -> Result<AvroSchema<Raw>, ParserError> {
        let avro_schema = if self.parse_keywords(&[CONFLUENT, SCHEMA, REGISTRY]) {
            let csr_connection = self.parse_csr_connection_avro()?;
            AvroSchema::Csr { csr_connection }
        } else if self.parse_keywords(&[AWS, GLUE, SCHEMA, REGISTRY]) {
            self.expect_keyword(CONNECTION)?;
            let connection = self.parse_raw_name()?;
            let with_options = if self.consume_token(&Token::LParen) {
                let opts = self.parse_comma_separated(Parser::parse_glue_avro_option)?;
                self.expect_token(&Token::RParen)?;
                opts
            } else {
                vec![]
            };
            // SEED VALUE SCHEMA '<json>' is normally emitted by purification
            // and re-parsed when persisted create_sql is reloaded. A user may
            // also write it directly; that is accepted here (purification trusts
            // a pre-populated seed), though it is not the intended path.
            let seed = if self.parse_keyword(SEED) {
                self.expect_keywords(&[VALUE, SCHEMA])?;
                let value_schema = self.parse_literal_string()?;
                Some(GlueAvroSeed { value_schema })
            } else {
                None
            };
            AvroSchema::Glue {
                connection,
                with_options,
                seed,
            }
        } else if self.parse_keyword(SCHEMA) {
            self.prev_token();
            self.expect_keyword(SCHEMA)?;
            let schema = Schema {
                schema: self.parse_literal_string()?,
            };
            let with_options = if self.consume_token(&Token::LParen) {
                let with_options = self.parse_comma_separated(Parser::parse_avro_schema_option)?;
                self.expect_token(&Token::RParen)?;
                with_options
            } else {
                vec![]
            };
            AvroSchema::InlineSchema {
                schema,
                with_options,
            }
        } else {
            return self.expected(
                self.peek_pos(),
                "CONFLUENT SCHEMA REGISTRY, AWS GLUE SCHEMA REGISTRY, or SCHEMA",
                self.peek_token(),
            );
        };
        Ok(avro_schema)
    }

    fn parse_avro_schema_option(&mut self) -> Result<AvroSchemaOption<Raw>, ParserError> {