Add COPY INTO statement parsing for Azure Synapse Analytics

- Create CopyStatement AST type with From, Into, and Options
- Add CopyOption, SingleValueTypeCopyOption, CopyCredentialOption
- Add ListTypeCopyOption and CopyColumnOption for column definitions
- Parse COPY INTO table (columns) FROM 'url' WITH (options)
- Handle Credential and ErrorFileCredential options with Identity/Secret
- Normalize option names to PascalCase for JSON output

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kyleconroy

ast/copy_statement.go

@@ -0,0 +1,58 @@
+package ast
+
+// CopyStatement represents a COPY INTO statement for Azure Synapse Analytics
+type CopyStatement struct {
+	Into    *SchemaObjectName  `json:"Into,omitempty"`
+	From    []ScalarExpression `json:"From,omitempty"`
+	Options []*CopyOption      `json:"Options,omitempty"`
+}
+
+func (*CopyStatement) node()      {}
+func (*CopyStatement) statement() {}
+
+// CopyOption represents an option in COPY INTO
+type CopyOption struct {
+	Kind  string          `json:"Kind,omitempty"`
+	Value CopyOptionValue `json:"Value,omitempty"`
+}
+
+func (*CopyOption) node() {}
+
+// CopyOptionValue is an interface for COPY option values
+type CopyOptionValue interface {
+	copyOptionValue()
+}
+
+// SingleValueTypeCopyOption represents a simple value option
+type SingleValueTypeCopyOption struct {
+	SingleValue *IdentifierOrValueExpression `json:"SingleValue,omitempty"`
+}
+
+func (*SingleValueTypeCopyOption) node()            {}
+func (*SingleValueTypeCopyOption) copyOptionValue() {}
+
+// CopyCredentialOption represents a credential option with Identity and optional Secret
+type CopyCredentialOption struct {
+	Identity ScalarExpression `json:"Identity,omitempty"`
+	Secret   ScalarExpression `json:"Secret,omitempty"`
+}
+
+func (*CopyCredentialOption) node()            {}
+func (*CopyCredentialOption) copyOptionValue() {}
+
+// ListTypeCopyOption represents a list of column options
+type ListTypeCopyOption struct {
+	Options []*CopyColumnOption `json:"Options,omitempty"`
+}
+
+func (*ListTypeCopyOption) node()            {}
+func (*ListTypeCopyOption) copyOptionValue() {}
+
+// CopyColumnOption represents a column option with name, default value, and ordinal
+type CopyColumnOption struct {
+	ColumnName   *Identifier      `json:"ColumnName,omitempty"`
+	DefaultValue ScalarExpression `json:"DefaultValue,omitempty"`
+	FieldNumber  ScalarExpression `json:"FieldNumber,omitempty"`
+}
+
+func (*CopyColumnOption) node() {}

parser/marshal.go

