Method parse_create_table_from_source

src/sql-parser/src/parser.rs:5109–5185

(&mut self)

    }

    fn parse_create_table_from_source(&mut self) -> Result<Statement<Raw>, ParserError> {
        if self.parse_keyword(TEMP) || self.parse_keyword(TEMPORARY) {
            return parser_err!(
                self,
                self.peek_prev_pos(),
                "temporary tables FROM SOURCE are not supported"
            );
        }
        self.expect_keyword(TABLE)?;
        let if_not_exists = self.parse_if_not_exists()?;
        let table_name = self.parse_item_name()?;

        if self.parse_keywords(&[FROM, WEBHOOK]) {
            // Webhook Source, which works differently than all other sources.
            return self.parse_create_webhook_source(table_name, if_not_exists, None, true);
        }

        let (columns, constraints) = self.parse_table_from_source_columns()?;

        self.expect_keywords(&[FROM, SOURCE])?;

        let source = self.parse_raw_name()?;

        let external_reference = if self.consume_token(&Token::LParen) {
            self.expect_keyword(REFERENCE)?;
            let _ = self.consume_token(&Token::Eq);
            let external_reference = self.parse_item_name()?;
            self.expect_token(&Token::RParen)?;
            Some(external_reference)
        } else {
            None
        };

        let format = match self.parse_one_of_keywords(&[KEY, FORMAT]) {
            Some(KEY) => {
                self.expect_keyword(FORMAT)?;
                let key = self.parse_format()?;
                self.expect_keywords(&[VALUE, FORMAT])?;
                let value = self.parse_format()?;
                Some(FormatSpecifier::KeyValue { key, value })
            }
            Some(FORMAT) => Some(FormatSpecifier::Bare(self.parse_format()?)),
            Some(_) => unreachable!("parse_one_of_keywords returns None for this"),
            None => None,
        };
        let include_metadata = self.parse_source_include_metadata()?;

        let envelope = if self.parse_keyword(ENVELOPE) {
            Some(self.parse_source_envelope()?)
        } else {
            None
        };

        let with_options = if self.parse_keyword(WITH) {
            self.expect_token(&Token::LParen)?;
            let options = self.parse_comma_separated(Parser::parse_table_from_source_option)?;
            self.expect_token(&Token::RParen)?;
            options