diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 00000000..408ef3df --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,47 @@ +# Claude Development Guide + +## Next Steps + +To continue implementing parser support for skipped tests, consult: + +``` +skipped_tests_by_size.txt +``` + +This file lists all skipped tests ordered by query file size (smallest first). Smaller tests are generally simpler to implement. + +## Workflow + +1. Pick tests from `skipped_tests_by_size.txt` starting from the top +2. Check the test's `query.sql` to understand what SQL needs parsing +3. Check the test's `ast.json` to understand the expected output format +4. Implement the necessary AST types in `ast/` +5. Add parser logic in `parser/parser.go` +6. Add JSON marshaling functions in `parser/parser.go` +7. Enable the test by setting `{"skip": false}` in its `metadata.json` +8. Run `go test ./parser/...` to verify +9. **Update `skipped_tests_by_size.txt`** after enabling tests + +## Updating skipped_tests_by_size.txt + +After enabling tests, regenerate the file: + +```bash +cd parser/testdata +for dir in */; do + if [ -f "$dir/metadata.json" ] && grep -q '"skip": true' "$dir/metadata.json" 2>/dev/null; then + if [ -f "$dir/query.sql" ]; then + size=$(wc -c < "$dir/query.sql") + name="${dir%/}" + echo "$size $name" + fi + fi +done | sort -n > ../../skipped_tests_by_size.txt +``` + +## Test Structure + +Each test in `parser/testdata/` contains: +- `metadata.json` - `{"skip": true}` or `{"skip": false}` +- `query.sql` - T-SQL to parse +- `ast.json` - Expected AST output diff --git a/ast/begin_transaction_statement.go b/ast/begin_transaction_statement.go new file mode 100644 index 00000000..9c111ac6 --- /dev/null +++ b/ast/begin_transaction_statement.go @@ -0,0 +1,12 @@ +package ast + +// BeginTransactionStatement represents a BEGIN [DISTRIBUTED] [TRAN|TRANSACTION] statement. +type BeginTransactionStatement struct { + Name *IdentifierOrValueExpression `json:"Name,omitempty"` + Distributed bool `json:"Distributed"` + MarkDefined bool `json:"MarkDefined"` + MarkDescription ScalarExpression `json:"MarkDescription,omitempty"` +} + +func (b *BeginTransactionStatement) node() {} +func (b *BeginTransactionStatement) statement() {} diff --git a/ast/commit_transaction_statement.go b/ast/commit_transaction_statement.go new file mode 100644 index 00000000..a05ae19e --- /dev/null +++ b/ast/commit_transaction_statement.go @@ -0,0 +1,10 @@ +package ast + +// CommitTransactionStatement represents a COMMIT [TRAN|TRANSACTION] statement. +type CommitTransactionStatement struct { + Name *IdentifierOrValueExpression `json:"Name,omitempty"` + DelayedDurabilityOption string `json:"DelayedDurabilityOption,omitempty"` +} + +func (c *CommitTransactionStatement) node() {} +func (c *CommitTransactionStatement) statement() {} diff --git a/ast/create_default_statement.go b/ast/create_default_statement.go new file mode 100644 index 00000000..d2c4aeb2 --- /dev/null +++ b/ast/create_default_statement.go @@ -0,0 +1,10 @@ +package ast + +// CreateDefaultStatement represents a CREATE DEFAULT statement. +type CreateDefaultStatement struct { + Name *SchemaObjectName `json:"Name"` + Expression ScalarExpression `json:"Expression"` +} + +func (c *CreateDefaultStatement) node() {} +func (c *CreateDefaultStatement) statement() {} diff --git a/ast/create_master_key_statement.go b/ast/create_master_key_statement.go new file mode 100644 index 00000000..1e1e4ed8 --- /dev/null +++ b/ast/create_master_key_statement.go @@ -0,0 +1,9 @@ +package ast + +// CreateMasterKeyStatement represents a CREATE MASTER KEY ENCRYPTION BY PASSWORD statement. +type CreateMasterKeyStatement struct { + Password ScalarExpression `json:"Password"` +} + +func (c *CreateMasterKeyStatement) node() {} +func (c *CreateMasterKeyStatement) statement() {} diff --git a/ast/goto_statement.go b/ast/goto_statement.go new file mode 100644 index 00000000..40246278 --- /dev/null +++ b/ast/goto_statement.go @@ -0,0 +1,9 @@ +package ast + +// GoToStatement represents a GOTO label statement. +type GoToStatement struct { + LabelName *Identifier `json:"LabelName"` +} + +func (g *GoToStatement) node() {} +func (g *GoToStatement) statement() {} diff --git a/ast/identifier_or_value_expression.go b/ast/identifier_or_value_expression.go index 49d3bd59..011bd6b1 100644 --- a/ast/identifier_or_value_expression.go +++ b/ast/identifier_or_value_expression.go @@ -2,8 +2,9 @@ package ast // IdentifierOrValueExpression represents either an identifier or a value expression. type IdentifierOrValueExpression struct { - Value string `json:"Value,omitempty"` - Identifier *Identifier `json:"Identifier,omitempty"` + Value string `json:"Value,omitempty"` + Identifier *Identifier `json:"Identifier,omitempty"` + ValueExpression ScalarExpression `json:"ValueExpression,omitempty"` } func (*IdentifierOrValueExpression) node() {} diff --git a/ast/label_statement.go b/ast/label_statement.go new file mode 100644 index 00000000..0a8f7da5 --- /dev/null +++ b/ast/label_statement.go @@ -0,0 +1,9 @@ +package ast + +// LabelStatement represents a label definition (e.g., "start:"). +type LabelStatement struct { + Value string `json:"Value"` +} + +func (l *LabelStatement) node() {} +func (l *LabelStatement) statement() {} diff --git a/ast/parenthesis_expression.go b/ast/parenthesis_expression.go new file mode 100644 index 00000000..72d7a126 --- /dev/null +++ b/ast/parenthesis_expression.go @@ -0,0 +1,9 @@ +package ast + +// ParenthesisExpression represents a parenthesized scalar expression. +type ParenthesisExpression struct { + Expression ScalarExpression `json:"Expression,omitempty"` +} + +func (p *ParenthesisExpression) node() {} +func (p *ParenthesisExpression) scalarExpression() {} diff --git a/ast/rollback_transaction_statement.go b/ast/rollback_transaction_statement.go new file mode 100644 index 00000000..50e973f7 --- /dev/null +++ b/ast/rollback_transaction_statement.go @@ -0,0 +1,9 @@ +package ast + +// RollbackTransactionStatement represents a ROLLBACK [TRAN|TRANSACTION] statement. +type RollbackTransactionStatement struct { + Name *IdentifierOrValueExpression `json:"Name,omitempty"` +} + +func (r *RollbackTransactionStatement) node() {} +func (r *RollbackTransactionStatement) statement() {} diff --git a/ast/save_transaction_statement.go b/ast/save_transaction_statement.go new file mode 100644 index 00000000..91c6f8ea --- /dev/null +++ b/ast/save_transaction_statement.go @@ -0,0 +1,9 @@ +package ast + +// SaveTransactionStatement represents a SAVE [TRAN|TRANSACTION] statement. +type SaveTransactionStatement struct { + Name *IdentifierOrValueExpression `json:"Name,omitempty"` +} + +func (s *SaveTransactionStatement) node() {} +func (s *SaveTransactionStatement) statement() {} diff --git a/ast/try_catch_statement.go b/ast/try_catch_statement.go new file mode 100644 index 00000000..df5b22c7 --- /dev/null +++ b/ast/try_catch_statement.go @@ -0,0 +1,10 @@ +package ast + +// TryCatchStatement represents a BEGIN TRY...END TRY BEGIN CATCH...END CATCH block. +type TryCatchStatement struct { + TryStatements *StatementList `json:"TryStatements,omitempty"` + CatchStatements *StatementList `json:"CatchStatements,omitempty"` +} + +func (t *TryCatchStatement) node() {} +func (t *TryCatchStatement) statement() {} diff --git a/ast/waitfor_statement.go b/ast/waitfor_statement.go new file mode 100644 index 00000000..6f6d1ade --- /dev/null +++ b/ast/waitfor_statement.go @@ -0,0 +1,12 @@ +package ast + +// WaitForStatement represents a WAITFOR [DELAY|TIME] statement. +type WaitForStatement struct { + WaitForOption string `json:"WaitForOption"` + Parameter ScalarExpression `json:"Parameter,omitempty"` + Timeout ScalarExpression `json:"Timeout,omitempty"` + Statement Statement `json:"Statement,omitempty"` +} + +func (w *WaitForStatement) node() {} +func (w *WaitForStatement) statement() {} diff --git a/parser/lexer.go b/parser/lexer.go index 2f69345e..da77a376 100644 --- a/parser/lexer.go +++ b/parser/lexer.go @@ -130,6 +130,27 @@ const ( TokenRevoke TokenTo TokenPublic + + // Transaction keywords + TokenCommit + TokenRollback + TokenSave + TokenTransaction + TokenTran + TokenWork + + // Additional keywords + TokenWaitfor + TokenDelay + TokenTime + TokenMaster + TokenKey + TokenEncryption + TokenPassword + TokenLabel + TokenRaiserror + TokenTruncate + TokenColon ) // Token represents a lexical token. @@ -211,6 +232,10 @@ func (l *Lexer) NextToken() Token { tok.Type = TokenSemicolon tok.Literal = ";" l.readChar() + case ':': + tok.Type = TokenColon + tok.Literal = ":" + l.readChar() case '=': tok.Type = TokenEquals tok.Literal = "=" @@ -478,6 +503,21 @@ var keywords = map[string]TokenType{ "REVOKE": TokenRevoke, "TO": TokenTo, "PUBLIC": TokenPublic, + "COMMIT": TokenCommit, + "ROLLBACK": TokenRollback, + "SAVE": TokenSave, + "TRANSACTION": TokenTransaction, + "TRAN": TokenTran, + "WORK": TokenWork, + "WAITFOR": TokenWaitfor, + "DELAY": TokenDelay, + "TIME": TokenTime, + "MASTER": TokenMaster, + "KEY": TokenKey, + "ENCRYPTION": TokenEncryption, + "PASSWORD": TokenPassword, + "RAISERROR": TokenRaiserror, + "TRUNCATE": TokenTruncate, } func lookupKeyword(ident string) TokenType { diff --git a/parser/parser.go b/parser/parser.go index 47a45fdd..9c6d3579 100644 --- a/parser/parser.go +++ b/parser/parser.go @@ -105,7 +105,7 @@ func (p *Parser) parseStatement() (ast.Statement, error) { case TokenWhile: return p.parseWhileStatement() case TokenBegin: - return p.parseBeginEndBlockStatement() + return p.parseBeginStatement() case TokenCreate: return p.parseCreateStatement() case TokenExec, TokenExecute: @@ -128,9 +128,22 @@ func (p *Parser) parseStatement() (ast.Statement, error) { return p.parseContinueStatement() case TokenGrant: return p.parseGrantStatement() + case TokenCommit: + return p.parseCommitTransactionStatement() + case TokenRollback: + return p.parseRollbackTransactionStatement() + case TokenSave: + return p.parseSaveTransactionStatement() + case TokenWaitfor: + return p.parseWaitForStatement() + case TokenGoto: + return p.parseGotoStatement() case TokenSemicolon: p.nextToken() return nil, nil + case TokenIdent: + // Check for label (identifier followed by colon) + return p.parseLabelOrError() default: return nil, fmt.Errorf("unexpected token: %s", p.curTok.Literal) } @@ -784,6 +797,11 @@ func (p *Parser) parsePrimaryExpression() (ast.ScalarExpression, error) { p.nextToken() return &ast.VariableReference{Name: name}, nil } + // Check for N-prefixed national string (N'...') + if strings.ToUpper(p.curTok.Literal) == "N" && p.peekTok.Type == TokenString { + p.nextToken() // consume N + return p.parseNationalStringLiteral() + } return p.parseColumnReference() case TokenNumber: val := p.curTok.Literal @@ -808,7 +826,7 @@ func (p *Parser) parsePrimaryExpression() (ast.ScalarExpression, error) { return nil, fmt.Errorf("expected ), got %s", p.curTok.Literal) } p.nextToken() - return expr, nil + return &ast.ParenthesisExpression{Expression: expr}, nil default: return nil, fmt.Errorf("unexpected token in expression: %s", p.curTok.Literal) } @@ -884,6 +902,31 @@ func (p *Parser) parseStringLiteral() (*ast.StringLiteral, error) { }, nil } +func (p *Parser) parseNationalStringLiteral() (*ast.StringLiteral, error) { + raw := p.curTok.Literal + p.nextToken() + + // Remove surrounding quotes and handle escaped quotes + if len(raw) >= 2 && raw[0] == '\'' && raw[len(raw)-1] == '\'' { + inner := raw[1 : len(raw)-1] + // Replace escaped quotes + value := strings.ReplaceAll(inner, "''", "'") + return &ast.StringLiteral{ + LiteralType: "String", + IsNational: true, + IsLargeObject: false, + Value: value, + }, nil + } + + return &ast.StringLiteral{ + LiteralType: "String", + IsNational: true, + IsLargeObject: false, + Value: raw, + }, nil +} + func (p *Parser) parseColumnReference() (*ast.ColumnReferenceExpression, error) { var identifiers []*ast.Identifier @@ -2437,6 +2480,177 @@ func (p *Parser) parseWhileStatement() (*ast.WhileStatement, error) { return stmt, nil } +func (p *Parser) parseBeginStatement() (ast.Statement, error) { + // Peek at what follows BEGIN + p.nextToken() // consume BEGIN + + switch p.curTok.Type { + case TokenTransaction, TokenTran: + return p.parseBeginTransactionStatementContinued(false) + case TokenTry: + return p.parseTryCatchStatement() + case TokenIdent: + // Check for DISTRIBUTED + if strings.ToUpper(p.curTok.Literal) == "DISTRIBUTED" { + p.nextToken() // consume DISTRIBUTED + if p.curTok.Type == TokenTransaction || p.curTok.Type == TokenTran { + return p.parseBeginTransactionStatementContinued(true) + } + return nil, fmt.Errorf("expected TRANSACTION after DISTRIBUTED, got %s", p.curTok.Literal) + } + // Fall through to BEGIN...END block + fallthrough + default: + return p.parseBeginEndBlockStatementContinued() + } +} + +func (p *Parser) parseBeginTransactionStatementContinued(distributed bool) (*ast.BeginTransactionStatement, error) { + // TRANSACTION or TRAN already consumed by caller + p.nextToken() + + stmt := &ast.BeginTransactionStatement{ + Distributed: distributed, + } + + // Optional transaction name or variable + if p.curTok.Type == TokenIdent && !isKeyword(p.curTok.Literal) { + stmt.Name = &ast.IdentifierOrValueExpression{ + Value: p.curTok.Literal, + Identifier: &ast.Identifier{ + Value: p.curTok.Literal, + QuoteType: "NotQuoted", + }, + } + p.nextToken() + } else if p.curTok.Type == TokenIdent && p.curTok.Literal[0] == '@' { + stmt.Name = &ast.IdentifierOrValueExpression{ + Value: p.curTok.Literal, + ValueExpression: &ast.VariableReference{ + Name: p.curTok.Literal, + }, + } + p.nextToken() + } + + // Check for WITH MARK + if p.curTok.Type == TokenWith { + p.nextToken() // consume WITH + if p.curTok.Type == TokenIdent && strings.ToUpper(p.curTok.Literal) == "MARK" { + stmt.MarkDefined = true + p.nextToken() // consume MARK + // Optional mark description + if p.curTok.Type == TokenString || (p.curTok.Type == TokenIdent && p.curTok.Literal[0] == '@') { + desc, err := p.parseScalarExpression() + if err != nil { + return nil, err + } + stmt.MarkDescription = desc + } + } + } + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + +func (p *Parser) parseTryCatchStatement() (*ast.TryCatchStatement, error) { + // TRY already seen, consume it + p.nextToken() + + stmt := &ast.TryCatchStatement{ + TryStatements: &ast.StatementList{}, + } + + // Parse statements until END TRY + for p.curTok.Type != TokenEnd && p.curTok.Type != TokenEOF { + s, err := p.parseStatement() + if err != nil { + return nil, err + } + if s != nil { + stmt.TryStatements.Statements = append(stmt.TryStatements.Statements, s) + } + } + + // Consume END TRY + if p.curTok.Type == TokenEnd { + p.nextToken() // consume END + if p.curTok.Type == TokenTry { + p.nextToken() // consume TRY + } + } + + // Expect BEGIN CATCH + if p.curTok.Type == TokenBegin { + p.nextToken() // consume BEGIN + if p.curTok.Type == TokenCatch { + p.nextToken() // consume CATCH + } + } + + stmt.CatchStatements = &ast.StatementList{} + + // Parse catch statements until END CATCH + for p.curTok.Type != TokenEnd && p.curTok.Type != TokenEOF { + s, err := p.parseStatement() + if err != nil { + return nil, err + } + if s != nil { + stmt.CatchStatements.Statements = append(stmt.CatchStatements.Statements, s) + } + } + + // Consume END CATCH + if p.curTok.Type == TokenEnd { + p.nextToken() // consume END + if p.curTok.Type == TokenCatch { + p.nextToken() // consume CATCH + } + } + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + +func (p *Parser) parseBeginEndBlockStatementContinued() (*ast.BeginEndBlockStatement, error) { + stmt := &ast.BeginEndBlockStatement{ + StatementList: &ast.StatementList{}, + } + + // Parse statements until END + for p.curTok.Type != TokenEnd && p.curTok.Type != TokenEOF { + s, err := p.parseStatement() + if err != nil { + return nil, err + } + if s != nil { + stmt.StatementList.Statements = append(stmt.StatementList.Statements, s) + } + } + + // Consume END + if p.curTok.Type == TokenEnd { + p.nextToken() + } + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + func (p *Parser) parseBeginEndBlockStatement() (*ast.BeginEndBlockStatement, error) { // Consume BEGIN p.nextToken() @@ -2480,6 +2694,10 @@ func (p *Parser) parseCreateStatement() (ast.Statement, error) { return p.parseCreateViewStatement() case TokenSchema: return p.parseCreateSchemaStatement() + case TokenDefault: + return p.parseCreateDefaultStatement() + case TokenMaster: + return p.parseCreateMasterKeyStatement() default: return nil, fmt.Errorf("unexpected token after CREATE: %s", p.curTok.Literal) } @@ -2592,6 +2810,90 @@ func (p *Parser) parseCreateSchemaStatement() (*ast.CreateSchemaStatement, error return stmt, nil } +func (p *Parser) parseCreateDefaultStatement() (*ast.CreateDefaultStatement, error) { + // Consume DEFAULT + p.nextToken() + + stmt := &ast.CreateDefaultStatement{} + + // Parse default name + name, err := p.parseSchemaObjectName() + if err != nil { + return nil, err + } + stmt.Name = name + + // Expect AS + if p.curTok.Type == TokenAs { + p.nextToken() + } + + // Parse expression + expr, err := p.parseScalarExpression() + if err != nil { + return nil, err + } + stmt.Expression = expr + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + +func (p *Parser) parseCreateMasterKeyStatement() (*ast.CreateMasterKeyStatement, error) { + // Consume MASTER + p.nextToken() + + stmt := &ast.CreateMasterKeyStatement{} + + // Expect KEY + if p.curTok.Type != TokenKey { + return nil, fmt.Errorf("expected KEY after MASTER, got %s", p.curTok.Literal) + } + p.nextToken() + + // Expect ENCRYPTION + if p.curTok.Type != TokenEncryption { + return nil, fmt.Errorf("expected ENCRYPTION after KEY, got %s", p.curTok.Literal) + } + p.nextToken() + + // Expect BY + if p.curTok.Type != TokenBy { + return nil, fmt.Errorf("expected BY after ENCRYPTION, got %s", p.curTok.Literal) + } + p.nextToken() + + // Expect PASSWORD + if p.curTok.Type != TokenPassword { + return nil, fmt.Errorf("expected PASSWORD after BY, got %s", p.curTok.Literal) + } + p.nextToken() + + // Expect = + if p.curTok.Type != TokenEquals { + return nil, fmt.Errorf("expected = after PASSWORD, got %s", p.curTok.Literal) + } + p.nextToken() + + // Parse password expression + password, err := p.parseScalarExpression() + if err != nil { + return nil, err + } + stmt.Password = password + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + func (p *Parser) parseExecuteStatement() (*ast.ExecuteStatement, error) { execSpec, err := p.parseExecuteSpecification() if err != nil { @@ -2652,6 +2954,202 @@ func (p *Parser) parseContinueStatement() (*ast.ContinueStatement, error) { return &ast.ContinueStatement{}, nil } +func (p *Parser) parseCommitTransactionStatement() (*ast.CommitTransactionStatement, error) { + // Consume COMMIT + p.nextToken() + + stmt := &ast.CommitTransactionStatement{ + DelayedDurabilityOption: "NotSet", + } + + // Skip optional WORK, TRAN, or TRANSACTION + if p.curTok.Type == TokenWork || p.curTok.Type == TokenTran || p.curTok.Type == TokenTransaction { + p.nextToken() + } + + // Optional transaction name or variable + if p.curTok.Type == TokenIdent && !isKeyword(p.curTok.Literal) && p.curTok.Literal[0] != '@' { + stmt.Name = &ast.IdentifierOrValueExpression{ + Value: p.curTok.Literal, + Identifier: &ast.Identifier{ + Value: p.curTok.Literal, + QuoteType: "NotQuoted", + }, + } + p.nextToken() + } else if p.curTok.Type == TokenIdent && p.curTok.Literal[0] == '@' { + stmt.Name = &ast.IdentifierOrValueExpression{ + Value: p.curTok.Literal, + ValueExpression: &ast.VariableReference{ + Name: p.curTok.Literal, + }, + } + p.nextToken() + } + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + +func (p *Parser) parseRollbackTransactionStatement() (*ast.RollbackTransactionStatement, error) { + // Consume ROLLBACK + p.nextToken() + + stmt := &ast.RollbackTransactionStatement{} + + // Skip optional WORK, TRAN, or TRANSACTION + if p.curTok.Type == TokenWork || p.curTok.Type == TokenTran || p.curTok.Type == TokenTransaction { + p.nextToken() + } + + // Optional transaction name or variable + if p.curTok.Type == TokenIdent && !isKeyword(p.curTok.Literal) && p.curTok.Literal[0] != '@' { + stmt.Name = &ast.IdentifierOrValueExpression{ + Value: p.curTok.Literal, + Identifier: &ast.Identifier{ + Value: p.curTok.Literal, + QuoteType: "NotQuoted", + }, + } + p.nextToken() + } else if p.curTok.Type == TokenIdent && p.curTok.Literal[0] == '@' { + stmt.Name = &ast.IdentifierOrValueExpression{ + Value: p.curTok.Literal, + ValueExpression: &ast.VariableReference{ + Name: p.curTok.Literal, + }, + } + p.nextToken() + } + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + +func (p *Parser) parseSaveTransactionStatement() (*ast.SaveTransactionStatement, error) { + // Consume SAVE + p.nextToken() + + stmt := &ast.SaveTransactionStatement{} + + // Skip optional TRAN or TRANSACTION + if p.curTok.Type == TokenTran || p.curTok.Type == TokenTransaction { + p.nextToken() + } + + // Optional transaction name or variable + if p.curTok.Type == TokenIdent && !isKeyword(p.curTok.Literal) && p.curTok.Literal[0] != '@' { + stmt.Name = &ast.IdentifierOrValueExpression{ + Value: p.curTok.Literal, + Identifier: &ast.Identifier{ + Value: p.curTok.Literal, + QuoteType: "NotQuoted", + }, + } + p.nextToken() + } else if p.curTok.Type == TokenIdent && p.curTok.Literal[0] == '@' { + stmt.Name = &ast.IdentifierOrValueExpression{ + Value: p.curTok.Literal, + ValueExpression: &ast.VariableReference{ + Name: p.curTok.Literal, + }, + } + p.nextToken() + } + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + +func (p *Parser) parseWaitForStatement() (*ast.WaitForStatement, error) { + // Consume WAITFOR + p.nextToken() + + stmt := &ast.WaitForStatement{} + + // Expect DELAY or TIME + if p.curTok.Type == TokenDelay { + stmt.WaitForOption = "Delay" + p.nextToken() + } else if p.curTok.Type == TokenTime { + stmt.WaitForOption = "Time" + p.nextToken() + } else { + return nil, fmt.Errorf("expected DELAY or TIME after WAITFOR, got %s", p.curTok.Literal) + } + + // Parse the parameter expression + param, err := p.parseScalarExpression() + if err != nil { + return nil, err + } + stmt.Parameter = param + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + +func (p *Parser) parseGotoStatement() (*ast.GoToStatement, error) { + // Consume GOTO + p.nextToken() + + stmt := &ast.GoToStatement{} + + // Expect label name + if p.curTok.Type == TokenIdent { + stmt.LabelName = &ast.Identifier{ + Value: p.curTok.Literal, + QuoteType: "NotQuoted", + } + p.nextToken() + } else { + return nil, fmt.Errorf("expected label name after GOTO, got %s", p.curTok.Literal) + } + + // Skip optional semicolon + if p.curTok.Type == TokenSemicolon { + p.nextToken() + } + + return stmt, nil +} + +func (p *Parser) parseLabelOrError() (ast.Statement, error) { + // Check if this is a label (identifier followed by colon) + label := p.curTok.Literal + p.nextToken() + + // Check if followed by colon - then it's a label + if p.curTok.Type == TokenColon { + p.nextToken() // consume the colon + return &ast.LabelStatement{Value: label + ":"}, nil + } + + // Not a label - return error + return nil, fmt.Errorf("unexpected identifier: %s", label) +} + +func isKeyword(s string) bool { + _, ok := keywords[strings.ToUpper(s)] + return ok +} + // ======================= End New Statement Parsing Functions ======================= // jsonNode represents a generic JSON node from the AST JSON format. @@ -2739,6 +3237,26 @@ func statementToJSON(stmt ast.Statement) jsonNode { return grantStatementToJSON(s) case *ast.PredicateSetStatement: return predicateSetStatementToJSON(s) + case *ast.CommitTransactionStatement: + return commitTransactionStatementToJSON(s) + case *ast.RollbackTransactionStatement: + return rollbackTransactionStatementToJSON(s) + case *ast.SaveTransactionStatement: + return saveTransactionStatementToJSON(s) + case *ast.BeginTransactionStatement: + return beginTransactionStatementToJSON(s) + case *ast.WaitForStatement: + return waitForStatementToJSON(s) + case *ast.GoToStatement: + return goToStatementToJSON(s) + case *ast.LabelStatement: + return labelStatementToJSON(s) + case *ast.CreateDefaultStatement: + return createDefaultStatementToJSON(s) + case *ast.CreateMasterKeyStatement: + return createMasterKeyStatementToJSON(s) + case *ast.TryCatchStatement: + return tryCatchStatementToJSON(s) default: return jsonNode{"$type": "UnknownStatement"} } @@ -3109,6 +3627,14 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode { node["Expression"] = scalarExpressionToJSON(e.Expression) } return node + case *ast.ParenthesisExpression: + node := jsonNode{ + "$type": "ParenthesisExpression", + } + if e.Expression != nil { + node["Expression"] = scalarExpressionToJSON(e.Expression) + } + return node default: return jsonNode{"$type": "UnknownScalarExpression"} } @@ -3153,6 +3679,9 @@ func identifierOrValueExpressionToJSON(iove *ast.IdentifierOrValueExpression) js if iove.Identifier != nil { node["Identifier"] = identifierToJSON(iove.Identifier) } + if iove.ValueExpression != nil { + node["ValueExpression"] = scalarExpressionToJSON(iove.ValueExpression) + } return node } @@ -4159,3 +4688,116 @@ func predicateSetStatementToJSON(s *ast.PredicateSetStatement) jsonNode { "IsOn": s.IsOn, } } + +func commitTransactionStatementToJSON(s *ast.CommitTransactionStatement) jsonNode { + node := jsonNode{ + "$type": "CommitTransactionStatement", + "DelayedDurabilityOption": s.DelayedDurabilityOption, + } + if s.Name != nil { + node["Name"] = identifierOrValueExpressionToJSON(s.Name) + } + return node +} + +func rollbackTransactionStatementToJSON(s *ast.RollbackTransactionStatement) jsonNode { + node := jsonNode{ + "$type": "RollbackTransactionStatement", + } + if s.Name != nil { + node["Name"] = identifierOrValueExpressionToJSON(s.Name) + } + return node +} + +func saveTransactionStatementToJSON(s *ast.SaveTransactionStatement) jsonNode { + node := jsonNode{ + "$type": "SaveTransactionStatement", + } + if s.Name != nil { + node["Name"] = identifierOrValueExpressionToJSON(s.Name) + } + return node +} + +func beginTransactionStatementToJSON(s *ast.BeginTransactionStatement) jsonNode { + node := jsonNode{ + "$type": "BeginTransactionStatement", + "Distributed": s.Distributed, + "MarkDefined": s.MarkDefined, + } + if s.Name != nil { + node["Name"] = identifierOrValueExpressionToJSON(s.Name) + } + if s.MarkDescription != nil { + node["MarkDescription"] = scalarExpressionToJSON(s.MarkDescription) + } + return node +} + +func waitForStatementToJSON(s *ast.WaitForStatement) jsonNode { + node := jsonNode{ + "$type": "WaitForStatement", + "WaitForOption": s.WaitForOption, + } + if s.Parameter != nil { + node["Parameter"] = scalarExpressionToJSON(s.Parameter) + } + if s.Timeout != nil { + node["Timeout"] = scalarExpressionToJSON(s.Timeout) + } + return node +} + +func goToStatementToJSON(s *ast.GoToStatement) jsonNode { + node := jsonNode{ + "$type": "GoToStatement", + } + if s.LabelName != nil { + node["LabelName"] = identifierToJSON(s.LabelName) + } + return node +} + +func labelStatementToJSON(s *ast.LabelStatement) jsonNode { + return jsonNode{ + "$type": "LabelStatement", + "Value": s.Value, + } +} + +func createDefaultStatementToJSON(s *ast.CreateDefaultStatement) jsonNode { + node := jsonNode{ + "$type": "CreateDefaultStatement", + } + if s.Name != nil { + node["Name"] = schemaObjectNameToJSON(s.Name) + } + if s.Expression != nil { + node["Expression"] = scalarExpressionToJSON(s.Expression) + } + return node +} + +func createMasterKeyStatementToJSON(s *ast.CreateMasterKeyStatement) jsonNode { + node := jsonNode{ + "$type": "CreateMasterKeyStatement", + } + if s.Password != nil { + node["Password"] = scalarExpressionToJSON(s.Password) + } + return node +} + +func tryCatchStatementToJSON(s *ast.TryCatchStatement) jsonNode { + node := jsonNode{ + "$type": "TryCatchStatement", + } + if s.TryStatements != nil { + node["TryStatements"] = statementListToJSON(s.TryStatements) + } + if s.CatchStatements != nil { + node["CatchStatements"] = statementListToJSON(s.CatchStatements) + } + return node +} diff --git a/parser/testdata/BaselinesCommon_CommitTransactionStatementTests/metadata.json b/parser/testdata/BaselinesCommon_CommitTransactionStatementTests/metadata.json index 49e9182b..e27d63a6 100644 --- a/parser/testdata/BaselinesCommon_CommitTransactionStatementTests/metadata.json +++ b/parser/testdata/BaselinesCommon_CommitTransactionStatementTests/metadata.json @@ -1 +1 @@ -{"skip": true} +{"skip": false} diff --git a/parser/testdata/BaselinesCommon_RollbackTransactionStatementTests/metadata.json b/parser/testdata/BaselinesCommon_RollbackTransactionStatementTests/metadata.json index 49e9182b..e27d63a6 100644 --- a/parser/testdata/BaselinesCommon_RollbackTransactionStatementTests/metadata.json +++ b/parser/testdata/BaselinesCommon_RollbackTransactionStatementTests/metadata.json @@ -1 +1 @@ -{"skip": true} +{"skip": false} diff --git a/parser/testdata/BaselinesCommon_WaitForStatementTests/metadata.json b/parser/testdata/BaselinesCommon_WaitForStatementTests/metadata.json index 49e9182b..e27d63a6 100644 --- a/parser/testdata/BaselinesCommon_WaitForStatementTests/metadata.json +++ b/parser/testdata/BaselinesCommon_WaitForStatementTests/metadata.json @@ -1 +1 @@ -{"skip": true} +{"skip": false} diff --git a/parser/testdata/CommitTransactionStatementTests/metadata.json b/parser/testdata/CommitTransactionStatementTests/metadata.json index 49e9182b..e27d63a6 100644 --- a/parser/testdata/CommitTransactionStatementTests/metadata.json +++ b/parser/testdata/CommitTransactionStatementTests/metadata.json @@ -1 +1 @@ -{"skip": true} +{"skip": false} diff --git a/parser/testdata/CreateDefaultStatementTests/metadata.json b/parser/testdata/CreateDefaultStatementTests/metadata.json index 49e9182b..e27d63a6 100644 --- a/parser/testdata/CreateDefaultStatementTests/metadata.json +++ b/parser/testdata/CreateDefaultStatementTests/metadata.json @@ -1 +1 @@ -{"skip": true} +{"skip": false} diff --git a/parser/testdata/CreateMasterKeyStatementTests/metadata.json b/parser/testdata/CreateMasterKeyStatementTests/metadata.json index 49e9182b..e27d63a6 100644 --- a/parser/testdata/CreateMasterKeyStatementTests/metadata.json +++ b/parser/testdata/CreateMasterKeyStatementTests/metadata.json @@ -1 +1 @@ -{"skip": true} +{"skip": false} diff --git a/parser/testdata/RollbackTransactionStatementTests/metadata.json b/parser/testdata/RollbackTransactionStatementTests/metadata.json index 49e9182b..e27d63a6 100644 --- a/parser/testdata/RollbackTransactionStatementTests/metadata.json +++ b/parser/testdata/RollbackTransactionStatementTests/metadata.json @@ -1 +1 @@ -{"skip": true} +{"skip": false} diff --git a/parser/testdata/WaitForStatementTests/metadata.json b/parser/testdata/WaitForStatementTests/metadata.json index 49e9182b..e27d63a6 100644 --- a/parser/testdata/WaitForStatementTests/metadata.json +++ b/parser/testdata/WaitForStatementTests/metadata.json @@ -1 +1 @@ -{"skip": true} +{"skip": false} diff --git a/skipped_tests_by_size.txt b/skipped_tests_by_size.txt new file mode 100644 index 00000000..608f7858 --- /dev/null +++ b/skipped_tests_by_size.txt @@ -0,0 +1,998 @@ +0 BaselinesCommon_ZeroLengthFile +16 PhaseOne_InsertBulkTest +22 PhaseOne_BackupStatementTest +24 PhaseOne_BulkInsertTest +25 PhaseOne_RestoreStatementTest +33 Baselines170_DropExternalModelStatementTests170 +33 DropExternalModelStatementTests170 +42 Baselines90_DeprecatedKeywordsIn90Tests +45 Baselines150_OptimizerHintsTests150 +47 OptimizerHintsTests150 +50 PhaseOne_AlterUserTest +51 PhaseOne_AlterRouteTest +51 PhaseOne_CreateRole +51 PhaseOne_CreateUser +52 Baselines110_WhitespaceTests +52 PhaseOne_CreateLogin +52 PhaseOne_CreateRoute +54 PhaseOne_AlterAssemblyTest +54 PhaseOne_CreateRuleStatementTest +54 PhaseOne_CreateService +55 PhaseOne_AlterEndpointTest +55 PhaseOne_CreateAssembly +55 PhaseOne_CreateContract +55 PhaseOne_CreateDatabase +55 PhaseOne_CreateEndpoint +55 PhaseOne_CreateProcedureStatementTest +55 PhaseOne_CreateQueue +55 PhaseOne_CreateViewStatementTest +56 PhaseOne_AlterLoginTest +56 PhaseOne_AlterRoleTest +57 PhaseOne_AlterServiceTest +57 PhaseOne_CreateCredential +58 PhaseOne_CreateSynonym +59 AlterTableAlterIndex130 +59 PhaseOne_AlterCredentialTest +59 PhaseOne_CreateAggregate +59 PhaseOne_CreateFunctionStatementTest +59 PhaseOne_CreateMessageType +60 PhaseOne_AlterCertificateTest +60 PhaseOne_CreateDefaultStatementTest +60 PhaseOne_CreateSymmetricKey +60 PhaseOne_CreateTypeUddt +61 PhaseOne_AlterServiceMasterKeyTest +61 PhaseOne_CreateAsymmetricKey +61 PhaseOne_CreateExternalTable +62 Baselines130_AlterTableAlterIndex130 +62 PhaseOne_AlterApplicationRoleTest +62 PhaseOne_AlterAssymetricKeyTest +62 PhaseOne_AlterQueueTest +62 PhaseOne_CreateXmlIndex +63 PhaseOne_CreateApplicationRole +63 PhaseOne_CreateFulltextCatalog +63 PhaseOne_CreatePartitionScheme +63 PhaseOne_CreateTableStatementTest +64 MoveConversationStatementTests +64 PhaseOne_AlterPartitionSchemeTest +64 PhaseOne_CreateTypeUdt +65 Baselines110_OptimizerHintsTests110 +65 PhaseOne_AlterTriggerDatabaseTest +65 PhaseOne_CreateEventNotification +66 PhaseOne_CreateIndexStatementTest +67 Baselines160_CreateUserFromExternalProvider160 +67 Baselines90_MoveConversationStatementTests +67 CreateUserFromExternalProvider160 +67 PhaseOne_AlterTriggerAllServerTest +67 PhaseOne_CreatePartitionFunction +67 PhaseOne_CreateTriggerStatementTest +68 LoginStatementTests100 +68 MiscTests110 +68 PhaseOne_AlterRemoteServiceBindingTest +68 PhaseOne_CreateFulltextIndex +69 Baselines90_MiscDeprecatedIn100Tests +69 PhaseOne_AlterDatabaseAddFileStatementTest +69 PhaseOne_AlterPartitionFunctionTest +69 PhaseOne_CreateExternalDataSource +69 PhaseOne_CreateExternalFileFormat +69 PhaseOne_CreateRemoteServiceBinding +70 PhaseOne_AlterDatabaseModifyFileStatementTest +70 PhaseOne_AlterSymmetricKeyTest +70 PhaseOne_CreatePrimaryXmlIndex +70 PhaseOne_CreateStatisticsStatementTest +71 Baselines100_LoginStatementTests100 +71 PhaseOne_AlterDatabaseAddLogFileStatementTest +71 PhaseOne_AlterFulltextCatalogTest +71 PhaseOne_AlterTableAddColumnDefinitionTest +71 PhaseOne_AlterXmlSchemaCollectionTest +71 PhaseOne_CreateXmlSchemaCollection +72 BaselinesCommon_VariableTests +72 PhaseOne_AlterDatabaseScopedCredential +73 PhaseOne_CreateDatabaseScopedCredential +74 PhaseOne_CreateSchemaStatementTest +75 Baselines110_MiscTests110 +76 Baselines160_AlterTableStatementTests160 +77 Baselines110_RoleStatementTests110 +77 Baselines80_CreateDefaultStatementTests +77 BaselinesCommon_AlterTableDropTableElementStatementTests +78 PhaseOne_AlterDatabaseAddFilegroupStatementTest +78 PhaseOne_AlterDatabaseRemoveFileStatementTest +79 Baselines130_CreateMasterKeyStatementTests130 +79 Baselines90_CreateDefaultStatementTests +79 CreateMasterKeyStatementTests130 +79 PhaseOne_AlterTableDropTableElementStatementTest +80 PhaseOne_AlterDatabaseModifyNameStatementTest +80 PhaseOne_AlterTableAlterColumnStatementTest +81 AlterTableAddIndexTests +81 Baselines130_AlterTableAddIndexTests +81 PhaseOne_AlterDatabaseRemoveFilegroupStatementTest +81 PhaseOne_AlterDatabaseWithSqlCommandIdentifier +82 DropExternalLibrary140 +83 Baselines90_SemicolonsBeforeStatementTests1 +86 Baselines140_DropExternalLibrary140 +88 PhaseOne_AlterFulltextIndexTest +88 PhaseOne_AlterTableTriggerModificationStatementTest +89 PhaseOne_AlterDatabaseModifyFilegroup3StatementTest +90 AlterServerConfigurationSoftNumaTests130 +90 Baselines100_CreateAggregateStatementTests100 +90 Baselines130_AlterServerConfigurationSoftNumaTests130 +90 PhaseOne_AlterMasterKeyTest +91 PhaseOne_AlterDatabaseModifyFilegroup1StatementTest +92 PhaseOne_AlterTableAddCheckConstraintTest +93 Baselines160_TestTrimReturn160 +94 Baselines150_DropExternalLanguage150 +94 DropExternalLanguage150 +94 PhaseOne_AlterTableAddEdgeConstraintTest +94 PhaseOne_AlterTableAddUniqueConstraintTest +95 AlterCreateDatabaseStatementTests90 +95 IntegerTests +95 PhaseOne_AlterTableAddForeignKeyConstraintTest +95 PhaseOne_AlterTableAddPrimaryKeyConstraintTest +96 BaselinesCommon_IntegerTests +96 PhaseOne_AlterTableAddDefaultConstraintTest +96 PhaseOne_AlterTableConstraintModificationStatementTest +98 MiscDeprecatedIn100Tests +98 PhaseOne_AlterDatabaseModifyFilegroup2StatementTest +100 Baselines130_CreateColumnStoreIndexTestsDw +100 Baselines90_RoleStatementTests +100 RoleStatementTests110 +101 BaselinesCommon_DeclareVariableStatementTests +102 Baselines170_OptimizedLockingTests170 +103 Baselines130_CreateTriggerStatementTests130 +103 OptimizedLockingTests170 +103 PhaseOne_AlterMessageTypeTest +105 Baselines80_CreateRuleStatementTests +105 GetTokenTypesFailureTests +106 BaselinesCommon_AlterTriggerStatementTests +107 Baselines90_CreateRuleStatementTests +107 CreateAggregateStatementTests100 +108 Baselines130_CreateUserFromExternalProvider130 +108 CreateUserFromExternalProvider130 +109 DeprecatedKeywordsIn90Tests +112 AlterMessageTypeStatementTests +112 BaselinesCommon_NullableConstraintTests +114 Baselines160_TestJsonArrayReturn160 +114 CreatePartitionSchemeStatementTests +115 AlterDatabaseOptionsTests140_Azure +115 Baselines140_AlterDatabaseOptionsTests140_Azure +117 Baselines90_CreateMasterKeyStatementTests +118 Baselines100_DeclareVariableWithAssignmentTests +118 Baselines130_AlterTableSwitchStatementTests130 +120 VariableTests +123 Baselines100_AlterIndexStatementTests100 +124 AcceleratedDatabaseRecoveryTests150 +125 Baselines90_AlterMessageTypeStatementTests +125 CreateContractStatementTests +125 CreateCredentialStatementTests +125 CreateTriggerStatementTests130 +128 CreateColumnStoreIndexTestsDw +128 PhaseOne_CreateCertificate +129 BaselinesCommon_ReadTextStatementTests +129 CreateSchemaStatementErrorTests +129 NullableConstraintTests +130 Baselines150_AcceleratedDatabaseRecoveryTests150 +133 GetTokenTypesTests +134 AlterDatabaseScopedCredentialStatementTests130 +134 ShiftOperatorTests160 +135 Baselines90_CreatePartitionSchemeStatementTests +135 SimpleJsonObjectReturn160 +136 Baselines160_ShiftOperatorTests160 +136 Baselines90_WaitForStatementTests90 +136 GetConversationGroupStatementTests +137 Baselines90_CreateCredentialStatementTests +138 Baselines90_AlterXmlSchemaCollectionStatementTests +138 Baselines90_CreateContractStatementTests +140 Baselines90_GetConversationGroupStatementTests +141 Baselines100_BackupStatementTests100 +143 AlterIndexStatementTests100 +143 AlterTriggerStatementTests +145 Baselines130_AlterDatabaseScopedCredentialStatementTests130 +146 Baselines90_CreateXmlSchemaCollectionStatementTests +147 AlterTableSwitchStatementTests130 +149 DeclareVariableElementTest +150 Baselines150_DeclareTableVariableTests150 +150 Baselines90_CreateSynonymStatementTests +154 CreateRuleStatementTests +154 TestJsonArrayReturn160 +157 BaselinesCommon_AlterTableTriggerModificationStatementTests +158 AlterSchemaStatementTests +158 DeclareVariableWithAssignmentTests +159 BaselinesCommon_GotoStatementTests +160 Baselines120_TruncatePartitions120 +161 AlterTableStatementTests160 +162 AlterRemoteServiceBindingStatementTests +163 TruncatePartitions120 +163 WaitForStatementTests90 +164 Baselines100_RowsetsInSelectTests100 +164 TestTrimReturn160 +167 Baselines90_SetVariableStatementTests90 +168 Baselines120_DeclareVariableElementTest +168 CreateTriggerStatementErrorTests +170 Baselines90_AlterSchemaStatementTests +171 ReadTextStatementTests +172 CreateDatabaseScopedCredentialStatementTests130 +174 DropStatementsTests110 +175 CreateSearchPropertyListStatementTests +178 Baselines110_UseFederationTests110 +179 Baselines110_CreateSearchPropertyListStatementTests +180 BackupStatementTests100 +181 Baselines90_AlterRemoteServiceBindingStatementTests +181 CreateAlterFederationStatementTestsAzure110 +182 Baselines110_DropStatementsTests110 +183 Baselines100_QueueStatementTests100 +183 Baselines130_CreateDatabaseScopedCredentialStatementTests130 +183 BaselinesCommon_DeclareTableStatementTests +183 CreateExternalFileFormatStatementTests160 +184 Baselines110_CreateAlterFederationStatementTestsAzure110 +184 BaselinesCommon_SaveTransactionStatementTests +185 CreatePartitionFunctionStatementTests +189 CreateCredentialStatementTests100 +192 GotoStatementTests +194 AlterServerConfigurationStatementTests +194 BaselinesCommon_AlterTableConstraintModificationStatementTests +196 Baselines100_AlterServerConfigurationStatementTests +196 BaselinesCommon_WhileStatementTests +197 ExecuteAsStatementTests +198 Baselines100_CreateCredentialStatementTests100 +198 Baselines170_CreateColumnStoreIndexTests170 +198 CreateColumnStoreIndexTests170 +202 AlterXmlSchemaCollectionStatementTests +202 CreateXmlSchemaCollectionStatementTests +203 Baselines160_CreateExternalFileFormatStatementTests160 +203 Baselines90_CreatePartitionFunctionStatementTests +204 RoleStatementTests +207 BaselinesCommon_WriteTextStatementTests +208 BaselinesCommon_AlterProcedureStatementTests +208 RowsetsInSelectTests100 +210 AlterCreateCredentialStatementTests +213 Baselines150_AlterDatabaseScopedConfigClearProcCacheTests150 +213 DeclareTableVariableTests150 +217 Baselines90_ExecuteAsStatementTests +218 AlterDatabaseScopedConfigClearProcCacheTests150 +218 Baselines90_SemicolonsBeforeStatementTests2 +218 WhileStatementTests +219 CreateSynonymStatementTests +220 AlterTableDropTableElementStatementTests +221 SemicolonsBeforeStatementTests1 +223 Baselines160_CreateExternalDataSourceStatementTests160 +223 CreateExternalDataSourceStatementTests160 +224 Baselines100_MiscTests100 +224 Baselines150_AlterServerConfigurationExternalAuthenticationTests150 +224 BaselinesCommon_BigIntRowCountPageCountTests +224 BigIntRowCountPageCountTests +225 AlterServerConfigurationExternalAuthenticationTests150 +225 DeclareTableStatementTests +226 Baselines90_RowsetsInSelectTests90 +231 BackupCertificateStatementTests +231 Baselines90_AlterTableSwitchStatementTests +231 Baselines90_ExecuteStatementTests90 +232 BaselinesCommon_RaiseErrorStatementTests +233 AlterResourceGovernorStatementTests +233 Baselines100_AlterResourceGovernorStatementTests +235 AlterFulltextCatalogStatementTests +235 UseFederationTests110 +236 AlterTableStatementTests140_Azure +236 Baselines140_AlterTableStatementTests140_Azure +236 Baselines90_AlterCreateCredentialStatementTests +236 WriteTextStatementTests +239 Baselines100_EventNotificationStatementTests100 +239 Baselines120_AlterDatabaseOptionsTests120 +239 Baselines160_FuzzyStringMatchingTests160 +240 RowsetsInSelectTests90 +241 Baselines150_AlterDatabaseScopedConfigForSecondaryClearProcCacheTests150 +241 Baselines90_AlterCertificateStatementTests +242 CryptographicProviderStatementTests +243 CreateWorkloadClassifierStatementSqlDwTests +244 AlterDatabaseScopedConfigForSecondaryClearProcCacheTests150 +244 QueueStatementTests100 +245 Baselines130_RenameStatementTests +245 Baselines90_AlterFulltextCatalogStatementTests +245 BaselinesCommon_SetVariableStatementTests +245 RenameStatementTests +247 SaveTransactionStatementTests +247 VectorTypeSecondParameterTests170 +249 AlterDatabaseOptionsTests120 +249 Baselines90_BackupCertificateStatementTests +250 CreateSpatialIndexStatementTests110 +251 BaselinesCommon_BaseTableNameTests +251 PhaseOne_AvoidingInfiniteRecursionAtBatchLevel +253 Baselines90_AlterTableDropTableElementStatementTests90 +254 PhaseOne_AvoidingInfiniteLoopAtStatementLevel +257 MiscTests100 +260 Baselines100_CryptographicProviderStatementTests +265 AlterServiceMasterKeyStatementTests +268 Baselines100_ExpressionTests100 +269 AlterTableTriggerModificationStatementTests +270 Baselines130_AlterDatabaseStatementTests130 +271 Baselines160_CreateDatabaseTests160 +271 CreateDatabaseTests160 +271 SendStatementTests +272 AlterTableDropTableElementStatementTests90 +272 Baselines90_AlterServiceMasterKeyStatementTests +273 Baselines110_ServerRoleStatementTests +274 RaiseErrorStatementTests +275 BaselinesCommon_TSqlParserTestScript2 +277 BaseTableNameTests +277 Baselines170_VectorTypeSecondParameterTests170 +277 Baselines90_OptimizerHintsTests90 +277 CreateAlterWorkloadGroupStatementTests110 +278 Baselines160_AlterFunctionJsonObjectTests160 +278 BaselinesFabricDW_CloneTableTestsFabricDW +278 CloneTableTestsFabricDW +280 Baselines90_SendStatementTests +280 WhitespaceTests +281 Baselines90_TrivialStatementTests90 +284 AlterDatabaseStatementTests130 +286 Baselines110_SendStatementTests +286 Baselines130_SecurityStatement130Tests +286 SecurityStatement130Tests +288 BaselinesCommon_TSqlParserTestScript3 +290 DumpLoadStatement90Tests +290 OptimizerHintsTests90 +291 Baselines90_DumpLoadStatementTests +292 AlterTableConstraintModificationStatementTests +292 Baselines90_CreateTypeStatementTests +293 CursorStatementsTests +297 Baselines90_CreateMessageTypeStatementTests +298 CreateAggregateStatementTests +298 ExecuteStatementTests90 +301 AlterDatabaseManualCutoverTests170 +301 Baselines170_AlterDatabaseManualCutoverTests170 +302 Baselines160_BitManipulationFunctionTests160 +302 CreateHekatonTriggerStatementTest +303 Baselines90_ApplicationRoleStatementTests +304 Baselines90_DumpLoadStatement90Tests +306 CreateTypeStatementTests +308 EventNotificationStatementTests100 +308 SendStatementTests110 +308 TSqlParserTestScript2 +309 Baselines110_CreateSpatialIndexStatementTests110 +311 Baselines130_CreateHekatonTriggerStatementTest +312 Baselines110_SendStatementTests110 +313 Baselines160_CreateFunctionStatementTests160 +314 BaselinesCommon_CursorStatementsTests +315 ServerAuditStatementTests110 +316 AlterCertificateStatementTests +317 AlterSequenceStatementTests +317 Baselines130_CreateWorkloadClassifierStatementSqlDwTests +318 Baselines90_AlterPartitionStatementsTests +320 BaselinesCommon_AlterFunctionStatementTests +322 Baselines90_CreateFulltextCatalogStatementTests +322 BaselinesCommon_CreateStatisticsStatementTests +324 BaselinesCommon_DeleteStatementTests +324 BaselinesCommon_IdentifierTests +325 Baselines130_CreateColumnStoreIndexTests130 +325 Baselines150_AlterIndexStatementTests150 +328 Baselines90_CreateAggregateStatementTests +328 EnableDisableTriggerStatementTests +329 Baselines90_InsertStatementTests90 +332 SetVariableStatementTests90 +334 AlterExternalLibrary140 +334 Baselines130_DropStatementsTests130 +334 Baselines140_AlterExternalLibrary140 +334 DropStatementsTests130 +334 FuzzyStringMatchingTests160 +337 Baselines120_FromClauseTests120 +338 CreateAlterDatabaseStatementTestsAzure110 +339 AlterPartitionStatementsTests +339 AsymmetricKeyStatementTests100 +340 Baselines140_CreateExternalLibrary140 +340 CreateExternalLibrary140 +340 StringConcatOperatorTests160 +341 Baselines100_TableParametersTests +344 Baselines110_ServerAuditStatementTests110 +345 CreateSequenceStatementTests +347 AlterMasterKeyStatementTests +350 Baselines90_EnableDisableTriggerStatementTests +352 InsertStatementTests90 +352 SelectStatementTests140 +353 BeginEndStatementErrorTests +357 Baselines140_SelectStatementTests140 +359 Baselines120_AlterCreateDatabaseStatementTests120 +360 Baselines90_AlterMasterKeyStatementTests +362 Baselines100_AsymmetricKeyStatementTests100 +364 AlterIndexStatementTests150 +369 SemicolonsBeforeStatementTests2 +372 Baselines110_CreateAlterDatabaseStatementTestsAzure110 +374 Baselines130_OptimizerHintsTests130 +374 OptimizerHintsTests130 +376 BaselinesCommon_SetOffsetsAndOnOffSetTests +377 Baselines140_CreateDatabaseTests140 +378 Baselines160_StringConcatOperatorTests160 +379 AlterCreateServiceStatementTests +382 Baselines90_AlterCreateServiceStatementTests +382 TableParametersTests +383 AlterTableSwitchStatementTests +384 BitManipulationFunctionTests160 +385 Baselines100_SymmetricKeyStatementTests100 +386 Baselines100_CTEStatementTests100 +386 CreateDatabaseTests140 +387 AlterFunctionJsonObjectTests160 +391 CreateStatisticsStatementTests +393 ServerRoleStatementTests +395 FromClauseTests120 +398 Baselines90_AlterAsymmetricKeyStatementTests +399 CreateFunctionStatementTests160 +403 AlterEndpointStatementTests +403 Baselines110_AlterSequenceStatementTests +404 BaselinesCommon_TrivialStatementTests +407 Baselines110_CreateAlterUserStatementTests110 +407 Baselines160_WithinGroupTests160 +407 Baselines90_OpenSymmetricKeyStatementTests +410 ExecuteStatementTests110 +412 Baselines140_OptimizerHintsTests140 +412 OptimizerHintsTests140 +416 Baselines110_CreateAlterWorkloadGroupStatementTests110 +421 Baselines90_CreateRemoteServiceBindingStatementTests +421 CreateColumnStoreIndexTests130 +422 AlterCreateDatabaseFilePath150 +422 CreateRemoteServiceBindingStatementTests +423 Baselines90_ReceiveStatementTests +423 MultipleErrorTests +423 SetOffsetsAndOnOffSetTests +425 TrivialStatementTests90 +426 ApplicationRoleStatementTests +426 OpenSymmetricKeyStatementTests +427 SymmetricKeyStatementTests100 +429 WithinGroupTests160 +430 CreateAlterUserStatementTests110 +430 ReceiveStatementTests +438 Baselines120_CreateAggregateStatementTests120 +438 CreateAggregateStatementTests120 +438 DeclareCursorStatementTests +438 DumpLoadStatementTests +439 Baselines110_CreateSequenceStatementTests +442 ExpressionTests100 +443 SetVariableStatementTests +445 CreateStatisticsStatementTests100 +446 AlterCreateDatabaseStatementTests120 +448 AlwaysEncryptedTests150 +451 Baselines100_CreateTableTests100 +452 Baselines90_RouteStatementTests +453 Baselines90_CreateProcedureStatementTests90 +454 DropIndexStatementTests100 +455 Baselines150_AlterCreateDatabaseFilePath150 +455 BaselinesCommon_BeginTransactionStatementTests +455 ReturnStatementTests +455 TSqlParserTestScript1 +456 Baselines90_AlterEndpointStatementTests +456 BaselinesFabricDW_IdentityColumnTestsFabricDW +456 IdentityColumnTestsFabricDW +459 BaselinesCommon_DeclareCursorStatementTests +461 BaselinesCommon_ReturnStatementTests +462 Baselines160_AlterTableResumableTests160 +463 BaselinesCommon_DropStatementsTests +464 BaselinesCommon_IfStatementTests +467 Baselines160_NotEnforcedConstraintTests160 +467 NotEnforcedConstraintTests160 +469 BaselinesFabricDW_CreateProcedureCloneTableTestsFabricDW +469 CreateProcedureCloneTableTestsFabricDW +471 Baselines170_JsonArrayAggOrderBy170 +472 BaselinesCommon_TSqlParserTestScript1 +477 OptimizerHintsTests +477 ScalarUDFInlineTests150 +479 Baselines100_CreateStatisticsStatementTests100 +480 AddDropSignatureStatementTests +481 Baselines90_UpdateStatementTests90 +481 TrivialStatementTests +482 Baselines150_AlwaysEncryptedTests150 +482 CreateFunctionStatementTests100 +483 Baselines90_AlterAssemblyStatementTests +484 TableTypeTests120 +485 Baselines110_AlterSearchPropertyListStatementTests +488 BaselinesCommon_UpdateStatisticsStatementTests +492 AlterSearchPropertyListStatementTests +492 Baselines140_RestoreStatementTests140_Azure +493 RestoreStatementTests140_Azure +494 AlterAssemblyStatementTests +495 BackupRestoreServiceMasterKeyStatementTests +496 BaselinesCommon_OptimizerHintsTests +497 BaselinesCommon_BeginEndBlockStatementTests +499 Baselines90_BackupRestoreServiceMasterKeyStatementTests +503 Baselines100_CreateFunctionStatementTests100 +503 SymmetricKeyStatementTests +509 Baselines90_AddDropSignatureStatementTests +510 AlterExternalLibrary150 +510 Baselines100_DatabaseEncryptionKeyStatementTests +510 Baselines100_DropIndexStatementTests100 +510 Baselines150_AlterExternalLibrary150 +510 DatabaseEncryptionKeyStatementTests +511 Baselines90_UniqueConstraintTests90 +511 BaselinesCommon_AlterTableAlterColumnStatementTests +514 AlterTableResumableTests160 +514 Baselines160_IgnoreRespectNullsSyntaxTests160 +514 CreateTableTests100 +515 IgnoreRespectNullsSyntaxTests160 +520 CreateExternalDataSource140 +521 Baselines160_ComplexJsonObjectFunctionTests160 +521 Baselines170_ComplexJsonObjectFunctionTests170 +522 DataClassificationTests130 +522 DataClassificationTests140 +522 DataClassificationTests150 +523 Baselines120_TableTypeTests120 +523 BaselinesCommon_UpdateStatementTests +524 Baselines130_DataClassificationTests130 +524 Baselines140_DataClassificationTests140 +524 Baselines150_DataClassificationTests150 +527 Baselines90_CreateIndexStatementTests90 +535 Baselines90_UserStatementTests +536 Baselines150_CreateExternalLibrary150 +536 CreateExternalLibrary150 +538 TSqlParserTestScript3 +539 Baselines90_SymmetricKeyStatementTests +540 AlterExternalModelStatementTests170 +540 Baselines170_AlterExternalModelStatementTests170 +540 CreateSchemaStatementTests90 +544 Baselines90_CreateAssemblyStatementTests +546 Baselines170_RegexpTVFTests170 +546 CTEStatementTests100 +546 PredictSqlDwTests +546 RegexpTVFTests170 +547 Baselines150_ScalarUDFInlineTests150 +547 CreateStatisticsStatementTests160 +549 Baselines120_UniqueConstraintTests120 +550 CreateMessageTypeStatementTests +550 RouteStatementTests +552 CreateAssemblyStatementTests +554 Baselines110_ExecuteStatementTests110 +564 CommitTransactionStatementTests120 +565 Baselines130_AlterIndexStatementTests130 +566 MaterializedViewTests140 +566 MaterializedViewTests150 +566 MaterializedViewTests160 +567 Baselines100_InsertStatementTests100 +567 Baselines130_CreateIndexStatementTests130 +568 UpdateTextStatementTests +570 BaselinesCommon_UpdateTextStatementTests +571 UpdateStatementTests90 +576 DropStatementsTests +579 Baselines160_CreateStatisticsStatementTests160 +580 CreateEventSessionNotLikePredicate +580 CreateIndexStatementTests130 +580 WithinGroupTests140 +581 Baselines120_CommitTransactionStatementTests120 +584 BeginTransactionStatementTests +586 Baselines80_CreateSchemaStatementTests +586 CreateFulltextCatalogStatementTests +586 MiscTests80 +587 UniqueConstraintTests90 +588 BaselinesCommon_DbccStatementsTests +592 Baselines160_CreateProcedureStatementTests160 +593 Baselines80_ParserModeTests +593 Baselines90_CreateSchemaStatementTests +594 CreateIndexStatementTests110 +594 EndConversationStatementTests +595 UpdateStatisticsStatementTests +596 SelectWithCollation +598 DeleteStatementTests +599 DbccStatementsTests +601 CreateIndexStatementTests90 +602 UniqueConstraintTests120 +603 Baselines140_CreateExternalDataSource140 +607 Baselines100_ColumnDefinitionTests100 +610 ComplexJsonObjectFunctionTests160 +610 ComplexJsonObjectFunctionTests170 +611 Baselines110_SelectWithCollation +611 Baselines120_SelectWithCollation +611 Baselines90_DeleteStatementTests90 +612 Baselines130_SelectWithCollation +620 PredicateSetTests +622 DeleteStatementTests90 +623 Baselines140_WithinGroupTests140 +623 Baselines160_InlineIndexColumnWithINCLUDEtest +623 InlineIndexColumnWithINCLUDEtest +624 BeginConversationStatementTests +627 Baselines110_CreateIndexStatementTests110 +627 Baselines90_AlterIndexStatementTests +628 Baselines90_CreateSchemaStatementTests90 +628 CreateCertificateStatementTests +630 Baselines90_EndConversationStatementTests +631 Baselines140_MaterializedViewTests140 +631 Baselines150_MaterializedViewTests150 +631 Baselines160_MaterializedViewTests160 +632 Baselines80_MiscTests80 +633 BaselinesCommon_SelectExpressionTests +637 AlterIndexStatementTests130 +641 Baselines90_CreateCertificateStatementTests +644 Baselines130_CreateOrAlterStatementTests130 +646 BaselinesFabricDW_CreateAlterTableClusterByTestsFabricDW +646 CreateAlterTableClusterByTestsFabricDW +647 Baselines130_CreateEventSessionNotLikePredicate +647 Baselines140_CreateEventSessionNotLikePredicate +647 Baselines150_CreateEventSessionNotLikePredicate +647 Baselines160_CreateEventSessionNotLikePredicate +647 Baselines170_CreateEventSessionNotLikePredicate +648 Baselines80_CreateIndexStatementTests +648 BaselinesFabricDW_CreateEventSessionNotLikePredicate +652 BaselinesCommon_ExecuteStatementTests +654 Baselines90_CreateTableTests90 +658 ColumnDefinitionTests100 +662 Baselines160_VectorFunctionTests160 +672 BaselinesCommon_PredicateSetTests +672 UserStatementTests +677 JsonArrayAggOrderBy170 +677 WithinGroupTests130 +678 AlterProcedureStatementTests +679 Baselines90_CreateIndexStatementTests +681 Baselines140_TrimBuiltInTest140 +683 DropIndexStatementTests140 +683 ScalarDataTypeTests90 +686 Baselines90_BeginConversationStatementTests +686 BaselinesCommon_ForClauseTests +689 ParserModeTests +691 Baselines160_CreateExternalTableStatementTests160 +692 CreateExternalTableStatementTests160 +695 ForClauseTests +697 GraphDbSyntaxTests150 +697 InsertStatementTests100 +700 Baselines150_BulkInsertStatementTests150 +702 IncrementalStatsTests +704 Baselines130_PredictSqlDwTests +712 AlterIndexStatementTests +713 AlterSelectiveXmlIndexStatementTests +720 Baselines100_AlterCreateDatabaseStatementTests100 +725 Baselines120_AlterTableSwitchStatementTests120 +725 Baselines140_DropIndexStatementTests140 +726 Baselines90_QueueStatementTests +726 BulkInsertStatementTests150 +727 Baselines130_WithinGroupTests130 +729 Baselines110_AlterSelectiveXmlIndexStatementTests +738 VectorFunctionTests160 +744 Baselines150_UniqueConstraintTests150 +751 ServerAuditStatementTests +752 Baselines150_CreateIndexStatementTests150 +755 JsonForClauseTests130 +756 AlterTableSwitchStatementTests120 +758 Baselines120_IncrementalStatsTests +758 Baselines90_CreateXmlIndexStatementTests +760 Baselines90_TryCatchStatementTests +761 Baselines100_ServerAuditStatementTests +762 Baselines130_RemoteDataArchiveDatabaseTests130 +762 BaselinesCommon_SetCommandsAndMiscTests +775 AlterDatabaseOptionsTests100 +780 RemoteDataArchiveDatabaseTests130 +781 Baselines130_JsonForClauseTests130 +783 Baselines100_AlterDatabaseOptionsTests100 +784 OffsetClause +787 Baselines150_GraphDbSyntaxTests150 +788 CreateAlterTableStatementTests110 +788 GroupByClauseTests130 +788 GroupByClauseTests140 +788 GroupByClauseTests150 +792 UniqueConstraintTests150 +793 CreateXmlIndexStatementTests +797 UpdateStatementTests +800 Baselines150_CreateExternalLanguage150 +801 CreateIndexStatementTests150 +804 AlterExternalLanguage150 +809 AlterCreateDatabaseStatementTests100 +811 Baselines110_FromClauseTests110 +811 Baselines150_AlterExternalLanguage150 +812 Baselines170_CreateExternalModelStatementTests170 +812 CreateExternalModelStatementTests170 +817 Baselines130_AtTimeZoneTests130 +818 Baselines110_CreateAlterTableStatementTests110 +818 Baselines130_GroupByClauseTests130 +818 Baselines140_GroupByClauseTests140 +818 Baselines150_GroupByClauseTests150 +819 QueueStatementTests +821 AlterWorkloadGroupStatementTests130 +824 AlterTableAlterColumnStatementTests +827 CreateWorkloadGroupStatementTests130 +828 AlterFulltextIndexStatementTests +832 FromClauseTests110 +841 Baselines100_AssignmentWithOperationTests +858 SetCommandsAndMiscTests +863 CreateAlterResourcePoolStatementTests110 +867 BaselinesCommon_CreateDatabaseStatementTests +877 ExecuteStatementTests +877 TrimBuiltInTest140 +881 Baselines80_SelectStatementDeprecatedIn110Tests +881 Baselines90_CTEStatementTests +889 LoginStatementTests150 +892 AssignmentWithOperationTests +892 CreateAlterDropFulltextStoplistStatementTests +895 CreateTableTests90 +898 CTEStatementTests +899 BaselinesCommon_InsertStatementTests +903 Baselines100_GroupByClauseTests100 +907 Baselines90_ScalarDataTypeTests90 +908 Baselines110_OffsetClause +910 Baselines100_CreateAlterDropFulltextStoplistStatementTests +911 BaselinesCommon_QueryExpressionTests +913 CreateAlterDropBrokerPriorityStatementTests +914 AtTimeZoneTests130 +917 Baselines90_ExpressionTests90 +920 CreateProcedureStatementTests160 +920 MiscTests90 +923 CreateTriggerStatementTests90 +931 Baselines80_MiscDeprecatedIn110Tests +933 CreateIndexStatementTests +941 AlterTableDropTableElementStatementTests140 +941 BaselinesCommon_AlterDatabaseStatementTests +948 Baselines150_LoginStatementTests150 +949 Baselines170_RegexpTests170 +950 CreateDatabaseStatementTests +953 MergeStatementTests160 +954 Baselines110_ExpressionTests110 +954 SelectStatementDeprecatedIn110Tests +963 NativelyCompiledScalarUDFTests130 +965 CreateFunctionStatementTests90 +970 Baselines130_NativelyCompiledScalarUDFTests130 +971 SelectExpressionTests +975 ColumnStoreInlineIndex130 +979 CreateExternalLanguage150 +983 Baselines130_UniqueInlineIndex130 +983 ExpressionTests90 +984 Baselines100_AlterTableStatementTests100 +984 Baselines140_AlterTableDropTableElementStatementTests140 +986 CreateProcedureStatementTests90 +996 Baselines160_MergeStatementTests160 +1001 Baselines90_MiscTests90 +1017 MiscDeprecatedIn110Tests +1027 GroupByClauseTests100 +1031 CreateIndexStatementTests100 +1035 Baselines90_CreateFunctionStatementTests90 +1035 Baselines90_CreateTriggerStatementTests90 +1043 BaselinesFabricDW_ScalarFunctionTestsFabricDW +1043 ScalarFunctionTestsFabricDW +1047 CreateSpatialIndexStatementTests +1048 Baselines170_JsonIndexTests170 +1054 Baselines120_ColumnDefinitionTests120 +1060 Baselines140_OpenRowsetBulkStatementTests140 +1064 ExpressionTests110 +1070 Baselines130_ColumnStoreInlineIndex130 +1071 AlterCreateResourcePoolStatement120 +1072 AuditSpecificationStatementTests110 +1072 ExternalTableCtasStatementTests +1085 AlterTableStatementTests100 +1086 OpenRowsetBulkStatementTests140 +1090 Baselines90_AlterTableAddTableElementStatementTests +1090 CreateAlterDropResourcePoolStatementTests +1098 CreateTriggerStatementTests +1100 QueryExpressionTests +1103 Baselines100_CreateIndexStatementTests100 +1106 Baselines90_SecurityStatement80Tests +1108 InsertStatementTests +1110 Baselines80_AlterTableAddTableElementStatementTests +1110 Baselines80_SecurityStatement80Tests +1112 AlterDatabaseOptionsTests +1112 Baselines130_AlterWorkloadGroupStatementTests130 +1116 AlterExternalResourcePoolStatementTests130 +1117 Baselines110_AuditSpecificationStatementTests110 +1118 Baselines130_CreateWorkloadGroupStatementTests130 +1124 Baselines130_DropIfExistsTests130 +1127 CreateAlterDropWorkloadGroupStatementTests +1129 CreateOrAlterStatementTests130 +1130 ViewStatementTests +1137 Baselines130_ExternalTableCtasStatementTests +1141 Baselines80_ViewStatementTests +1145 CreateAvailabilityGroupStatementTests +1146 Baselines120_BackupStatementTests120 +1147 AlterDatabaseStatementTests +1150 SelectStatementTests160 +1151 Baselines90_ViewStatementTests +1155 Baselines170_RegexpLikeTests170 +1159 AlterTableAlterColumnStatementTests140 +1164 IdentifierTests +1168 BackupStatementTests120 +1181 CreateAlterDatabaseStatementTestsAzure120 +1184 Baselines140_AlterTableAlterColumnStatementTests140 +1191 BaselinesFabricDW_CreateExternalTableStatementTestsFabricDW +1191 CreateExternalTableStatementTestsFabricDW +1191 RemoteDataArchiveTableTests130 +1194 Baselines150_ServerAuditStatementTests150 +1194 ServerAuditStatementTests150 +1201 Baselines110_CreateAvailabilityGroupStatementTests +1203 BulkInsertStatementTests140 +1205 AlterProcedureStatementTests120 +1213 BaselinesCommon_AlterDatabaseOptionsTests +1215 Baselines120_CreateAlterDatabaseStatementTestsAzure120 +1216 AlterDatabaseOptionsTests90 +1224 Baselines140_BulkInsertStatementTests140 +1229 SecurityStatement80Tests +1230 VectorFunctionTests170 +1232 RegexpLikeTests170 +1234 Baselines130_RemoteDataArchiveTableTests130 +1235 Baselines120_AlterProcedureStatementTests120 +1238 Baselines110_CreateAlterResourcePoolStatementTests110 +1241 BaselinesCommon_ForeignKeyConstraintTests +1242 BaselinesCommon_CreateTriggerStatementTests +1245 Baselines170_VectorIndexTests170 +1246 Baselines100_CreateAlterDropBrokerPriorityStatementTests +1256 ColumnDefinitionTests120 +1259 RegexpTests170 +1263 AsymmetricKeyStatementTests +1278 ForeignKeyConstraintTests +1286 Baselines90_AlterCreateDatabaseStatementTests90 +1287 Baselines90_AlterDatabaseOptionsTests90 +1291 Baselines120_CreateTableTests120 +1293 Baselines160_SelectStatementTests160 +1296 CreateExternalResourcePoolStatementTests130 +1311 Baselines160_TrimFunctionTests160 +1311 Baselines90_AsymmetricKeyStatementTests +1318 Baselines170_VectorFunctionTests170 +1327 TrimFunctionTests160 +1341 BaselinesCommon_RestoreStatementTests +1345 UniqueInlineIndex130 +1359 AlterTableAddTableElementStatementTests +1371 Baselines160_OpenRowsetBulkStatementTests160 +1385 BaselinesFabricDW_NestedCTETestsFabricDW +1385 NestedCTETestsFabricDW +1397 Baselines100_CreateSpatialIndexStatementTests +1407 RestoreStatementTests +1416 BaselinesCommon_FunctionStatementTests +1428 JsonIndexTests170 +1431 FunctionStatementTests +1445 AlterWorkloadGroupStatementSqlDwTests +1470 LoginStatementTests +1472 OpenRowsetBulkStatementTests160 +1475 Baselines90_DropStatementsTests2 +1490 Baselines150_FromClauseTests150 +1493 DatabaseAuditSpecificationStatementTests +1495 CreateTableTests120 +1520 CreateIndexStatementTests120 +1523 BaselinesCommon_SelectStatementTests +1526 Baselines160_CreateTableTests160 +1533 DropStatementsTests2 +1538 Baselines160_WindowClauseTests160 +1539 FromClauseTests150 +1543 Baselines120_CreateIndexStatementTests120 +1551 Baselines90_LoginStatementTests +1555 BaselinesCommon_BackupStatementTests +1565 VectorIndexTests170 +1566 Baselines120_AlterCreateResourcePoolStatement120 +1581 BackupStatementTests +1583 SecurityStatementExternalModelTests170 +1586 Baselines100_DatabaseAuditSpecificationStatementTests +1602 Baselines170_SecurityStatementExternalModelTests170 +1603 Baselines160_CreateIndexStatementTests160 +1610 Baselines100_CreateAlterDropResourcePoolStatementTests +1613 Baselines90_UniqueConstraintTests +1633 Baselines100_FromClauseTests100 +1633 Baselines160_ExpressionTests160 +1634 CreateTableTests160 +1637 CreateAlterDatabaseStatementTests110 +1638 Baselines100_CreateAlterDropWorkloadGroupStatementTests +1641 Baselines80_UniqueConstraintTests +1644 AiGenerateEmbeddingsTests170 +1644 AlterAvailabilityGroupStatementTests +1644 Baselines130_AlterExternalResourcePoolStatementTests130 +1644 Baselines170_AiGenerateEmbeddingsTests170 +1650 Baselines150_DatabaseAuditSpecificationStatementTests150 +1650 DatabaseAuditSpecificationStatementTests150 +1653 UniqueConstraintTests +1678 TryCatchStatementTests +1686 Baselines110_AlterAvailabilityGroupStatementTests +1703 Baselines160_JsonFunctionTests160 +1707 JsonFunctionTests160 +1733 BaselinesCommon_BulkInsertStatementTests +1733 BulkInsertStatementTests +1737 Baselines110_CreateAlterDatabaseStatementTests110 +1743 WindowClauseTests160 +1766 OverClauseTests110 +1779 FromClauseTests100 +1803 Baselines110_CreateSelectiveXmlIndexStatementTests +1805 AlterDatabaseOptionsTests140 +1809 Baselines130_AlterDatabaseScopedConfigurationTests130 +1810 CreateSelectiveXmlIndexStatementTests +1815 Baselines150_CreateTableTests150 +1839 AlterDatabaseOptionsTests130 +1840 Baselines110_OverClauseTests110 +1845 Baselines140_AlterDatabaseOptionsTests140 +1846 Baselines100_MergeStatementTests +1860 Baselines90_ColumnDefinitionTests +1864 Baselines120_AlterIndexStatementTests120 +1864 Baselines80_ColumnDefinitionTests +1887 CreateIndexStatementTests140 +1889 Baselines130_CreateExternalResourcePoolStatementTests130 +1896 Baselines140_CreateIndexStatementTests140 +1901 MaterializedViewTests130 +1905 Baselines130_AlterDatabaseOptionsTests130 +1924 Baselines100_FulltextIndexStatementTests100 +1928 CreateIndexStatementTests160 +1929 AlterIndexStatementTests120 +1931 Baselines120_AlterTableStatementTests120 +1934 AlterIndexStatementTests140 +1939 Baselines130_AlterWorkloadGroupStatementSqlDwTests +1954 Baselines130_CtasStatementTests +1955 Baselines160_BuiltInFunctionTests160 +1966 BuiltInFunctionTests160 +1975 AlterDatabaseScopedConfigurationTests130 +1982 CtasStatementTests +1983 Baselines140_AlterIndexStatementTests140 +1990 AlterServerConfigurationStatementTests110 +2006 Baselines110_AlterServerConfigurationStatementTests110 +2014 FulltextIndexStatementTests100 +2016 ScalarDataTypeTests +2035 Baselines90_FromClauseTests90 +2035 ColumnDefinitionTests +2041 MergeStatementTests +2068 CreateTableTests150 +2080 BaselinesCommon_RowsetsInSelectTests +2096 Baselines130_MaterializedViewTests130 +2102 ServerAuditSpecificationStatementTests +2106 Baselines100_ServerAuditSpecificationStatementTests +2123 AlterExternalDataSourceStatementTests130 +2123 AlterTableStatementTests120 +2123 Baselines130_AlterExternalDataSourceStatementTests130 +2170 Baselines150_ServerAuditSpecificationStatementTests150 +2170 ServerAuditSpecificationStatementTests150 +2180 FromClauseTests90 +2189 Baselines90_FulltextIndexStatementTests +2190 Baselines130_TemporalSelectTest130 +2264 CreateWorkloadGroupStatementSqlDwTests130 +2294 Baselines150_OpenRowsetBulkStatementTests150 +2327 Baselines130_CreateWorkloadGroupStatementSqlDwTests130 +2343 RowsetsInSelectTests +2345 TemporalSelectTest130 +2366 BaselinesCommon_CreateProcedureStatementTests +2382 Baselines140_AlterDatabaseScopedGenericConfigurationTests140 +2394 Baselines130_FromClauseTests130 +2394 FromClauseTests130 +2405 OpenRowsetBulkStatementTests150 +2410 BaselinesCommon_TSqlParserTestScript5 +2414 Baselines160_OpenRowsetStatementTests160 +2416 OpenRowsetStatementTests160 +2422 BaselinesCommon_ScalarDataTypeTests +2426 ExpressionTests160 +2480 Baselines130_CreateExternalDataSourceStatementTests130 +2480 CreateExternalDataSourceStatementTests130 +2502 TSqlParserTestScript5 +2549 AlterDatabaseScopedGenericConfigurationTests140 +2638 AiGenerateChunksTests170 +2638 Baselines170_AiGenerateChunksTests170 +2674 Baselines110_FulltextIndexStatementTests110 +2732 FulltextIndexStatementTests110 +3007 IPv4AddressTests +3086 Baselines120_CreateProcedureStatementTests120 +3128 Baselines140_GraphDbSyntaxTests140 +3147 Baselines130_AlterTableAlterColumnStatementTests130 +3154 GraphDbSyntaxTests140 +3174 CreateProcedureStatementTests120 +3436 CreateAlterSecurityPolicyStatementTests130 +3541 Baselines90_SecurityStatement90Tests +3558 SecurityStatement90Tests +3668 EventSessionStatementTests +3701 Baselines130_CreateAlterSecurityPolicyStatementTests130 +3789 Baselines130_AlterTableStatementTests130 +3803 Baselines130_CopyCommandTestsDw +3856 DropIfExistsTests130 +3883 CreateEndpointStatementTests +3979 Baselines130_CreateExternalFileFormatStatementTests130 +3983 CreateExternalFileFormatStatementTests130 +4010 BaselinesCommon_ExpressionTests +4147 CopyCommandTestsDw +4308 Baselines90_IPv4AddressTests +4394 FulltextIndexStatementTests +4560 AlterTableStatementTests130 +4594 ExpressionTests +4725 Baselines100_EventSessionStatementTests +4854 Baselines170_JsonFunctionTests170 +4962 BooleanExpressionTests +5074 CreateExternalTableStatementTests130 +5077 Baselines130_CreateExternalTableStatementTests130 +5111 BaselinesCommon_FromClauseTests +5139 JsonFunctionTests170 +5214 FromClauseTests +5454 BaselinesCommon_BooleanExpressionTests +5483 GraphDbEdgeConstraintsSyntaxTests150 +5532 AlterTableAlterColumnStatementTests130 +5587 CreateTableTests140 +5675 Baselines140_CreateTableTests140_Azure +5680 CreateTableTests140_Azure +5966 Baselines150_GraphDbEdgeConstraintsSyntaxTests150 +6019 Baselines90_CreateEventNotificationStatementTests +6035 CreateEventNotificationStatementTests +6091 Baselines90_CreateEndpointStatementTests +6093 Baselines140_CreateTableTests140 +6822 CreateProcedureStatementTests +7162 AlwaysEncryptedTests130 +7178 GraphDbShortestPathSyntaxTests150 +7252 Baselines130_AlwaysEncryptedTests130 +7402 EventSessionDbScopeStatementTests +8100 Baselines150_GraphDbShortestPathSyntaxTests150 +9516 Baselines130_EventSessionDbScopeStatementTests +10746 CreateLedgerTableTests160 +12248 Baselines160_CreateLedgerTableTests160 +19295 CreateTableTests130 +21556 Baselines130_CreateTableTests130