@@ -599,6 +599,8 @@ func statementToJSON(stmt ast.Statement) jsonNode {
 		return insertBulkStatementToJSON(s)
 	case *ast.BulkInsertStatement:
 		return bulkInsertStatementToJSON(s)
+	case *ast.CopyStatement:
+		return copyStatementToJSON(s)
 	case *ast.AlterUserStatement:
 		return alterUserStatementToJSON(s)
 	case *ast.AlterRouteStatement:
@@ -17682,6 +17684,121 @@ func bulkInsertStatementToJSON(s *ast.BulkInsertStatement) jsonNode {
 	return node
 }
 
+func copyStatementToJSON(s *ast.CopyStatement) jsonNode {
+	node := jsonNode{
+		"$type": "CopyStatement",
+	}
+	if len(s.From) > 0 {
+		from := make([]jsonNode, len(s.From))
+		for i, f := range s.From {
+			from[i] = scalarExpressionToJSON(f)
+		}
+		node["From"] = from
+	}
+	if s.Into != nil {
+		node["Into"] = schemaObjectNameToJSON(s.Into)
+	}
+	if len(s.Options) > 0 {
+		opts := make([]jsonNode, len(s.Options))
+		for i, opt := range s.Options {
+			opts[i] = copyOptionToJSON(opt)
+		}
+		node["Options"] = opts
+	}
+	return node
+}
+
+func copyOptionToJSON(o *ast.CopyOption) jsonNode {
+	node := jsonNode{
+		"$type": "CopyOption",
+		"Kind":  normalizeCopyOptionKind(o.Kind),
+	}
+	if o.Value != nil {
+		node["Value"] = copyOptionValueToJSON(o.Value)
+	}
+	return node
+}
+
+// normalizeCopyOptionKind converts option names to PascalCase
+func normalizeCopyOptionKind(kind string) string {
+	// Map common option names
+	optionMap := map[string]string{
+		"FILE_TYPE":            "File_Type",
+		"FIELDTERMINATOR":      "FieldTerminator",
+		"ROWTERMINATOR":        "RowTerminator",
+		"FIELDQUOTE":           "FieldQuote",
+		"DATEFORMAT":           "DateFormat",
+		"ENCODING":             "Encoding",
+		"MAXERRORS":            "MaxErrors",
+		"ERRORFILE":            "ErrorFile",
+		"FIRSTROW":             "FirstRow",
+		"CREDENTIAL":           "Credential",
+		"IDENTITY_INSERT":      "Identity_Insert",
+		"COMPRESSION":          "Compression",
+		"FILE_FORMAT":          "File_Format",
+		"ERRORFILE_CREDENTIAL": "ErrorFileCredential",
+		"COLUMNOPTIONS":        "ColumnOptions",
+	}
+	upper := strings.ToUpper(kind)
+	if mapped, ok := optionMap[upper]; ok {
+		return mapped
+	}
+	return kind
+}
+
+func copyOptionValueToJSON(v ast.CopyOptionValue) jsonNode {
+	switch val := v.(type) {
+	case *ast.SingleValueTypeCopyOption:
+		node := jsonNode{
+			"$type": "SingleValueTypeCopyOption",
+		}
+		if val.SingleValue != nil {
+			node["SingleValue"] = identifierOrValueExpressionToJSON(val.SingleValue)
+		}
+		return node
+	case *ast.CopyCredentialOption:
+		node := jsonNode{
+			"$type": "CopyCredentialOption",
+		}
+		if val.Identity != nil {
+			node["Identity"] = scalarExpressionToJSON(val.Identity)
+		}
+		if val.Secret != nil {
+			node["Secret"] = scalarExpressionToJSON(val.Secret)
+		}
+		return node
+	case *ast.ListTypeCopyOption:
+		node := jsonNode{
+			"$type": "ListTypeCopyOption",
+		}
+		if len(val.Options) > 0 {
+			opts := make([]jsonNode, len(val.Options))
+			for i, opt := range val.Options {
+				opts[i] = copyColumnOptionToJSON(opt)
+			}
+			node["Options"] = opts
+		}
+		return node
+	}
+	return nil
+}
+
+func copyColumnOptionToJSON(c *ast.CopyColumnOption) jsonNode {
+	node := jsonNode{
+		"$type": "CopyColumnOption",
+	}
+	if c.ColumnName != nil {
+		node["ColumnName"] = identifierToJSON(c.ColumnName)
+	}
+	if c.DefaultValue != nil {
+		node["DefaultValue"] = scalarExpressionToJSON(c.DefaultValue)
+	}
+	if c.FieldNumber != nil {
+		node["FieldNumber"] = scalarExpressionToJSON(c.FieldNumber)
+	}
+	return node
+}
+
 func alterUserStatementToJSON(s *ast.AlterUserStatement) jsonNode {
 	node := jsonNode{
 		"$type": "AlterUserStatement",

parser/parse_dml.go

@@ -2949,3 +2949,199 @@ func (p *Parser) parseOutputClause() (*ast.OutputClause, *ast.OutputIntoClause,
 	}, nil, nil
 }
 
+// parseCopyStatement parses COPY INTO statement for Azure Synapse Analytics
+func (p *Parser) parseCopyStatement() (*ast.CopyStatement, error) {
+	// Consume COPY
+	p.nextToken()
+
+	stmt := &ast.CopyStatement{}
+
+	// Expect INTO
+	if strings.ToUpper(p.curTok.Literal) == "INTO" {
+		p.nextToken() // consume INTO
+	}
+
+	// Parse target table name
+	tableName, err := p.parseSchemaObjectName()
+	if err != nil {
+		return nil, err
+	}
+	stmt.Into = tableName
+
+	// Parse optional column list with defaults: (col1 DEFAULT 'value' 1, col2 DEFAULT 2 3)
+	if p.curTok.Type == TokenLParen {
+		p.nextToken() // consume (
+		columnOpts := &ast.ListTypeCopyOption{}
+		for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+			colOpt := &ast.CopyColumnOption{}
+			colOpt.ColumnName = p.parseIdentifier()
+
+			// Check for DEFAULT
+			if strings.ToUpper(p.curTok.Literal) == "DEFAULT" {
+				p.nextToken() // consume DEFAULT
+				defValue, err := p.parseScalarExpression()
+				if err != nil {
+					return nil, err
+				}
+				colOpt.DefaultValue = defValue
+			}
+
+			// Parse field number (integer)
+			if p.curTok.Type == TokenNumber {
+				val := p.curTok.Literal
+				colOpt.FieldNumber = &ast.IntegerLiteral{Value: val, LiteralType: "Integer"}
+				p.nextToken()
+			}
+
+			columnOpts.Options = append(columnOpts.Options, colOpt)
+
+			if p.curTok.Type == TokenComma {
+				p.nextToken()
+			} else {
+				break
+			}
+		}
+		if p.curTok.Type == TokenRParen {
+			p.nextToken() // consume )
+		}
+		// Add column options as an option
+		if len(columnOpts.Options) > 0 {
+			stmt.Options = append(stmt.Options, &ast.CopyOption{
+				Kind:  "ColumnOptions",
+				Value: columnOpts,
+			})
+		}
+	}
+
+	// Expect FROM
+	if strings.ToUpper(p.curTok.Literal) == "FROM" {
+		p.nextToken() // consume FROM
+	}
+
+	// Parse source URLs (comma-separated string literals)
+	for {
+		if p.curTok.Type == TokenString || p.curTok.Type == TokenNationalString {
+			strLit, err := p.parseStringLiteral()
+			if err != nil {
+				return nil, err
+			}
+			stmt.From = append(stmt.From, strLit)
+		}
+		if p.curTok.Type == TokenComma {
+			p.nextToken()
+		} else {
+			break
+		}
+	}
+
+	// Parse WITH clause if present
+	if p.curTok.Type == TokenWith {
+		p.nextToken() // consume WITH
+		if p.curTok.Type == TokenLParen {
+			p.nextToken() // consume (
+		}
+
+		for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF && p.curTok.Type != TokenSemicolon {
+			opt, err := p.parseCopyOption()
+			if err != nil {
+				return nil, err
+			}
+			if opt != nil {
+				stmt.Options = append(stmt.Options, opt)
+			}
+
+			if p.curTok.Type == TokenComma {
+				p.nextToken()
+			} else {
+				break
+			}
+		}
+
+		if p.curTok.Type == TokenRParen {
+			p.nextToken() // consume )
+		}
+	}
+
+	// Skip optional semicolon
+	if p.curTok.Type == TokenSemicolon {
+		p.nextToken()
+	}
+
+	return stmt, nil
+}
+
+// parseCopyOption parses a single COPY option
+func (p *Parser) parseCopyOption() (*ast.CopyOption, error) {
+	opt := &ast.CopyOption{}
+
+	// Get option name
+	optName := p.curTok.Literal
+	opt.Kind = optName
+	p.nextToken()
+
+	// Handle = sign
+	if p.curTok.Type == TokenEquals {
+		p.nextToken() // consume =
+	}
+
+	// Check for credential option (Identity = ..., Secret = ...)
+	if strings.ToUpper(optName) == "CREDENTIAL" || strings.ToUpper(optName) == "ERRORFILE_CREDENTIAL" {
+		credOpt := &ast.CopyCredentialOption{}
+		// Expect (
+		if p.curTok.Type == TokenLParen {
+			p.nextToken() // consume (
+		}
+		// Parse Identity = '...'
+		for p.curTok.Type != TokenRParen && p.curTok.Type != TokenEOF {
+			keyName := strings.ToUpper(p.curTok.Literal)
+			p.nextToken()
+			if p.curTok.Type == TokenEquals {
+				p.nextToken() // consume =
+			}
+			if keyName == "IDENTITY" {
+				strLit, _ := p.parseStringLiteral()
+				credOpt.Identity = strLit
+			} else if keyName == "SECRET" {
+				strLit, _ := p.parseStringLiteral()
+				credOpt.Secret = strLit
+			}
+			if p.curTok.Type == TokenComma {
+				p.nextToken()
+			} else {
+				break
+			}
+		}
+		if p.curTok.Type == TokenRParen {
+			p.nextToken() // consume )
+		}
+		opt.Value = credOpt
+	} else {
+		// Single value option
+		singleOpt := &ast.SingleValueTypeCopyOption{}
+		idOrVal := &ast.IdentifierOrValueExpression{}
+
+		if p.curTok.Type == TokenString || p.curTok.Type == TokenNationalString {
+			strLit, _ := p.parseStringLiteral()
+			// Extract value without quotes
+			val := strLit.Value
+			idOrVal.Value = val
+			idOrVal.ValueExpression = strLit
+		} else if p.curTok.Type == TokenNumber {
+			val := p.curTok.Literal
+			idOrVal.Value = val
+			idOrVal.ValueExpression = &ast.IntegerLiteral{Value: val, LiteralType: "Integer"}
+			p.nextToken()
+		} else {
+			// Identifier value (like FILEFORMAT, GZIP, etc.)
+			val := p.curTok.Literal
+			idOrVal.Value = val
+			idOrVal.Identifier = &ast.Identifier{Value: val, QuoteType: "NotQuoted"}
+			p.nextToken()
+		}
+		singleOpt.SingleValue = idOrVal
+		opt.Value = singleOpt
+	}
+
+	return opt, nil
+}
+