Method parseCreateTable

parser/parser_table.go:309–400

(pos Pos, orReplace bool)

}

func (p *Parser) parseCreateTable(pos Pos, orReplace bool) (*CreateTable, error) {
	createTable := &CreateTable{CreatePos: pos, OrReplace: orReplace}
	createTable.HasTemporary = p.tryConsumeKeywords(KeywordTemporary)

	if err := p.expectKeyword(KeywordTable); err != nil {
		return nil, err
	}

	// parse IF NOT EXISTS clause if exists
	var err error
	createTable.IfNotExists, err = p.tryParseIfNotExists()
	if err != nil {
		return nil, err
	}

	tableIdentifier, err := p.parseTableIdentifier(p.Pos())
	if err != nil {
		return nil, err
	}
	createTable.Name = tableIdentifier

	// try parse UUID clause if exists
	uuid, err := p.tryParseUUID()
	if err != nil {
		return nil, err
	}
	createTable.UUID = uuid
	// parse ON CLUSTER clause if exists
	onCluster, err := p.tryParseClusterClause(p.Pos())
	if err != nil {
		return nil, err
	}
	createTable.OnCluster = onCluster

	tableSchema, err := p.parseTableSchemaClause(p.Pos())
	if err != nil {
		return nil, err
	}
	createTable.TableSchema = tableSchema

	engineExpr, err := p.tryParseEngineExpr(p.Pos())
	if err != nil {
		return nil, err
	}
	if engineExpr != nil {
		createTable.Engine = engineExpr
		createTable.StatementEnd = engineExpr.End()
	}

	if p.tryConsumeKeywords(KeywordAs) {
		// After AS, we can have: SELECT/WITH (with or without parens), or table_function(...)
		// Check if it's a SELECT/WITH query (explicitly check keywords/paren before ident)
		if p.matchKeyword(KeywordSelect) || p.matchKeyword(KeywordWith) || p.matchTokenKind(TokenKindLParen) {
			// It's a SELECT or WITH query (with or without parentheses)
			subQuery, err := p.parseSubQuery(p.Pos())
			if err != nil {
				return nil, err
			}