diff --git a/.gitignore b/.gitignore index 6344b99a909..5ff03c56c33 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ .idea /.sqlfluff **/.DS_Store +.junie # Ignore Python cache and prebuilt things .cache diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 48a0d01d4fb..1547e68bccf 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -70,7 +70,7 @@ repos: rev: 7.1.1 hooks: - id: flake8 - additional_dependencies: [flake8-black>=0.3.6] + additional_dependencies: [flake8-black>=0.3.7] - repo: https://github.com/pycqa/doc8 rev: v1.1.2 hooks: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 51c8373b78d..6bb6f8bb8b5 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -337,13 +337,12 @@ need a [GitHub Personal Access Token](https://docs.github.com/en/authentication/ scope, and read permissions on the "Metadata" scope. The reason we need both read & write access on the "Content" scope is that only tokens with write access can see _draft_ releases, which is what we need access to). -All maintainers should have sufficient access to generate such a token: +All maintainers should have sufficient access to generate such a token. Once +generated, store it in your env (zshrc, etc) as `SQLFLUFF_GITHUB_TOKEN`. Then: ```shell -source .venv/bin/activate -export GITHUB_REPOSITORY_OWNER=sqlfluff -export GITHUB_TOKEN=gho_xxxxxxxx # Change to your token with "repo" permissions. -python util.py release 2.0.3 # Change to your release number +make shell +make release 3.4.2 # Change to your release number ``` When all of the changes planned for the release have been merged, and diff --git a/Makefile b/Makefile index f610c47f8f0..3c8b216ccc6 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,14 @@ -.PHONY: help build clean fresh shell start stop +.PHONY: help build clean fresh release shell start stop .DEFAULT_GOAL := help +# Set VERSION from first argument if provided +VERSION := $(word 2,$(filter-out $(.DEFAULT_GOAL),$(MAKECMDGOALS))) + +# Treat flow name as a target (prevents make errors) +$(VERSION): + @: + help: ## Show this available targets @grep -E '^[/a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' @@ -16,6 +23,9 @@ clean: ## Clean up all containers and images fresh: ## Build the development container from scratch docker-compose build --no-cache development +release: ## Release a new version + @python util.py release $(VERSION) + shell: ## Start a bash session in the development container docker-compose exec development bash diff --git a/docker-compose.yml b/docker-compose.yml index e5a1f058050..ff1863ccdbb 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -4,8 +4,10 @@ services: context: . dockerfile: ./docker/development/Dockerfile environment: - - SSH_AUTH_SOCK=/ssh-agent + - GITHUB_REPOSITORY_OWNER=sqlfluff + - GITHUB_TOKEN=${SQLFLUFF_GITHUB_TOKEN} - POSTGRES_HOST=postgres + - SSH_AUTH_SOCK=/ssh-agent volumes: - .:/app - ./test/fixtures/dbt/profiles_yml:/root/.dbt diff --git a/docs/source/configuration/layout.rst b/docs/source/configuration/layout.rst index d2da5279bc2..e49dcd24895 100644 --- a/docs/source/configuration/layout.rst +++ b/docs/source/configuration/layout.rst @@ -167,11 +167,62 @@ the least obvious. The following example illustrates the impact it has. -- align_scope = file -- align_within = statement +Templating and alignment coordinate space +----------------------------------------- + +When using templating (e.g. Jinja), alignment is for human readability and +stable diffs. SQLFluff aligns based on the source (visible) positions whenever +templated (non-literal) segments are involved in the alignment scope. This +prevents excessive padding caused by the rendered output being longer than the +source template. If all segments are literal (non-templated), alignment uses +the regular templated working positions. + +Example (Jinja templating, align alias expressions within a select clause): + +.. code-block:: jinja + + select + {{ "longtemplated" }} as test_key, + b as b_col + +The alignment above is computed against the source text so that both lines line +up visually in the editor, regardless of the rendered length of +``{{ "longtemplated" }}``. + +Advanced: coordinate space override +----------------------------------- + +You can optionally force the coordinate space either: + +1) via the alignment constraint suffix (available for `spacing_before` and + `spacing_after`), or +2) via the `alignment_coordinate_space` key in layout config for the target type. + +.. code-block:: ini + + [sqlfluff:layout:type:alias_expression] + spacing_before = align:alias_expression:select_clause:bracketed:source + +Alternatively, the equivalent can be configured more declaratively: + +.. code-block:: ini + + [sqlfluff:layout:type:alias_expression] + spacing_before = align + align_within = select_clause + align_scope = bracketed + alignment_coordinate_space = source + +Supported values are ``source`` and ``templated``. In most cases, ``source`` is +the recommended choice for readability. + +.. code-block:: sql + WITH foo as ( SELECT a, b, - c AS first_column + c AS first_column, d + e AS second_column ) @@ -625,7 +676,7 @@ subsections of an :code:`ON` block with each other. If set to :code:`False` These can also be combined, so if :code:`indented_using_on` config is set to :code:`False`, :code:`indented_on_contents` is also set to :code:`False`, and -:code:`allow_implicit_indents` is set tot :code:`True` then the SQL would +:code:`allow_implicit_indents` is set to :code:`True` then the SQL would become: .. code-block:: sql diff --git a/pyproject.toml b/pyproject.toml index f575bafc5c2..38dfbd0a54c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -241,6 +241,7 @@ extend-select = ["I", "D"] # D418: Function/ Method decorated with @overload shouldn’t contain a docstring ignore = ["D107", "D105", "D418"] + [tool.ruff.lint.isort] # Mark sqlfluff, test and it's plugins as known first party known-first-party = [ diff --git a/requirements_dev.txt b/requirements_dev.txt index 6852cba2e3f..a4422cbfa3b 100644 --- a/requirements_dev.txt +++ b/requirements_dev.txt @@ -6,7 +6,7 @@ flake8 flake8-docstrings pydocstyle!=6.2.0, !=6.2.1 # See: https://github.com/PyCQA/pydocstyle/issues/618 black>=22.1.0 -flake8-black>=0.2.4 +flake8-black>=0.3.7 ruff import-linter yamllint diff --git a/src/sqlfluff/__main__.py b/src/sqlfluff/__main__.py index e94ed783add..55825f48af8 100644 --- a/src/sqlfluff/__main__.py +++ b/src/sqlfluff/__main__.py @@ -1,6 +1,6 @@ """Export cli to __main__ for use like python -m sqlfluff.""" -from sqlfluff.cli.commands import cli +from sqlfluff.cli.commands import cli # pragma: no cover -if __name__ == "__main__": - cli() +if __name__ == "__main__": # pragma: no cover + cli() # pragma: no cover diff --git a/src/sqlfluff/core/config/fluffconfig.py b/src/sqlfluff/core/config/fluffconfig.py index e034adc8306..201dc90b8fe 100644 --- a/src/sqlfluff/core/config/fluffconfig.py +++ b/src/sqlfluff/core/config/fluffconfig.py @@ -120,8 +120,10 @@ def __init__( # If any existing configs are provided. Validate them: if configs: validate_config_dict(configs, "") + empty_config: ConfigMappingType = {"core": {}} + empty_overrides: ConfigMappingType = {} self._configs = nested_combine( - defaults, configs or {"core": {}}, overrides or {} + defaults, configs or empty_config, overrides or empty_overrides ) # Some configs require special treatment self._configs["core"]["color"] = ( diff --git a/src/sqlfluff/core/helpers/string.py b/src/sqlfluff/core/helpers/string.py index 14ae2cae7d1..0126e6c03d0 100644 --- a/src/sqlfluff/core/helpers/string.py +++ b/src/sqlfluff/core/helpers/string.py @@ -7,7 +7,7 @@ def curtail_string(s: str, length: int = 20) -> str: """Trim a string nicely to length.""" if len(s) > length: - return s[:length] + "..." + return s[:length] + "..." # pragma: no cover else: return s diff --git a/src/sqlfluff/dialects/dialect_ansi.py b/src/sqlfluff/dialects/dialect_ansi.py index 6b1476bff11..d33e2c32f94 100644 --- a/src/sqlfluff/dialects/dialect_ansi.py +++ b/src/sqlfluff/dialects/dialect_ansi.py @@ -805,11 +805,16 @@ class FileSegment(BaseFileSegment): has no match_grammar. """ - match_grammar = Delimited( - Ref("StatementSegment"), - delimiter=AnyNumberOf(Ref("DelimiterGrammar"), min_times=1), - allow_gaps=True, - allow_trailing=True, + # Allow leading & trailing delimiters plus runs of delimited statements. + match_grammar = Sequence( + AnyNumberOf(Ref("DelimiterGrammar")), + Delimited( + Ref("StatementSegment"), + delimiter=AnyNumberOf(Ref("DelimiterGrammar"), min_times=1), + allow_gaps=True, + allow_trailing=True, + ), + AnyNumberOf(Ref("DelimiterGrammar")), ) def get_table_references(self) -> set[str]: diff --git a/src/sqlfluff/dialects/dialect_bigquery.py b/src/sqlfluff/dialects/dialect_bigquery.py index 02eabe01c8b..34f307243e9 100644 --- a/src/sqlfluff/dialects/dialect_bigquery.py +++ b/src/sqlfluff/dialects/dialect_bigquery.py @@ -605,6 +605,7 @@ class FileSegment(BaseFileSegment): # NB: We don't need a match_grammar here because we're # going straight into instantiating it directly usually. match_grammar = Sequence( + AnyNumberOf(Ref("DelimiterGrammar")), Sequence( OneOf( Ref("MultiStatementSegment"), @@ -618,7 +619,7 @@ class FileSegment(BaseFileSegment): Ref("StatementSegment"), ), ), - Ref("DelimiterGrammar", optional=True), + AnyNumberOf(Ref("DelimiterGrammar")), ) @@ -3128,10 +3129,24 @@ class CreateVectorIndexStatementSegment(BaseSegment): Ref("IndexColumnDefinitionSegment"), ), ), + Ref("StoringSegment", optional=True), Ref("OptionsSegment"), ) +class StoringSegment(BaseSegment): + """The `STORING` clause for a `CREATE VECTOR INDEX` statement. + + https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#create_vector_index_statement + """ + + type = "storing_segment" + match_grammar: Matchable = Sequence( + "STORING", + Bracketed(Delimited(Ref("SingleIdentifierGrammar"))), + ) + + class DropVectorIndexStatementSegment(BaseSegment): """A `DROP VECTOR INDEX` statement. diff --git a/src/sqlfluff/dialects/dialect_bigquery_keywords.py b/src/sqlfluff/dialects/dialect_bigquery_keywords.py index 75e03120c79..473a201bfe2 100644 --- a/src/sqlfluff/dialects/dialect_bigquery_keywords.py +++ b/src/sqlfluff/dialects/dialect_bigquery_keywords.py @@ -278,6 +278,7 @@ SOURCE STAGE START +STORING STREAM STRICT SUNDAY diff --git a/src/sqlfluff/dialects/dialect_clickhouse.py b/src/sqlfluff/dialects/dialect_clickhouse.py index 762cbd83ef0..be2c68a3ad5 100644 --- a/src/sqlfluff/dialects/dialect_clickhouse.py +++ b/src/sqlfluff/dialects/dialect_clickhouse.py @@ -1421,6 +1421,38 @@ class DropUserStatementSegment(ansi.DropUserStatementSegment): ) +class CreateUserStatementSegment(BaseSegment): + """A `CREATE USER` statement. + + As specified in + https://clickhouse.com/docs/en/sql-reference/statements/create/user/ + """ + + type = "create_user_statement" + + match_grammar = Sequence( + "CREATE", + "USER", + Ref("IfNotExistsGrammar", optional=True), + Ref("SingleIdentifierGrammar"), + Ref("OnClusterClauseSegment", optional=True), + # IDENTIFIED BY 'password' or IDENTIFIED WITH ... BY ... + Sequence( + "IDENTIFIED", + Sequence( + "WITH", + Ref("SingleIdentifierGrammar"), + optional=True, + ), + Sequence( + "BY", + Ref("QuotedLiteralSegment"), + ), + optional=True, + ), + ) + + class DropRoleStatementSegment(ansi.DropRoleStatementSegment): """A `DROP ROLE` statement. @@ -2119,6 +2151,18 @@ class AlterTableStatementSegment(BaseSegment): optional=True, ), ), + # ALTER TABLE ... DROP PARTITION|PART partition_expr + Sequence( + "DROP", OneOf("PARTITION", "PART"), Ref("SingleIdentifierGrammar") + ), + # ALTER TABLE ... REPLACE PARTITION partition_expr FROM table1 + Sequence( + "REPLACE", + "PARTITION", + Ref("SingleIdentifierGrammar"), + "FROM", + Ref("TableReferenceSegment"), + ), ), ) @@ -2128,6 +2172,7 @@ class StatementSegment(ansi.StatementSegment): match_grammar = ansi.StatementSegment.match_grammar.copy( insert=[ + Ref("CreateUserStatementSegment"), Ref("CreateMaterializedViewStatementSegment"), Ref("DropDictionaryStatementSegment"), Ref("DropQuotaStatementSegment"), diff --git a/src/sqlfluff/dialects/dialect_clickhouse_keywords.py b/src/sqlfluff/dialects/dialect_clickhouse_keywords.py index 1cf358ac1ef..837151c1dc1 100644 --- a/src/sqlfluff/dialects/dialect_clickhouse_keywords.py +++ b/src/sqlfluff/dialects/dialect_clickhouse_keywords.py @@ -170,6 +170,7 @@ "HIERARCHICAL", "HOUR", "ID", + "IDENTIFIED", "IF", "ILIKE", "IN", @@ -219,6 +220,7 @@ "OR", "OUTFILE", "OVERRIDE", + "PART", "PASTE", "POPULATE", "POSTGRESQL", diff --git a/src/sqlfluff/dialects/dialect_databricks.py b/src/sqlfluff/dialects/dialect_databricks.py index c3aa06d9681..1d49f25da36 100644 --- a/src/sqlfluff/dialects/dialect_databricks.py +++ b/src/sqlfluff/dialects/dialect_databricks.py @@ -1567,6 +1567,10 @@ class CommentOnStatementSegment(BaseSegment): "VOLUME", Ref("VolumeReferenceSegment"), ), + Sequence( + "COLUMN", + Ref("ColumnReferenceSegment"), + ), # TODO: Split out individual items if they have references Sequence( OneOf( diff --git a/src/sqlfluff/dialects/dialect_mariadb.py b/src/sqlfluff/dialects/dialect_mariadb.py index 4deb9c2516f..798655f282e 100644 --- a/src/sqlfluff/dialects/dialect_mariadb.py +++ b/src/sqlfluff/dialects/dialect_mariadb.py @@ -6,6 +6,7 @@ from sqlfluff.core.dialects import load_raw_dialect from sqlfluff.core.parser import ( AnyNumberOf, + AnySetOf, BaseSegment, Bracketed, Dedent, @@ -587,3 +588,138 @@ class WithRollupClauseSegment(BaseSegment): "WITH", "ROLLUP", ) + + +class IndexTypeSegment(BaseSegment): + """Index type specification: USING {BTREE | HASH | RTREE}.""" + + type = "index_type" + + match_grammar = Sequence( + "USING", + OneOf("BTREE", "HASH", "RTREE"), + ) + + +class IndexOptionSegment(BaseSegment): + """Index option specification for MariaDB.""" + + type = "index_option" + + match_grammar = AnyNumberOf( + # KEY_BLOCK_SIZE [=] value + Sequence( + "KEY_BLOCK_SIZE", + Ref("EqualsSegment", optional=True), + Ref("NumericLiteralSegment"), + ), + # index_type + Ref("IndexTypeSegment"), + # WITH PARSER parser_name + Sequence( + "WITH", + "PARSER", + Ref("ObjectReferenceSegment"), + ), + # COMMENT 'string' + Sequence( + "COMMENT", + Ref("QuotedLiteralSegment"), + ), + # CLUSTERING={YES| NO} + Sequence( + "CLUSTERING", + Ref("EqualsSegment", optional=True), + OneOf("YES", "NO"), + ), + # IGNORED | NOT IGNORED + OneOf( + "IGNORED", + Sequence("NOT", "IGNORED"), + ), + ) + + +class AlgorithmOptionSegment(BaseSegment): + """Algorithm option: ALGORITHM [=] {DEFAULT|INPLACE|COPY|NOCOPY|INSTANT}.""" + + type = "algorithm_option" + + match_grammar = Sequence( + "ALGORITHM", + Ref("EqualsSegment", optional=True), + OneOf("DEFAULT", "INPLACE", "COPY", "NOCOPY", "INSTANT"), + ) + + +class LockOptionSegment(BaseSegment): + """Lock option: LOCK [=] {DEFAULT|NONE|SHARED|EXCLUSIVE}.""" + + type = "lock_option" + + match_grammar = Sequence( + "LOCK", + Ref("EqualsSegment", optional=True), + OneOf("DEFAULT", "NONE", "SHARED", "EXCLUSIVE"), + ) + + +class WaitOptionSegment(BaseSegment): + """Wait option: WAIT n | NOWAIT.""" + + type = "wait_option" + + match_grammar = OneOf( + Sequence("WAIT", Ref("NumericLiteralSegment")), + "NOWAIT", + ) + + +class CreateIndexStatementSegment(mysql.CreateIndexStatementSegment): + """A `CREATE INDEX` statement for MariaDB.""" + + type = "create_index_statement" + + match_grammar = Sequence( + "CREATE", + Ref("OrReplaceGrammar", optional=True), + OneOf("UNIQUE", "FULLTEXT", "SPATIAL", optional=True), + "INDEX", + Ref("IfNotExistsGrammar", optional=True), + Ref("IndexReferenceSegment"), + Ref("IndexTypeSegment", optional=True), + "ON", + Ref("TableReferenceSegment"), + Ref("BracketedKeyPartListGrammar"), + Ref("WaitOptionSegment", optional=True), + Ref("IndexOptionSegment", optional=True), + AnySetOf( + Ref("AlgorithmOptionSegment"), + Ref("LockOptionSegment"), + optional=True, + ), + ) + + +class CreateProcedureStatementSegment(mysql.CreateProcedureStatementSegment): + """A `CREATE PROCEDURE` statement. + + https://mariadb.com/docs/server/server-usage/stored-routines/stored-procedures/create-procedure + """ + + match_grammar = mysql.CreateProcedureStatementSegment.match_grammar.copy( + insert=[Ref("OrReplaceGrammar", optional=True)], + before=Ref("ProcedureKeywordSegment"), + ) + + +class CreateFunctionStatementSegment(mysql.CreateFunctionStatementSegment): + """A `CREATE FUNCTION` statement. + + https://mariadb.com/docs/server/reference/sql-statements/data-definition/create/create-function + """ + + match_grammar = mysql.CreateFunctionStatementSegment.match_grammar.copy( + insert=[Ref("OrReplaceGrammar", optional=True)], + before=Ref("FunctionKeywordSegment"), + ) diff --git a/src/sqlfluff/dialects/dialect_mariadb_keywords.py b/src/sqlfluff/dialects/dialect_mariadb_keywords.py index a784d33839b..f9b9bcca55a 100644 --- a/src/sqlfluff/dialects/dialect_mariadb_keywords.py +++ b/src/sqlfluff/dialects/dialect_mariadb_keywords.py @@ -306,6 +306,7 @@ CLIENT CLOB CLOSE +CLUSTERING COALESCE CODE COLLATION diff --git a/src/sqlfluff/dialects/dialect_mysql.py b/src/sqlfluff/dialects/dialect_mysql.py index 4832693ea4b..ff3c36275cc 100644 --- a/src/sqlfluff/dialects/dialect_mysql.py +++ b/src/sqlfluff/dialects/dialect_mysql.py @@ -1478,6 +1478,7 @@ class CreateProcedureStatementSegment(BaseSegment): "CREATE", Ref("DefinerSegment", optional=True), "PROCEDURE", + Ref("IfNotExistsGrammar", optional=True), Ref("FunctionNameSegment"), Ref("ProcedureParameterListGrammar", optional=True), Ref("CommentClauseSegment", optional=True), diff --git a/src/sqlfluff/dialects/dialect_oracle.py b/src/sqlfluff/dialects/dialect_oracle.py index 7019fa150b5..f8bc826c215 100644 --- a/src/sqlfluff/dialects/dialect_oracle.py +++ b/src/sqlfluff/dialects/dialect_oracle.py @@ -268,6 +268,7 @@ oracle_dialect.sets("bare_functions").clear() oracle_dialect.sets("bare_functions").update( [ + "column_value", "current_date", "current_timestamp", "dbtimezone", @@ -281,7 +282,7 @@ oracle_dialect.patch_lexer_matchers( [ - RegexLexer("word", r"[a-zA-Z][0-9a-zA-Z_$#]*", WordSegment), + RegexLexer("word", r"[\p{L}][\p{L}\p{N}_$#]*", WordSegment), RegexLexer( "single_quote", r"'([^'\\]|\\|\\.|'')*'", @@ -720,7 +721,7 @@ ), NakedIdentifierSegment=SegmentGenerator( lambda dialect: RegexParser( - r"[A-Z0-9_]*[A-Z][A-Z0-9_#$]*", + r"[\p{L}\p{N}_]*[\p{L}][\p{L}\p{N}_#$]*", IdentifierSegment, type="naked_identifier", anti_template=r"^(" + r"|".join(dialect.sets("reserved_keywords")) + r")$", @@ -2520,7 +2521,7 @@ class CaseExpressionSegment(BaseSegment): "CASE", ImplicitIndent, AnyNumberOf( - Ref("WhenClauseSegment"), + Ref("WhenClauseSegment", terminators=[Ref.keyword("WHEN")]), reset_terminators=True, terminators=[Ref.keyword("ELSE"), Ref.keyword("END")], ), @@ -2537,7 +2538,7 @@ class CaseExpressionSegment(BaseSegment): "CASE", ImplicitIndent, AnyNumberOf( - Ref("WhenClauseSegment"), + Ref("WhenClauseSegment", terminators=[Ref.keyword("WHEN")]), reset_terminators=True, terminators=[Ref.keyword("ELSE"), Ref.keyword("END")], ), @@ -2560,7 +2561,7 @@ class CaseExpressionSegment(BaseSegment): ), ImplicitIndent, AnyNumberOf( - Ref("WhenClauseSegment"), + Ref("WhenClauseSegment", terminators=[Ref.keyword("WHEN")]), reset_terminators=True, terminators=[Ref.keyword("ELSE"), Ref.keyword("END")], ), diff --git a/src/sqlfluff/dialects/dialect_postgres.py b/src/sqlfluff/dialects/dialect_postgres.py index 16ee5673d44..10a9b3b49df 100644 --- a/src/sqlfluff/dialects/dialect_postgres.py +++ b/src/sqlfluff/dialects/dialect_postgres.py @@ -116,6 +116,19 @@ r"->>?|#>>?|@[>@?]|<@|\?[|&]?|#-", SymbolSegment, ), + # <% word_similarity + # %> word_similarity (reverse) + # <<% strict_word_similarity + # %>> strict_word_similarity (reverse) + # <<-> word_similarity distance + # <->> word_similarity distance (reverse) + # <<<-> strict_word_similarity distance + # <->>> strict_word_similarity distance (reverse) + RegexLexer( + "pg_trgm_operator", + r"<<<->|<->>>|<->>|<<->(?!>)|<<%|%>>|<%|%>", + SymbolSegment, + ), # L2 nearest neighbor (<->), # inner product (<#>), # cosine distance (<=>), @@ -354,6 +367,9 @@ PgvectorOperatorSegment=TypedParser( "pgvector_operator", SymbolSegment, type="binary_operator" ), + PgTrgmOperatorSegment=TypedParser( + "pg_trgm_operator", SymbolSegment, type="binary_operator" + ), SimpleGeometryGrammar=AnyNumberOf(Ref("NumericLiteralSegment")), # N.B. this MultilineConcatenateDelimiterGrammar is only created # to parse multiline-concatenated string literals @@ -470,6 +486,7 @@ Ref("AdjacentSegment"), Ref("PostgisOperatorSegment"), Ref("PgvectorOperatorSegment"), + Ref("PgTrgmOperatorSegment"), ), NakedIdentifierSegment=SegmentGenerator( # Generate the anti template from the set of reserved keywords @@ -504,6 +521,11 @@ FunctionContentsExpressionGrammar=OneOf( Ref("ExpressionSegment"), Ref("NamedArgumentSegment"), + # VARIADIC function call argument + # https://www.postgresql.org/docs/current/xfunc-sql.html#XFUNC-SQL-VARIADIC-FUNCTIONS + Sequence( + "VARIADIC", OneOf(Ref("ExpressionSegment"), Ref("NamedArgumentSegment")) + ), ), FunctionContentsGrammar=AnyNumberOf( Ref("ExpressionSegment"), @@ -527,9 +549,6 @@ optional=True, ), ), - # VARIADIC function call argument - # https://www.postgresql.org/docs/current/xfunc-sql.html#XFUNC-SQL-VARIADIC-FUNCTIONS - Sequence("VARIADIC", Ref("ExpressionSegment")), Sequence( # Allow an optional distinct keyword here. Ref.keyword("DISTINCT", optional=True), @@ -4951,10 +4970,14 @@ class StatementSegment(ansi.StatementSegment): Ref("DropPublicationStatementSegment"), Ref("CreateTypeStatementSegment"), Ref("AlterTypeStatementSegment"), + Ref("CreateTextSearchConfigurationStatementSegment"), + Ref("AlterTextSearchConfigurationStatementSegment"), + Ref("DropTextSearchConfigurationStatementSegment"), Ref("AlterSchemaStatementSegment"), Ref("LockTableStatementSegment"), Ref("ClusterStatementSegment"), Ref("CreateCollationStatementSegment"), + Ref("DropCollationStatementSegment"), Ref("CallStoredProcedureSegment"), Ref("CreateServerStatementSegment"), Ref("CreateUserMappingStatementSegment"), @@ -5795,9 +5818,7 @@ class CopyStatementSegment(BaseSegment): _postgres9_compatible_stdin_options, ), Sequence( - OneOf( - _table_definition, Bracketed(Ref("UnorderedSelectStatementSegment")) - ), + OneOf(_table_definition, Bracketed(Ref("SelectableGrammar"))), "TO", OneOf( _target_subset, @@ -5806,9 +5827,7 @@ class CopyStatementSegment(BaseSegment): _option, ), Sequence( - OneOf( - _table_definition, Bracketed(Ref("UnorderedSelectStatementSegment")) - ), + OneOf(_table_definition, Bracketed(Ref("SelectableGrammar"))), "TO", OneOf( Ref("QuotedLiteralSegment"), @@ -5859,7 +5878,8 @@ class CTEDefinitionSegment(ansi.CTEDefinitionSegment): https://www.postgresql.org/docs/14/queries-with.html - TODO: Data-Modifying Statements (INSERT, UPDATE, DELETE) in WITH + Data-Modifying Statements (INSERT, UPDATE, DELETE) in WITH are + matched by ansi.SelectableGrammar > NonWithSelectableGrammar. """ match_grammar = Sequence( @@ -6090,6 +6110,125 @@ class CreateTypeStatementSegment(BaseSegment): ) +class CreateTextSearchConfigurationStatementSegment(BaseSegment): + """A `CREATE TEXT SEARCH CONFIGURATION` statement. + + https://www.postgresql.org/docs/current/sql-createtsconfig.html + """ + + type = "create_text_search_configuration_statement" + match_grammar: Matchable = Sequence( + "CREATE", + "TEXT", + "SEARCH", + "CONFIGURATION", + Ref("ObjectReferenceSegment"), + Bracketed( + OneOf( + Sequence("PARSER", Ref("EqualsSegment"), Ref("ObjectReferenceSegment")), + Sequence("COPY", Ref("EqualsSegment"), Ref("ObjectReferenceSegment")), + ) + ), + ) + + +class AlterTextSearchConfigurationStatementSegment(BaseSegment): + """An `ALTER TEXT SEARCH CONFIGURATION` statement. + + https://www.postgresql.org/docs/current/sql-altertsconfig.html + """ + + type = "alter_text_search_configuration_statement" + match_grammar: Matchable = Sequence( + "ALTER", + "TEXT", + "SEARCH", + "CONFIGURATION", + Ref("ObjectReferenceSegment"), + OneOf( + Sequence( + "ADD", + "MAPPING", + "FOR", + Delimited(Ref("ObjectReferenceSegment")), + "WITH", + Delimited(Ref("ObjectReferenceSegment")), + ), + Sequence( + "ALTER", + "MAPPING", + "FOR", + Delimited(Ref("ObjectReferenceSegment")), + "WITH", + Delimited(Ref("ObjectReferenceSegment")), + ), + Sequence( + "ALTER", + "MAPPING", + "REPLACE", + Ref("ObjectReferenceSegment"), + "WITH", + Ref("ObjectReferenceSegment"), + ), + Sequence( + "ALTER", + "MAPPING", + "FOR", + Delimited(Ref("ObjectReferenceSegment")), + "REPLACE", + Ref("ObjectReferenceSegment"), + "WITH", + Ref("ObjectReferenceSegment"), + ), + Sequence( + "DROP", + "MAPPING", + Ref("IfExistsGrammar", optional=True), + "FOR", + Delimited(Ref("ObjectReferenceSegment")), + ), + Sequence( + "RENAME", + "TO", + Ref("ObjectReferenceSegment"), + ), + Sequence( + "OWNER", + "TO", + OneOf( + Ref("ObjectReferenceSegment"), + "CURRENT_ROLE", + "CURRENT_USER", + "SESSION_USER", + ), + ), + Sequence( + "SET", + "SCHEMA", + Ref("ObjectReferenceSegment"), + ), + ), + ) + + +class DropTextSearchConfigurationStatementSegment(BaseSegment): + """A `DROP TEXT SEARCH CONFIGURATION` statement. + + https://www.postgresql.org/docs/current/sql-droptsconfig.html + """ + + type = "drop_text_search_configuration_statement" + match_grammar: Matchable = Sequence( + "DROP", + "TEXT", + "SEARCH", + "CONFIGURATION", + Ref("IfExistsGrammar", optional=True), + Ref("ObjectReferenceSegment"), + Ref("DropBehaviorGrammar", optional=True), + ) + + class AlterTypeStatementSegment(BaseSegment): """An `ALTER TYPE` statement. @@ -6240,6 +6379,22 @@ class CreateCollationStatementSegment(BaseSegment): ) +class DropCollationStatementSegment(BaseSegment): + """A `DROP COLLATION` statement. + + https://www.postgresql.org/docs/current/sql-dropcollation.html + """ + + type = "drop_collation_statement" + match_grammar = Sequence( + "DROP", + "COLLATION", + Ref("IfExistsGrammar", optional=True), + Ref("ObjectReferenceSegment"), + Ref("DropBehaviorGrammar", optional=True), + ) + + class AlterSchemaStatementSegment(BaseSegment): """An `ALTER SCHEMA` statement. @@ -6372,7 +6527,9 @@ class NamedArgumentSegment(BaseSegment): type = "named_argument" match_grammar = Sequence( Ref("NakedIdentifierSegment"), - OneOf(Ref("RightArrowSegment"), Ref("WalrusOperatorSegment")), + OneOf( + Ref("RightArrowSegment"), Ref("WalrusOperatorSegment"), Ref("EqualsSegment") + ), Ref("ExpressionSegment"), ) diff --git a/src/sqlfluff/dialects/dialect_redshift.py b/src/sqlfluff/dialects/dialect_redshift.py index 45930c4f251..ab65ab08774 100644 --- a/src/sqlfluff/dialects/dialect_redshift.py +++ b/src/sqlfluff/dialects/dialect_redshift.py @@ -1812,10 +1812,7 @@ class ProcedureParameterListSegment(BaseSegment): class CreateProcedureStatementSegment(BaseSegment): """A `CREATE PROCEDURE` statement. - https://www.postgresql.org/docs/14/sql-createprocedure.html - - TODO: Just a basic statement for now, without full syntax. - based on CreateFunctionStatementSegment without a return type. + https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_PROCEDURE.html """ type = "create_procedure_statement" @@ -1826,6 +1823,7 @@ class CreateProcedureStatementSegment(BaseSegment): "PROCEDURE", Ref("FunctionNameSegment"), Ref("ProcedureParameterListSegment"), + Ref.keyword("NONATOMIC", optional=True), Ref("FunctionDefinitionGrammar"), ) diff --git a/src/sqlfluff/dialects/dialect_redshift_keywords.py b/src/sqlfluff/dialects/dialect_redshift_keywords.py index 686ab82acf9..15ad5c56daf 100644 --- a/src/sqlfluff/dialects/dialect_redshift_keywords.py +++ b/src/sqlfluff/dialects/dialect_redshift_keywords.py @@ -667,6 +667,7 @@ NOREPLICATION NOSUPERUSER NONE +NONATOMIC NOORDER NORMALIZE OUTPUTFORMAT diff --git a/src/sqlfluff/dialects/dialect_snowflake.py b/src/sqlfluff/dialects/dialect_snowflake.py index f061de773d3..4adcd4fe33e 100644 --- a/src/sqlfluff/dialects/dialect_snowflake.py +++ b/src/sqlfluff/dialects/dialect_snowflake.py @@ -198,6 +198,22 @@ ], ) +snowflake_dialect.sets("resource_constraints").clear() +snowflake_dialect.sets("resource_constraints").update( + [ + "STANDARD_GEN_1", + "STANDARD_GEN_2", + "MEMORY_1X", + "MEMORY_1X_x86", + "MEMORY_16X", + "MEMORY_16X_x86", + "MEMORY_64X", + "MEMORY_64X_x86", + "MEMORY_256X", + "MEMORY_256X_x86", + ], +) + snowflake_dialect.sets("warehouse_scaling_policies").clear() snowflake_dialect.sets("warehouse_scaling_policies").update( [ @@ -306,6 +322,22 @@ type="warehouse_size", ), ), + ResourceConstraint=OneOf( + MultiStringParser( + [ + size + for size in snowflake_dialect.sets("resource_constraints") + if "-" not in size + ], + CodeSegment, + type="resource_constraint", + ), + MultiStringParser( + [f"'{size}'" for size in snowflake_dialect.sets("resource_constraints")], + CodeSegment, + type="resource_constraint", + ), + ), RefreshModeType=OneOf( MultiStringParser( snowflake_dialect.sets("refreshmode_types"), @@ -3998,6 +4030,11 @@ class WarehouseObjectPropertiesSegment(BaseSegment): Ref("EqualsSegment"), Ref("WarehouseSize"), ), + Sequence( + "RESOURCE_CONSTRAINT", + Ref("EqualsSegment"), + Ref("ResourceConstraint"), + ), Sequence( "WAIT_FOR_COMPLETION", Ref("EqualsSegment"), @@ -5902,6 +5939,11 @@ class CsvFileFormatTypeParameters(BaseSegment): Ref("EqualsSegment"), Ref("CompressionType"), ), + Sequence( + "MULTI_LINE", + Ref("EqualsSegment"), + Ref("BooleanLiteralGrammar"), + ), Sequence("FILE_EXTENSION", Ref("EqualsSegment"), Ref("QuotedLiteralSegment")), Sequence( "SKIP_HEADER", diff --git a/src/sqlfluff/dialects/dialect_snowflake_keywords.py b/src/sqlfluff/dialects/dialect_snowflake_keywords.py index cc90a09314c..2e955514650 100644 --- a/src/sqlfluff/dialects/dialect_snowflake_keywords.py +++ b/src/sqlfluff/dialects/dialect_snowflake_keywords.py @@ -461,6 +461,7 @@ MONITOR MONITORS MONTHLY +MULTI_LINE MUST_CHANGE_PASSWORD NAME NAN @@ -590,6 +591,7 @@ REQUIRED RESET RESOURCE +RESOURCE_CONSTRAINT RESOURCE_MONITOR RESPECT RESPONSE_TRANSLATOR diff --git a/src/sqlfluff/dialects/dialect_sparksql.py b/src/sqlfluff/dialects/dialect_sparksql.py index 293e938fed7..c828a2eb50d 100644 --- a/src/sqlfluff/dialects/dialect_sparksql.py +++ b/src/sqlfluff/dialects/dialect_sparksql.py @@ -683,6 +683,29 @@ "OF", Ref("NumericLiteralSegment"), ), + InsertSourceGrammar=OneOf( + AnyNumberOf( + Ref("ValuesClauseSegment"), + min_times=1, + ), + Ref("SelectableGrammar"), + Sequence( + Ref.keyword("TABLE", optional=True), + Ref("TableReferenceSegment"), + ), + Sequence( + "FROM", + Ref("TableReferenceSegment"), + "SELECT", + Delimited( + Ref("ColumnReferenceSegment"), + ), + Ref("WhereClauseSegment", optional=True), + Ref("GroupByClauseSegment", optional=True), + Ref("OrderByClauseSegment", optional=True), + Ref("LimitClauseSegment", optional=True), + ), + ), # Adding Hint related segments so they are not treated as generic comments # https://spark.apache.org/docs/latest/sql-ref-syntax-qry-select-hints.html StartHintSegment=StringParser("/*+", SymbolSegment, type="start_hint"), @@ -1662,7 +1685,7 @@ class CreateTableStatementSegment(ansi.CreateTableStatementSegment): class CreateViewStatementSegment(ansi.CreateViewStatementSegment): """A `CREATE VIEW` statement. - https://spark.apache.org/docs/3.0.0/sql-ref-syntax-ddl-create-view.html#syntax + https://spark.apache.org/docs/latest/sql-ref-syntax-ddl-create-view.html#syntax """ match_grammar = Sequence( @@ -1691,6 +1714,11 @@ class CreateViewStatementSegment(ansi.CreateViewStatementSegment): ), Sequence("USING", Ref("DataSourceFormatSegment"), optional=True), Ref("OptionsGrammar", optional=True), + OneOf( + Ref("PartitionSpecGrammar"), + Ref("TableClusterByClauseSegment"), + optional=True, + ), Ref("CommentGrammar", optional=True), Ref("TablePropertiesGrammar", optional=True), Ref("CreateViewClausesGrammar", optional=True), @@ -1824,10 +1852,9 @@ class UseDatabaseStatementSegment(BaseSegment): # Data Manipulation Statements class InsertStatementSegment(BaseSegment): - """A `INSERT [TABLE]` statement to insert or overwrite new rows into a table. + """An `INSERT [TABLE]` statement to insert or overwrite new rows into a table. - https://spark.apache.org/docs/latest/sql-ref-syntax-dml-insert-into.html - https://spark.apache.org/docs/latest/sql-ref-syntax-dml-insert-overwrite-table.html + https://spark.apache.org/docs/latest/sql-ref-syntax-dml-insert-table.html#insert-table """ type = "insert_statement" @@ -1837,29 +1864,22 @@ class InsertStatementSegment(BaseSegment): OneOf("INTO", "OVERWRITE"), Ref.keyword("TABLE", optional=True), Ref("TableReferenceSegment"), - Ref("PartitionSpecGrammar", optional=True), - Ref("BracketedColumnReferenceListGrammar", optional=True), OneOf( - AnyNumberOf( - Ref("ValuesClauseSegment"), - min_times=1, + Sequence( + Ref("PartitionSpecGrammar", optional=True), + Ref("BracketedColumnReferenceListGrammar", optional=True), + Ref("InsertSourceGrammar"), ), - Ref("SelectableGrammar"), Sequence( - Ref.keyword("TABLE", optional=True), - Ref("TableReferenceSegment"), + "REPLACE", + Ref("WhereClauseSegment"), + Ref("InsertSourceGrammar"), ), Sequence( - "FROM", - Ref("TableReferenceSegment"), - "SELECT", - Delimited( - Ref("ColumnReferenceSegment"), - ), - Ref("WhereClauseSegment", optional=True), - Ref("GroupByClauseSegment", optional=True), - Ref("OrderByClauseSegment", optional=True), - Ref("LimitClauseSegment", optional=True), + "REPLACE", + "USING", + Ref("BracketedColumnReferenceListGrammar"), + Ref("InsertSourceGrammar"), ), ), ) diff --git a/src/sqlfluff/dialects/dialect_tsql.py b/src/sqlfluff/dialects/dialect_tsql.py index 77e86236627..c2fddbc81ae 100644 --- a/src/sqlfluff/dialects/dialect_tsql.py +++ b/src/sqlfluff/dialects/dialect_tsql.py @@ -206,6 +206,19 @@ before="back_quote", ) +# Add hexadecimal literal lexer matcher before word matcher to ensure +# patterns like 0x0, 0xAE are tokenized as numeric literals, not words +tsql_dialect.insert_lexer_matchers( + [ + RegexLexer( + "numeric_literal", + r"([xX]'([\da-fA-F][\da-fA-F])+'|0[xX][\da-fA-F]*)", + LiteralSegment, + ), + ], + before="word", +) + tsql_dialect.patch_lexer_matchers( [ # Patching single_quote to allow for TSQL-style escaped quotes @@ -266,6 +279,11 @@ ) tsql_dialect.add( + PercentSegment=TypedParser( + "percent", + CodeSegment, + type="percent", + ), BracketedIdentifierSegment=TypedParser( "square_quote", IdentifierSegment, @@ -292,6 +310,16 @@ Ref("QuotedLiteralSegment"), Ref("QuotedLiteralSegmentWithN"), ), + IntegerLiteralSegment=RegexParser( + r"(? Override + Ref("AlterDatabaseStatementSegment"), + # Ref("DropDatabaseStatementSegment"), + # Ref("CreateTableStatementSegment"), Ref("CreateTableGraphStatementSegment"), - Ref( - "CreateTableAsSelectStatementSegment" - ), # Azure Synapse Analytics specific - Ref("RenameStatementSegment"), # Azure Synapse Analytics specific - Ref("ExecuteScriptSegment"), - Ref("DropStatisticsStatementSegment"), + Ref("AlterTableSwitchStatementSegment"), + # Ref("DropTableStatementSegment"), + # Ref("CreateViewStatementSegment"), + # Ref("AlterViewStatementSegment"), + # Ref("DropIndexStatementSegment"), + # Ref("CreateIndexStatementSegment"), + Ref("AlterIndexStatementSegment"), + # Ref("DropViewStatementSegment"), + Ref("CreateProcedureStatementSegment"), + # Ref("AlterProcedureStatementSegment"), Ref("DropProcedureStatementSegment"), - Ref("UpdateStatisticsStatementSegment"), - Ref("BeginEndSegment"), - Ref("TryCatchSegment"), - Ref("MergeStatementSegment"), - Ref("ThrowStatementSegment"), - Ref("RaiserrorStatementSegment"), - Ref("ReturnStatementSegment"), - Ref("GotoStatement"), - Ref("LabelStatementSegment"), + Ref("DropStatisticsStatementSegment"), Ref("DisableTriggerStatementSegment"), - Ref("WhileExpressionStatement"), + Ref("CreatePartitionFunctionSegment"), + Ref("AlterPartitionSchemeSegment"), + Ref("CreateMasterKeySegment"), + Ref("AlterMasterKeySegment"), + Ref("DropMasterKeySegment"), + Ref("CreateSecurityPolicySegment"), + Ref("AlterSecurityPolicySegment"), + Ref("DropSecurityPolicySegment"), + Ref("CreateSynonymStatementSegment"), + Ref("DropSynonymStatementSegment"), + # DML Data Manipulation Language + # https://learn.microsoft.com/en-us/sql/t-sql/queries/queries + Ref("BulkInsertStatementSegment"), + Ref("MergeStatementSegment"), + # CFL Control of Flow Language + # https://learn.microsoft.com/en-us/sql/t-sql/language-elements/control-of-flow + Ref("BeginEndSegment"), Ref("BreakStatement"), Ref("ContinueStatement"), + Ref("GotoStatement"), + Ref("IfExpressionStatement"), + Ref("ReturnStatementSegment"), + Ref("ThrowStatementSegment"), + Ref("TryCatchSegment"), Ref("WaitForStatementSegment"), + Ref("WhileExpressionStatement"), + # Cursor statements + Ref("DeclareCursorStatementSegment"), Ref("OpenCursorStatementSegment"), + Ref("FetchCursorStatementSegment"), Ref("CloseCursorStatementSegment"), Ref("DeallocateCursorStatementSegment"), - Ref("FetchCursorStatementSegment"), + # Other statements + Ref("PrintStatementSegment"), + Ref("RaiserrorStatementSegment"), + Ref("DeclareStatementSegment"), + Ref("ExecuteScriptSegment"), + # Ref("PermissionStatementSegment"), + Ref("SetStatementSegment"), + Ref("SetLanguageStatementSegment"), + # Ref("UseStatementSegment"), + # Unsorted + Ref("SetLocalVariableStatementSegment"), + # Azure Synapse Analytics specific + Ref("CreateTableAsSelectStatementSegment"), + # Azure Synapse Analytics specific + Ref("RenameStatementSegment"), + Ref("UpdateStatisticsStatementSegment"), + Ref("LabelStatementSegment"), Ref("CreateTypeStatementSegment"), - Ref("CreateSynonymStatementSegment"), - Ref("DropSynonymStatementSegment"), - Ref("BulkInsertStatementSegment"), - Ref("AlterIndexStatementSegment"), Ref("CreateDatabaseScopedCredentialStatementSegment"), Ref("CreateExternalDataSourceStatementSegment"), Ref("SqlcmdCommandSegment"), @@ -723,78 +857,704 @@ class StatementSegment(ansi.StatementSegment): Ref("AtomicBeginEndSegment"), Ref("ReconfigureStatementSegment"), Ref("CreateColumnstoreIndexStatementSegment"), - Ref("CreatePartitionFunctionSegment"), - Ref("AlterPartitionSchemeSegment"), Ref("CreatePartitionSchemeSegment"), Ref("AlterPartitionFunctionSegment"), - Ref("CreateMasterKeySegment"), - Ref("AlterMasterKeySegment"), - Ref("DropMasterKeySegment"), Ref("OpenSymmetricKeySegment"), Ref("CreateLoginStatementSegment"), Ref("SetContextInfoSegment"), - Ref("CreateSecurityPolicySegment"), - Ref("AlterSecurityPolicySegment"), - Ref("DropSecurityPolicySegment"), ], remove=[ + Ref("CreateCastStatementSegment"), + Ref("DropCastStatementSegment"), Ref("CreateModelStatementSegment"), Ref("DropModelStatementSegment"), Ref("DescribeStatementSegment"), + Ref("ExplainStatementSegment"), ], ) -class GreaterThanOrEqualToSegment(CompositeComparisonOperatorSegment): - """Greater than or equal to operator. +# Level 3 + + +class CreateDatabaseStatementSegment(BaseSegment): + """A `CREATE DATABASE` statement.""" + + _file_group = Sequence( + "FILEGROUP", + Ref("NakedOrQuotedIdentifierGrammar"), + OneOf( + Sequence( + Sequence("CONTAINS", "FILESTREAM", optional=True), + Sequence("DEFAULT", optional=True), + ), + Sequence("CONTAINS", "MEMORY_OPTIMIZED_DATA"), + optional=True, + ), + Delimited(Ref("FileSpecSegment")), + ) + + _filestream_option = OneOf( + Sequence( + "NON_TRANSACTED_ACCESS", + Ref("EqualsSegment"), + OneOf("OFF", "READ_ONLY", "FULL"), + ), + Sequence( + "DIRECTORY_NAME", + Ref("EqualsSegment"), + Ref("QuotedLiteralSegment"), + ), + ) + + _create_database_option = OneOf( + Sequence( + "FILESTREAM", + Bracketed(Delimited(_filestream_option, min_delimiters=1)), + ), + Sequence( + "DEFAULT_FULLTEXT_LANGUAGE", + Ref("EqualsSegment"), + OneOf( + Ref("NumericLiteralSegment"), + Ref("QuotedLiteralSegment"), + Ref("NakedIdentifierSegment"), + ), + ), + Sequence( + "DEFAULT_LANGUAGE", + Ref("EqualsSegment"), + OneOf( + Ref("NumericLiteralSegment"), + Ref("QuotedLiteralSegment"), + Ref("NakedIdentifierSegment"), + ), + ), + Sequence( + "NESTED_TRIGGERS", + Ref("EqualsSegment"), + OneOf("OFF", "ON"), + ), + Sequence( + "TRANSFORM_NOISE_WORDS", + Ref("EqualsSegment"), + OneOf("OFF", "ON"), + ), + Sequence( + "TWO_DIGIT_YEAR_CUTOFF", + Ref("EqualsSegment"), + Ref("NumericLiteralSegment"), + ), + Sequence( + "DB_CHAINING", + OneOf("OFF", "ON"), + ), + Sequence( + "TRUSTWORTHY", + OneOf("OFF", "ON"), + ), + Sequence( + "PERSISTENT_LOG_BUFFER", + Ref("EqualsSegment"), + "ON", + Bracketed( + Sequence( + "DIRECTORY_NAME", + Ref("EqualsSegment"), + Ref("QuotedLiteralSegment"), + ) + ), + ), + Sequence( + "LEDGER", + Ref("EqualsSegment"), + OneOf("ON", "OFF"), + ), + Sequence( + "CATALOG_COLLATION", + Ref("EqualsSegment"), + Ref("CollationReferenceSegment"), + ), + ) + + _create_database_normal = Sequence( + Sequence( + "CONTAINMENT", + Ref("EqualsSegment"), + OneOf("NONE", "PARTIAL"), + optional=True, + ), + Sequence( + "ON", + Sequence("PRIMARY", optional=True), + Delimited(Ref("FileSpecSegment")), + Sequence( + Ref("CommaSegment"), + Delimited(_file_group, optional=True), + optional=True, + ), + Sequence( + "LOG", + "ON", + Delimited(Ref("FileSpecSegment")), + optional=True, + ), + optional=True, + ), + Sequence( + "COLLATE", + Ref("CollationReferenceSegment"), + optional=True, + ), + Sequence( + "WITH", + Delimited(_create_database_option), + optional=True, + ), + ) + + _attach_database_option = OneOf( + # Service broker options + "ENABLE_BROKER", + "NEW_BROKER", + "ERROR_BROKER_CONVERSATIONS", + "RESTRICTED_USER", + Sequence( + "FILESTREAM", + Bracketed( + Sequence( + "DIRECTORY_NAME", + Ref("EqualsSegment"), + OneOf( + Ref("QuotedLiteralSegment"), + "NULL", + ), + ) + ), + ), + ) + + _create_database_attach = Sequence( + "ON", + Delimited(Ref("FileSpecSegment")), + "FOR", + OneOf( + Sequence( + "ATTACH", + Sequence( + "WITH", + _attach_database_option, + optional=True, + ), + ), + "ATTACH_REBUILD_LOG", + ), + ) + + _create_database_snapshot = Sequence( + "ON", + Delimited( + Bracketed( + Sequence( + Ref("LogicalFileNameSegment", optional=True), + Ref("FileSpecFileNameSegment"), + ), + ), + min_delimiters=1, + ), + "AS", + "SNAPSHOT", + "OF", + Ref("NakedIdentifierSegment"), + ) + + type = "create_database_statement" + # https://learn.microsoft.com/en-us/sql/t-sql/statements/create-database-transact-sql + match_grammar: Matchable = Sequence( + "CREATE", + "DATABASE", + Ref("DatabaseReferenceSegment"), + OneOf( + _create_database_normal, + _create_database_attach, + _create_database_snapshot, + optional=True, + ), + ) + + +class AlterDatabaseStatementSegment(BaseSegment): + """An `ALTER DATABASE` statement.""" + + _modify_name = Sequence( + "MODIFY", + "NAME", + Ref("EqualsSegment"), + Ref("DatabaseReferenceSegment"), + ) + + _add_or_modify_files = OneOf( + Sequence( + "ADD", + "FILE", + Ref("FileSpecSegmentInAlterDatabase"), + Sequence( + "TO", + "FILEGROUP", + Ref("NakedOrQuotedIdentifierGrammar", optional=True), + optional=True, + ), + ), + Sequence( + "ADD", + "LOG", + "FILE", + Delimited(Ref("FileSpecSegmentInAlterDatabase"), min_delimiters=1), + ), + Sequence( + "REMOVE", + "FILE", + Ref("LiteralSegment"), + ), + Sequence( + "MODIFY", + "FILE", + Ref("FileSpecSegmentInAlterDatabase"), + ), + ) + + _add_or_modify_filegroups = Sequence( + OneOf( + "ADD", + "REMOVE", + ), + "FILEGROUP", + ) + + _accelerated_database_recovery = Sequence( + "ACCELERATED_DATABASE_RECOVERY", + OneOf("ON", "OFF"), + Bracketed( + "PERSISTENT_VERSION_STORE_FILEGROUP", + Ref("EqualsSegment"), + Ref("NakedOrQuotedIdentifierGrammar"), + ), + ) + + _set_option = Sequence( + "SET", + OptionallyBracketed( + Delimited( + OneOf( + Ref("CompatibilityLevelSegment"), + Ref("AutoOptionSegment"), + _accelerated_database_recovery, + # catch-all for all ON | OFF + # if needed, more specific grammar can be added + Sequence( + Ref("NakedIdentifierSegment"), + Ref("EqualsSegment"), + OneOf("ON", "OFF"), + ), + # catch all for size settings + Sequence( + Ref("NakedIdentifierSegment"), + Ref("EqualsSegment"), + Ref("NumericLiteralSegment"), + OneOf("KB", "MB", "GB", "TB", optional=True), + ), + ), + ), + ), + ) + + _add_secondary_option = OneOf( + Ref("AllowConnectionsSegment"), Ref("ServiceObjectiveSegment") + ) + + _secondary_server_option = Sequence( + OneOf("ADD", "REMOVE"), + "SECONDARY", + "ON", + "SERVER", + Ref("NakedOrQuotedIdentifierGrammar"), + Sequence( + "WITH", + Bracketed( + Delimited( + _add_secondary_option, + ) + ), + optional=True, + ), + ) + + _modify_options = Sequence( + "MODIFY", + Bracketed( + Delimited( + OneOf( + Ref("FileSpecMaxSizeSegment"), + Ref("EditionSegment"), + Ref("ServiceObjectiveSegment"), + ), + ) + ), + Sequence("WITH", "MANUAL_CUTOVER", optional=True), + ) + + _modify_backup_storage = Sequence( + "MODIFY", + Ref("BackupStorageRedundancySegment"), + ) + + type = "alter_database_statement" + match_grammar: Matchable = Sequence( + "ALTER", + "DATABASE", + OneOf( + Ref("DatabaseReferenceSegment"), + "CURRENT", + ), + OneOf( + _modify_name, + _modify_backup_storage, + _add_or_modify_files, + _add_or_modify_filegroups, + _modify_options, + Ref("CollateGrammar"), + _set_option, + _secondary_server_option, + "PERFORM_CUTOVER", + "FAILOVER", + "FORCE_FAILOVER_ALLOW_DATA_LOSS", + optional=True, + ), + ) + + +# Shared grammars +class GreaterThanOrEqualToSegment(CompositeComparisonOperatorSegment): + """Greater than or equal to operator. + + N.B. Patching to add !< and + to allow spaces between operators. + """ + + match_grammar = OneOf( + Sequence( + Ref("RawGreaterThanSegment"), + Ref("RawEqualsSegment"), + ), + Sequence( + Ref("RawNotSegment"), + Ref("RawLessThanSegment"), + ), + ) + + +class LessThanOrEqualToSegment(CompositeComparisonOperatorSegment): + """Greater than or equal to operator. + + N.B. Patching to add !> and + to allow spaces between operators. + """ + + match_grammar = OneOf( + Sequence( + Ref("RawLessThanSegment"), + Ref("RawEqualsSegment"), + ), + Sequence( + Ref("RawNotSegment"), + Ref("RawGreaterThanSegment"), + ), + ) + + +class NotEqualToSegment(CompositeComparisonOperatorSegment): + """Not equal to operator. + + N.B. Patching to allow spaces between operators. + """ + + match_grammar = OneOf( + Sequence(Ref("RawNotSegment"), Ref("RawEqualsSegment")), + Sequence(Ref("RawLessThanSegment"), Ref("RawGreaterThanSegment")), + ) + + +class LogicalFileNameSegment(BaseSegment): + """A logical file name for CREATE DATABASE and CREATE DATABASE statements. + + https://learn.microsoft.com/en-us/sql/t-sql/statements/create-database-transact-sql + """ + + type = "logical_file_name" + match_grammar = Sequence( + "NAME", + Ref("EqualsSegment"), + OneOf( + Ref("NakedIdentifierSegment"), + Ref("QuotedLiteralSegmentOptWithN"), + ), + ) + + +class FileSpecFileNameSegment(BaseSegment): + """FILENAME specification segment.""" + + type = "file_spec_file_name" + match_grammar = Sequence( + Ref("CommaSegment", optional=True), + "FILENAME", + Ref("EqualsSegment"), + Ref("QuotedLiteralSegmentOptWithN"), + ) + + +class FileSpecNewNameSegment(BaseSegment): + """NEWNAME specification segment.""" + + type = "file_spec_new_name" + match_grammar = Sequence( + Ref("CommaSegment"), + "NEWNAME", + Ref("EqualsSegment"), + Ref("QuotedLiteralSegmentOptWithN"), + ) + + +class FileSpecSizeSegment(BaseSegment): + """File SIZE specification segment.""" + + type = "file_spec_size" + match_grammar = Sequence( + Ref("CommaSegment"), + "SIZE", + Ref("EqualsSegment"), + OneOf( + Ref("SizeLiteralSegment"), + Sequence( + Ref("NumericLiteralSegment"), + OneOf("KB", "MB", "GB", "TB", optional=True), + ), + ), + ) + + +class FileSpecMaxSizeSegment(BaseSegment): + """MAXSIZE specification segment.""" + + type = "file_spec_max_size" + match_grammar = Sequence( + Ref("CommaSegment", optional=True), + "MAXSIZE", + Ref("EqualsSegment"), + OneOf( + Ref("SizeLiteralSegment"), + Sequence( + Ref("NumericLiteralSegment"), + OneOf("KB", "MB", "GB", "TB", optional=True), + ), + "UNLIMITED", + ), + ) + + +class FileSpecFileGrowthSegment(BaseSegment): + """FILEGROWTH specification segment.""" - N.B. Patching to add !< and - to allow spaces between operators. + type = "file_spec_file_growth" + match_grammar = Sequence( + Ref("CommaSegment"), + "FILEGROWTH", + Ref("EqualsSegment"), + OneOf( + Ref("SizeLiteralSegment"), + Sequence( + Ref("NumericLiteralSegment"), + OneOf("KB", "MB", "GB", "TB", Ref("PercentSegment"), optional=True), + ), + ), + ) + + +class UnbracketedFileSpecSegment(BaseSegment): + """A file specification without brackets. + + Used at CREATE DATABASE statement """ - match_grammar = OneOf( - Sequence( - Ref("RawGreaterThanSegment"), - Ref("RawEqualsSegment"), - ), - Sequence( - Ref("RawNotSegment"), - Ref("RawLessThanSegment"), - ), + type = "file_spec_without_bracket" + match_grammar = Sequence( + Ref("LogicalFileNameSegment", optional=True), + Ref("FileSpecFileNameSegment"), + Ref("FileSpecSizeSegment", optional=True), + Ref("FileSpecMaxSizeSegment", optional=True), + Ref("FileSpecFileGrowthSegment", optional=True), ) -class LessThanOrEqualToSegment(CompositeComparisonOperatorSegment): - """Greater than or equal to operator. +class FileSpecSegment(BaseSegment): + """A file specification for CREATE DATABASE statements. - N.B. Patching to add !> and - to allow spaces between operators. + https://learn.microsoft.com/en-us/sql/t-sql/statements/create-database-transact-sql """ - match_grammar = OneOf( - Sequence( - Ref("RawLessThanSegment"), - Ref("RawEqualsSegment"), + type = "file_spec" + match_grammar = Bracketed(Ref("UnbracketedFileSpecSegment")) + + +class FileSpecSegmentInAlterDatabase(BaseSegment): + """A file specification for ALTER DATABASE statements.""" + + # make FILENAME optional and add NEWNAME segment + _inner = UnbracketedFileSpecSegment.match_grammar.copy( + remove=[Ref("FileSpecFileNameSegment")], + insert=[ + Ref("FileSpecNewNameSegment", optional=True), + Ref("FileSpecFileNameSegment", optional=True), + ], + before=Ref("FileSpecSizeSegment", optional=True), + ) + + type = "file_spec" + match_grammar = Bracketed(_inner) + + +class CollationReferenceSegment(ansi.ObjectReferenceSegment): + """A reference to a collation.""" + + type = "collation_reference" + # https://learn.microsoft.com/en-us/sql/t-sql/statements/collations + match_grammar: Matchable = OneOf( + Ref("QuotedLiteralSegment"), Ref("NakedIdentifierSegment"), "DATABASE_DEFAULT" + ) + + +class CompatibilityLevelSegment(BaseSegment): + """COMPATIBILITY_LEVEL specification segment.""" + + type = "compatibility_level" + match_grammar: Matchable = Sequence( + "COMPATIBILITY_LEVEL", Ref("EqualsSegment"), Ref("NumericLiteralSegment") + ) + + +class AutoOptionSegment(BaseSegment): + """AUTO options segment.""" + + _auto_options = Sequence( + OneOf( + "AUTO_CLOSE", + "AUTO_SHRINK", + "AUTO_UPDATE_STATISTICS", + "AUTO_UPDATE_STATISTICS_ASYNC", ), - Sequence( - Ref("RawNotSegment"), - Ref("RawGreaterThanSegment"), + OneOf("ON", "OFF"), + ) + + _auto_create_statistics = Sequence( + "AUTO_CREATE_STATISTICS", + OneOf( + "ON", + "OFF", + Bracketed( + "INCREMENTAL", + Ref("EqualsSegment"), + OneOf( + "ON", + "OFF", + ), + optional=True, + ), ), ) + type = "auto_option" + match_grammar: Matchable = OneOf( + _auto_options, + _auto_create_statistics, + ) -class NotEqualToSegment(CompositeComparisonOperatorSegment): - """Not equal to operator. - N.B. Patching to allow spaces between operators. +class ServiceObjectiveSegment(BaseSegment): + """SERVICE_OBJECTIVE specification segment.""" + + type = "service_objective" + match_grammar: Matchable = Sequence( + "SERVICE_OBJECTIVE", + Ref("EqualsSegment"), + OneOf( + Ref("QuotedLiteralSegment"), + Sequence( + "ELASTIC_POOL", + Bracketed( + "NAME", + Ref("EqualsSegment"), + Ref("NakedOrQuotedIdentifierGrammar"), + ), + ), + ), + ) + + +class EditionSegment(BaseSegment): + """EDITION specification segment.""" + + type = "edition" + match_grammar: Matchable = Sequence( + "EDITION", + Ref("EqualsSegment"), + Ref("QuotedLiteralSegment"), + ) + + +class AllowConnectionsSegment(BaseSegment): + """ALLOW_CONNECTIONS specification segment.""" + + type = "allow_connections" + match_grammar: Matchable = Sequence( + "ALLOW_CONNECTIONS", + Ref("EqualsSegment"), + OneOf("ALL", "NO", "READ_ONLY", "READ_WRITE"), + ) + + +class BackupStorageRedundancySegment(BaseSegment): + """BACKUP_STORAGE_REDUNDANCY specification segment.""" + + type = "backup_storage_redundancy" + match_grammar: Matchable = Sequence( + "BACKUP_STORAGE_REDUNDANCY", + Ref("EqualsSegment"), + Ref("QuotedLiteralSegment"), + ) + + +class CursorDefinitionSegment(BaseSegment): + """A cursor definition. + + https://learn.microsoft.com/en-us/sql/t-sql/language-elements/cursors """ - match_grammar = OneOf( - Sequence(Ref("RawNotSegment"), Ref("RawEqualsSegment")), - Sequence(Ref("RawLessThanSegment"), Ref("RawGreaterThanSegment")), + type = "cursor_definition" + match_grammar: Matchable = Sequence( + "CURSOR", + OneOf("LOCAL", "GLOBAL", optional=True), + OneOf("FORWARD_ONLY", "SCROLL", optional=True), + OneOf("STATIC", "KEYSET", "DYNAMIC", "FAST_FORWARD", optional=True), + OneOf("READ_ONLY", "SCROLL_LOCKS", "OPTIMISTIC", optional=True), + Sequence("TYPE_WARNING", optional=True), + "FOR", + Ref("SelectStatementSegment"), ) +# Originals + + class SelectClauseElementSegment(ansi.SelectClauseElementSegment): """An element in the targets of a select statement. @@ -2303,6 +3063,7 @@ class DeclareStatementSegment(BaseSegment): optional=True, ), ), + "CURSOR", Sequence( "TABLE", Bracketed( @@ -2332,29 +3093,20 @@ class DeclareCursorStatementSegment(BaseSegment): type = "declare_segment" match_grammar = Sequence( "DECLARE", - Ref("NakedIdentifierSegment"), - "CURSOR", - OneOf("LOCAL", "GLOBAL", optional=True), - OneOf("FORWARD_ONLY", "SCROLL", optional=True), - OneOf("STATIC", "KEYSET", "DYNAMIC", "FAST_FORWARD", optional=True), - OneOf("READ_ONLY", "SCROLL_LOCKS", "OPTIMISTIC", optional=True), - Sequence("TYPE_WARNING", optional=True), - "FOR", - Ref("SelectStatementSegment"), + Ref("CursorNameGrammar"), + OneOf( + Ref("CursorDefinitionSegment"), + Sequence( + Ref.keyword("INSENSITIVE", optional=True), + Ref.keyword("SCROLL", optional=True), + "CURSOR", + "FOR", + Ref("SelectStatementSegment"), + ), + ), ) -class GoStatementSegment(BaseSegment): - """GO signals the end of a batch of Transact-SQL statements. - - GO statements are not part of the TSQL language. They are used to signal batch - statements so that clients know in how batches of statements can be executed. - """ - - type = "go_statement" - match_grammar = Ref.keyword("GO") - - class BracketedArguments(ansi.BracketedArguments): """A series of bracketed arguments. @@ -2791,13 +3543,47 @@ class ExecuteAsClauseSegment(BaseSegment): ) +class SetLocalVariableStatementSegment(BaseSegment): + """A Set Local Variable statement. + + https://docs.microsoft.com/en-us/sql/t-sql/language-elements/set-local-variable-transact-sql + """ + + type = "set_local_variable_segment" + match_grammar = Sequence( + "SET", + Indent, + Delimited( + OneOf( + Sequence( + Ref("ParameterNameSegment"), + Ref("AssignmentOperatorSegment"), + OneOf( + Ref("ExpressionSegment"), + Ref("SelectableGrammar"), + ), + ), + Sequence( + Ref("ParameterNameSegment"), + Ref("EqualsSegment"), + OneOf( + Ref("ParameterNameSegment"), + Ref("NakedIdentifierSegment"), + Ref("CursorDefinitionSegment"), + ), + ), + ), + ), + Dedent, + ) + + class SetStatementSegment(BaseSegment): """A Set statement. Setting an already declared variable or global variable. https://docs.microsoft.com/en-us/sql/t-sql/statements/set-statements-transact-sql - https://docs.microsoft.com/en-us/sql/t-sql/language-elements/set-local-variable-transact-sql """ type = "set_segment" @@ -2889,14 +3675,6 @@ class SetStatementSegment(BaseSegment): Ref("QualifiedNumericLiteralSegment"), ), ), - Sequence( - Ref("ParameterNameSegment"), - Ref("AssignmentOperatorSegment"), - OneOf( - Ref("ExpressionSegment"), - Ref("SelectableGrammar"), - ), - ), ), ), Dedent, @@ -4177,46 +4955,6 @@ class TryCatchSegment(BaseSegment): ) -class BatchSegment(BaseSegment): - """A segment representing a GO batch within a file or script.""" - - type = "batch" - match_grammar = OneOf( - # Things that can be bundled - Ref("OneOrMoreStatementsGrammar"), - # Things that can't be bundled - Ref("CreateProcedureStatementSegment"), - ) - - -class FileSegment(BaseFileSegment): - """A segment representing a whole file or script. - - We override default as T-SQL allows concept of several - batches of commands separated by GO as well as usual - semicolon-separated statement lines. - - This is also the default "root" segment of the dialect, - and so is usually instantiated directly. It therefore - has no match_grammar. - """ - - match_grammar = Sequence( - AnyNumberOf(Ref("BatchDelimiterGrammar")), - Delimited( - Ref("BatchSegment"), - delimiter=AnyNumberOf( - Sequence( - Ref("DelimiterGrammar", optional=True), Ref("BatchDelimiterGrammar") - ), - min_times=1, - ), - allow_gaps=True, - allow_trailing=True, - ), - ) - - class OpenRowSetSegment(BaseSegment): """A `OPENROWSET` segment. @@ -4735,6 +5473,25 @@ class SetContextInfoSegment(BaseSegment): ) +class SetLanguageStatementSegment(BaseSegment): + """A `SET LANGUAGE` statement. + + https://learn.microsoft.com/en-us/sql/t-sql/statements/set-language-transact-sql + """ + + type = "set_language_statement" + match_grammar = Sequence( + "SET", + "LANGUAGE", + OneOf( + Ref("QuotedLiteralSegment"), + Ref("BracketedIdentifierSegment"), + Ref("NakedIdentifierSegment"), + ), + Ref("DelimiterGrammar", optional=True), + ) + + class PrintStatementSegment(BaseSegment): """PRINT statement segment.""" @@ -4985,7 +5742,7 @@ class ForClauseSegment(BaseSegment): type = "for_clause" - _common_directives_for_xml = Sequence( + _common_directives_for_xml = AnyNumberOf( Sequence( "BINARY", "BASE64", @@ -5529,26 +6286,21 @@ class RaiserrorStatementSegment(BaseSegment): Bracketed( Delimited( OneOf( - Ref("NumericLiteralSegment"), - Ref("QuotedLiteralSegment"), - Ref("QuotedLiteralSegmentWithN"), - Ref("ParameterNameSegment"), - ), - OneOf( - Ref("NumericLiteralSegment"), - Ref("QualifiedNumericLiteralSegment"), - Ref("ParameterNameSegment"), + Ref("NumericLiteralSegment"), # msg_id + Ref("QuotedLiteralSegment"), # msg_str + Ref("QuotedLiteralSegmentWithN"), # msg_str + Ref("ParameterNameSegment"), # @local_variable ), - OneOf( - Ref("NumericLiteralSegment"), - Ref("QualifiedNumericLiteralSegment"), - Ref("ParameterNameSegment"), + Sequence( + Ref("CommaSegment"), + Ref("NumericLiteralSegment"), # severity + Ref("CommaSegment"), + Ref("NumericLiteralSegment"), # state ), + # [ , argument [ , ...n ] ] AnyNumberOf( - Ref("LiteralGrammar"), - Ref("ParameterNameSegment"), - min_times=0, - max_times=20, + Ref("CommaSegment"), + Ref("ExpressionSegment"), ), ), ), @@ -5911,6 +6663,7 @@ class OpenCursorStatementSegment(BaseSegment): type = "open_cursor_statement" match_grammar: Matchable = Sequence( "OPEN", + Ref.keyword("GLOBAL", optional=True), Ref("CursorNameGrammar"), ) @@ -5924,6 +6677,7 @@ class CloseCursorStatementSegment(BaseSegment): type = "close_cursor_statement" match_grammar: Matchable = Sequence( "CLOSE", + Ref.keyword("GLOBAL", optional=True), Ref("CursorNameGrammar"), ) @@ -5937,6 +6691,7 @@ class DeallocateCursorStatementSegment(BaseSegment): type = "deallocate_cursor_statement" match_grammar: Matchable = Sequence( "DEALLOCATE", + Ref.keyword("GLOBAL", optional=True), Ref("CursorNameGrammar"), ) @@ -5950,8 +6705,19 @@ class FetchCursorStatementSegment(BaseSegment): type = "fetch_cursor_statement" match_grammar: Matchable = Sequence( "FETCH", - OneOf("NEXT", "PRIOR", "FIRST", "LAST", optional=True), - "FROM", + OneOf( + "NEXT", + "PRIOR", + "FIRST", + "LAST", + Sequence( + OneOf("ABSOLUTE", "RELATIVE"), + Ref("SignedSegmentGrammar", optional=True), + Ref("NumericLiteralSegment"), + ), + optional=True, + ), + Ref.keyword("FROM", optional=True), Ref("CursorNameGrammar"), Sequence("INTO", Delimited(Ref("ParameterNameSegment")), optional=True), ) diff --git a/src/sqlfluff/dialects/dialect_tsql_keywords.py b/src/sqlfluff/dialects/dialect_tsql_keywords.py index 5e3c909aff8..b972aa88153 100644 --- a/src/sqlfluff/dialects/dialect_tsql_keywords.py +++ b/src/sqlfluff/dialects/dialect_tsql_keywords.py @@ -255,9 +255,12 @@ "ABORT_AFTER_WAIT", "ABORT", "ABSENT", + "ABSOLUTE", + "ACCELERATED_DATABASE_RECOVERY", "ACTION", "AFTER", "ALGORITHM", + "ALLOW_CONNECTIONS", "ALLOW_ENCRYPTED_VALUE_MODIFICATIONS", "ALLOW_PAGE_LOCKS", "ALLOW_ROW_LOCKS", @@ -276,8 +279,16 @@ "ASYMMETRIC", "AT", "ATOMIC", + "ATTACH", + "ATTACH_REBUILD_LOG", + "AUTO_CLOSE", + "AUTO_CREATE_STATISTICS", "AUTO_CREATE_TABLE", + "AUTO_SHRINK", + "AUTO_UPDATE_STATISTICS", + "AUTO_UPDATE_STATISTICS_ASYNC", "AUTO", + "BACKUP_STORAGE_REDUNDANCY", "BEFORE", # *future* "BERNOULLI", "BINARY", @@ -288,6 +299,7 @@ "CALLED", "CALLER", "CAST", + "CATALOG_COLLATION", "CATCH", "CERTIFICATE", "CHANGE_TRACKING", @@ -298,6 +310,7 @@ "COLUMNSTORE_ARCHIVE", "COLUMNSTORE", "COMMITTED", + "COMPATIBILITY_LEVEL", "COMPRESS_ALL_ROW_GROUPS", "COMPRESSION_DELAY", "COMPRESSION", @@ -306,6 +319,7 @@ "CONNECTION", "CONNECTION_OPTIONS", "CONTAINED", + "CONTAINMENT", "CONTEXT_INFO", "CONTINUE", "CONTROL", @@ -318,6 +332,7 @@ "DATA_DELETION", "DATA_SOURCE", "DATA", + "DATABASE_DEFAULT", "DATAFILETYPE", "DATASOURCE", "DATE_FORMAT", @@ -326,8 +341,10 @@ "DATEFORMAT", "DAY", "DAYS", + "DB_CHAINING", "DEADLOCK_PRIORITY", "DEFAULT_DATABASE", + "DEFAULT_FULLTEXT_LANGUAGE", "DEFAULT_LANGUAGE", "DEFAULT_SCHEMA", "DELAY", @@ -336,6 +353,7 @@ "DELTA", "DENSE_RANK", "DETERMINISTIC", + "DIRECTORY_NAME", "DISABLE", "DISK", # listed as reserved but functionally unreserved "DISTRIBUTION", # Azure Synapse Analytics specific @@ -343,12 +361,16 @@ "DUMP", # listed as reserved but functionally unreserved "DURABILITY", "EDGE", + "EDITION", + "ELASTIC_POOL", "ELEMENT", # *future* "ELEMENTS", + "ENABLE_BROKER", "ENCODING", "ENCRYPTED", "ENCRYPTION_TYPE", "ENCRYPTION", + "ERROR_BROKER_CONVERSATIONS", "ERRORFILE_CREDENTIAL", "ERRORFILE_DATA_SOURCE", "ERRORFILE", @@ -356,6 +378,7 @@ "EXPLAIN", # Azure Synapse Analytics specific "EXPLICIT", "EXTERNALPUSHDOWN", + "FAILOVER", "FAST", "FIELD_TERMINATOR", "FIELDQUOTE", @@ -363,9 +386,10 @@ "FILE_FORMAT", "FILE_TYPE", "FILEGROUP", + "FILEGROWTH", + "FILENAME", "FILESTREAM_ON", "FILESTREAM", - "FILESTREAM", "FILETABLE_COLLATE_FILENAME", "FILETABLE_DIRECTORY", "FILETABLE_FULLPATH_UNIQUE_CONSTRAINT_NAME", @@ -383,6 +407,7 @@ "FOLLOWING", "FORCE", "FORCED", + "FORCE_FAILOVER_ALLOW_DATA_LOSS", "FORCEPLAN", "FORCESCAN", "FORCESEEK", @@ -392,7 +417,10 @@ "FORMATFILE_DATA_SOURCE", "FORMATFILE", "FULLTEXT", + "GB", "GENERATED", + "GEO", + "GEOZONE", "HASH", "HEAP", # Azure Synapse Analytics specific "HIDDEN", @@ -410,9 +438,11 @@ "INCLUDE_NULL_VALUES", "INCLUDE", "INCREMENT", + "INCREMENTAL", "INFINITE", "INLINE", "INPUT", + "INSENSITIVE", "INSTEAD", "INTERVAL", "IO", @@ -420,6 +450,7 @@ "JSON", "JSON_ARRAY", "JSON_OBJECT", + "KB", "KEEP", "KEEPDEFAULTS", "KEEPFIXED", @@ -443,6 +474,7 @@ "LOOP", "LOW", "MANUAL", + "MANUAL_CUTOVER", "MASKED", "MASTER", "MATCHED", @@ -452,16 +484,23 @@ "MAXDOP", "MAXERRORS", "MAXRECURSION", + "MAXSIZE", "MAXVALUE", + "MB", "MEMORY_OPTIMIZED", + "MEMORY_OPTIMIZED_DATA", "MIGRATION_STATE", "MIN_GRANT_PERCENT", "MINUTES", "MINVALUE", + "MODIFY", "MONTH", "MONTHS", "MUST_CHANGE", "NAME", + "NESTED_TRIGGERS", + "NEWNAME", + "NEW_BROKER", "NEXT", "NO_PERFORMANCE_SPOOL", "NO", @@ -471,6 +510,7 @@ "NOEXPAND", "NOLOCK", "NONE", + "NON_TRANSACTED_ACCESS", "NORMAL", "NOWAIT", "NTILE", @@ -511,8 +551,11 @@ "PERCENTAGE", "PERCENTILE_CONT", "PERCENTILE_DISC", + "PERFORM_CUTOVER", "PERIOD", "PERSISTED", + "PERSISTENT_LOG_BUFFER", + "PERSISTENT_VERSION_STORE_FILEGROUP", "POLICY", "POPULATION", "PRECEDING", @@ -536,6 +579,7 @@ "READCOMMITTEDLOCK", "READONLY", "READPAST", + "READ_WRITE", "READUNCOMMITTED", "REBUILD", "RECEIVE", @@ -555,8 +599,10 @@ "REJECT_TYPE", "REJECT_VALUE", "REJECTED_ROW_LOCATION", + "RELATIVE", "REMOTE_DATA_ARCHIVE", "REMOTE_PROC_TRANSACTIONS", + "REMOVE", "RENAME", # Azure Synapse Analytics specific "REORGANIZE", "REPEATABLE", @@ -567,6 +613,7 @@ "RESULT", "RESULT_SET_CACHING", # Azure Synapse Analytics specific "RESUMABLE", + "RESTRICTED_USER", "RESUME", "RETENTION_PERIOD", "RETURNS", @@ -590,6 +637,7 @@ "SCHEME", "SCOPED", "SEARCH", + "SECONDARY", "SECRET", "SECURITY", "SECURITYAUDIT", # listed as reserved but functionally unreserved @@ -601,6 +649,7 @@ "SERIALIZABLE", "SERVER", "SERVICE", + "SERVICE_OBJECTIVE", "SETERROR", "SETS", "SETVAR", # sqlcmd command @@ -611,6 +660,7 @@ "SINGLE_BLOB", "SINGLE_CLOB", "SINGLE_NCLOB", + "SIZE", "SNAPSHOT", "SORT_IN_TEMPDB", "SOURCE", @@ -630,6 +680,7 @@ "SYSTEM_TIME", "SYSTEM_VERSIONING", "SYSTEM", + "TB", "TABLOCK", "TABLOCKX", "TAKE", @@ -641,13 +692,17 @@ "TIMESTAMP", "TRANSACTION_ID_COLUMN_NAME", "TRANSACTION_ID", + "TRANSFORM_NOISE_WORDS", "TRUNCATE_TARGET", # Azure Synapse Analytics specific + "TRUSTWORTHY", "TRY", "TYPE", + "TWO_DIGIT_YEAR_CUTOFF", "UNBOUNDED", "UNCOMMITTED", "UNDEFINED", "UNKNOWN", + "UNLIMITED", "UPDLOCK", "USE_TYPE_DEFAULT", "USED", diff --git a/src/sqlfluff/rules/ambiguous/AM09.py b/src/sqlfluff/rules/ambiguous/AM09.py new file mode 100644 index 00000000000..f87e1fb81fc --- /dev/null +++ b/src/sqlfluff/rules/ambiguous/AM09.py @@ -0,0 +1,68 @@ +"""Implementation of Rule AM09.""" + +from typing import Optional, Tuple + +from sqlfluff.core.rules import BaseRule, LintResult, RuleContext +from sqlfluff.core.rules.crawlers import SegmentSeekerCrawler + + +class Rule_AM09(BaseRule): + """Use of LIMIT and OFFSET without ORDER BY may lead to non-deterministic results. + + When using ``LIMIT`` or ``OFFSET``, it's generally recommended to include + an ``ORDER BY`` clause to ensure deterministic results. + + **Anti-pattern** + + The following query has LIMIT and OFFSET without ORDER BY, which may return + different results in successive executions. + + .. code-block:: sql + + SELECT * + FROM foo + LIMIT 10 OFFSET 5; + + **Best practice** + + Include an ``ORDER BY`` clause: + + .. code-block:: sql + + SELECT * + FROM foo + ORDER BY id + LIMIT 10 OFFSET 5; + """ + + name = "ambiguous.order_by_limit" + aliases = () + groups: Tuple[str, ...] = ("all", "ambiguous") + crawl_behaviour = SegmentSeekerCrawler({"select_statement"}) + + def _eval(self, context: RuleContext) -> Optional[LintResult]: + """Check if LIMIT and OFFSET are used without ORDER BY.""" + segment = context.segment + + # Ensure it's a SELECT statement + if not segment.is_type("select_statement"): + return None + + # Detect presence of LIMIT and OFFSET + has_limit = segment.get_child("limit_clause") + has_offset = segment.get_child("offset_clause") + has_order_by = segment.get_child("orderby_clause") + + # If LIMIT or OFFSET exist but ORDER BY is missing, issue a warning + if (has_limit or has_offset) and not has_order_by: + # Use the first relevant segment (LIMIT or OFFSET) as the anchor + anchor_segment = has_limit or has_offset + return LintResult( + anchor=anchor_segment, + description=( + "LIMIT and OFFSET are used without ORDER BY," + " which may lead to non-deterministic results." + ), + ) + + return None # No issues found diff --git a/src/sqlfluff/rules/ambiguous/__init__.py b/src/sqlfluff/rules/ambiguous/__init__.py index 6481d300a8e..2e613b5cb73 100644 --- a/src/sqlfluff/rules/ambiguous/__init__.py +++ b/src/sqlfluff/rules/ambiguous/__init__.py @@ -40,6 +40,7 @@ def get_rules() -> list[type[BaseRule]]: from sqlfluff.rules.ambiguous.AM06 import Rule_AM06 from sqlfluff.rules.ambiguous.AM07 import Rule_AM07 from sqlfluff.rules.ambiguous.AM08 import Rule_AM08 + from sqlfluff.rules.ambiguous.AM09 import Rule_AM09 return [ Rule_AM01, @@ -50,4 +51,5 @@ def get_rules() -> list[type[BaseRule]]: Rule_AM06, Rule_AM07, Rule_AM08, + Rule_AM09, ] diff --git a/src/sqlfluff/rules/convention/CV05.py b/src/sqlfluff/rules/convention/CV05.py index be63560596d..87e8a09e880 100644 --- a/src/sqlfluff/rules/convention/CV05.py +++ b/src/sqlfluff/rules/convention/CV05.py @@ -76,8 +76,26 @@ def _eval(self, context: RuleContext) -> Optional[LintResult]: if context.segment.raw not in ("=", "!=", "<>"): return None - # We only care if it's followed by a NULL literal. + # Check if this is a T-SQL variable assignment in a SELECT statement + # In T-SQL, @Variable = NULL is an assignment, not a comparison siblings = Segments(*context.parent_stack[-1].segments) + before_op_list = siblings.select(stop_seg=context.segment) + prev_code = before_op_list.last(sp.is_code()) + + # If the previous code is a parameter (T-SQL variable starting with @) + # and we're in a select_clause_element, this is likely a variable assignment + prev_code_seg = prev_code.get() if prev_code else None + if ( + prev_code_seg + and prev_code_seg.is_type("parameter") + and prev_code_seg.raw.startswith("@") + and any( + seg.is_type("select_clause_element") for seg in context.parent_stack + ) + ): + return None + + # We only care if it's followed by a NULL literal. after_op_list = siblings.select(start_seg=context.segment) next_code = after_op_list.first(sp.is_code()) diff --git a/src/sqlfluff/rules/convention/CV11.py b/src/sqlfluff/rules/convention/CV11.py index e5d9e598934..fee903a2bb6 100644 --- a/src/sqlfluff/rules/convention/CV11.py +++ b/src/sqlfluff/rules/convention/CV11.py @@ -202,8 +202,11 @@ def _eval(self, context: RuleContext) -> Optional[LintResult]: # Config type hints self.preferred_type_casting_style: str - # Rule disabled for teradata. - if context.dialect.name == "teradata": + # Rule disabled for teradata, athena, or trino. + # They only support one of the options + # TODO: add additional dialects that only support a single option here. + # TODO: add a tier list for dialects support multiples, but not all. + if context.dialect.name in ("teradata", "athena", "trino"): return None # If we're in a templated section, don't consider the current location. diff --git a/src/sqlfluff/rules/structure/ST03.py b/src/sqlfluff/rules/structure/ST03.py index c26ba07176e..3f8e69ae2be 100644 --- a/src/sqlfluff/rules/structure/ST03.py +++ b/src/sqlfluff/rules/structure/ST03.py @@ -5,6 +5,27 @@ from sqlfluff.utils.analysis.query import Query +def _is_data_modifying_cte(cte_query: Query) -> bool: + cte_def = cte_query.cte_definition_segment + if cte_def is not None: + try: + next( + cte_def.recursive_crawl( + "insert_statement", + "update_statement", + "delete_statement", + "merge_statement", + recurse_into=False, + no_recursive_seg_type=["select_statement"], + ) + ) + return True + except StopIteration: + return False + + raise NotImplementedError("CTE definition is required") # pragma: no cover + + class Rule_ST03(BaseRule): """Query defines a CTE (common-table expression) but does not use it. @@ -51,16 +72,23 @@ def _eval(self, context: RuleContext) -> EvalResultType: result = [] query: Query = Query.from_root(context.segment, dialect=context.dialect) - # Build up a dict of remaining CTEs (uppercased as not case sensitive). - remaining_ctes = {k.upper(): k for k in query.ctes} + # Some dialects (e.g. Postgres) have data-modifying statements in + # WITH blocks that are always executed regardless of whether they + # are referenced by the primary query. Do not flag those as unused. + # https://github.com/sqlfluff/sqlfluff/issues/7084 + non_data_modifying_ctes = { + k.upper(): k + for k, cte in query.ctes.items() + if not _is_data_modifying_cte(cte) + } # Work through all the references in the file, checking off CTES as the # are referenced. for reference in context.segment.recursive_crawl("table_reference"): - remaining_ctes.pop(reference.raw_normalized(False).upper(), None) + non_data_modifying_ctes.pop(reference.raw_normalized(False).upper(), None) # For any left un-referenced at the end. Raise an issue about them. - for name in remaining_ctes.values(): + for name in non_data_modifying_ctes.values(): cte = query.ctes[name] result += [ LintResult( diff --git a/src/sqlfluff/rules/structure/ST12.py b/src/sqlfluff/rules/structure/ST12.py new file mode 100644 index 00000000000..e8c960e414c --- /dev/null +++ b/src/sqlfluff/rules/structure/ST12.py @@ -0,0 +1,177 @@ +"""Implementation of Rule ST12.""" + +# Standard library imports intentionally minimal. + +from sqlfluff.core.rules import ( + BaseRule, + EvalResultType, + LintFix, + LintResult, + RuleContext, +) +from sqlfluff.core.rules.crawlers import RootOnlyCrawler + + +class Rule_ST12(BaseRule): + """Consecutive semicolons detected. + + This rule flags runs of two or more semicolons (optionally with intervening + whitespace/newlines) which usually indicate an empty statement or an + accidental duplicate terminator. + + **Anti-pattern** + + .. code-block:: sql + :force: + + SELECT 1;; + ;;SELECT 2; + + **Best practice** + + Collapse duplicate semicolons unless intentionally separating batches. + + .. code-block:: sql + :force: + + SELECT 1; + SELECT 2; + """ + + name = "structure.consecutive_semicolons" + aliases: tuple[str, ...] = () + groups: tuple[str, ...] = ("all", "structure") + crawl_behaviour = RootOnlyCrawler() + is_fix_compatible = True + + def _eval(self, context: RuleContext) -> EvalResultType: + """Detect consecutive semicolons and provide fixes. + + Operates at the file root, builds a cached bounded prefix of + non-whitespace characters, then finds adjacent terminators that + are separated only by whitespace. + """ + if not context.segment.is_type("file"): # pragma: no cover + return None + + file_seg = context.segment + + def _pos_start(seg): + m = seg.pos_marker + assert m + # Use templated positions when a templated file exists. + # Otherwise use source positions. + return ( + m.templated_slice.start + if context.templated_file is not None + else m.source_slice.start + ) + + def _pos_stop(seg): + m = seg.pos_marker + assert m + return ( + m.templated_slice.stop + if context.templated_file is not None + else m.source_slice.stop + ) + + # Collect semicolon terminators assuming they are in order. + terms = [ + t for t in file_seg.recursive_crawl("statement_terminator") if t.pos_marker + ] + if len(terms) <= 1: + return None + + # Calculate the bounding window across all terminators. Using the + # min and max across all starts/stops avoids relying on their order + # in the parse tree and eliminates the need for a defensive guard. + starts = [_pos_start(t) for t in terms] + stops = [_pos_stop(t) for t in terms] + min_start = min(starts) + max_stop = max(stops) + + # Prefer the templated view when available. + # Otherwise fall back to the raw file text. + s = ( + context.templated_file.templated_str + if context.templated_file is not None + else file_seg.raw + ) + sub = s[min_start:max_stop] + # prefix[i] counts non-whitespace characters in sub[:i] + prefix = [0] * (len(sub) + 1) + acc = 0 + _isspace = str.isspace + for i, ch in enumerate(sub): + if not _isspace(ch): + acc += 1 + prefix[i + 1] = acc + + # Is the range between two segments only whitespace? + def _whitespace_only_between(a, b) -> bool: + lo = _pos_stop(a) + hi = _pos_start(b) + lo_rel = lo - min_start + hi_rel = hi - min_start + # If the end is at or after the start there are no characters + # between them, so consider that whitespace-only (i.e. empty). + if hi_rel <= lo_rel: + return True + # Relative indices should be within the prefix range. + # Compute the difference. + return (prefix[hi_rel] - prefix[lo_rel]) == 0 + + # Find runs of adjacent semicolons separated only by whitespace + results: list[LintResult] = [] + i = 0 + n = len(terms) + while i < n - 1: + j = i + while j + 1 < n and _whitespace_only_between(terms[j], terms[j + 1]): + j += 1 + run_len = j - i + 1 + if run_len >= 2: + anchor = terms[i] + to_delete = terms[i + 1 : j + 1] + fixes = [LintFix.delete(seg) for seg in to_delete] + results.append( + LintResult( + anchor=anchor, + fixes=fixes, + description=( + f"Consecutive semicolons detected (count {run_len})." + ), + ) + ) + i = j + 1 + else: + i += 1 + # Run detection complete + + # In templated files, collapse duplicate violations that map to + # the same source slice to avoid repeated reports. + if results and context.templated_file is not None: + seen_keys = set() + deduped_results: list[LintResult] = [] + for res in results: + # Anchors from `terms` have position markers; assert the invariant. + assert res.anchor is not None + assert res.anchor.pos_marker is not None + pm = res.anchor.pos_marker + src_slice = pm.source_slice + key = ( + ( + src_slice.start + if src_slice is not None + else pm.templated_slice.start + ), + res.anchor.raw, + ) + if key in seen_keys: + continue + seen_keys.add(key) + deduped_results.append(res) + results = deduped_results + + return results or None diff --git a/src/sqlfluff/rules/structure/__init__.py b/src/sqlfluff/rules/structure/__init__.py index 32b090dc09d..fa35ace9a4e 100644 --- a/src/sqlfluff/rules/structure/__init__.py +++ b/src/sqlfluff/rules/structure/__init__.py @@ -40,6 +40,7 @@ def get_rules() -> list[type[BaseRule]]: from sqlfluff.rules.structure.ST09 import Rule_ST09 from sqlfluff.rules.structure.ST10 import Rule_ST10 from sqlfluff.rules.structure.ST11 import Rule_ST11 + from sqlfluff.rules.structure.ST12 import Rule_ST12 return [ Rule_ST01, @@ -53,4 +54,5 @@ def get_rules() -> list[type[BaseRule]]: Rule_ST09, Rule_ST10, Rule_ST11, + Rule_ST12, ] diff --git a/src/sqlfluff/utils/reflow/config.py b/src/sqlfluff/utils/reflow/config.py index 3104ec7cb06..7cdc4eda772 100644 --- a/src/sqlfluff/utils/reflow/config.py +++ b/src/sqlfluff/utils/reflow/config.py @@ -99,6 +99,11 @@ def from_dict(cls, config_dict: ConfigDictType, **kwargs: Any) -> "ReflowConfig" new_key += ":" + config_dict[seg_type]["align_within"] if config_dict[seg_type].get("align_scope", None): new_key += ":" + config_dict[seg_type]["align_scope"] + # Optional coordinate space override + if config_dict[seg_type].get("alignment_coordinate_space", None): + new_key += ( + ":" + config_dict[seg_type]["alignment_coordinate_space"] + ) config_dict[seg_type][key] = new_key return cls(_config_dict=config_dict, config_types=config_types, **kwargs) diff --git a/src/sqlfluff/utils/reflow/respace.py b/src/sqlfluff/utils/reflow/respace.py index 92c90e95143..c471755eda7 100644 --- a/src/sqlfluff/utils/reflow/respace.py +++ b/src/sqlfluff/utils/reflow/respace.py @@ -24,6 +24,60 @@ reflow_logger = logging.getLogger("sqlfluff.rules.reflow") +# --------------------------- +# Small helper functions +# --------------------------- + + +def _pos_line(pm: PositionMarker, use_source: bool) -> int: + """Return the line number in the chosen coordinate space.""" + return pm.line_no if use_source else pm.working_line_no + + +def _pos_col(pm: PositionMarker, use_source: bool) -> int: + """Return the column (position) in the chosen coordinate space.""" + return pm.line_pos if use_source else pm.working_line_pos + + +def _has_templated_content( + parent_segment: BaseSegment, siblings: list[BaseSegment], next_seg: RawSegment +) -> bool: + """Check if any participating segments contain templated content. + + Returns True if any of the participating segments are non-literal (templated) + or if any code tokens in the alignment parent are non-literal. + """ + try: + if next_seg.pos_marker and not next_seg.pos_marker.is_literal(): + return True # pragma: no cover + if any(s.pos_marker and not s.pos_marker.is_literal() for s in siblings): + return True # pragma: no cover + for rs in parent_segment.raw_segments: + if rs.is_code and rs.pos_marker and not rs.pos_marker.is_literal(): + return True + except AttributeError: # pragma: no cover + # Handle missing pos_marker attributes gracefully + return False + return False + + +def _group_siblings_by_line( + siblings: list[BaseSegment], use_source: bool +) -> dict[int, list[BaseSegment]]: + """Group sibling segments by line and sort by column within each line.""" + grouped: dict[int, list[BaseSegment]] = defaultdict(list) + for sibling in siblings: + _pos = sibling.pos_marker + assert _pos + grouped[_pos_line(_pos, use_source)].append(sibling) + # Sort each line's segments by column position in the chosen coordinate space + for line_siblings in grouped.values(): + line_siblings.sort( + key=lambda s: _pos_col(cast(PositionMarker, s.pos_marker), use_source) + ) + return grouped + + def _unpack_constraint(constraint: str, strip_newlines: bool) -> tuple[str, bool]: """Unpack a spacing constraint. @@ -198,14 +252,30 @@ def _determine_aligned_inline_spacing( segment_type: str, align_within: Optional[str], align_scope: Optional[str], + align_space: Optional[str], ) -> str: - """Work out spacing for instance of an `align` constraint.""" - # Find the level of segment that we're aligning. - # NOTE: Reverse slice + """Work out spacing for instance of an `align` constraint. + + Args: + root_segment: The root segment to search within. + whitespace_seg: The whitespace segment being modified. + next_seg: The segment immediately following the whitespace. + next_pos: Position marker for the next segment. + segment_type: Type of segments to align (e.g., 'alias_expression'). + align_within: Parent segment type to limit alignment scope. + align_scope: Further scope limitation (e.g., 'bracketed'). + align_space: Coordinate space override ('source', 'templated', or None). + + Returns: + A string of spaces to achieve proper alignment. + + Note: + When align_space is None, automatically chooses 'source' coordinates if + templated content is detected, otherwise uses 'templated' coordinates. + See https://github.com/sqlfluff/sqlfluff/issues/5429 for rationale. + """ + # Find the parent segment within which we're aligning parent_segment = None - - # Edge case: if next_seg has no position, we should use the position - # of the whitespace for searching. if align_within: for ps in root_segment.path_to( next_seg if next_seg.pos_marker else whitespace_seg @@ -234,34 +304,61 @@ def _determine_aligned_inline_spacing( sibling, ) - # If the segment we're aligning, has position. Use that position. - # If it doesn't, then use the provided one. We can't do sibling analysis without it. + # Use the segment's position marker if available, fallback to provided position if next_seg.pos_marker: next_pos = next_seg.pos_marker - # Purge any siblings which are either on the same line or on another line and - # have another index - siblings_by_line: dict[int, list[BaseSegment]] = defaultdict(list) - for sibling in siblings: - _pos = sibling.pos_marker - assert _pos - siblings_by_line[_pos.working_line_no].append(sibling) + # Choose coordinate space: source (visible) vs templated (rendered) + if align_space == "source": + use_source_positions = True + elif align_space == "templated": + use_source_positions = False + else: + use_source_positions = _has_templated_content( + parent_segment, siblings, next_seg + ) + reflow_logger.debug( + " Alignment coordinate space: %s", + "source" if use_source_positions else "templated", + ) - # Sort all segments by position to easily access index information - for line_siblings in siblings_by_line.values(): - line_siblings.sort( - key=lambda s: cast(PositionMarker, s.pos_marker).working_line_pos + # Group siblings by line using the chosen coordinate space + siblings_by_line = _group_siblings_by_line(siblings, use_source_positions) + + # Identify the alignment column index for the current line + current_line_key = _pos_line(next_pos, use_source_positions) + current_line_segments = siblings_by_line.get(current_line_key, []) + + # Handle edge case where no segments are found on the current line + # This is defensive: in practice siblings should exist on the line, but this + # provides a safe fallback. Excluded from coverage as it's difficult to trigger. + if not current_line_segments: # pragma: no cover + reflow_logger.debug( + " No segments found on current line for alignment. Treat as single." ) + return " " target_index = next( - idx - for idx, segment in enumerate(siblings_by_line[next_pos.working_line_no]) - if ( - cast(PositionMarker, segment.pos_marker).working_line_pos - == next_pos.working_line_pos - ) + ( + idx + for idx, segment in enumerate(current_line_segments) + if ( + _pos_col(cast(PositionMarker, segment.pos_marker), use_source_positions) + == _pos_col(next_pos, use_source_positions) + ) + ), + None, # Default value if no match found ) + # Handle case where target segment is not found + # This is defensive: the target should normally be found among siblings, but + # provides a safe fallback. Excluded from coverage as it's difficult to trigger. + if target_index is None: # pragma: no cover + reflow_logger.debug( + " Target segment not found in current line. Treat as single." + ) + return " " + # Now that we know the target index, we can extract the relevant segment from # all lines siblings = [ @@ -295,7 +392,11 @@ def _determine_aligned_inline_spacing( and seg.pos_marker.working_loc == sibling.pos_marker.working_loc and last_code ): - loc = last_code.pos_marker.working_loc_after(last_code.raw) + if use_source_positions: + end_pm = last_code.pos_marker.end_point_marker() + loc = (_pos_line(end_pm, True), _pos_col(end_pm, True)) + else: + loc = last_code.pos_marker.working_loc_after(last_code.raw) reflow_logger.debug( " loc for %s: %s from %s", sibling, @@ -307,9 +408,12 @@ def _determine_aligned_inline_spacing( if seg.is_code: last_code = seg - desired_space = " " * ( - 1 + max_desired_line_pos - whitespace_seg.pos_marker.working_line_pos - ) + # Compute desired whitespace size in the chosen coordinate space. + # Ensure we always return at least a single space to avoid deleting + # whitespace when the current position already exceeds the target. + current_ws_pos = _pos_col(whitespace_seg.pos_marker, use_source_positions) + pad_width = max(1, 1 + max_desired_line_pos - current_ws_pos) + desired_space = " " * pad_width reflow_logger.debug( " desired_space: %r (based on max line pos of %s)", desired_space, @@ -320,15 +424,27 @@ def _determine_aligned_inline_spacing( def _extract_alignment_config( constraint: str, -) -> tuple[str, Optional[str], Optional[str]]: +) -> tuple[str, Optional[str], Optional[str], Optional[str]]: """Helper function to break apart an alignment config. + Returns: + Tuple of (segment_type, align_within, align_scope, align_space) + + - segment_type: The type of segments to align + - align_within: Parent segment type to limit alignment scope + - align_scope: Further scope limitation (e.g., 'bracketed') + - align_space: Coordinate space ('source', 'templated', or None) + >>> _extract_alignment_config("align:alias_expression") - ('alias_expression', None, None) + ('alias_expression', None, None, None) >>> _extract_alignment_config("align:alias_expression:statement") - ('alias_expression', 'statement', None) + ('alias_expression', 'statement', None, None) >>> _extract_alignment_config("align:alias_expression:statement:bracketed") - ('alias_expression', 'statement', 'bracketed') + ('alias_expression', 'statement', 'bracketed', None) + >>> _extract_alignment_config("align:alias_expression:select_clause:bracketed:source") # noqa: E501 + ('alias_expression', 'select_clause', 'bracketed', 'source') + >>> _extract_alignment_config("align:alias_expression:select_clause:bracketed:templated") # noqa: E501 + ('alias_expression', 'select_clause', 'bracketed', 'templated') """ assert ":" in constraint alignment_config = constraint.split(":") @@ -336,13 +452,14 @@ def _extract_alignment_config( seg_type = alignment_config[1] align_within = alignment_config[2] if len(alignment_config) > 2 else None align_scope = alignment_config[3] if len(alignment_config) > 3 else None + align_space = alignment_config[4] if len(alignment_config) > 4 else None reflow_logger.debug( " Alignment Config: %s, %s, %s", seg_type, align_within, align_scope, ) - return seg_type, align_within, align_scope + return seg_type, align_within, align_scope, align_space def handle_respace__inline_with_space( @@ -404,8 +521,8 @@ def handle_respace__inline_with_space( ) or pre_constraint == post_constraint == "single": # Determine the desired spacing, either as alignment or as a single. if post_constraint.startswith("align") and next_block: - seg_type, align_within, align_scope = _extract_alignment_config( - post_constraint + seg_type, align_within, align_scope, align_space = ( + _extract_alignment_config(post_constraint) ) next_pos: Optional[PositionMarker] @@ -434,6 +551,7 @@ def handle_respace__inline_with_space( seg_type, align_within, align_scope, + align_space, ) desc = ( diff --git a/test/fixtures/dialects/ansi/multiple_semicolons.sql b/test/fixtures/dialects/ansi/multiple_semicolons.sql new file mode 100644 index 00000000000..a9bc38d6901 --- /dev/null +++ b/test/fixtures/dialects/ansi/multiple_semicolons.sql @@ -0,0 +1,17 @@ +-- Leading double semicolons before first statement +;;SELECT col1 FROM tbl1; + +-- Statement with trailing double semicolons +SELECT col2 FROM tbl2;; + +-- Multiple semicolons separating statements +SELECT col3 FROM tbl3;;;;SELECT col4 FROM tbl4; + +-- Mixed whitespace and semicolons +; ; ;SELECT col5 FROM tbl5; ; ; + +-- Many semicolons at end +SELECT col6 FROM tbl6;;;;;; + +-- Many semicolons at end +SELECT col6 FROM tbl6;;;;;; diff --git a/test/fixtures/dialects/ansi/multiple_semicolons.yml b/test/fixtures/dialects/ansi/multiple_semicolons.yml new file mode 100644 index 00000000000..ee6125bc1ef --- /dev/null +++ b/test/fixtures/dialects/ansi/multiple_semicolons.yml @@ -0,0 +1,133 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: c7901ba5232a351b7c4a48cc85eaca61d95587caaa0099ab4f4da20272beac13 +file: +- statement_terminator: ; +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col1 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl1 +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col2 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl2 +- statement_terminator: ; +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col3 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl3 +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col4 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl4 +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col5 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl5 +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col6 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl6 +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col6 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl6 +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; +- statement_terminator: ; diff --git a/test/fixtures/dialects/bigquery/create_index.sql b/test/fixtures/dialects/bigquery/create_index.sql index 916044fcedd..8bca230ca7a 100644 --- a/test/fixtures/dialects/bigquery/create_index.sql +++ b/test/fixtures/dialects/bigquery/create_index.sql @@ -7,6 +7,7 @@ OPTIONS (analyzer = 'NO_OP_ANALYZER'); CREATE VECTOR INDEX my_index ON example_dataset.example_table(example_column) +STORING(stored_column1, stored_column2) OPTIONS(index_type = 'IVF'); CREATE OR REPLACE VECTOR INDEX IF NOT EXISTS my_index diff --git a/test/fixtures/dialects/bigquery/create_index.yml b/test/fixtures/dialects/bigquery/create_index.yml index f2503f04796..afe736c6833 100644 --- a/test/fixtures/dialects/bigquery/create_index.yml +++ b/test/fixtures/dialects/bigquery/create_index.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 5b43eae86a84edfdbb9dfdbaf664af036471b7bff1a24bc8772c1993a5b8007c +_hash: 966bba35384f04776e0d8d472c460fdb0fd8fe0043d3a79e78b0314efc98a066 file: - statement: create_search_index_statement: @@ -76,6 +76,14 @@ file: index_column_definition: naked_identifier: example_column end_bracket: ) + - storing_segment: + keyword: STORING + bracketed: + - start_bracket: ( + - naked_identifier: stored_column1 + - comma: ',' + - naked_identifier: stored_column2 + - end_bracket: ) - options_segment: keyword: OPTIONS bracketed: diff --git a/test/fixtures/dialects/clickhouse/alter_table.sql b/test/fixtures/dialects/clickhouse/alter_table.sql index 5ca4f764517..4188b3db73f 100644 --- a/test/fixtures/dialects/clickhouse/alter_table.sql +++ b/test/fixtures/dialects/clickhouse/alter_table.sql @@ -115,3 +115,13 @@ ALTER TABLE mv MODIFY QUERY FROM table1 AS t1 JOIN table2 AS t2 ON t1.id = t2.id WHERE t1.active = 1; + +-- DROP PARTITION examples +ALTER TABLE x DROP PARTITION y; +ALTER TABLE x ON CLUSTER '{cluster}' DROP PARTITION 'y'; +ALTER TABLE x DROP PART 'y'; +ALTER TABLE x ON CLUSTER '{cluster}' DROP PART 'y'; + +-- REPLACE PARTITION examples +ALTER TABLE x REPLACE PARTITION 'y' FROM z; +ALTER TABLE x ON CLUSTER '{cluster}' REPLACE PARTITION 'y' FROM z; diff --git a/test/fixtures/dialects/clickhouse/alter_table.yml b/test/fixtures/dialects/clickhouse/alter_table.yml index dc83d8ff51c..a51c34de1c4 100644 --- a/test/fixtures/dialects/clickhouse/alter_table.yml +++ b/test/fixtures/dialects/clickhouse/alter_table.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 218a737e4d9075599ddf01a2260e7aad078e4d6472e4276ad71297c4cd741e20 +_hash: 6dbe11ccf20071e36fd4bc834de1d67b8aa497152ce9849f6ff363b157c4701d file: - statement: alter_table_statement: @@ -1278,3 +1278,81 @@ file: raw_comparison_operator: '=' numeric_literal: '1' - statement_terminator: ; +- statement: + alter_table_statement: + - keyword: ALTER + - keyword: TABLE + - table_reference: + naked_identifier: x + - keyword: DROP + - keyword: PARTITION + - naked_identifier: y +- statement_terminator: ; +- statement: + alter_table_statement: + - keyword: ALTER + - keyword: TABLE + - table_reference: + naked_identifier: x + - on_cluster_clause: + - keyword: 'ON' + - keyword: CLUSTER + - quoted_identifier: "'{cluster}'" + - keyword: DROP + - keyword: PARTITION + - quoted_identifier: "'y'" +- statement_terminator: ; +- statement: + alter_table_statement: + - keyword: ALTER + - keyword: TABLE + - table_reference: + naked_identifier: x + - keyword: DROP + - keyword: PART + - quoted_identifier: "'y'" +- statement_terminator: ; +- statement: + alter_table_statement: + - keyword: ALTER + - keyword: TABLE + - table_reference: + naked_identifier: x + - on_cluster_clause: + - keyword: 'ON' + - keyword: CLUSTER + - quoted_identifier: "'{cluster}'" + - keyword: DROP + - keyword: PART + - quoted_identifier: "'y'" +- statement_terminator: ; +- statement: + alter_table_statement: + - keyword: ALTER + - keyword: TABLE + - table_reference: + naked_identifier: x + - keyword: REPLACE + - keyword: PARTITION + - quoted_identifier: "'y'" + - keyword: FROM + - table_reference: + naked_identifier: z +- statement_terminator: ; +- statement: + alter_table_statement: + - keyword: ALTER + - keyword: TABLE + - table_reference: + naked_identifier: x + - on_cluster_clause: + - keyword: 'ON' + - keyword: CLUSTER + - quoted_identifier: "'{cluster}'" + - keyword: REPLACE + - keyword: PARTITION + - quoted_identifier: "'y'" + - keyword: FROM + - table_reference: + naked_identifier: z +- statement_terminator: ; diff --git a/test/fixtures/dialects/clickhouse/create_user.sql b/test/fixtures/dialects/clickhouse/create_user.sql new file mode 100644 index 00000000000..dff3c07a56b --- /dev/null +++ b/test/fixtures/dialects/clickhouse/create_user.sql @@ -0,0 +1,7 @@ +-- This file tests CREATE USER with/without IDENTIFIED BY for ClickHouse dialect +-- sqlfluff:dialect:clickhouse + +CREATE USER new_user IDENTIFIED BY 'secret'; +CREATE USER another_user IDENTIFIED WITH sha256_password BY 'hash'; + +CREATE USER yet_another_user; diff --git a/test/fixtures/dialects/clickhouse/create_user.yml b/test/fixtures/dialects/clickhouse/create_user.yml new file mode 100644 index 00000000000..07e7632024e --- /dev/null +++ b/test/fixtures/dialects/clickhouse/create_user.yml @@ -0,0 +1,33 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 21eefdf7f0a0123c09698e6628bb651718b9de77e8d513411ac9f676b404fa32 +file: +- statement: + create_user_statement: + - keyword: CREATE + - keyword: USER + - naked_identifier: new_user + - keyword: IDENTIFIED + - keyword: BY + - quoted_literal: "'secret'" +- statement_terminator: ; +- statement: + create_user_statement: + - keyword: CREATE + - keyword: USER + - naked_identifier: another_user + - keyword: IDENTIFIED + - keyword: WITH + - naked_identifier: sha256_password + - keyword: BY + - quoted_literal: "'hash'" +- statement_terminator: ; +- statement: + create_user_statement: + - keyword: CREATE + - keyword: USER + - naked_identifier: yet_another_user +- statement_terminator: ; diff --git a/test/fixtures/dialects/databricks/comment_on.sql b/test/fixtures/dialects/databricks/comment_on.sql index 3b91abfa87e..dff1cc4d7dd 100644 --- a/test/fixtures/dialects/databricks/comment_on.sql +++ b/test/fixtures/dialects/databricks/comment_on.sql @@ -17,3 +17,7 @@ COMMENT ON RECIPIENT my_recipient IS 'A good recipient'; COMMENT ON PROVIDER my_provider IS 'A good provider'; COMMENT ON VOLUME my_volume IS 'Huge volume'; + +COMMENT ON COLUMN my_catalog.my_schema.my_table.my_column IS 'This is my column in a catalog'; + +COMMENT ON COLUMN my_column IS 'This is my column'; diff --git a/test/fixtures/dialects/databricks/comment_on.yml b/test/fixtures/dialects/databricks/comment_on.yml index d8af27eba7a..89f0acbd41a 100644 --- a/test/fixtures/dialects/databricks/comment_on.yml +++ b/test/fixtures/dialects/databricks/comment_on.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: dea3b1bd03043d9c632669f603ac0787f764a78efe1628003ee13b4440a1dfc0 +_hash: 3a83632ea31eb351e076a58321a5069d43dd578441f3a013480b4fba8b080feb file: - statement: comment_clause: @@ -105,3 +105,29 @@ file: - keyword: IS - quoted_literal: "'Huge volume'" - statement_terminator: ; +- statement: + comment_clause: + - keyword: COMMENT + - keyword: 'ON' + - keyword: COLUMN + - column_reference: + - naked_identifier: my_catalog + - dot: . + - naked_identifier: my_schema + - dot: . + - naked_identifier: my_table + - dot: . + - naked_identifier: my_column + - keyword: IS + - quoted_literal: "'This is my column in a catalog'" +- statement_terminator: ; +- statement: + comment_clause: + - keyword: COMMENT + - keyword: 'ON' + - keyword: COLUMN + - column_reference: + naked_identifier: my_column + - keyword: IS + - quoted_literal: "'This is my column'" +- statement_terminator: ; diff --git a/test/fixtures/dialects/mariadb/create_index.sql b/test/fixtures/dialects/mariadb/create_index.sql index ecfe098916d..5ee334fe84c 100644 --- a/test/fixtures/dialects/mariadb/create_index.sql +++ b/test/fixtures/dialects/mariadb/create_index.sql @@ -12,3 +12,4 @@ CREATE INDEX idx ON tbl (col) ALGORITHM NOCOPY; CREATE INDEX idx ON tbl (col) ALGORITHM INSTANT; CREATE INDEX idx ON tbl (col) LOCK DEFAULT; CREATE INDEX idx ON tbl ((col1 + col2), (col1 - col2), col1); +CREATE INDEX IF NOT EXISTS index_name ON table_name (field_name); diff --git a/test/fixtures/dialects/mariadb/create_index.yml b/test/fixtures/dialects/mariadb/create_index.yml index 5f25facc305..0bfcd114379 100644 --- a/test/fixtures/dialects/mariadb/create_index.yml +++ b/test/fixtures/dialects/mariadb/create_index.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 5ba008b762b05319be63ea1b01262c62e054e8ba120801da8589dc396cd1fdd3 +_hash: 70e8096d9ebac30601b9494145812f9a3a853e35558fb69843eed2d9413be171 file: - statement: create_index_statement: @@ -169,8 +169,9 @@ file: column_reference: naked_identifier: col end_bracket: ) - - keyword: ALGORITHM - - keyword: DEFAULT + - algorithm_option: + - keyword: ALGORITHM + - keyword: DEFAULT - statement_terminator: ; - statement: create_index_statement: @@ -186,8 +187,9 @@ file: column_reference: naked_identifier: col end_bracket: ) - - keyword: ALGORITHM - - keyword: NOCOPY + - algorithm_option: + - keyword: ALGORITHM + - keyword: NOCOPY - statement_terminator: ; - statement: create_index_statement: @@ -203,8 +205,9 @@ file: column_reference: naked_identifier: col end_bracket: ) - - keyword: ALGORITHM - - keyword: INSTANT + - algorithm_option: + - keyword: ALGORITHM + - keyword: INSTANT - statement_terminator: ; - statement: create_index_statement: @@ -220,8 +223,9 @@ file: column_reference: naked_identifier: col end_bracket: ) - - keyword: LOCK - - keyword: DEFAULT + - lock_option: + - keyword: LOCK + - keyword: DEFAULT - statement_terminator: ; - statement: create_index_statement: @@ -258,3 +262,21 @@ file: naked_identifier: col1 - end_bracket: ) - statement_terminator: ; +- statement: + create_index_statement: + - keyword: CREATE + - keyword: INDEX + - keyword: IF + - keyword: NOT + - keyword: EXISTS + - index_reference: + naked_identifier: index_name + - keyword: 'ON' + - table_reference: + naked_identifier: table_name + - bracketed: + start_bracket: ( + column_reference: + naked_identifier: field_name + end_bracket: ) +- statement_terminator: ; diff --git a/test/fixtures/dialects/mariadb/create_or_replace_function.sql b/test/fixtures/dialects/mariadb/create_or_replace_function.sql new file mode 100644 index 00000000000..7c9a54e87ac --- /dev/null +++ b/test/fixtures/dialects/mariadb/create_or_replace_function.sql @@ -0,0 +1,6 @@ +CREATE OR REPLACE FUNCTION `testfunction`() +RETURNS VARCHAR(20) +DETERMINISTIC +BEGIN + RETURN "foo"; +END~ diff --git a/test/fixtures/dialects/mariadb/create_or_replace_function.yml b/test/fixtures/dialects/mariadb/create_or_replace_function.yml new file mode 100644 index 00000000000..5d9ae1aa229 --- /dev/null +++ b/test/fixtures/dialects/mariadb/create_or_replace_function.yml @@ -0,0 +1,42 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 15a9af7086327ded904213de09564964e460af44035f0d2e3d5cbd3e6e96767e +file: +- statement: + create_function_statement: + - keyword: CREATE + - keyword: OR + - keyword: REPLACE + - keyword: FUNCTION + - function_name: + quoted_identifier: '`testfunction`' + - function_parameter_list: + bracketed: + start_bracket: ( + end_bracket: ) + - keyword: RETURNS + - data_type: + data_type_identifier: VARCHAR + bracketed_arguments: + bracketed: + start_bracket: ( + numeric_literal: '20' + end_bracket: ) + - characteristic_statement: + keyword: DETERMINISTIC + - function_definition: + transaction_statement: + keyword: BEGIN + statement: + return_statement: + keyword: RETURN + expression: + quoted_literal: '"foo"' +- statement_terminator: ; +- statement: + transaction_statement: + keyword: END +- statement_terminator: '~' diff --git a/test/fixtures/dialects/mariadb/create_or_replace_procedure.sql b/test/fixtures/dialects/mariadb/create_or_replace_procedure.sql new file mode 100644 index 00000000000..f3d3871deef --- /dev/null +++ b/test/fixtures/dialects/mariadb/create_or_replace_procedure.sql @@ -0,0 +1,4 @@ +CREATE OR REPLACE PROCEDURE `testprocedure`() +BEGIN + SELECT 1; +END~ diff --git a/test/fixtures/dialects/mariadb/create_or_replace_procedure.yml b/test/fixtures/dialects/mariadb/create_or_replace_procedure.yml new file mode 100644 index 00000000000..a5548f9b4f4 --- /dev/null +++ b/test/fixtures/dialects/mariadb/create_or_replace_procedure.yml @@ -0,0 +1,33 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 4881b19a510a898d7f0830ad227034155f9430db71d6e08b4b6e95fbf60f871a +file: +- statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: REPLACE + - keyword: PROCEDURE + - function_name: + quoted_identifier: '`testprocedure`' + - procedure_parameter_list: + bracketed: + start_bracket: ( + end_bracket: ) + - function_definition: + transaction_statement: + keyword: BEGIN + statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + numeric_literal: '1' +- statement_terminator: ; +- statement: + transaction_statement: + keyword: END +- statement_terminator: '~' diff --git a/test/fixtures/dialects/mysql/create_procedure.sql b/test/fixtures/dialects/mysql/create_procedure.sql new file mode 100644 index 00000000000..1e058965a9b --- /dev/null +++ b/test/fixtures/dialects/mysql/create_procedure.sql @@ -0,0 +1,4 @@ +CREATE PROCEDURE IF NOT EXISTS create_if_not_exists() +BEGIN + SELECT 1; +END; diff --git a/test/fixtures/dialects/mysql/create_procedure.yml b/test/fixtures/dialects/mysql/create_procedure.yml new file mode 100644 index 00000000000..125f233371c --- /dev/null +++ b/test/fixtures/dialects/mysql/create_procedure.yml @@ -0,0 +1,34 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: eadec52c86a1924f31db92b9eebbd2d8675bd39e51a51dcfb2979cea1ffbf036 +file: +- statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - keyword: IF + - keyword: NOT + - keyword: EXISTS + - function_name: + function_name_identifier: create_if_not_exists + - procedure_parameter_list: + bracketed: + start_bracket: ( + end_bracket: ) + - function_definition: + transaction_statement: + keyword: BEGIN + statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + numeric_literal: '1' +- statement_terminator: ; +- statement: + transaction_statement: + keyword: END +- statement_terminator: ; diff --git a/test/fixtures/dialects/oracle/case_expressions.sql b/test/fixtures/dialects/oracle/case_expressions.sql index 8ca4c0b7092..3797c327c3a 100644 --- a/test/fixtures/dialects/oracle/case_expressions.sql +++ b/test/fixtures/dialects/oracle/case_expressions.sql @@ -280,3 +280,14 @@ SELECT ELSE 0 END my_case AS result FROM abc; + +-- Test 28: CASE expression with bracketed condition +SELECT + CASE + WHEN abc = 1 THEN NULL + WHEN ( + defg = 2 + AND hijk = 3 + ) THEN NULL + END AS result +FROM abc; diff --git a/test/fixtures/dialects/oracle/case_expressions.yml b/test/fixtures/dialects/oracle/case_expressions.yml index 6de801ac9ab..ca498660ebc 100644 --- a/test/fixtures/dialects/oracle/case_expressions.yml +++ b/test/fixtures/dialects/oracle/case_expressions.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 3e97b082c60397a779fe8a11a12edd2b13365b238d4456fbdbac139747b6f76d +_hash: 162ce31b0e333dc38b301e2cd94fff10314fd8eec6c2863fdd253212729da876 file: - statement: select_statement: @@ -1714,3 +1714,56 @@ file: table_reference: naked_identifier: abc - statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + case_expression: + - keyword: CASE + - when_clause: + - keyword: WHEN + - expression: + column_reference: + naked_identifier: abc + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '1' + - keyword: THEN + - expression: + null_literal: 'NULL' + - when_clause: + - keyword: WHEN + - expression: + bracketed: + start_bracket: ( + expression: + - column_reference: + naked_identifier: defg + - comparison_operator: + raw_comparison_operator: '=' + - numeric_literal: '2' + - binary_operator: AND + - column_reference: + naked_identifier: hijk + - comparison_operator: + raw_comparison_operator: '=' + - numeric_literal: '3' + end_bracket: ) + - keyword: THEN + - expression: + null_literal: 'NULL' + - keyword: END + alias_expression: + alias_operator: + keyword: AS + naked_identifier: result + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: abc +- statement_terminator: ; diff --git a/test/fixtures/dialects/oracle/column_value.sql b/test/fixtures/dialects/oracle/column_value.sql new file mode 100644 index 00000000000..11551c7485f --- /dev/null +++ b/test/fixtures/dialects/oracle/column_value.sql @@ -0,0 +1,2 @@ +SELECT column_value AS mnth +FROM sys.dbms_debug_vc2coll('01', '05', '09'); diff --git a/test/fixtures/dialects/oracle/column_value.yml b/test/fixtures/dialects/oracle/column_value.yml new file mode 100644 index 00000000000..b517b7ce09f --- /dev/null +++ b/test/fixtures/dialects/oracle/column_value.yml @@ -0,0 +1,40 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 27978468b93e9dba77b130443f65ee299dd445cf77d0644ba5f3bfacf393db49 +file: + statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + bare_function: column_value + alias_expression: + alias_operator: + keyword: AS + naked_identifier: mnth + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + function: + function_name: + naked_identifier: sys + dot: . + function_name_identifier: dbms_debug_vc2coll + function_contents: + bracketed: + - start_bracket: ( + - expression: + quoted_literal: "'01'" + - comma: ',' + - expression: + quoted_literal: "'05'" + - comma: ',' + - expression: + quoted_literal: "'09'" + - end_bracket: ) + statement_terminator: ; diff --git a/test/fixtures/dialects/oracle/select_utf8.sql b/test/fixtures/dialects/oracle/select_utf8.sql new file mode 100644 index 00000000000..41c6985f9f1 --- /dev/null +++ b/test/fixtures/dialects/oracle/select_utf8.sql @@ -0,0 +1,4 @@ +SELECT + 'Não' reativação +FROM + TABLE1; diff --git a/test/fixtures/dialects/oracle/select_utf8.yml b/test/fixtures/dialects/oracle/select_utf8.yml new file mode 100644 index 00000000000..336da638f7c --- /dev/null +++ b/test/fixtures/dialects/oracle/select_utf8.yml @@ -0,0 +1,23 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: f1c3dffdf5a678de7b661f45cc8ce4680645faca1673ac871c1a4b916380ce07 +file: + statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + quoted_literal: "'Não'" + alias_expression: + naked_identifier: reativação + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: TABLE1 + statement_terminator: ; diff --git a/test/fixtures/dialects/postgres/alter_text_search_configuration.sql b/test/fixtures/dialects/postgres/alter_text_search_configuration.sql new file mode 100644 index 00000000000..2a9c8df216d --- /dev/null +++ b/test/fixtures/dialects/postgres/alter_text_search_configuration.sql @@ -0,0 +1,8 @@ +ALTER TEXT SEARCH CONFIGURATION my_config ADD MAPPING FOR asciiword WITH english_stem; +ALTER TEXT SEARCH CONFIGURATION my_config ALTER MAPPING FOR word WITH french_stem; +ALTER TEXT SEARCH CONFIGURATION my_config ALTER MAPPING REPLACE english WITH french; +ALTER TEXT SEARCH CONFIGURATION my_config ALTER MAPPING FOR asciiword REPLACE english_stem WITH french_stem; +ALTER TEXT SEARCH CONFIGURATION my_config DROP MAPPING IF EXISTS FOR email; +ALTER TEXT SEARCH CONFIGURATION my_config RENAME TO new_config; +ALTER TEXT SEARCH CONFIGURATION my_config OWNER TO new_owner; +ALTER TEXT SEARCH CONFIGURATION my_config SET SCHEMA new_schema; diff --git a/test/fixtures/dialects/postgres/alter_text_search_configuration.yml b/test/fixtures/dialects/postgres/alter_text_search_configuration.yml new file mode 100644 index 00000000000..bf8878b0bbf --- /dev/null +++ b/test/fixtures/dialects/postgres/alter_text_search_configuration.yml @@ -0,0 +1,133 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 4e7a5512b8fb4e3a9e2cc3c7ddef7ab9cfaf65a29d1bc6b7064a9764403c6bfc +file: +- statement: + alter_text_search_configuration_statement: + - keyword: ALTER + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: ADD + - keyword: MAPPING + - keyword: FOR + - object_reference: + naked_identifier: asciiword + - keyword: WITH + - object_reference: + naked_identifier: english_stem +- statement_terminator: ; +- statement: + alter_text_search_configuration_statement: + - keyword: ALTER + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: ALTER + - keyword: MAPPING + - keyword: FOR + - object_reference: + naked_identifier: word + - keyword: WITH + - object_reference: + naked_identifier: french_stem +- statement_terminator: ; +- statement: + alter_text_search_configuration_statement: + - keyword: ALTER + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: ALTER + - keyword: MAPPING + - keyword: REPLACE + - object_reference: + naked_identifier: english + - keyword: WITH + - object_reference: + naked_identifier: french +- statement_terminator: ; +- statement: + alter_text_search_configuration_statement: + - keyword: ALTER + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: ALTER + - keyword: MAPPING + - keyword: FOR + - object_reference: + naked_identifier: asciiword + - keyword: REPLACE + - object_reference: + naked_identifier: english_stem + - keyword: WITH + - object_reference: + naked_identifier: french_stem +- statement_terminator: ; +- statement: + alter_text_search_configuration_statement: + - keyword: ALTER + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: DROP + - keyword: MAPPING + - keyword: IF + - keyword: EXISTS + - keyword: FOR + - object_reference: + naked_identifier: email +- statement_terminator: ; +- statement: + alter_text_search_configuration_statement: + - keyword: ALTER + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: RENAME + - keyword: TO + - object_reference: + naked_identifier: new_config +- statement_terminator: ; +- statement: + alter_text_search_configuration_statement: + - keyword: ALTER + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: OWNER + - keyword: TO + - object_reference: + naked_identifier: new_owner +- statement_terminator: ; +- statement: + alter_text_search_configuration_statement: + - keyword: ALTER + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: SET + - keyword: SCHEMA + - object_reference: + naked_identifier: new_schema +- statement_terminator: ; diff --git a/test/fixtures/dialects/postgres/copy.sql b/test/fixtures/dialects/postgres/copy.sql index d0fd203ab9b..24ba61a029b 100644 --- a/test/fixtures/dialects/postgres/copy.sql +++ b/test/fixtures/dialects/postgres/copy.sql @@ -8,6 +8,7 @@ COPY (Select * From my_table) TO '/tmp/dump.csv' WITH (FORMAT csv, ESCAPE '\', F COPY (Select * From my_table) TO '/tmp/dump.csv' WITH (FORMAT csv, ESCAPE '\', FORCE_NULL (col1, col2), FREEZE false); COPY (Select * From my_table) TO STDOUT WITH (FORMAT csv, ESCAPE '\', FORCE_NULL (col1, col2), FREEZE true); COPY (Select * From my_table) TO PROGRAM '/path/to/script' WITH (FORMAT csv, ESCAPE '\', FORCE_NULL (col1, col2), FREEZE false); +COPY (WITH c AS (SELECT 1::int AS id) SELECT id FROM c) TO STDOUT WITH (FORMAT csv, HEADER); COPY my_table(col) TO '/tmp/dump.csv'; COPY my_table TO '/tmp/dump.csv' WITH (FORMAT csv, HEADER true, FREEZE true, FORCE_NULL (col1, col2)); COPY my_table(col1, col2) TO '/tmp/dump.csv' WITH (FORMAT csv, HEADER true); diff --git a/test/fixtures/dialects/postgres/copy.yml b/test/fixtures/dialects/postgres/copy.yml index b9c5f40409f..2beaf0e8fbe 100644 --- a/test/fixtures/dialects/postgres/copy.yml +++ b/test/fixtures/dialects/postgres/copy.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 4b115542ab2c94e730d6366b2cd172e0e8f7802ebe34ee63239b86b3346e1e96 +_hash: 7183a7dc7491c71f71cee5e900729ff0c5f0d5eb9d01884c0b76be0b066ad37c file: - statement: copy_statement: @@ -371,6 +371,58 @@ file: - boolean_literal: 'false' - end_bracket: ) - statement_terminator: ; +- statement: + copy_statement: + - keyword: COPY + - bracketed: + start_bracket: ( + with_compound_statement: + keyword: WITH + common_table_expression: + naked_identifier: c + keyword: AS + bracketed: + start_bracket: ( + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + cast_expression: + numeric_literal: '1' + casting_operator: '::' + data_type: + keyword: int + alias_expression: + alias_operator: + keyword: AS + naked_identifier: id + end_bracket: ) + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: id + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: c + end_bracket: ) + - keyword: TO + - keyword: STDOUT + - keyword: WITH + - bracketed: + - start_bracket: ( + - keyword: FORMAT + - naked_identifier: csv + - comma: ',' + - keyword: HEADER + - end_bracket: ) +- statement_terminator: ; - statement: copy_statement: - keyword: COPY diff --git a/test/fixtures/dialects/postgres/create_text_search_configuration.sql b/test/fixtures/dialects/postgres/create_text_search_configuration.sql new file mode 100644 index 00000000000..a68c322f153 --- /dev/null +++ b/test/fixtures/dialects/postgres/create_text_search_configuration.sql @@ -0,0 +1,9 @@ +CREATE TEXT SEARCH CONFIGURATION my_config ( + PARSER = my_parser +); +CREATE TEXT SEARCH CONFIGURATION public.my_config ( + PARSER = pg_catalog."default" +); +CREATE TEXT SEARCH CONFIGURATION copy_config ( + COPY = pg_catalog.english +); diff --git a/test/fixtures/dialects/postgres/create_text_search_configuration.yml b/test/fixtures/dialects/postgres/create_text_search_configuration.yml new file mode 100644 index 00000000000..3d1dd4e7c04 --- /dev/null +++ b/test/fixtures/dialects/postgres/create_text_search_configuration.yml @@ -0,0 +1,64 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 4881222dd1e4d7e457a778fdee89c1aac0d34cceb1fed28b22f08d089b6e8d76 +file: +- statement: + create_text_search_configuration_statement: + - keyword: CREATE + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - bracketed: + start_bracket: ( + keyword: PARSER + comparison_operator: + raw_comparison_operator: '=' + object_reference: + naked_identifier: my_parser + end_bracket: ) +- statement_terminator: ; +- statement: + create_text_search_configuration_statement: + - keyword: CREATE + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + - naked_identifier: public + - dot: . + - naked_identifier: my_config + - bracketed: + start_bracket: ( + keyword: PARSER + comparison_operator: + raw_comparison_operator: '=' + object_reference: + naked_identifier: pg_catalog + dot: . + quoted_identifier: '"default"' + end_bracket: ) +- statement_terminator: ; +- statement: + create_text_search_configuration_statement: + - keyword: CREATE + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: copy_config + - bracketed: + start_bracket: ( + keyword: COPY + comparison_operator: + raw_comparison_operator: '=' + object_reference: + - naked_identifier: pg_catalog + - dot: . + - naked_identifier: english + end_bracket: ) +- statement_terminator: ; diff --git a/test/fixtures/dialects/postgres/drop_collation.sql b/test/fixtures/dialects/postgres/drop_collation.sql new file mode 100644 index 00000000000..dca5b027ee7 --- /dev/null +++ b/test/fixtures/dialects/postgres/drop_collation.sql @@ -0,0 +1,7 @@ +DROP COLLATION case_insensitive; + +DROP COLLATION IF EXISTS german; + +DROP COLLATION german CASCADE; + +DROP COLLATION german RESTRICT; diff --git a/test/fixtures/dialects/postgres/drop_collation.yml b/test/fixtures/dialects/postgres/drop_collation.yml new file mode 100644 index 00000000000..64bcd5c98b3 --- /dev/null +++ b/test/fixtures/dialects/postgres/drop_collation.yml @@ -0,0 +1,39 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 9e647da07578027ea6de99cf734f9502e93514a581e2c8bb248d52e58e2fff66 +file: +- statement: + drop_collation_statement: + - keyword: DROP + - keyword: COLLATION + - object_reference: + naked_identifier: case_insensitive +- statement_terminator: ; +- statement: + drop_collation_statement: + - keyword: DROP + - keyword: COLLATION + - keyword: IF + - keyword: EXISTS + - object_reference: + naked_identifier: german +- statement_terminator: ; +- statement: + drop_collation_statement: + - keyword: DROP + - keyword: COLLATION + - object_reference: + naked_identifier: german + - keyword: CASCADE +- statement_terminator: ; +- statement: + drop_collation_statement: + - keyword: DROP + - keyword: COLLATION + - object_reference: + naked_identifier: german + - keyword: RESTRICT +- statement_terminator: ; diff --git a/test/fixtures/dialects/postgres/drop_text_search_configuration.sql b/test/fixtures/dialects/postgres/drop_text_search_configuration.sql new file mode 100644 index 00000000000..4efffdcbb75 --- /dev/null +++ b/test/fixtures/dialects/postgres/drop_text_search_configuration.sql @@ -0,0 +1,4 @@ +DROP TEXT SEARCH CONFIGURATION my_config; +DROP TEXT SEARCH CONFIGURATION IF EXISTS my_config; +DROP TEXT SEARCH CONFIGURATION public.my_config CASCADE; +DROP TEXT SEARCH CONFIGURATION my_config RESTRICT; diff --git a/test/fixtures/dialects/postgres/drop_text_search_configuration.yml b/test/fixtures/dialects/postgres/drop_text_search_configuration.yml new file mode 100644 index 00000000000..fcea47c27d1 --- /dev/null +++ b/test/fixtures/dialects/postgres/drop_text_search_configuration.yml @@ -0,0 +1,49 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: cefd4e3ac8bc4fc3153085835e5fffe4139f7a76b34b4412eb9a627ee4e7543a +file: +- statement: + drop_text_search_configuration_statement: + - keyword: DROP + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config +- statement_terminator: ; +- statement: + drop_text_search_configuration_statement: + - keyword: DROP + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - keyword: IF + - keyword: EXISTS + - object_reference: + naked_identifier: my_config +- statement_terminator: ; +- statement: + drop_text_search_configuration_statement: + - keyword: DROP + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + - naked_identifier: public + - dot: . + - naked_identifier: my_config + - keyword: CASCADE +- statement_terminator: ; +- statement: + drop_text_search_configuration_statement: + - keyword: DROP + - keyword: TEXT + - keyword: SEARCH + - keyword: CONFIGURATION + - object_reference: + naked_identifier: my_config + - keyword: RESTRICT +- statement_terminator: ; diff --git a/test/fixtures/dialects/postgres/pg_trgm.sql b/test/fixtures/dialects/postgres/pg_trgm.sql new file mode 100644 index 00000000000..d2a2e280643 --- /dev/null +++ b/test/fixtures/dialects/postgres/pg_trgm.sql @@ -0,0 +1,32 @@ +-- PostgreSQL pg_trgm similarity operators +-- https://www.postgresql.org/docs/current/pgtrgm.html + +-- text % text → boolean (similarity) +SELECT 'abc' % 'abd'; + +-- text <% text → boolean (word_similarity) +SELECT 'word' <% 'some word here'; + +-- text %> text → boolean (word_similarity reverse) +SELECT 'some word here' %> 'word'; + +-- text <<% text → boolean (strict_word_similarity) +SELECT 'text' <<% 'some text example'; + +-- text %>> text → boolean (strict_word_similarity reverse) +SELECT 'some text example' %>> 'text'; + +-- text <-> text → real (similarity distance) +SELECT 'str1' <-> 'str2'; + +-- text <<-> text → real (word_similarity distance) +SELECT 'item' <<-> 'some item value'; + +-- text <->> text → real (word_similarity distance reverse) +SELECT 'some item value' <->> 'item'; + +-- text <<<-> text → real (strict_word_similarity distance) +SELECT 'name' <<<-> 'some name field'; + +-- text <->>> text → real (strict_word_similarity distance reverse) +SELECT 'some name field' <->>> 'name'; diff --git a/test/fixtures/dialects/postgres/pg_trgm.yml b/test/fixtures/dialects/postgres/pg_trgm.yml new file mode 100644 index 00000000000..ca741c98555 --- /dev/null +++ b/test/fixtures/dialects/postgres/pg_trgm.yml @@ -0,0 +1,107 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 03179320010b6cc91a0a772f4900a9d934e4d542f9c2091159093f47da555b06 +file: +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'abc'" + - binary_operator: '%' + - quoted_literal: "'abd'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'word'" + - binary_operator: <% + - quoted_literal: "'some word here'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'some word here'" + - binary_operator: '%>' + - quoted_literal: "'word'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'text'" + - binary_operator: <<% + - quoted_literal: "'some text example'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'some text example'" + - binary_operator: '%>>' + - quoted_literal: "'text'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'str1'" + - binary_operator: <-> + - quoted_literal: "'str2'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'item'" + - binary_operator: <<-> + - quoted_literal: "'some item value'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'some item value'" + - binary_operator: <->> + - quoted_literal: "'item'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'name'" + - binary_operator: <<<-> + - quoted_literal: "'some name field'" +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + expression: + - quoted_literal: "'some name field'" + - binary_operator: <->>> + - quoted_literal: "'name'" +- statement_terminator: ; diff --git a/test/fixtures/dialects/postgres/variadic.sql b/test/fixtures/dialects/postgres/variadic.sql index 229e17b031e..4a092eb62f0 100644 --- a/test/fixtures/dialects/postgres/variadic.sql +++ b/test/fixtures/dialects/postgres/variadic.sql @@ -37,3 +37,17 @@ SELECT my_function(VARIADIC ARRAY[ ]); SELECT my_function(VARIADIC ARRAY(SELECT value FROM table1)); + +SELECT my_function(VARIADIC param_name = ARRAY[1, 2, 3]); + +SELECT my_function( + regular_param = 'value', + VARIADIC variadic_param = ARRAY[1, 2, 3] +); + +SELECT my_function(VARIADIC param_name => ARRAY[1, 2, 3]); + +SELECT my_function( + regular_param => 'value', + VARIADIC variadic_param => ARRAY[1, 2, 3] +); diff --git a/test/fixtures/dialects/postgres/variadic.yml b/test/fixtures/dialects/postgres/variadic.yml index 0feb174797d..2c7520823e1 100644 --- a/test/fixtures/dialects/postgres/variadic.yml +++ b/test/fixtures/dialects/postgres/variadic.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: bb65cc3c9b09e1bfd50bb9cff407fffcaf933dd3e2e6def51b4cfc580b874f9c +_hash: 92b2cf467675139e3bc7ac853e3792c534f91964fa86bc59d627204c88e096a4 file: - statement: create_function_statement: @@ -388,3 +388,134 @@ file: end_bracket: ) end_bracket: ) - statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + function: + function_name: + function_name_identifier: my_function + function_contents: + bracketed: + start_bracket: ( + keyword: VARIADIC + expression: + column_reference: + naked_identifier: param_name + comparison_operator: + raw_comparison_operator: '=' + typed_array_literal: + array_type: + keyword: ARRAY + array_literal: + - start_square_bracket: '[' + - numeric_literal: '1' + - comma: ',' + - numeric_literal: '2' + - comma: ',' + - numeric_literal: '3' + - end_square_bracket: ']' + end_bracket: ) +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + function: + function_name: + function_name_identifier: my_function + function_contents: + bracketed: + - start_bracket: ( + - expression: + column_reference: + naked_identifier: regular_param + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'value'" + - comma: ',' + - keyword: VARIADIC + - expression: + column_reference: + naked_identifier: variadic_param + comparison_operator: + raw_comparison_operator: '=' + typed_array_literal: + array_type: + keyword: ARRAY + array_literal: + - start_square_bracket: '[' + - numeric_literal: '1' + - comma: ',' + - numeric_literal: '2' + - comma: ',' + - numeric_literal: '3' + - end_square_bracket: ']' + - end_bracket: ) +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + function: + function_name: + function_name_identifier: my_function + function_contents: + bracketed: + start_bracket: ( + keyword: VARIADIC + named_argument: + naked_identifier: param_name + right_arrow: => + expression: + typed_array_literal: + array_type: + keyword: ARRAY + array_literal: + - start_square_bracket: '[' + - numeric_literal: '1' + - comma: ',' + - numeric_literal: '2' + - comma: ',' + - numeric_literal: '3' + - end_square_bracket: ']' + end_bracket: ) +- statement_terminator: ; +- statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + function: + function_name: + function_name_identifier: my_function + function_contents: + bracketed: + - start_bracket: ( + - named_argument: + naked_identifier: regular_param + right_arrow: => + expression: + quoted_literal: "'value'" + - comma: ',' + - keyword: VARIADIC + - named_argument: + naked_identifier: variadic_param + right_arrow: => + expression: + typed_array_literal: + array_type: + keyword: ARRAY + array_literal: + - start_square_bracket: '[' + - numeric_literal: '1' + - comma: ',' + - numeric_literal: '2' + - comma: ',' + - numeric_literal: '3' + - end_square_bracket: ']' + - end_bracket: ) +- statement_terminator: ; diff --git a/test/fixtures/dialects/redshift/create_procedure.sql b/test/fixtures/dialects/redshift/create_procedure.sql index a23b1c899f4..b427b7f4006 100644 --- a/test/fixtures/dialects/redshift/create_procedure.sql +++ b/test/fixtures/dialects/redshift/create_procedure.sql @@ -29,3 +29,30 @@ BEGIN SELECT INTO out_var count(*) from my_etl; END; $$ LANGUAGE plpgsql; + +CREATE OR REPLACE PROCEDURE test_sp_nonatomic () +NONATOMIC +AS $$ +BEGIN + SELECT 1; +END; +$$ LANGUAGE plpgsql +SECURITY INVOKER; + +CREATE PROCEDURE etl.test_sp_na (param1 int) +NONATOMIC +AS $$ +BEGIN + INSERT INTO test_table VALUES (param1); + COMMIT; + SELECT param1; +END; +$$ LANGUAGE plpgsql; + +CREATE PROCEDURE test_set_config() +AS $$ +BEGIN + SELECT 1; +END; +$$ LANGUAGE plpgsql +SET work_mem = '256MB'; diff --git a/test/fixtures/dialects/redshift/create_procedure.yml b/test/fixtures/dialects/redshift/create_procedure.yml index d6b4908b607..631bb120fd2 100644 --- a/test/fixtures/dialects/redshift/create_procedure.yml +++ b/test/fixtures/dialects/redshift/create_procedure.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 0e20869fcec0f6fe55c3878cff6ee41a18f240da24684251b572a59c7522478b +_hash: ee354884f73a976bdc9bbcbbf2c7a58b131c2c98bb4bbd33190081ec5542ea09 file: - statement: create_procedure_statement: @@ -89,3 +89,71 @@ file: keyword: LANGUAGE naked_identifier: plpgsql - statement_terminator: ; +- statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: REPLACE + - keyword: PROCEDURE + - function_name: + function_name_identifier: test_sp_nonatomic + - procedure_parameter_list: + bracketed: + start_bracket: ( + end_bracket: ) + - keyword: NONATOMIC + - function_definition: + - keyword: AS + - quoted_literal: "$$\nBEGIN\n SELECT 1;\nEND;\n$$" + - language_clause: + keyword: LANGUAGE + naked_identifier: plpgsql + - keyword: SECURITY + - keyword: INVOKER +- statement_terminator: ; +- statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - function_name: + naked_identifier: etl + dot: . + function_name_identifier: test_sp_na + - procedure_parameter_list: + bracketed: + start_bracket: ( + parameter: param1 + data_type: + keyword: int + end_bracket: ) + - keyword: NONATOMIC + - function_definition: + keyword: AS + quoted_literal: "$$\nBEGIN\n INSERT INTO test_table VALUES (param1);\n\ + \ COMMIT;\n SELECT param1;\nEND;\n$$" + language_clause: + keyword: LANGUAGE + naked_identifier: plpgsql +- statement_terminator: ; +- statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - function_name: + function_name_identifier: test_set_config + - procedure_parameter_list: + bracketed: + start_bracket: ( + end_bracket: ) + - function_definition: + - keyword: AS + - quoted_literal: "$$\nBEGIN\n SELECT 1;\nEND;\n$$" + - language_clause: + keyword: LANGUAGE + naked_identifier: plpgsql + - keyword: SET + - parameter: work_mem + - comparison_operator: + raw_comparison_operator: '=' + - quoted_literal: "'256MB'" +- statement_terminator: ; diff --git a/test/fixtures/dialects/snowflake/alter_warehouse.sql b/test/fixtures/dialects/snowflake/alter_warehouse.sql index 927c6f6b3fa..08a1a9bd3e4 100644 --- a/test/fixtures/dialects/snowflake/alter_warehouse.sql +++ b/test/fixtures/dialects/snowflake/alter_warehouse.sql @@ -34,6 +34,9 @@ alter warehouse set warehouse_size=medium; alter warehouse LOAD_WH set WAREHOUSE_TYPE = STANDARD; alter warehouse LOAD_WH set WAREHOUSE_TYPE = 'SNOWPARK-OPTIMIZED'; +alter warehouse LOAD_WH set RESOURCE_CONSTRAINT = 'MEMORY_64X'; +alter warehouse LOAD_WH set RESOURCE_CONSTRAINT = MEMORY_1X; + ALTER WAREHOUSE IDENTIFIER($var_wh) SET WAREHOUSE_TYPE = STANDARD; ALTER WAREHOUSE CI_TRANSFORMING diff --git a/test/fixtures/dialects/snowflake/alter_warehouse.yml b/test/fixtures/dialects/snowflake/alter_warehouse.yml index 302d4fcabd7..a517acb6947 100644 --- a/test/fixtures/dialects/snowflake/alter_warehouse.yml +++ b/test/fixtures/dialects/snowflake/alter_warehouse.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: b227019a09cb36cf82bd18f0eed983d21a02cb14dead33e699dc264103614cc6 +_hash: e4bfc3027cccd8358898f1632cde0c85fa1eeb48e2ae882aa91d36b48600abb3 file: - statement: alter_warehouse_statement: @@ -383,6 +383,32 @@ file: raw_comparison_operator: '=' warehouse_size: "'SNOWPARK-OPTIMIZED'" - statement_terminator: ; +- statement: + alter_warehouse_statement: + - keyword: alter + - keyword: warehouse + - object_reference: + naked_identifier: LOAD_WH + - keyword: set + - warehouse_object_properties: + keyword: RESOURCE_CONSTRAINT + comparison_operator: + raw_comparison_operator: '=' + resource_constraint: "'MEMORY_64X'" +- statement_terminator: ; +- statement: + alter_warehouse_statement: + - keyword: alter + - keyword: warehouse + - object_reference: + naked_identifier: LOAD_WH + - keyword: set + - warehouse_object_properties: + keyword: RESOURCE_CONSTRAINT + comparison_operator: + raw_comparison_operator: '=' + resource_constraint: MEMORY_1X +- statement_terminator: ; - statement: alter_warehouse_statement: - keyword: ALTER diff --git a/test/fixtures/dialects/snowflake/copy_into_table.sql b/test/fixtures/dialects/snowflake/copy_into_table.sql index f12b0dc56b0..77671b0ab69 100644 --- a/test/fixtures/dialects/snowflake/copy_into_table.sql +++ b/test/fixtures/dialects/snowflake/copy_into_table.sql @@ -87,3 +87,7 @@ COPY INTO test.transactions_all FROM @rawdata.STITCH_STAGE_NETSUITE/transactions/ FILE_FORMAT = rawdata.json_format MATCH_BY_COLUMN_NAME = 'case_insensitive'; + +copy into mytable1 + from 's3://bucket/source' + file_format = (type=csv MULTI_LINE=FALSE); diff --git a/test/fixtures/dialects/snowflake/copy_into_table.yml b/test/fixtures/dialects/snowflake/copy_into_table.yml index c24dc589724..cdcf23aef8d 100644 --- a/test/fixtures/dialects/snowflake/copy_into_table.yml +++ b/test/fixtures/dialects/snowflake/copy_into_table.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: bb1866f50d55e35a9207b2e6b5e1cd61a384d7ec40f6a021d63bf43146ca148b +_hash: 03ebb03d1607d492fc6f819c3273de3b70736a79c54de8357b6fe94c3933f4c4 file: - statement: copy_into_table_statement: @@ -492,3 +492,29 @@ file: raw_comparison_operator: '=' - quoted_literal: "'case_insensitive'" - statement_terminator: ; +- statement: + copy_into_table_statement: + - keyword: copy + - keyword: into + - table_reference: + naked_identifier: mytable1 + - keyword: from + - storage_location: + bucket_path: "'s3://bucket/source'" + - keyword: file_format + - comparison_operator: + raw_comparison_operator: '=' + - file_format_segment: + bracketed: + start_bracket: ( + csv_file_format_type_parameters: + - keyword: type + - comparison_operator: + raw_comparison_operator: '=' + - file_type: csv + - keyword: MULTI_LINE + - comparison_operator: + raw_comparison_operator: '=' + - boolean_literal: 'FALSE' + end_bracket: ) +- statement_terminator: ; diff --git a/test/fixtures/dialects/snowflake/create_warehouse.sql b/test/fixtures/dialects/snowflake/create_warehouse.sql index 4f7148097f5..8076408f826 100644 --- a/test/fixtures/dialects/snowflake/create_warehouse.sql +++ b/test/fixtures/dialects/snowflake/create_warehouse.sql @@ -12,3 +12,16 @@ create warehouse my_wh ; CREATE OR ALTER WAREHOUSE my_wh; + +create warehouse my_wh + resource_constraint = 'STANDARD_GEN_1' + warehouse_size = 'medium' +; + +create warehouse my_wh + resource_constraint = STANDARD_GEN_2 + warehouse_size = 'medium' + SCALING_POLICY = ECONOMY + comment = 'comment' + auto_suspend = 60 +; diff --git a/test/fixtures/dialects/snowflake/create_warehouse.yml b/test/fixtures/dialects/snowflake/create_warehouse.yml index 464e6415afa..aeb8918d778 100644 --- a/test/fixtures/dialects/snowflake/create_warehouse.yml +++ b/test/fixtures/dialects/snowflake/create_warehouse.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: de761543eef0be5d871c4b1a1ac070e8c2048b350c9577099cd604ecc0607484 +_hash: c8aa1c8d1703ac6362bfed86ee6cd05d33f7847f043864f4996a21f146439cee file: - statement: create_statement: @@ -111,3 +111,49 @@ file: - object_reference: naked_identifier: my_wh - statement_terminator: ; +- statement: + create_statement: + - keyword: create + - keyword: warehouse + - object_reference: + naked_identifier: my_wh + - warehouse_object_properties: + - keyword: resource_constraint + - comparison_operator: + raw_comparison_operator: '=' + - resource_constraint: "'STANDARD_GEN_1'" + - keyword: warehouse_size + - comparison_operator: + raw_comparison_operator: '=' + - warehouse_size: "'medium'" +- statement_terminator: ; +- statement: + create_statement: + - keyword: create + - keyword: warehouse + - object_reference: + naked_identifier: my_wh + - warehouse_object_properties: + - keyword: resource_constraint + - comparison_operator: + raw_comparison_operator: '=' + - resource_constraint: STANDARD_GEN_2 + - keyword: warehouse_size + - comparison_operator: + raw_comparison_operator: '=' + - warehouse_size: "'medium'" + - keyword: SCALING_POLICY + - comparison_operator: + raw_comparison_operator: '=' + - scaling_policy: ECONOMY + - comment_equals_clause: + keyword: comment + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'comment'" + - warehouse_object_properties: + keyword: auto_suspend + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '60' +- statement_terminator: ; diff --git a/test/fixtures/dialects/sparksql/databricks_dlt_create_view.sql b/test/fixtures/dialects/sparksql/databricks_dlt_create_view.sql index fb2fa4f93be..bacb32961e1 100644 --- a/test/fixtures/dialects/sparksql/databricks_dlt_create_view.sql +++ b/test/fixtures/dialects/sparksql/databricks_dlt_create_view.sql @@ -36,3 +36,31 @@ AS SELECT a, b FROM live.dlt_bronze; + +CREATE OR REFRESH MATERIALIZED VIEW my_dlt_mat_view ( + col1 STRING COMMENT 'Dummy column 1', + col2 BIGINT COMMENT 'Dummy column 2', + col3 BOOLEAN COMMENT 'Dummy column 3' +) +PARTITIONED BY (col1) +COMMENT 'Example simplified materialized view with dummy fields.' +TBLPROPERTIES ('quality' = 'gold') +AS SELECT + col1, + col2, + col3 +FROM my_source_table; + +CREATE OR REFRESH MATERIALIZED VIEW my_dlt_mat_view ( + col1 STRING COMMENT 'Dummy column 1', + col2 BIGINT COMMENT 'Dummy column 2', + col3 BOOLEAN COMMENT 'Dummy column 3' +) +CLUSTER BY (col1) +COMMENT 'Example simplified materialized view with dummy fields.' +TBLPROPERTIES ('quality' = 'gold') +AS SELECT + col1, + col2, + col3 +FROM my_source_table; diff --git a/test/fixtures/dialects/sparksql/databricks_dlt_create_view.yml b/test/fixtures/dialects/sparksql/databricks_dlt_create_view.yml index c657e8289b9..b73dc14467f 100644 --- a/test/fixtures/dialects/sparksql/databricks_dlt_create_view.yml +++ b/test/fixtures/dialects/sparksql/databricks_dlt_create_view.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 662d898d3182641df898b2ce6e2764fddffcbeb3003ad42317b6830c756b48ca +_hash: 555cf4e02736d842de63f822a3855bd54d969e2fb17a88186d4b53e039aa3241 file: - statement: create_view_statement: @@ -213,3 +213,156 @@ file: - dot: . - naked_identifier: dlt_bronze - statement_terminator: ; +- statement: + create_view_statement: + - keyword: CREATE + - keyword: OR + - keyword: REFRESH + - keyword: MATERIALIZED + - keyword: VIEW + - table_reference: + naked_identifier: my_dlt_mat_view + - bracketed: + - start_bracket: ( + - column_reference: + naked_identifier: col1 + - data_type: + primitive_type: + keyword: STRING + - keyword: COMMENT + - quoted_literal: "'Dummy column 1'" + - comma: ',' + - column_reference: + naked_identifier: col2 + - data_type: + primitive_type: + keyword: BIGINT + - keyword: COMMENT + - quoted_literal: "'Dummy column 2'" + - comma: ',' + - column_reference: + naked_identifier: col3 + - data_type: + primitive_type: + keyword: BOOLEAN + - keyword: COMMENT + - quoted_literal: "'Dummy column 3'" + - end_bracket: ) + - keyword: PARTITIONED + - keyword: BY + - bracketed: + start_bracket: ( + column_reference: + naked_identifier: col1 + end_bracket: ) + - keyword: COMMENT + - quoted_literal: "'Example simplified materialized view with dummy fields.'" + - keyword: TBLPROPERTIES + - bracketed: + start_bracket: ( + property_name_identifier: + quoted_identifier: "'quality'" + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'gold'" + end_bracket: ) + - keyword: AS + - select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + naked_identifier: col1 + - comma: ',' + - select_clause_element: + column_reference: + naked_identifier: col2 + - comma: ',' + - select_clause_element: + column_reference: + naked_identifier: col3 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: my_source_table +- statement_terminator: ; +- statement: + create_view_statement: + - keyword: CREATE + - keyword: OR + - keyword: REFRESH + - keyword: MATERIALIZED + - keyword: VIEW + - table_reference: + naked_identifier: my_dlt_mat_view + - bracketed: + - start_bracket: ( + - column_reference: + naked_identifier: col1 + - data_type: + primitive_type: + keyword: STRING + - keyword: COMMENT + - quoted_literal: "'Dummy column 1'" + - comma: ',' + - column_reference: + naked_identifier: col2 + - data_type: + primitive_type: + keyword: BIGINT + - keyword: COMMENT + - quoted_literal: "'Dummy column 2'" + - comma: ',' + - column_reference: + naked_identifier: col3 + - data_type: + primitive_type: + keyword: BOOLEAN + - keyword: COMMENT + - quoted_literal: "'Dummy column 3'" + - end_bracket: ) + - table_cluster_by_clause: + - keyword: CLUSTER + - keyword: BY + - bracketed: + start_bracket: ( + column_reference: + naked_identifier: col1 + end_bracket: ) + - keyword: COMMENT + - quoted_literal: "'Example simplified materialized view with dummy fields.'" + - keyword: TBLPROPERTIES + - bracketed: + start_bracket: ( + property_name_identifier: + quoted_identifier: "'quality'" + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'gold'" + end_bracket: ) + - keyword: AS + - select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + naked_identifier: col1 + - comma: ',' + - select_clause_element: + column_reference: + naked_identifier: col2 + - comma: ',' + - select_clause_element: + column_reference: + naked_identifier: col3 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: my_source_table +- statement_terminator: ; diff --git a/test/fixtures/dialects/sparksql/insert_table.sql b/test/fixtures/dialects/sparksql/insert_table.sql index 11690860da5..b59ce96db19 100644 --- a/test/fixtures/dialects/sparksql/insert_table.sql +++ b/test/fixtures/dialects/sparksql/insert_table.sql @@ -62,3 +62,31 @@ INSERT INTO students PARTITION (student_id = 11215017) (address, name) VALUES INSERT OVERWRITE students PARTITION (student_id = 11215017) (address, name) VALUES ('Hangzhou, China', 'Kent Yao Jr.'); + +INSERT INTO students REPLACE USING (country) +SELECT * +FROM new_students; + +INSERT INTO students REPLACE USING (country, city) +SELECT * +FROM new_students; + +INSERT INTO students REPLACE USING (country, city) +VALUES + ('Amy Smith', 1100), + ('Kent Yao', 2200); + +INSERT INTO sales REPLACE +WHERE tx_date BETWEEN '2023-10-01' AND '2023-10-02' +VALUES + ('2023-10-01', 1100), + ('2023-10-02', 2200), + ('2023-10-04', 4000); + +INSERT INTO sales REPLACE +WHERE + tx_date BETWEEN '2023-10-01' AND '2023-10-02' + AND store_nbr = 1 + AND item_nbr = 1 +SELECT * +FROM new_sales; diff --git a/test/fixtures/dialects/sparksql/insert_table.yml b/test/fixtures/dialects/sparksql/insert_table.yml index f0771cab6b0..7fa9da08f72 100644 --- a/test/fixtures/dialects/sparksql/insert_table.yml +++ b/test/fixtures/dialects/sparksql/insert_table.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 968d5d3c702a1448221fa10c22f49b99596abfe28865007f84ec6b6eb8398fdb +_hash: 7d1f784da0d1a5b69542c47e576be28a6593442bb78ea5a2ef95440385e8704f file: - statement: insert_statement: @@ -408,3 +408,186 @@ file: quoted_literal: "'Kent Yao Jr.'" - end_bracket: ) - statement_terminator: ; +- statement: + insert_statement: + - keyword: INSERT + - keyword: INTO + - table_reference: + naked_identifier: students + - keyword: REPLACE + - keyword: USING + - bracketed: + start_bracket: ( + column_reference: + naked_identifier: country + end_bracket: ) + - select_statement: + select_clause: + keyword: SELECT + select_clause_element: + wildcard_expression: + wildcard_identifier: + star: '*' + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: new_students +- statement_terminator: ; +- statement: + insert_statement: + - keyword: INSERT + - keyword: INTO + - table_reference: + naked_identifier: students + - keyword: REPLACE + - keyword: USING + - bracketed: + - start_bracket: ( + - column_reference: + naked_identifier: country + - comma: ',' + - column_reference: + naked_identifier: city + - end_bracket: ) + - select_statement: + select_clause: + keyword: SELECT + select_clause_element: + wildcard_expression: + wildcard_identifier: + star: '*' + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: new_students +- statement_terminator: ; +- statement: + insert_statement: + - keyword: INSERT + - keyword: INTO + - table_reference: + naked_identifier: students + - keyword: REPLACE + - keyword: USING + - bracketed: + - start_bracket: ( + - column_reference: + naked_identifier: country + - comma: ',' + - column_reference: + naked_identifier: city + - end_bracket: ) + - values_clause: + - keyword: VALUES + - bracketed: + - start_bracket: ( + - expression: + quoted_literal: "'Amy Smith'" + - comma: ',' + - expression: + numeric_literal: '1100' + - end_bracket: ) + - comma: ',' + - bracketed: + - start_bracket: ( + - expression: + quoted_literal: "'Kent Yao'" + - comma: ',' + - expression: + numeric_literal: '2200' + - end_bracket: ) +- statement_terminator: ; +- statement: + insert_statement: + - keyword: INSERT + - keyword: INTO + - table_reference: + naked_identifier: sales + - keyword: REPLACE + - where_clause: + keyword: WHERE + expression: + - column_reference: + naked_identifier: tx_date + - keyword: BETWEEN + - quoted_literal: "'2023-10-01'" + - keyword: AND + - quoted_literal: "'2023-10-02'" + - values_clause: + - keyword: VALUES + - bracketed: + - start_bracket: ( + - expression: + quoted_literal: "'2023-10-01'" + - comma: ',' + - expression: + numeric_literal: '1100' + - end_bracket: ) + - comma: ',' + - bracketed: + - start_bracket: ( + - expression: + quoted_literal: "'2023-10-02'" + - comma: ',' + - expression: + numeric_literal: '2200' + - end_bracket: ) + - comma: ',' + - bracketed: + - start_bracket: ( + - expression: + quoted_literal: "'2023-10-04'" + - comma: ',' + - expression: + numeric_literal: '4000' + - end_bracket: ) +- statement_terminator: ; +- statement: + insert_statement: + - keyword: INSERT + - keyword: INTO + - table_reference: + naked_identifier: sales + - keyword: REPLACE + - where_clause: + keyword: WHERE + expression: + - column_reference: + naked_identifier: tx_date + - keyword: BETWEEN + - quoted_literal: "'2023-10-01'" + - keyword: AND + - quoted_literal: "'2023-10-02'" + - binary_operator: AND + - column_reference: + naked_identifier: store_nbr + - comparison_operator: + raw_comparison_operator: '=' + - numeric_literal: '1' + - binary_operator: AND + - column_reference: + naked_identifier: item_nbr + - comparison_operator: + raw_comparison_operator: '=' + - numeric_literal: '1' + - select_statement: + select_clause: + keyword: SELECT + select_clause_element: + wildcard_expression: + wildcard_identifier: + star: '*' + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: new_sales +- statement_terminator: ; diff --git a/test/fixtures/dialects/trino/common_on.sql b/test/fixtures/dialects/trino/comment_on.sql similarity index 100% rename from test/fixtures/dialects/trino/common_on.sql rename to test/fixtures/dialects/trino/comment_on.sql diff --git a/test/fixtures/dialects/trino/common_on.yml b/test/fixtures/dialects/trino/comment_on.yml similarity index 100% rename from test/fixtures/dialects/trino/common_on.yml rename to test/fixtures/dialects/trino/comment_on.yml diff --git a/test/fixtures/dialects/tsql/add_index.yml b/test/fixtures/dialects/tsql/add_index.yml index c5050c7c7a9..52ab465d9ff 100644 --- a/test/fixtures/dialects/tsql/add_index.yml +++ b/test/fixtures/dialects/tsql/add_index.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 333acdf9243a058e27457a9e769f500611d59400530ba6f5e77acc40f92644c0 +_hash: 9d119f3b0afd3a4cdc5b1bccd4279cc7b93842900463fec104277cd95dfbb7f6 file: - batch: statement: @@ -59,8 +59,8 @@ file: naked_identifier: DATE_LAST_INSERTED end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: if_then_statement: @@ -115,8 +115,8 @@ file: naked_identifier: DATE_LAST_INSERTED end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: if_then_statement: @@ -170,8 +170,8 @@ file: naked_identifier: DATE_LAST_INSERTED end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_index_statement: @@ -209,8 +209,8 @@ file: null_literal: 'NULL' end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_index_statement: @@ -237,8 +237,8 @@ file: filegroup_name: quoted_identifier: '[PRIMARY]' - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_index_statement: @@ -266,10 +266,10 @@ file: - keyword: FILLFACTOR - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '80' + - integer_literal: '80' - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: create_index_statement: @@ -332,8 +332,8 @@ file: - keyword: 'ON' - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: create_index_statement: @@ -381,8 +381,8 @@ file: end_bracket: ) - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_index_statement: @@ -421,8 +421,8 @@ file: - keyword: TO - numeric_literal: '8' - end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_index_statement: @@ -447,8 +447,8 @@ file: - index_column_definition: quoted_identifier: '[Population]' - end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: update_statistics_statement: @@ -460,8 +460,8 @@ file: - naked_identifier: Population - naked_identifier: Stats_Population - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: update_statistics_statement: @@ -478,8 +478,8 @@ file: - naked_identifier: Stats_Population - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: update_statistics_statement: @@ -498,8 +498,8 @@ file: - keyword: WITH - keyword: FULLSCAN statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: update_statistics_statement: @@ -518,8 +518,8 @@ file: - keyword: WITH - keyword: RESAMPLE statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_statement: @@ -531,8 +531,8 @@ file: - naked_identifier: Population - dot: . - naked_identifier: Stats_Population -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_index_statement: @@ -546,5 +546,5 @@ file: - dot: . - naked_identifier: VIMR_INFECTIOUS_PEOPLE - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/alter_database.sql b/test/fixtures/dialects/tsql/alter_database.sql new file mode 100644 index 00000000000..cc32569867c --- /dev/null +++ b/test/fixtures/dialects/tsql/alter_database.sql @@ -0,0 +1,84 @@ +-- Rename database +ALTER DATABASE AdventureWorks2022 +Modify Name = Northwind ; +GO + +ALTER DATABASE db1 + MODIFY Name = db2 ; + +ALTER DATABASE CURRENT + MODIFY Name = db2 ; + +-- Change collation +ALTER DATABASE testDB +COLLATE French_CI_AI ; +GO + +-- Add file +ALTER DATABASE WideWorldImporters + ADD FILE (NAME = 'data_17'); + +-- change database options using SET +ALTER DATABASE CustomerSales + SET AUTO_CREATE_STATISTICS ON; + +ALTER DATABASE CustomerSales + SET AUTO_UPDATE_STATISTICS ON; + +ALTER DATABASE CURRENT + SET AUTO_UPDATE_STATISTICS_ASYNC ON; + +-- Add / remove secondary database +ALTER DATABASE db1 +ADD SECONDARY ON SERVER secondaryserver; + +ALTER DATABASE db1 +ADD SECONDARY ON SERVER secondaryserver +WITH ( ALLOW_CONNECTIONS = ALL ); + +ALTER DATABASE db1 +REMOVE SECONDARY ON SERVER testsecondaryserver; + +-- Initiate failover +ALTER DATABASE db1 FAILOVER; + +ALTER DATABASE db1 FORCE_FAILOVER_ALLOW_DATA_LOSS; + +ALTER DATABASE [mySampleDatabase] PERFORM_CUTOVER; + +-- Modify database options using MODIFY +ALTER DATABASE current + MODIFY (EDITION = 'Premium'); + +ALTER DATABASE db1 + MODIFY (SERVICE_OBJECTIVE = 'P6'); + +ALTER DATABASE dw1 MODIFY ( MAXSIZE=10240 GB ); + +ALTER DATABASE [db1] + MODIFY (EDITION = 'Standard', MAXSIZE = 250 GB, SERVICE_OBJECTIVE = 'S0'); + +ALTER DATABASE db1 + MODIFY ( SERVICE_OBJECTIVE = ELASTIC_POOL ( name = pool1 ) ) ; + +ALTER DATABASE [mySampleDatabase] + MODIFY (EDITION = 'Hyperscale', SERVICE_OBJECTIVE = 'HS_Gen5_2') + WITH MANUAL_CUTOVER; + +ALTER DATABASE db1 + MODIFY BACKUP_STORAGE_REDUNDANCY = 'ZONE'; + +ALTER DATABASE CustomerSales + SET ( AUTOGROW = ON ); + +ALTER DATABASE CustomerSales + SET ( REPLICATED_SIZE = 1 GB ); + +ALTER DATABASE CustomerSales + SET ( DISTRIBUTED_SIZE = 1000 GB ); + +ALTER DATABASE CustomerSales + SET ( LOG_SIZE = 10 GB ); + +ALTER DATABASE CustomerSales + SET ( AUTOGROW = ON, LOG_SIZE = 10 GB ); diff --git a/test/fixtures/dialects/tsql/alter_database.yml b/test/fixtures/dialects/tsql/alter_database.yml new file mode 100644 index 00000000000..58991b1218d --- /dev/null +++ b/test/fixtures/dialects/tsql/alter_database.yml @@ -0,0 +1,402 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: d94814131b9204de4ffab1b073a1353f1ad8a05629d65dcc9af9d313fb35a190 +file: +- batch: + statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: AdventureWorks2022 + - keyword: Modify + - keyword: Name + - comparison_operator: + raw_comparison_operator: '=' + - database_reference: + naked_identifier: Northwind + statement_terminator: ; + go_statement: + keyword: GO +- batch: + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: MODIFY + - keyword: Name + - comparison_operator: + raw_comparison_operator: '=' + - database_reference: + naked_identifier: db2 + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - keyword: CURRENT + - keyword: MODIFY + - keyword: Name + - comparison_operator: + raw_comparison_operator: '=' + - database_reference: + naked_identifier: db2 + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: testDB + - keyword: COLLATE + - collation_reference: + naked_identifier: French_CI_AI + - statement_terminator: ; + - go_statement: + keyword: GO +- batch: + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: WideWorldImporters + - keyword: ADD + - keyword: FILE + - file_spec: + bracketed: + start_bracket: ( + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'data_17'" + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: CustomerSales + - keyword: SET + - auto_option: + - keyword: AUTO_CREATE_STATISTICS + - keyword: 'ON' + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: CustomerSales + - keyword: SET + - auto_option: + - keyword: AUTO_UPDATE_STATISTICS + - keyword: 'ON' + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - keyword: CURRENT + - keyword: SET + - auto_option: + - keyword: AUTO_UPDATE_STATISTICS_ASYNC + - keyword: 'ON' + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: ADD + - keyword: SECONDARY + - keyword: 'ON' + - keyword: SERVER + - naked_identifier: secondaryserver + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: ADD + - keyword: SECONDARY + - keyword: 'ON' + - keyword: SERVER + - naked_identifier: secondaryserver + - keyword: WITH + - bracketed: + start_bracket: ( + allow_connections: + - keyword: ALLOW_CONNECTIONS + - comparison_operator: + raw_comparison_operator: '=' + - keyword: ALL + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: REMOVE + - keyword: SECONDARY + - keyword: 'ON' + - keyword: SERVER + - naked_identifier: testsecondaryserver + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: FAILOVER + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: FORCE_FAILOVER_ALLOW_DATA_LOSS + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + quoted_identifier: '[mySampleDatabase]' + - keyword: PERFORM_CUTOVER + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - keyword: current + - keyword: MODIFY + - bracketed: + start_bracket: ( + edition: + keyword: EDITION + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'Premium'" + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: MODIFY + - bracketed: + start_bracket: ( + service_objective: + keyword: SERVICE_OBJECTIVE + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'P6'" + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: dw1 + - keyword: MODIFY + - bracketed: + start_bracket: ( + file_spec_max_size: + - keyword: MAXSIZE + - comparison_operator: + raw_comparison_operator: '=' + - numeric_literal: '10240' + - keyword: GB + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + quoted_identifier: '[db1]' + - keyword: MODIFY + - bracketed: + - start_bracket: ( + - edition: + keyword: EDITION + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'Standard'" + - comma: ',' + - file_spec_max_size: + - keyword: MAXSIZE + - comparison_operator: + raw_comparison_operator: '=' + - numeric_literal: '250' + - keyword: GB + - comma: ',' + - service_objective: + keyword: SERVICE_OBJECTIVE + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'S0'" + - end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: MODIFY + - bracketed: + start_bracket: ( + service_objective: + - keyword: SERVICE_OBJECTIVE + - comparison_operator: + raw_comparison_operator: '=' + - keyword: ELASTIC_POOL + - bracketed: + start_bracket: ( + keyword: name + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: pool1 + end_bracket: ) + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + quoted_identifier: '[mySampleDatabase]' + - keyword: MODIFY + - bracketed: + start_bracket: ( + edition: + keyword: EDITION + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'Hyperscale'" + comma: ',' + service_objective: + keyword: SERVICE_OBJECTIVE + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'HS_Gen5_2'" + end_bracket: ) + - keyword: WITH + - keyword: MANUAL_CUTOVER + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: db1 + - keyword: MODIFY + - backup_storage_redundancy: + keyword: BACKUP_STORAGE_REDUNDANCY + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'ZONE'" + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: CustomerSales + - keyword: SET + - bracketed: + start_bracket: ( + naked_identifier: AUTOGROW + comparison_operator: + raw_comparison_operator: '=' + keyword: 'ON' + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: CustomerSales + - keyword: SET + - bracketed: + start_bracket: ( + naked_identifier: REPLICATED_SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '1' + keyword: GB + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: CustomerSales + - keyword: SET + - bracketed: + start_bracket: ( + naked_identifier: DISTRIBUTED_SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '1000' + keyword: GB + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: CustomerSales + - keyword: SET + - bracketed: + start_bracket: ( + naked_identifier: LOG_SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '10' + keyword: GB + end_bracket: ) + - statement_terminator: ; + - statement: + alter_database_statement: + - keyword: ALTER + - keyword: DATABASE + - database_reference: + naked_identifier: CustomerSales + - keyword: SET + - bracketed: + - start_bracket: ( + - naked_identifier: AUTOGROW + - comparison_operator: + raw_comparison_operator: '=' + - keyword: 'ON' + - comma: ',' + - naked_identifier: LOG_SIZE + - comparison_operator: + raw_comparison_operator: '=' + - numeric_literal: '10' + - keyword: GB + - end_bracket: ) + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/alter_table.yml b/test/fixtures/dialects/tsql/alter_table.yml index 3abe91a8f00..f2f0bbe9098 100644 --- a/test/fixtures/dialects/tsql/alter_table.yml +++ b/test/fixtures/dialects/tsql/alter_table.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 5589a876d8cca343f15539310fb540c839f80b2f4ad9f2525b28d8910794430c +_hash: 5de14ee956b14a5f09c9c51727b853ca119ab45abb334d90527c0b40ff275464 file: - batch: statement: @@ -22,8 +22,8 @@ file: data_type_identifier: INT end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -42,13 +42,13 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '20' + integer_literal: '20' end_bracket: ) column_constraint_segment: keyword: 'NULL' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -66,8 +66,8 @@ file: data_type_identifier: INT end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -86,7 +86,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '20' + integer_literal: '20' end_bracket: ) - column_constraint_segment: keyword: 'NULL' @@ -108,8 +108,8 @@ file: - column_reference: naked_identifier: column_c statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: execute_script_statement: @@ -120,8 +120,8 @@ file: column_reference: naked_identifier: doc_exc statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_table_statement: @@ -132,8 +132,8 @@ file: - dot: . - naked_identifier: doc_exc - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -156,8 +156,8 @@ file: data_type_identifier: INT - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: insert_statement: @@ -176,11 +176,11 @@ file: keyword: VALUES bracketed: start_bracket: ( - numeric_literal: '7' + integer_literal: '7' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -196,13 +196,13 @@ file: - object_reference: naked_identifier: col_b_def - keyword: DEFAULT - - numeric_literal: '50' + - integer_literal: '50' - keyword: FOR - column_reference: naked_identifier: column_b statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: insert_statement: @@ -221,11 +221,11 @@ file: keyword: VALUES bracketed: start_bracket: ( - numeric_literal: '10' + integer_literal: '10' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -245,8 +245,8 @@ file: - dot: . - naked_identifier: doc_exz statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_table_statement: @@ -257,8 +257,8 @@ file: - dot: . - naked_identifier: doc_exz - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -282,8 +282,8 @@ file: index_column_definition: naked_identifier: TransactionID end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -303,10 +303,10 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '36' + integer_literal: '36' end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: alter_table_statement: @@ -367,8 +367,8 @@ file: column_reference: quoted_identifier: '[ProductID]' end_bracket: ) -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -382,8 +382,8 @@ file: - keyword: CONSTRAINT - object_reference: quoted_identifier: '[FK_ProductCostHistory_Product_ProductID]' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -401,8 +401,8 @@ file: naked_identifier: my_col_2 data_type: data_type_identifier: INT -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -419,8 +419,8 @@ file: - keyword: 'ON' - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -437,8 +437,8 @@ file: - keyword: 'OFF' - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -463,8 +463,8 @@ file: end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -494,8 +494,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -530,8 +530,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -567,8 +567,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -604,8 +604,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -623,8 +623,8 @@ file: quoted_identifier: '"NULL"' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -642,8 +642,8 @@ file: quoted_identifier: '"default"' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -661,8 +661,8 @@ file: naked_identifier: PartitionSchemeName end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -679,8 +679,8 @@ file: - keyword: 'ON' - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -705,8 +705,8 @@ file: end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -737,8 +737,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -768,8 +768,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -800,8 +800,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -832,8 +832,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -857,8 +857,8 @@ file: - numeric_literal: '1.5' - keyword: PERSISTED statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -887,8 +887,8 @@ file: - keyword: NOT - keyword: 'NULL' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -916,8 +916,8 @@ file: data_type_identifier: date end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: alter_table_statement: @@ -957,8 +957,8 @@ file: - keyword: DELETE - keyword: CASCADE statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: alter_table_statement: @@ -1014,7 +1014,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '21' + integer_literal: '21' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -1028,7 +1028,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '400' + integer_literal: '400' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -1041,7 +1041,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '400' + integer_literal: '400' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -1078,14 +1078,14 @@ file: - keyword: DEFAULT - bracketed: start_bracket: ( - numeric_literal: '0x00' + binary_literal: '0x00' end_bracket: ) - keyword: FOR - column_reference: quoted_identifier: '[strSkill]' - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: - statement: alter_table_statement: diff --git a/test/fixtures/dialects/tsql/arithmetic_operations.yml b/test/fixtures/dialects/tsql/arithmetic_operations.yml index d76ab962d86..d777f4a5e1b 100644 --- a/test/fixtures/dialects/tsql/arithmetic_operations.yml +++ b/test/fixtures/dialects/tsql/arithmetic_operations.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: fa20731e4aa3e225ef7f46049c46e10961ea9303f05321c808a85c949d51d6c2 +_hash: ed19ed9216c31fdf3b8e35dacee92b2e7f5265e1497132501e17abc63a26376b file: batch: - statement: @@ -15,7 +15,7 @@ file: comparison_operator: raw_comparison_operator: '=' expression: - numeric_literal: '0' + integer_literal: '0' statement_terminator: ; - statement: select_statement: @@ -25,7 +25,7 @@ file: expression: parameter: '@I' binary_operator: + - numeric_literal: '1' + integer_literal: '1' statement_terminator: ; - statement: select_statement: @@ -37,7 +37,7 @@ file: binary_operator: - raw_comparison_operator: + - raw_comparison_operator: '=' - numeric_literal: '2' + integer_literal: '2' statement_terminator: ; - statement: select_statement: @@ -47,7 +47,7 @@ file: expression: parameter: '@I' binary_operator: '-' - numeric_literal: '3' + integer_literal: '3' statement_terminator: ; - statement: select_statement: @@ -59,7 +59,7 @@ file: binary_operator: - raw_comparison_operator: '-' - raw_comparison_operator: '=' - numeric_literal: '4' + integer_literal: '4' statement_terminator: ; - statement: select_statement: @@ -69,7 +69,7 @@ file: expression: parameter: '@I' binary_operator: '*' - numeric_literal: '5' + integer_literal: '5' statement_terminator: ; - statement: select_statement: @@ -81,7 +81,7 @@ file: binary_operator: - raw_comparison_operator: '*' - raw_comparison_operator: '=' - numeric_literal: '6' + integer_literal: '6' statement_terminator: ; - statement: select_statement: @@ -91,7 +91,7 @@ file: expression: parameter: '@I' binary_operator: / - numeric_literal: '7' + integer_literal: '7' statement_terminator: ; - statement: select_statement: @@ -103,7 +103,7 @@ file: binary_operator: - raw_comparison_operator: / - raw_comparison_operator: '=' - numeric_literal: '8' + integer_literal: '8' statement_terminator: ; - statement: select_statement: @@ -113,7 +113,7 @@ file: expression: parameter: '@I' binary_operator: '%' - numeric_literal: '9' + integer_literal: '9' statement_terminator: ; - statement: select_statement: @@ -125,5 +125,5 @@ file: binary_operator: - raw_comparison_operator: '%' - raw_comparison_operator: '=' - numeric_literal: '10' + integer_literal: '10' statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/begin_end_no_semicolon.yml b/test/fixtures/dialects/tsql/begin_end_no_semicolon.yml index f08b147d64f..ee2938dab82 100644 --- a/test/fixtures/dialects/tsql/begin_end_no_semicolon.yml +++ b/test/fixtures/dialects/tsql/begin_end_no_semicolon.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 5fb241b3172412eea845ce528dfdcda03e3470d89a9411bacbacd61898db3b8f +_hash: 07380e48564fa3da77cce3298974d2a2ba48c64446528f8ad05b5e24815037e1 file: batch: statement: @@ -14,5 +14,5 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' - keyword: END diff --git a/test/fixtures/dialects/tsql/binary_constants.sql b/test/fixtures/dialects/tsql/binary_constants.sql new file mode 100644 index 00000000000..d33bba2f5d2 --- /dev/null +++ b/test/fixtures/dialects/tsql/binary_constants.sql @@ -0,0 +1,17 @@ +-- T-SQL binary constants test cases +-- Test basic binary constants parsing +select 0x0; +select 0xAE; +select 0x12Ef; +select 0x69048AEFDD010E; +select 0x; + +-- Test mixed case +select 0X0; +select 0XAE; + +-- Test multiple constants in one query +select 0x0, 0xAE, 0x12Ef; + +-- Test with old-style x'...' format +select x'FF', X'DEAD'; diff --git a/test/fixtures/dialects/tsql/binary_constants.yml b/test/fixtures/dialects/tsql/binary_constants.yml new file mode 100644 index 00000000000..6489e6954b0 --- /dev/null +++ b/test/fixtures/dialects/tsql/binary_constants.yml @@ -0,0 +1,80 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 70b5da04f9a2080c9a0d439875944f36c83f4ca310d1e1002f0748eb487ab390 +file: + batch: + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + binary_literal: '0x0' + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + binary_literal: '0xAE' + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + binary_literal: '0x12Ef' + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + binary_literal: '0x69048AEFDD010E' + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + binary_literal: 0x + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + binary_literal: 0X0 + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + binary_literal: 0XAE + statement_terminator: ; + - statement: + select_statement: + select_clause: + - keyword: select + - select_clause_element: + binary_literal: '0x0' + - comma: ',' + - select_clause_element: + binary_literal: '0xAE' + - comma: ',' + - select_clause_element: + binary_literal: '0x12Ef' + statement_terminator: ; + - statement: + select_statement: + select_clause: + - keyword: select + - select_clause_element: + numeric_literal: "x'FF'" + - comma: ',' + - select_clause_element: + numeric_literal: "X'DEAD'" + statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/binary_constants_functions.sql b/test/fixtures/dialects/tsql/binary_constants_functions.sql new file mode 100644 index 00000000000..f854a8f37d4 --- /dev/null +++ b/test/fixtures/dialects/tsql/binary_constants_functions.sql @@ -0,0 +1,12 @@ +-- T-SQL binary constants function calls test cases +-- Function calls with binary constants +select CAST(0x0 as uniqueidentifier); +select CAST(0xAE as binary(2)); +select CAST(0x12Ef as varbinary(16)); + +-- Mixed cases with functions +select CAST(0X0 as uniqueidentifier); +select CONVERT(binary(4), 0x69048AEF); + +-- Empty binary constant in function +select CAST(0x as binary(1)); diff --git a/test/fixtures/dialects/tsql/binary_constants_functions.yml b/test/fixtures/dialects/tsql/binary_constants_functions.yml new file mode 100644 index 00000000000..3d00bb3d9e2 --- /dev/null +++ b/test/fixtures/dialects/tsql/binary_constants_functions.yml @@ -0,0 +1,140 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: f12221a8e7cfa2d7e24322b9d1eefb122cd5e4ec0fef843a0c1f313430a51751 +file: + batch: + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + binary_literal: '0x0' + keyword: as + data_type: + data_type_identifier: uniqueidentifier + end_bracket: ) + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + binary_literal: '0xAE' + keyword: as + data_type: + data_type_identifier: binary + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '2' + end_bracket: ) + end_bracket: ) + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + binary_literal: '0x12Ef' + keyword: as + data_type: + data_type_identifier: varbinary + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '16' + end_bracket: ) + end_bracket: ) + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + binary_literal: 0X0 + keyword: as + data_type: + data_type_identifier: uniqueidentifier + end_bracket: ) + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + function: + function_name: + keyword: CONVERT + function_contents: + bracketed: + start_bracket: ( + data_type: + data_type_identifier: binary + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '4' + end_bracket: ) + comma: ',' + expression: + binary_literal: '0x69048AEF' + end_bracket: ) + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + binary_literal: 0x + keyword: as + data_type: + data_type_identifier: binary + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '1' + end_bracket: ) + end_bracket: ) + statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/binary_constants_variables.sql b/test/fixtures/dialects/tsql/binary_constants_variables.sql new file mode 100644 index 00000000000..1958fe3057a --- /dev/null +++ b/test/fixtures/dialects/tsql/binary_constants_variables.sql @@ -0,0 +1,14 @@ +-- T-SQL binary constants variable assignment test cases +-- Variable assignment with binary constants +declare @var1 binary(1); +set @var1 = 0x0; + +declare @var2 binary(2); +set @var2 = 0xAE; + +declare @var3 binary(8); +set @var3 = 0x69048AEFDD010E; + +-- Empty binary constant +declare @var4 binary(16); +set @var4 = 0x; diff --git a/test/fixtures/dialects/tsql/binary_constants_variables.yml b/test/fixtures/dialects/tsql/binary_constants_variables.yml new file mode 100644 index 00000000000..b6fae0884b9 --- /dev/null +++ b/test/fixtures/dialects/tsql/binary_constants_variables.yml @@ -0,0 +1,96 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 21a89969ddb2dd512dffd966e93dfd2e2330ab6439e5feb2023463fc81853a89 +file: + batch: + - statement: + declare_segment: + keyword: declare + parameter: '@var1' + data_type: + data_type_identifier: binary + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '1' + end_bracket: ) + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: set + parameter: '@var1' + assignment_operator: + raw_comparison_operator: '=' + expression: + binary_literal: '0x0' + - statement_terminator: ; + - statement: + declare_segment: + keyword: declare + parameter: '@var2' + data_type: + data_type_identifier: binary + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '2' + end_bracket: ) + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: set + parameter: '@var2' + assignment_operator: + raw_comparison_operator: '=' + expression: + binary_literal: '0xAE' + - statement_terminator: ; + - statement: + declare_segment: + keyword: declare + parameter: '@var3' + data_type: + data_type_identifier: binary + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '8' + end_bracket: ) + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: set + parameter: '@var3' + assignment_operator: + raw_comparison_operator: '=' + expression: + binary_literal: '0x69048AEFDD010E' + - statement_terminator: ; + - statement: + declare_segment: + keyword: declare + parameter: '@var4' + data_type: + data_type_identifier: binary + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '16' + end_bracket: ) + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: set + parameter: '@var4' + assignment_operator: + raw_comparison_operator: '=' + expression: + binary_literal: 0x + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/cast_variable.yml b/test/fixtures/dialects/tsql/cast_variable.yml index 5a23a59acd9..f2d13f0a6fe 100644 --- a/test/fixtures/dialects/tsql/cast_variable.yml +++ b/test/fixtures/dialects/tsql/cast_variable.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: f0d6ed4515b8bc43701b4f6fbd3ae50b9b9f43470178a3f4f0f741439f7d0e4e +_hash: 4cdf2eb61314a53ba5b9dcf74737fe51291c226fed8d663d4a44bf55afd4d788 file: batch: - statement: @@ -79,7 +79,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '7' + integer_literal: '7' end_bracket: ) end_bracket: ) alias_expression: @@ -117,7 +117,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' keyword: as data_type: data_type_identifier: nvarchar diff --git a/test/fixtures/dialects/tsql/convert.yml b/test/fixtures/dialects/tsql/convert.yml index bd2637856c9..b68f198c259 100644 --- a/test/fixtures/dialects/tsql/convert.yml +++ b/test/fixtures/dialects/tsql/convert.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: a66102525efeec69422f37346be8e4f9742506e60d7c1cb30bd79d8b565e7614 +_hash: 719b2d8f7283202730f00e56e4675b3c1cdd7f8a2cce608ba3da0a63a47e9f34 file: batch: statement: @@ -23,7 +23,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) comma: ',' expression: diff --git a/test/fixtures/dialects/tsql/create_database.sql b/test/fixtures/dialects/tsql/create_database.sql new file mode 100644 index 00000000000..8b47b6efd36 --- /dev/null +++ b/test/fixtures/dialects/tsql/create_database.sql @@ -0,0 +1,154 @@ +CREATE DATABASE mytest; + +CREATE DATABASE Sales +ON +( NAME = Sales_dat, + FILENAME = 'C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\saledat.mdf', + SIZE = 10, + MAXSIZE = 50, + FILEGROWTH = 5 ) +LOG ON +( NAME = Sales_log, + FILENAME = 'C:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\DATA\salelog.ldf', + SIZE = 5MB, + MAXSIZE = 25MB, + FILEGROWTH = 5MB + ) ; +GO + +CREATE DATABASE Archive +ON +PRIMARY + (NAME = Arch1, + FILENAME = 'D:\SalesData\archdat1.mdf', + SIZE = 100MB, + MAXSIZE = 200, + FILEGROWTH = 20), + ( NAME = Arch2, + FILENAME = 'D:\SalesData\archdat2.ndf', + SIZE = 100MB, + MAXSIZE = 200, + FILEGROWTH = 20), + ( NAME = Arch3, + FILENAME = 'D:\SalesData\archdat3.ndf', + SIZE = 100MB, + MAXSIZE = 200, + FILEGROWTH = 20) +LOG ON + (NAME = Archlog1, + FILENAME = 'D:\SalesData\archlog1.ldf', + SIZE = 100MB, + MAXSIZE = 200, + FILEGROWTH = 20), + (NAME = Archlog2, + FILENAME = 'D:\SalesData\archlog2.ldf', + SIZE = 100MB, + MAXSIZE = 200, + FILEGROWTH = 20) ; +GO + +CREATE DATABASE Sales +ON PRIMARY +( NAME = SPri1_dat, + FILENAME = 'D:\SalesData\SPri1dat.mdf', + SIZE = 10, + MAXSIZE = 50, + FILEGROWTH = 15% ), +( NAME = SPri2_dat, + FILENAME = 'D:\SalesData\SPri2dt.ndf', + SIZE = 10, + MAXSIZE = 50, + FILEGROWTH = 15% ), +FILEGROUP SalesGroup1 +( NAME = SGrp1Fi1_dat, + FILENAME = 'D:\SalesData\SG1Fi1dt.ndf', + SIZE = 10, + MAXSIZE = 50, + FILEGROWTH = 5 ), +( NAME = SGrp1Fi2_dat, + FILENAME = 'D:\SalesData\SG1Fi2dt.ndf', + SIZE = 10, + MAXSIZE = 50, + FILEGROWTH = 5 ), +FILEGROUP SalesGroup2 +( NAME = SGrp2Fi1_dat, + FILENAME = 'D:\SalesData\SG2Fi1dt.ndf', + SIZE = 10, + MAXSIZE = 50, + FILEGROWTH = 5 ), +( NAME = SGrp2Fi2_dat, + FILENAME = 'D:\SalesData\SG2Fi2dt.ndf', + SIZE = 10, + MAXSIZE = 50, + FILEGROWTH = 5 ) +LOG ON +( NAME = Sales_log, + FILENAME = 'E:\SalesLog\salelog.ldf', + SIZE = 5MB, + MAXSIZE = 25MB, + FILEGROWTH = 5MB ) ; +GO + + +CREATE DATABASE sales_snapshot0600 ON + ( NAME = SPri1_dat, FILENAME = 'D:\SalesData\SPri1dat_0600.ss'), + ( NAME = SPri2_dat, FILENAME = 'D:\SalesData\SPri2dt_0600.ss'), + ( NAME = SGrp1Fi1_dat, FILENAME = 'D:\SalesData\SG1Fi1dt_0600.ss'), + ( NAME = SGrp1Fi2_dat, FILENAME = 'D:\SalesData\SG1Fi2dt_0600.ss'), + ( NAME = SGrp2Fi1_dat, FILENAME = 'D:\SalesData\SG2Fi1dt_0600.ss'), + ( NAME = SGrp2Fi2_dat, FILENAME = 'D:\SalesData\SG2Fi2dt_0600.ss') +AS SNAPSHOT OF Sales ; +GO + +CREATE DATABASE MyOptionsTest +COLLATE French_CI_AI +WITH TRUSTWORTHY ON, DB_CHAINING ON; + +CREATE DATABASE AdventureWorks2022 ON + (FILENAME = 'c:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\Data\AdventureWorks2022_data.mdf'), + (FILENAME = 'c:\Program Files\Microsoft SQL Server\MSSQL13.MSSQLSERVER\MSSQL\Data\AdventureWorks2022_log.ldf'), + (FILENAME = 'c:\myFTCatalogs\AdvWksFtCat') +FOR ATTACH; +GO + +CREATE DATABASE [BlobStore1] +CONTAINMENT = NONE +ON PRIMARY +( + NAME = N'BlobStore1', + FILENAME = N'C:\BlobStore\BlobStore1.mdf', + SIZE = 100MB, + MAXSIZE = UNLIMITED, + FILEGROWTH = 1MB +), +FILEGROUP [FS] CONTAINS FILESTREAM DEFAULT +( + NAME = N'FS1', + FILENAME = N'C:\BlobStore\FS1', + MAXSIZE = UNLIMITED +), +( + NAME = N'FS2', + FILENAME = N'C:\BlobStore\FS2', + MAXSIZE = 100MB +) +LOG ON +( + NAME = N'BlobStore1_log', + FILENAME = N'C:\BlobStore\BlobStore1_log.ldf', + SIZE = 100MB, + MAXSIZE = 1GB, + FILEGROWTH = 1MB +); +GO + +CREATE DATABASE [different-collations] COLLATE SQL_Latin1_General_CP1_CS_AS + +CREATE DATABASE [same-collations] COLLATE SQL_Latin1_General_CP1_CS_AS +WITH CATALOG_COLLATION = DATABASE_DEFAULT; + +CREATE DATABASE Archive + ON + (FILENAME = 'D:\SalesData\archdat1.mdf') + FOR ATTACH ; +GO diff --git a/test/fixtures/dialects/tsql/create_database.yml b/test/fixtures/dialects/tsql/create_database.yml new file mode 100644 index 00000000000..0c5490dd9cb --- /dev/null +++ b/test/fixtures/dialects/tsql/create_database.yml @@ -0,0 +1,899 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: a56b651f70869ddf897d090eab06dc410092dd246ffc1040e6b2cd9bbfb4973a +file: +- batch: + - statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + naked_identifier: mytest + - statement_terminator: ; + - statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + naked_identifier: Sales + - keyword: 'ON' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: Sales_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'C:\\Program Files\\Microsoft SQL Server\\MSSQL13.MSSQLSERVER\\\ + MSSQL\\DATA\\saledat.mdf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '10' + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '50' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '5' + end_bracket: ) + - keyword: LOG + - keyword: 'ON' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: Sales_log + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'C:\\Program Files\\Microsoft SQL Server\\MSSQL13.MSSQLSERVER\\\ + MSSQL\\DATA\\salelog.ldf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 5MB + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 25MB + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + size_literal: 5MB + end_bracket: ) + - statement_terminator: ; + - go_statement: + keyword: GO +- batch: + statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + naked_identifier: Archive + - keyword: 'ON' + - keyword: PRIMARY + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: Arch1 + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\archdat1.mdf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 100MB + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '200' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '20' + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: Arch2 + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\archdat2.ndf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 100MB + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '200' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '20' + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: Arch3 + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\archdat3.ndf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 100MB + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '200' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '20' + end_bracket: ) + - keyword: LOG + - keyword: 'ON' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: Archlog1 + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\archlog1.ldf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 100MB + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '200' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '20' + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: Archlog2 + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\archlog2.ldf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 100MB + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '200' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '20' + end_bracket: ) + statement_terminator: ; + go_statement: + keyword: GO +- batch: + statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + naked_identifier: Sales + - keyword: 'ON' + - keyword: PRIMARY + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SPri1_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SPri1dat.mdf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '10' + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '50' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '15' + percent: '%' + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SPri2_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SPri2dt.ndf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '10' + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '50' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '15' + percent: '%' + end_bracket: ) + - comma: ',' + - keyword: FILEGROUP + - naked_identifier: SalesGroup1 + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SGrp1Fi1_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SG1Fi1dt.ndf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '10' + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '50' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '5' + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SGrp1Fi2_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SG1Fi2dt.ndf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '10' + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '50' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '5' + end_bracket: ) + - comma: ',' + - keyword: FILEGROUP + - naked_identifier: SalesGroup2 + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SGrp2Fi1_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SG2Fi1dt.ndf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '10' + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '50' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '5' + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SGrp2Fi2_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SG2Fi2dt.ndf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '10' + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '50' + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + numeric_literal: '5' + end_bracket: ) + - keyword: LOG + - keyword: 'ON' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: Sales_log + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'E:\\SalesLog\\salelog.ldf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 5MB + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 25MB + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + size_literal: 5MB + end_bracket: ) + statement_terminator: ; + go_statement: + keyword: GO +- batch: + statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + naked_identifier: sales_snapshot0600 + - keyword: 'ON' + - bracketed: + start_bracket: ( + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SPri1_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SPri1dat_0600.ss'" + end_bracket: ) + - comma: ',' + - bracketed: + start_bracket: ( + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SPri2_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SPri2dt_0600.ss'" + end_bracket: ) + - comma: ',' + - bracketed: + start_bracket: ( + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SGrp1Fi1_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SG1Fi1dt_0600.ss'" + end_bracket: ) + - comma: ',' + - bracketed: + start_bracket: ( + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SGrp1Fi2_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SG1Fi2dt_0600.ss'" + end_bracket: ) + - comma: ',' + - bracketed: + start_bracket: ( + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SGrp2Fi1_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SG2Fi1dt_0600.ss'" + end_bracket: ) + - comma: ',' + - bracketed: + start_bracket: ( + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + naked_identifier: SGrp2Fi2_dat + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\SG2Fi2dt_0600.ss'" + end_bracket: ) + - keyword: AS + - keyword: SNAPSHOT + - keyword: OF + - naked_identifier: Sales + statement_terminator: ; + go_statement: + keyword: GO +- batch: + - statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + naked_identifier: MyOptionsTest + - keyword: COLLATE + - collation_reference: + naked_identifier: French_CI_AI + - keyword: WITH + - keyword: TRUSTWORTHY + - keyword: 'ON' + - comma: ',' + - keyword: DB_CHAINING + - keyword: 'ON' + - statement_terminator: ; + - statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + naked_identifier: AdventureWorks2022 + - keyword: 'ON' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + file_spec_file_name: + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'c:\\Program Files\\Microsoft SQL Server\\MSSQL13.MSSQLSERVER\\\ + MSSQL\\Data\\AdventureWorks2022_data.mdf'" + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + file_spec_file_name: + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'c:\\Program Files\\Microsoft SQL Server\\MSSQL13.MSSQLSERVER\\\ + MSSQL\\Data\\AdventureWorks2022_log.ldf'" + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + file_spec_file_name: + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'c:\\myFTCatalogs\\AdvWksFtCat'" + end_bracket: ) + - keyword: FOR + - keyword: ATTACH + - statement_terminator: ; + - go_statement: + keyword: GO +- batch: + statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + quoted_identifier: '[BlobStore1]' + - keyword: CONTAINMENT + - comparison_operator: + raw_comparison_operator: '=' + - keyword: NONE + - keyword: 'ON' + - keyword: PRIMARY + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "N'BlobStore1'" + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "N'C:\\BlobStore\\BlobStore1.mdf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 100MB + file_spec_max_size: + - comma: ',' + - keyword: MAXSIZE + - comparison_operator: + raw_comparison_operator: '=' + - keyword: UNLIMITED + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + size_literal: 1MB + end_bracket: ) + - comma: ',' + - keyword: FILEGROUP + - quoted_identifier: '[FS]' + - keyword: CONTAINS + - keyword: FILESTREAM + - keyword: DEFAULT + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "N'FS1'" + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "N'C:\\BlobStore\\FS1'" + file_spec_max_size: + - comma: ',' + - keyword: MAXSIZE + - comparison_operator: + raw_comparison_operator: '=' + - keyword: UNLIMITED + end_bracket: ) + - comma: ',' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "N'FS2'" + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "N'C:\\BlobStore\\FS2'" + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 100MB + end_bracket: ) + - keyword: LOG + - keyword: 'ON' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + logical_file_name: + keyword: NAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "N'BlobStore1_log'" + file_spec_file_name: + comma: ',' + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "N'C:\\BlobStore\\BlobStore1_log.ldf'" + file_spec_size: + comma: ',' + keyword: SIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 100MB + file_spec_max_size: + comma: ',' + keyword: MAXSIZE + comparison_operator: + raw_comparison_operator: '=' + size_literal: 1GB + file_spec_file_growth: + comma: ',' + keyword: FILEGROWTH + comparison_operator: + raw_comparison_operator: '=' + size_literal: 1MB + end_bracket: ) + statement_terminator: ; + go_statement: + keyword: GO +- batch: + - statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + quoted_identifier: '[different-collations]' + - keyword: COLLATE + - collation_reference: + naked_identifier: SQL_Latin1_General_CP1_CS_AS + - statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + quoted_identifier: '[same-collations]' + - keyword: COLLATE + - collation_reference: + naked_identifier: SQL_Latin1_General_CP1_CS_AS + - keyword: WITH + - keyword: CATALOG_COLLATION + - comparison_operator: + raw_comparison_operator: '=' + - collation_reference: + naked_identifier: DATABASE_DEFAULT + - statement_terminator: ; + - statement: + create_database_statement: + - keyword: CREATE + - keyword: DATABASE + - database_reference: + naked_identifier: Archive + - keyword: 'ON' + - file_spec: + bracketed: + start_bracket: ( + file_spec_without_bracket: + file_spec_file_name: + keyword: FILENAME + comparison_operator: + raw_comparison_operator: '=' + quoted_literal: "'D:\\SalesData\\archdat1.mdf'" + end_bracket: ) + - keyword: FOR + - keyword: ATTACH + - statement_terminator: ; + - go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/create_external_table.yml b/test/fixtures/dialects/tsql/create_external_table.yml index 9f946f83189..68f73d24dcf 100644 --- a/test/fixtures/dialects/tsql/create_external_table.yml +++ b/test/fixtures/dialects/tsql/create_external_table.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 0011b4bff405995cd8650f894336a6ccc8fe336b1989056543054c7b8a7628d2 +_hash: c263819fa6cb975216a75d976000aded350cc54e866945623c2bc99a36d3957e file: batch: - statement: @@ -25,7 +25,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - comma: ',' - column_definition: @@ -36,7 +36,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -49,7 +49,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -110,7 +110,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - comma: ',' - column_definition: @@ -121,7 +121,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -134,7 +134,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -198,7 +198,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '38' + integer_literal: '38' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -212,7 +212,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '38' + integer_literal: '38' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -238,10 +238,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '15' + integer_literal: '15' - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) column_constraint_segment: - keyword: NOT @@ -255,7 +255,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '0' + integer_literal: '0' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -269,7 +269,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '15' + integer_literal: '15' end_bracket: ) - column_constraint_segment: keyword: COLLATE @@ -287,7 +287,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '15' + integer_literal: '15' end_bracket: ) - column_constraint_segment: keyword: COLLATE @@ -305,7 +305,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '38' + integer_literal: '38' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -319,7 +319,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '79' + integer_literal: '79' end_bracket: ) - column_constraint_segment: keyword: COLLATE diff --git a/test/fixtures/dialects/tsql/create_function.yml b/test/fixtures/dialects/tsql/create_function.yml index de119db1162..c7f40845f15 100644 --- a/test/fixtures/dialects/tsql/create_function.yml +++ b/test/fixtures/dialects/tsql/create_function.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 7a1735a4a357946077c4f0899da92e7c31142c471811f180afe87c51e1d3dc10 +_hash: 7d5de0e4d9becaba930116f389423f5ecd48dcee6a43ccd5e13e48d2f4d80edd file: - batch: statement: @@ -43,7 +43,7 @@ file: data_type_identifier: int statement_terminator: ; - statement: - set_segment: + set_local_variable_segment: keyword: SET parameter: '@ISOweek' assignment_operator: @@ -61,7 +61,7 @@ file: parameter: '@DATE' end_bracket: ) - binary_operator: + - - numeric_literal: '1' + - integer_literal: '1' - binary_operator: '-' - function: function_name: @@ -97,13 +97,13 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '4' + integer_literal: '4' end_bracket: ) end_bracket: ) binary_operator: + quoted_literal: "'0104'" end_bracket: ) - statement_terminator: ; + - statement_terminator: ; - statement: if_then_statement: if_clause: @@ -115,10 +115,10 @@ file: parameter: '@ISOweek' comparison_operator: raw_comparison_operator: '=' - numeric_literal: '0' + integer_literal: '0' end_bracket: ) statement: - set_segment: + set_local_variable_segment: keyword: SET parameter: '@ISOweek' assignment_operator: @@ -152,7 +152,7 @@ file: parameter: '@DATE' end_bracket: ) binary_operator: '-' - numeric_literal: '1' + integer_literal: '1' keyword: AS data_type: data_type_identifier: CHAR @@ -160,7 +160,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '4' + integer_literal: '4' end_bracket: ) end_bracket: ) - binary_operator: + @@ -173,7 +173,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '24' + integer_literal: '24' binary_operator: + function: function_name: @@ -193,13 +193,13 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '2' + integer_literal: '2' end_bracket: ) end_bracket: ) end_bracket: ) binary_operator: + - numeric_literal: '1' - statement_terminator: ; + integer_literal: '1' + statement_terminator: ; - statement: if_then_statement: if_clause: @@ -224,7 +224,7 @@ file: end_bracket: ) comparison_operator: raw_comparison_operator: '=' - numeric_literal: '12' + integer_literal: '12' end_bracket: ) - binary_operator: AND - bracketed: @@ -260,18 +260,18 @@ file: comparison_operator: - raw_comparison_operator: '>' - raw_comparison_operator: '=' - numeric_literal: '28' + integer_literal: '28' end_bracket: ) end_bracket: ) statement: - set_segment: + set_local_variable_segment: keyword: SET parameter: '@ISOweek' assignment_operator: raw_comparison_operator: '=' expression: - numeric_literal: '1' - statement_terminator: ; + integer_literal: '1' + statement_terminator: ; - statement: return_segment: keyword: RETURN @@ -284,8 +284,8 @@ file: statement_terminator: ; - keyword: END statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_function_statement: @@ -322,7 +322,7 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' statement_terminator: ; - statement: return_segment: @@ -330,8 +330,8 @@ file: statement_terminator: ; - keyword: END statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_function_statement: @@ -361,11 +361,11 @@ file: return_segment: keyword: RETURN expression: - numeric_literal: '1' + integer_literal: '1' - keyword: END statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_function_statement: @@ -393,11 +393,11 @@ file: return_segment: keyword: RETURN expression: - numeric_literal: '0' + integer_literal: '0' - keyword: END statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_function_statement: @@ -471,7 +471,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '9999' + integer_literal: '9999' end_bracket: ) select_clause_element: column_reference: @@ -498,8 +498,8 @@ file: parameter: '@str' - keyword: END statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_function_statement: @@ -536,5 +536,5 @@ file: expression: parameter: '@my_parameter' - keyword: end -- go_statement: - keyword: go + go_statement: + keyword: go diff --git a/test/fixtures/dialects/tsql/create_partition_function.yml b/test/fixtures/dialects/tsql/create_partition_function.yml index 741534e75ec..ee628358ed4 100644 --- a/test/fixtures/dialects/tsql/create_partition_function.yml +++ b/test/fixtures/dialects/tsql/create_partition_function.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: d0f2bf71cbbadcbcccc4ffd6b5aea72c6b73113033f8150b639bb27aff680a6e +_hash: 11877a598cead9942eb3f3431838f17b69899ea620caf38e95cab93076f1966d file: batch: - statement: @@ -25,11 +25,11 @@ file: - keyword: VALUES - bracketed: - start_bracket: ( - - numeric_literal: '1' + - integer_literal: '1' - comma: ',' - - numeric_literal: '100' + - integer_literal: '100' - comma: ',' - - numeric_literal: '1000' + - integer_literal: '1000' - end_bracket: ) - statement_terminator: ; - statement: @@ -47,7 +47,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '1' + integer_literal: '1' end_bracket: ) end_bracket: ) - keyword: AS @@ -120,7 +120,7 @@ file: - keyword: RANGE - bracketed: start_bracket: ( - numeric_literal: '500' + integer_literal: '500' end_bracket: ) - statement_terminator: ; - statement: diff --git a/test/fixtures/dialects/tsql/create_procedure.yml b/test/fixtures/dialects/tsql/create_procedure.yml index 55d9f3a4e49..072b2903ad2 100644 --- a/test/fixtures/dialects/tsql/create_procedure.yml +++ b/test/fixtures/dialects/tsql/create_procedure.yml @@ -3,772 +3,790 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: b198e5208243b2a9a21749c951b837f04f4f7059012a4402190ea080e07ffb9b +_hash: c7c3995df07a16741818ad7afc051c9674964d12885cb033f569dd745c2be3e7 file: - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROC - - object_reference: - quoted_identifier: '[PROCEDURE_NAME]' - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROC + - object_reference: + quoted_identifier: '[PROCEDURE_NAME]' + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[TEST]' + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: ALTER - - keyword: PROC - - object_reference: - quoted_identifier: '[PROCEDURE_NAME]' - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: ALTER + - keyword: PROC + - object_reference: + quoted_identifier: '[PROCEDURE_NAME]' + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - quoted_identifier: '[PROCEDURE_NAME]' - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + quoted_identifier: '[PROCEDURE_NAME]' + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROC - - object_reference: - quoted_identifier: '[PROCEDURE_NAME]' - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROC + - object_reference: + quoted_identifier: '[PROCEDURE_NAME]' + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - quoted_identifier: '[PROCEDURE_NAME]' - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + quoted_identifier: '[PROCEDURE_NAME]' + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - procedure_parameter_list: - bracketed: - start_bracket: ( - parameter: '@id' - data_type: - data_type_identifier: UNIQUEIDENTIFIER - end_bracket: ) - - keyword: AS - - procedure_statement: - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[TEST]' + - procedure_parameter_list: + bracketed: + start_bracket: ( + parameter: '@id' + data_type: + data_type_identifier: UNIQUEIDENTIFIER + end_bracket: ) + - keyword: AS + - procedure_statement: + statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - procedure_parameter_list: - bracketed: - - start_bracket: ( - - parameter: '@id' - - data_type: - data_type_identifier: UNIQUEIDENTIFIER - - keyword: 'NULL' - - comparison_operator: - raw_comparison_operator: '=' - - expression: - null_literal: 'NULL' - - comma: ',' - - parameter: '@fooReadonly' - - data_type: - data_type_identifier: NVARCHAR - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '42' - end_bracket: ) - - comparison_operator: - raw_comparison_operator: '=' - - expression: - quoted_literal: "N'foo'" - - keyword: READONLY - - comma: ',' - - parameter: '@bar' - - data_type: - data_type_identifier: BIT - keyword: VARYING - - keyword: 'NULL' - - comparison_operator: - raw_comparison_operator: '=' - - expression: - null_literal: 'NULL' - - keyword: OUTPUT - - comma: ',' - - parameter: '@output' - - data_type: - data_type_identifier: TINYINT - - keyword: OUT - - end_bracket: ) - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - set_segment: - keyword: SET - parameter: '@output' - assignment_operator: - raw_comparison_operator: '=' - expression: - bracketed: - start_bracket: ( - expression: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - column_reference: - naked_identifier: tinyint_value - from_clause: - keyword: FROM - from_expression: - from_expression_element: - table_expression: - table_reference: - - naked_identifier: dbo - - dot: . - - naked_identifier: TEST - end_bracket: ) - statement_terminator: ; - - statement: - if_then_statement: - if_clause: - keyword: IF + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[TEST]' + - procedure_parameter_list: + bracketed: + - start_bracket: ( + - parameter: '@id' + - data_type: + data_type_identifier: UNIQUEIDENTIFIER + - keyword: 'NULL' + - comparison_operator: + raw_comparison_operator: '=' + - expression: + null_literal: 'NULL' + - comma: ',' + - parameter: '@fooReadonly' + - data_type: + data_type_identifier: NVARCHAR + bracketed_arguments: + bracketed: + start_bracket: ( expression: - parameter: '@id' - keyword: IS - null_literal: 'NULL' - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - - keyword: SELECT - - select_clause_element: - parameter: '@bar' - - comma: ',' - - select_clause_element: - parameter: '@fooReadonly' - statement_terminator: ; - - keyword: END - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO -- batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - procedure_parameter_list: - bracketed: - - start_bracket: ( - - parameter: '@id' - - data_type: - data_type_identifier: UNIQUEIDENTIFIER - - keyword: 'NULL' - - comparison_operator: - raw_comparison_operator: '=' - - expression: - null_literal: 'NULL' - - comma: ',' - - parameter: '@bar' - - data_type: - data_type_identifier: NVARCHAR - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '32' - end_bracket: ) - - keyword: 'NULL' - - comparison_operator: - raw_comparison_operator: '=' - - expression: - null_literal: 'NULL' - - end_bracket: ) - - keyword: WITH - - keyword: ENCRYPTION - - comma: ',' - - keyword: RECOMPILE - - comma: ',' - - execute_as_clause: - - keyword: EXECUTE + integer_literal: '42' + end_bracket: ) + - comparison_operator: + raw_comparison_operator: '=' + - expression: + quoted_literal: "N'foo'" + - keyword: READONLY + - comma: ',' + - parameter: '@bar' + - data_type: + data_type_identifier: BIT + keyword: VARYING + - keyword: 'NULL' + - comparison_operator: + raw_comparison_operator: '=' + - expression: + null_literal: 'NULL' + - keyword: OUTPUT + - comma: ',' + - parameter: '@output' + - data_type: + data_type_identifier: TINYINT + - keyword: OUT + - end_bracket: ) - keyword: AS - - quoted_literal: "'sa'" - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@output' + assignment_operator: + raw_comparison_operator: '=' + expression: + bracketed: + start_bracket: ( + expression: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: tinyint_value + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: dbo + - dot: . + - naked_identifier: TEST + end_bracket: ) + - statement_terminator: ; + - statement: + if_then_statement: + if_clause: + keyword: IF + expression: + parameter: '@id' + keyword: IS + null_literal: 'NULL' + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + parameter: '@bar' + - comma: ',' + - select_clause_element: + parameter: '@fooReadonly' + statement_terminator: ; + - keyword: END + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - procedure_parameter_list: - bracketed: - - start_bracket: ( - - parameter: '@id' - - data_type: - data_type_identifier: UNIQUEIDENTIFIER - - keyword: 'NULL' - - comparison_operator: - raw_comparison_operator: '=' - - expression: - null_literal: 'NULL' - - comma: ',' - - parameter: '@bar' - - data_type: - data_type_identifier: NVARCHAR - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '32' - end_bracket: ) - - keyword: 'NULL' - - comparison_operator: - raw_comparison_operator: '=' - - expression: - null_literal: 'NULL' - - end_bracket: ) - - keyword: WITH - - keyword: ENCRYPTION - - comma: ',' - - keyword: RECOMPILE - - comma: ',' - - execute_as_clause: - - keyword: EXECUTE + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[TEST]' + - procedure_parameter_list: + bracketed: + - start_bracket: ( + - parameter: '@id' + - data_type: + data_type_identifier: UNIQUEIDENTIFIER + - keyword: 'NULL' + - comparison_operator: + raw_comparison_operator: '=' + - expression: + null_literal: 'NULL' + - comma: ',' + - parameter: '@bar' + - data_type: + data_type_identifier: NVARCHAR + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '32' + end_bracket: ) + - keyword: 'NULL' + - comparison_operator: + raw_comparison_operator: '=' + - expression: + null_literal: 'NULL' + - end_bracket: ) + - keyword: WITH + - keyword: ENCRYPTION + - comma: ',' + - keyword: RECOMPILE + - comma: ',' + - execute_as_clause: + - keyword: EXECUTE + - keyword: AS + - quoted_literal: "'sa'" - keyword: AS - - quoted_literal: "'sa'" - - keyword: FOR - - keyword: REPLICATION - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - - keyword: SELECT - - select_clause_element: - parameter: '@id' - - comma: ',' - - select_clause_element: - parameter: '@bar' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - procedure_parameter_list: - bracketed: - - start_bracket: ( - - parameter: '@id' - - data_type: - data_type_identifier: INT - - keyword: NOT - - keyword: 'NULL' - - end_bracket: ) - - keyword: WITH - - keyword: NATIVE_COMPILATION - - comma: ',' - - keyword: SCHEMABINDING - - comma: ',' - - execute_as_clause: - - keyword: EXECUTE + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[TEST]' + - procedure_parameter_list: + bracketed: + - start_bracket: ( + - parameter: '@id' + - data_type: + data_type_identifier: UNIQUEIDENTIFIER + - keyword: 'NULL' + - comparison_operator: + raw_comparison_operator: '=' + - expression: + null_literal: 'NULL' + - comma: ',' + - parameter: '@bar' + - data_type: + data_type_identifier: NVARCHAR + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '32' + end_bracket: ) + - keyword: 'NULL' + - comparison_operator: + raw_comparison_operator: '=' + - expression: + null_literal: 'NULL' + - end_bracket: ) + - keyword: WITH + - keyword: ENCRYPTION + - comma: ',' + - keyword: RECOMPILE + - comma: ',' + - execute_as_clause: + - keyword: EXECUTE + - keyword: AS + - quoted_literal: "'sa'" + - keyword: FOR + - keyword: REPLICATION - keyword: AS - - keyword: OWNER - - keyword: AS - - procedure_statement: - statement: - atomic_begin_end_block: - - keyword: BEGIN - - keyword: ATOMIC - - keyword: WITH - - bracketed: - - start_bracket: ( - - keyword: LANGUAGE - - comparison_operator: - raw_comparison_operator: '=' - - quoted_literal: "N'us_english'" - - comma: ',' - - keyword: TRANSACTION - - keyword: ISOLATION - - keyword: LEVEL - - comparison_operator: - raw_comparison_operator: '=' - - keyword: SERIALIZABLE - - comma: ',' - - keyword: DATEFIRST - - comparison_operator: - raw_comparison_operator: '=' - - numeric_literal: '10' - - comma: ',' - - keyword: DATEFORMAT - - comparison_operator: - raw_comparison_operator: '=' - - date_format: dym - - comma: ',' - - keyword: DELAYED_DURABILITY - - comparison_operator: - raw_comparison_operator: '=' - - keyword: 'ON' - - end_bracket: ) - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + parameter: '@id' + - comma: ',' + - select_clause_element: + parameter: '@bar' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - procedure_parameter_list: - bracketed: - - start_bracket: ( - - parameter: '@id' - - data_type: - data_type_identifier: INT - - keyword: NOT - - keyword: 'NULL' - - end_bracket: ) - - keyword: WITH - - keyword: NATIVE_COMPILATION - - comma: ',' - - keyword: SCHEMABINDING - - comma: ',' - - execute_as_clause: - - keyword: EXECUTE + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[TEST]' + - procedure_parameter_list: + bracketed: + - start_bracket: ( + - parameter: '@id' + - data_type: + data_type_identifier: INT + - keyword: NOT + - keyword: 'NULL' + - end_bracket: ) + - keyword: WITH + - keyword: NATIVE_COMPILATION + - comma: ',' + - keyword: SCHEMABINDING + - comma: ',' + - execute_as_clause: + - keyword: EXECUTE + - keyword: AS + - keyword: OWNER - keyword: AS - - keyword: OWNER - - keyword: AS - - procedure_statement: - statement: - atomic_begin_end_block: - - keyword: BEGIN - - keyword: ATOMIC - - keyword: WITH - - bracketed: - - start_bracket: ( - - keyword: TRANSACTION - - keyword: ISOLATION - - keyword: LEVEL - - comparison_operator: - raw_comparison_operator: '=' - - keyword: SNAPSHOT - - comma: ',' - - keyword: LANGUAGE - - comparison_operator: - raw_comparison_operator: '=' - - quoted_literal: "'us_english'" - - end_bracket: ) - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + - procedure_statement: + statement: + atomic_begin_end_block: + - keyword: BEGIN + - keyword: ATOMIC + - keyword: WITH + - bracketed: + - start_bracket: ( + - keyword: LANGUAGE + - comparison_operator: + raw_comparison_operator: '=' + - quoted_literal: "N'us_english'" + - comma: ',' + - keyword: TRANSACTION + - keyword: ISOLATION + - keyword: LEVEL + - comparison_operator: + raw_comparison_operator: '=' + - keyword: SERIALIZABLE + - comma: ',' + - keyword: DATEFIRST + - comparison_operator: + raw_comparison_operator: '=' + - numeric_literal: '10' + - comma: ',' + - keyword: DATEFORMAT + - comparison_operator: + raw_comparison_operator: '=' + - date_format: dym + - comma: ',' + - keyword: DELAYED_DURABILITY + - comparison_operator: + raw_comparison_operator: '=' + - keyword: 'ON' + - end_bracket: ) + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - procedure_parameter_list: - bracketed: - - start_bracket: ( - - parameter: '@id' - - data_type: - data_type_identifier: INT - - keyword: NOT - - keyword: 'NULL' - - end_bracket: ) - - keyword: WITH - - keyword: NATIVE_COMPILATION - - comma: ',' - - keyword: SCHEMABINDING - - comma: ',' - - execute_as_clause: - - keyword: EXECUTE + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[TEST]' + - procedure_parameter_list: + bracketed: + - start_bracket: ( + - parameter: '@id' + - data_type: + data_type_identifier: INT + - keyword: NOT + - keyword: 'NULL' + - end_bracket: ) + - keyword: WITH + - keyword: NATIVE_COMPILATION + - comma: ',' + - keyword: SCHEMABINDING + - comma: ',' + - execute_as_clause: + - keyword: EXECUTE + - keyword: AS + - keyword: OWNER - keyword: AS - - keyword: OWNER - - keyword: AS - - procedure_statement: - statement: - atomic_begin_end_block: - - keyword: BEGIN - - keyword: ATOMIC - - keyword: WITH - - bracketed: - - start_bracket: ( - - keyword: TRANSACTION - - keyword: ISOLATION - - keyword: LEVEL - - comparison_operator: - raw_comparison_operator: '=' - - keyword: REPEATABLE - - keyword: READ - - comma: ',' - - keyword: LANGUAGE - - comparison_operator: - raw_comparison_operator: '=' - - quoted_literal: "N'us_english'" - - comma: ',' - - keyword: DELAYED_DURABILITY - - comparison_operator: - raw_comparison_operator: '=' - - keyword: 'OFF' - - comma: ',' - - keyword: DATEFORMAT - - comparison_operator: - raw_comparison_operator: '=' - - date_format: myd - - end_bracket: ) - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + - procedure_statement: + statement: + atomic_begin_end_block: + - keyword: BEGIN + - keyword: ATOMIC + - keyword: WITH + - bracketed: + - start_bracket: ( + - keyword: TRANSACTION + - keyword: ISOLATION + - keyword: LEVEL + - comparison_operator: + raw_comparison_operator: '=' + - keyword: SNAPSHOT + - comma: ',' + - keyword: LANGUAGE + - comparison_operator: + raw_comparison_operator: '=' + - quoted_literal: "'us_english'" + - end_bracket: ) + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - keyword: AS - - procedure_statement: - - keyword: EXTERNAL - - keyword: NAME + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE - object_reference: - quoted_identifier: '[dbo]' - dot: . - - quoted_identifier: '[class_name]' - - dot: . - - quoted_identifier: '[static_method]' -- statement_terminator: ; -- go_statement: - keyword: GO + - quoted_identifier: '[TEST]' + - procedure_parameter_list: + bracketed: + - start_bracket: ( + - parameter: '@id' + - data_type: + data_type_identifier: INT + - keyword: NOT + - keyword: 'NULL' + - end_bracket: ) + - keyword: WITH + - keyword: NATIVE_COMPILATION + - comma: ',' + - keyword: SCHEMABINDING + - comma: ',' + - execute_as_clause: + - keyword: EXECUTE + - keyword: AS + - keyword: OWNER + - keyword: AS + - procedure_statement: + statement: + atomic_begin_end_block: + - keyword: BEGIN + - keyword: ATOMIC + - keyword: WITH + - bracketed: + - start_bracket: ( + - keyword: TRANSACTION + - keyword: ISOLATION + - keyword: LEVEL + - comparison_operator: + raw_comparison_operator: '=' + - keyword: REPEATABLE + - keyword: READ + - comma: ',' + - keyword: LANGUAGE + - comparison_operator: + raw_comparison_operator: '=' + - quoted_literal: "N'us_english'" + - comma: ',' + - keyword: DELAYED_DURABILITY + - comparison_operator: + raw_comparison_operator: '=' + - keyword: 'OFF' + - comma: ',' + - keyword: DATEFORMAT + - comparison_operator: + raw_comparison_operator: '=' + - date_format: myd + - end_bracket: ) + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - statement_terminator: ; - - numeric_literal: '1064' - - keyword: AS - - procedure_statement: - - keyword: EXTERNAL - - keyword: NAME + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE - object_reference: - quoted_identifier: '[dbo]' - dot: . - - quoted_identifier: '[class_name]' + - quoted_identifier: '[TEST]' + - keyword: AS + - procedure_statement: + - keyword: EXTERNAL + - keyword: NAME + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[class_name]' + - dot: . + - quoted_identifier: '[static_method]' + statement_terminator: ; + go_statement: + keyword: GO +- batch: + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' - dot: . - - quoted_identifier: '[static_method]' -- statement_terminator: ; -- go_statement: - keyword: GO + - quoted_identifier: '[TEST]' + - statement_terminator: ; + - numeric_literal: '1064' + - keyword: AS + - procedure_statement: + - keyword: EXTERNAL + - keyword: NAME + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[class_name]' + - dot: . + - quoted_identifier: '[static_method]' + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[TEST]' - - procedure_parameter_list: - bracketed: - - start_bracket: ( - - parameter: '@id' - - data_type: - data_type_identifier: UNIQUEIDENTIFIER - - comparison_operator: - raw_comparison_operator: '=' - - expression: - function: - function_name: - function_name_identifier: NEWID - function_contents: + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[TEST]' + - procedure_parameter_list: + bracketed: + - start_bracket: ( + - parameter: '@id' + - data_type: + data_type_identifier: UNIQUEIDENTIFIER + - comparison_operator: + raw_comparison_operator: '=' + - expression: + function: + function_name: + function_name_identifier: NEWID + function_contents: + bracketed: + start_bracket: ( + end_bracket: ) + - comma: ',' + - parameter: '@output' + - data_type: + data_type_identifier: NVARCHAR + bracketed_arguments: bracketed: start_bracket: ( + expression: + integer_literal: '32' end_bracket: ) - - comma: ',' - - parameter: '@output' - - data_type: - data_type_identifier: NVARCHAR - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '32' - end_bracket: ) - - keyword: OUTPUT - - comma: ',' - - parameter: '@activated' - - data_type: - data_type_identifier: BIT - - keyword: OUT - - keyword: READONLY - - end_bracket: ) - - keyword: WITH - - execute_as_clause: - - keyword: EXECUTE + - keyword: OUTPUT + - comma: ',' + - parameter: '@activated' + - data_type: + data_type_identifier: BIT + - keyword: OUT + - keyword: READONLY + - end_bracket: ) + - keyword: WITH + - execute_as_clause: + - keyword: EXECUTE + - keyword: AS + - quoted_literal: "'sa'" - keyword: AS - - quoted_literal: "'sa'" - - keyword: AS - - procedure_statement: - - keyword: EXTERNAL - - keyword: NAME + - procedure_statement: + - keyword: EXTERNAL + - keyword: NAME + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[class_name]' + - dot: . + - quoted_identifier: '[static_method]' + statement_terminator: ; + go_statement: + keyword: GO +- batch: + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[class_name]' + - naked_identifier: dbo - dot: . - - quoted_identifier: '[static_method]' -- statement_terminator: ; -- go_statement: - keyword: GO -- batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - naked_identifier: dbo - - dot: . - - naked_identifier: DoSomething - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - set_segment: - - keyword: SET - - keyword: NOCOUNT - - keyword: 'ON' - - statement_terminator: ; - - statement: - set_segment: - - keyword: SET - - keyword: XACT_ABORT - - keyword: 'ON' - - statement_terminator: ; - - keyword: END -- go_statement: - keyword: GO + - naked_identifier: DoSomething + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + set_segment: + - keyword: SET + - keyword: NOCOUNT + - keyword: 'ON' + - statement_terminator: ; + - statement: + set_segment: + - keyword: SET + - keyword: XACT_ABORT + - keyword: 'ON' + - statement_terminator: ; + - keyword: END + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - naked_identifier: dbo - - dot: . - - naked_identifier: DoSomething - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - set_segment: - - keyword: SET - - keyword: NOCOUNT - - comma: ',' - - keyword: XACT_ABORT - - keyword: 'ON' - - statement_terminator: ; - - keyword: END -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + - naked_identifier: dbo + - dot: . + - naked_identifier: DoSomething + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + set_segment: + - keyword: SET + - keyword: NOCOUNT + - comma: ',' + - keyword: XACT_ABORT + - keyword: 'ON' + - statement_terminator: ; + - keyword: END + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/create_schema.yml b/test/fixtures/dialects/tsql/create_schema.yml index b9cbb6d653a..8dba5e0aaee 100644 --- a/test/fixtures/dialects/tsql/create_schema.yml +++ b/test/fixtures/dialects/tsql/create_schema.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: c308748e09e74b7c6c4e3a3cdbf45e63a4a756b19637c7fc16cf053dabb11c88 +_hash: aa88b774d251afb10bff49bd8ba6f74a9e5a57e4679cdfa4a11ed9262015f113 file: - batch: statement: @@ -12,8 +12,8 @@ file: - keyword: SCHEMA - schema_reference: quoted_identifier: '[Reporting]' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_schema_statement: @@ -25,5 +25,5 @@ file: - role_reference: quoted_identifier: '[dbo]' - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/create_security_policy.yml b/test/fixtures/dialects/tsql/create_security_policy.yml index 64b86987431..ce27a3aa70c 100644 --- a/test/fixtures/dialects/tsql/create_security_policy.yml +++ b/test/fixtures/dialects/tsql/create_security_policy.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: f9f30712fc6f77236180561f9d6bc365f45cb03949696416abebf223228a0da1 +_hash: f9759b36ec5a36dcf7d9a5a072e6af8d1547b56ba387f1cea8bb11eda9d90ced file: batch: - statement: @@ -235,7 +235,7 @@ file: naked_identifier: column2 comma: ',' expression: - numeric_literal: '1' + integer_literal: '1' end_bracket: ) - keyword: 'ON' - object_reference: diff --git a/test/fixtures/dialects/tsql/create_table.yml b/test/fixtures/dialects/tsql/create_table.yml index 965ff3a503f..ac4b8bfa43c 100644 --- a/test/fixtures/dialects/tsql/create_table.yml +++ b/test/fixtures/dialects/tsql/create_table.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 5da583c0e5899600af6cd8bd9abd5e14a54d6374cf5f53cdf7b03802e8c554ca +_hash: d19ff97c6f85b263467e76df08d9f755ccfe379bce5d231363467de24e1e74d6 file: batch: - statement: @@ -24,7 +24,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -35,7 +35,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -46,10 +46,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - statement: @@ -137,7 +137,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '0' + integer_literal: '0' end_bracket: ) - comma: ',' - column_definition: diff --git a/test/fixtures/dialects/tsql/create_table_constraints.yml b/test/fixtures/dialects/tsql/create_table_constraints.yml index 4294fbd673b..84d59699633 100644 --- a/test/fixtures/dialects/tsql/create_table_constraints.yml +++ b/test/fixtures/dialects/tsql/create_table_constraints.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 698fc3e052539d86352bbfca199a76a7809282b7a4834e12b7671cbfc94b00e7 +_hash: e64b9c172b854bed107cf62fa618aaec906090bbb1a71056a452d69683251cec file: - batch: statement: @@ -49,7 +49,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: DEFAULT @@ -77,7 +77,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '30' + integer_literal: '30' end_bracket: ) column_constraint_segment: keyword: DEFAULT @@ -144,8 +144,8 @@ file: - column_constraint_segment: keyword: 'NULL' - end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -174,8 +174,8 @@ file: keyword: ASC end_bracket: ) end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -207,8 +207,8 @@ file: keyword: DESC end_bracket: ) end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -228,7 +228,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - column_constraint_segment: keyword: FILESTREAM @@ -251,7 +251,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - column_constraint_segment: keyword: 'NULL' @@ -268,10 +268,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) column_constraint_segment: - keyword: GENERATED @@ -289,7 +289,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: encrypted_with_grammar: @@ -321,15 +321,15 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: collate collation_reference: naked_identifier: Latin1_General_BIN - end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: diff --git a/test/fixtures/dialects/tsql/create_table_graph.yml b/test/fixtures/dialects/tsql/create_table_graph.yml index 8b3b2f39521..37620f722d8 100644 --- a/test/fixtures/dialects/tsql/create_table_graph.yml +++ b/test/fixtures/dialects/tsql/create_table_graph.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: eec36e50396bb61abe0713b0338d60f4c17688597f014d5ea215db882d52c97d +_hash: 2095f14e269aad79e7f0a72e201c36eacf20e935ad462f7bc8dd0a1ca69df9f4 file: batch: - statement: @@ -32,7 +32,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - end_bracket: ) - keyword: AS diff --git a/test/fixtures/dialects/tsql/create_table_on_filegroup.yml b/test/fixtures/dialects/tsql/create_table_on_filegroup.yml index 67593a8e39a..29f9416bfcf 100644 --- a/test/fixtures/dialects/tsql/create_table_on_filegroup.yml +++ b/test/fixtures/dialects/tsql/create_table_on_filegroup.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: e98064d324c4b081392469410dbfab5dddbc12b258a107db6cd00d212abb8f2e +_hash: 35f9ccb757859a6f42cdd35e2f1bb7e267bb228a9885047903d0cd2fb3063ec6 file: batch: statement: @@ -24,7 +24,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -35,7 +35,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -46,10 +46,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - on_partition_or_filegroup_statement: diff --git a/test/fixtures/dialects/tsql/create_table_with_distribution.yml b/test/fixtures/dialects/tsql/create_table_with_distribution.yml index da5aa09cb17..2fe0330e94f 100644 --- a/test/fixtures/dialects/tsql/create_table_with_distribution.yml +++ b/test/fixtures/dialects/tsql/create_table_with_distribution.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 2b5704dab85931563d9a29f1d454c0ee1fbb3a2278481306089d4be3505ddc96 +_hash: a58aaa74fa016934f74518e90e45149957d9085e84d4ad7b316468b03e493539 file: - batch: statement: @@ -24,7 +24,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -35,7 +35,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -46,10 +46,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_distribution_index_clause: @@ -68,8 +68,8 @@ file: - keyword: ROUND_ROBIN end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_table_statement: @@ -79,8 +79,8 @@ file: - quoted_identifier: '[dbo]' - dot: . - quoted_identifier: '[EC DC]' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -100,7 +100,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -111,7 +111,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -122,10 +122,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_distribution_index_clause: @@ -142,8 +142,8 @@ file: - keyword: REPLICATE end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_table_statement: @@ -153,8 +153,8 @@ file: - quoted_identifier: '[dbo]' - dot: . - quoted_identifier: '[EC DC]' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -174,7 +174,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -185,7 +185,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -196,10 +196,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_distribution_index_clause: @@ -224,8 +224,8 @@ file: end_bracket: ) end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_table_statement: @@ -235,8 +235,8 @@ file: - quoted_identifier: '[dbo]' - dot: . - quoted_identifier: '[EC DC]' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -256,7 +256,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -267,7 +267,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -278,10 +278,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_distribution_index_clause: @@ -311,8 +311,8 @@ file: end_bracket: ) - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_table_statement: @@ -322,8 +322,8 @@ file: - quoted_identifier: '[dbo]' - dot: . - quoted_identifier: '[EC DC]' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -343,7 +343,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -354,7 +354,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -365,10 +365,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_distribution_index_clause: @@ -396,8 +396,8 @@ file: end_bracket: ) end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_table_statement: @@ -408,8 +408,8 @@ file: - dot: . - quoted_identifier: '[EC DC]' - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -429,7 +429,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -440,7 +440,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -451,10 +451,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_distribution_index_clause: @@ -484,8 +484,8 @@ file: end_bracket: ) end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_table_statement: @@ -496,8 +496,8 @@ file: - dot: . - quoted_identifier: '[EC DC]' - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -517,7 +517,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -554,5 +554,5 @@ file: - keyword: ASC - end_bracket: ) end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/create_table_with_sequence_bracketed.yml b/test/fixtures/dialects/tsql/create_table_with_sequence_bracketed.yml index a840bb023bd..81a92f5d032 100644 --- a/test/fixtures/dialects/tsql/create_table_with_sequence_bracketed.yml +++ b/test/fixtures/dialects/tsql/create_table_with_sequence_bracketed.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: d2ba1222dc34facb043345ddade735eaea43fc02bd63840d53eb3c4cbb4571ae +_hash: 967f8c317908ef73776942485e5d996bc02de9ba944ceff6cc831f277ee7cade file: - batch: statement: @@ -69,8 +69,8 @@ file: - keyword: BY - numeric_literal: '1' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: create_table_statement: @@ -119,7 +119,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -130,10 +130,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '16' + integer_literal: '16' - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -237,8 +237,8 @@ file: - keyword: BY - numeric_literal: '1' statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -283,7 +283,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -296,7 +296,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -309,7 +309,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -322,7 +322,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -335,7 +335,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -348,7 +348,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -361,7 +361,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -374,7 +374,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -387,7 +387,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -400,7 +400,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -413,7 +413,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -426,7 +426,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -446,8 +446,8 @@ file: end_bracket: ) - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_index_statement: @@ -467,8 +467,8 @@ file: index_column_definition: naked_identifier: DATE_LAST_INSERTED end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: create_index_statement: @@ -581,10 +581,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '16' + integer_literal: '16' - comma: ',' - expression: - numeric_literal: '1' + integer_literal: '1' - end_bracket: ) column_constraint_segment: keyword: 'NULL' @@ -633,10 +633,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '16' + integer_literal: '16' - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) - comma: ',' - column_definition: @@ -647,10 +647,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '16' + integer_literal: '16' - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) - comma: ',' - column_definition: @@ -661,10 +661,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '16' + integer_literal: '16' - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) - end_bracket: ) - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/create_table_with_trailing_comma.yml b/test/fixtures/dialects/tsql/create_table_with_trailing_comma.yml index 79f0f8db8b5..e4d0fb73492 100644 --- a/test/fixtures/dialects/tsql/create_table_with_trailing_comma.yml +++ b/test/fixtures/dialects/tsql/create_table_with_trailing_comma.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 1741f41c3ad5d4387b08448fc575cf531f48835b024826f368d22069ecf693d9 +_hash: d85b85f6dc0b3a8a3495aba3ad3780dc94579f001d35c4c469a6f32b0d371fd7 file: batch: statement: @@ -24,7 +24,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) comma: ',' end_bracket: ) diff --git a/test/fixtures/dialects/tsql/create_type.yml b/test/fixtures/dialects/tsql/create_type.yml index 8fd384af034..b386a598d51 100644 --- a/test/fixtures/dialects/tsql/create_type.yml +++ b/test/fixtures/dialects/tsql/create_type.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 1873d9ddf12a690dee729b24d8f6678ce9686f646e8321db57a10d32d349aadb +_hash: cddf5b8246647f2266c2c04b364b90ef6bf6eec3fff2d1b971e28c3543309234 file: batch: - statement: @@ -24,7 +24,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '10' + integer_literal: '10' end_bracket: ) - comma: ',' - column_definition: diff --git a/test/fixtures/dialects/tsql/create_view.yml b/test/fixtures/dialects/tsql/create_view.yml index 6a64f6a9147..30dbc5a83f1 100644 --- a/test/fixtures/dialects/tsql/create_view.yml +++ b/test/fixtures/dialects/tsql/create_view.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 48977d26c7882b0c980d91d20a2bb803892e87ddf2bcd0b2e78dd5d73c69fee3 +_hash: 49f77834a7e7a55591bede19e32cf1e49a67c62ccdce80e1827f2afa30d52aad file: batch: - statement: @@ -25,7 +25,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - select_clause_element: column_reference: @@ -101,7 +101,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - select_clause_element: column_reference: @@ -218,7 +218,7 @@ file: naked_identifier: ReceivedQty - comparison_operator: raw_comparison_operator: '>' - - numeric_literal: '0' + - integer_literal: '0' - binary_operator: AND - column_reference: naked_identifier: DueDate diff --git a/test/fixtures/dialects/tsql/create_view_with_cte.yml b/test/fixtures/dialects/tsql/create_view_with_cte.yml index aadab44dab7..57520da58a2 100644 --- a/test/fixtures/dialects/tsql/create_view_with_cte.yml +++ b/test/fixtures/dialects/tsql/create_view_with_cte.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 51599c477f3a608ab3b9d7d7bc3ba93834953c0a11ae4d82dbbc141f422c3793 +_hash: 0aadbd5ae416aa3d70081c386ae39077e732bb10ae832ce5b3d5149cb6a155f4 file: batch: statement: @@ -139,5 +139,5 @@ file: table_expression: table_reference: naked_identifier: cte - go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/create_view_with_set_statements.yml b/test/fixtures/dialects/tsql/create_view_with_set_statements.yml index 3d9139377ef..d1a4383a6ca 100644 --- a/test/fixtures/dialects/tsql/create_view_with_set_statements.yml +++ b/test/fixtures/dialects/tsql/create_view_with_set_statements.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: b6b6764cc3073636b3fd1cc45be9aae79045f732e7cf74c2d0590c663ece8748 +_hash: e69a431caa7eb761584484a6faae8dda8ae1eee47a240651b7c90704a6876ead file: - batch: statement: @@ -11,16 +11,16 @@ file: - keyword: SET - keyword: ANSI_NULLS - keyword: 'ON' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: set_segment: - keyword: SET - keyword: QUOTED_IDENTIFIER - keyword: 'ON' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_view_statement: @@ -37,7 +37,7 @@ file: select_clause_modifier: keyword: TOP expression: - numeric_literal: '1' + integer_literal: '1' select_clause_element: column_reference: naked_identifier: DATE_OF_REPORT @@ -49,8 +49,8 @@ file: table_reference: naked_identifier: BASE_CTE statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_view_statement: @@ -69,7 +69,7 @@ file: select_clause_modifier: keyword: TOP expression: - numeric_literal: '1' + integer_literal: '1' select_clause_element: column_reference: naked_identifier: DATE_OF_REPORT @@ -86,8 +86,8 @@ file: - column_reference: naked_identifier: DATE_OF_REPORT statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_view_statement: @@ -140,7 +140,7 @@ file: null_literal: 'NULL' - keyword: THEN - expression: - numeric_literal: '0' + integer_literal: '0' - else_clause: keyword: ELSE expression: @@ -165,7 +165,7 @@ file: null_literal: 'NULL' - keyword: THEN - expression: - numeric_literal: '0' + integer_literal: '0' - else_clause: keyword: ELSE expression: @@ -217,5 +217,5 @@ file: - column_reference: naked_identifier: LAST_DATE_OF_REPORT statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/cursor.sql b/test/fixtures/dialects/tsql/cursor.sql index c48f585a623..9ad565722c2 100644 --- a/test/fixtures/dialects/tsql/cursor.sql +++ b/test/fixtures/dialects/tsql/cursor.sql @@ -1,11 +1,18 @@ DECLARE pointy CURSOR LOCAL FORWARD_ONLY READ_ONLY FOR -SELECT column_a, column_b FROM some_table WHERE column_a IS NOT NULL ORDER BY column_b +SELECT + column_a, + column_b +FROM some_table +WHERE column_a IS NOT NULL +ORDER BY column_b OPEN pointy; -FETCH FIRST FROM @pointy into @result; +FETCH FIRST FROM @pointy INTO @result; FETCH NEXT FROM GLOBAL pointy; CLOSE GLOBAL pointy; DEALLOCATE pointy; + +DECLARE @cursorName CURSOR; diff --git a/test/fixtures/dialects/tsql/cursor.yml b/test/fixtures/dialects/tsql/cursor.yml index d86c129b730..0f507aa813e 100644 --- a/test/fixtures/dialects/tsql/cursor.yml +++ b/test/fixtures/dialects/tsql/cursor.yml @@ -3,48 +3,49 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: fa41197cd43f3e5dafdf93790658245f09fe3af641711997f525e23cf60b8b00 +_hash: ff024fdcaabd2eec2fda1e6730047c019e2718daa5f305da9f0da9a0be38fd1e file: batch: - statement: declare_segment: - - keyword: DECLARE - - naked_identifier: pointy - - keyword: CURSOR - - keyword: LOCAL - - keyword: FORWARD_ONLY - - keyword: READ_ONLY - - keyword: FOR - - select_statement: - select_clause: - - keyword: SELECT - - select_clause_element: - column_reference: - naked_identifier: column_a - - comma: ',' - - select_clause_element: - column_reference: - naked_identifier: column_b - from_clause: - keyword: FROM - from_expression: - from_expression_element: - table_expression: - table_reference: - naked_identifier: some_table - where_clause: - keyword: WHERE - expression: + keyword: DECLARE + naked_identifier: pointy + cursor_definition: + - keyword: CURSOR + - keyword: LOCAL + - keyword: FORWARD_ONLY + - keyword: READ_ONLY + - keyword: FOR + - select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + naked_identifier: column_a + - comma: ',' + - select_clause_element: + column_reference: + naked_identifier: column_b + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: some_table + where_clause: + keyword: WHERE + expression: + - column_reference: + naked_identifier: column_a + - keyword: IS + - keyword: NOT + - null_literal: 'NULL' + orderby_clause: + - keyword: ORDER + - keyword: BY - column_reference: - naked_identifier: column_a - - keyword: IS - - keyword: NOT - - null_literal: 'NULL' - orderby_clause: - - keyword: ORDER - - keyword: BY - - column_reference: - naked_identifier: column_b + naked_identifier: column_b - statement: open_cursor_statement: keyword: OPEN @@ -56,7 +57,7 @@ file: - keyword: FIRST - keyword: FROM - parameter: '@pointy' - - keyword: into + - keyword: INTO - parameter: '@result' - statement_terminator: ; - statement: @@ -78,3 +79,9 @@ file: keyword: DEALLOCATE naked_identifier: pointy - statement_terminator: ; + - statement: + declare_segment: + - keyword: DECLARE + - parameter: '@cursorName' + - keyword: CURSOR + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/date_functions.yml b/test/fixtures/dialects/tsql/date_functions.yml index 541f5c2edf9..ffa751c7361 100644 --- a/test/fixtures/dialects/tsql/date_functions.yml +++ b/test/fixtures/dialects/tsql/date_functions.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 6ccdd4fc819582a748c5513e359b50dc00c38f2478fb31ebf838e4b491e1c8d1 +_hash: 6ad333d1c2ec7a41ff35dc2c1320ccb47bc566cdc8935fe2bbd36aafc92ea349 file: batch: statement: @@ -39,7 +39,7 @@ file: - date_part: month - comma: ',' - expression: - numeric_literal: '0' + integer_literal: '0' - comma: ',' - expression: column_reference: @@ -49,7 +49,7 @@ file: - end_bracket: ) - comma: ',' - expression: - numeric_literal: '0' + integer_literal: '0' - end_bracket: ) end_bracket: ) alias_expression: @@ -105,7 +105,7 @@ file: - date_part: yy - comma: ',' - expression: - numeric_literal: '0' + integer_literal: '0' - comma: ',' - expression: function: @@ -117,9 +117,9 @@ file: end_bracket: ) - end_bracket: ) binary_operator: '-' - numeric_literal: '1' + integer_literal: '1' - comma: ',' - expression: - numeric_literal: '0' + integer_literal: '0' - end_bracket: ) end_bracket: ) diff --git a/test/fixtures/dialects/tsql/declare_with_following_statements.yml b/test/fixtures/dialects/tsql/declare_with_following_statements.yml index 5d12e9bfef0..b156c8bb3f0 100644 --- a/test/fixtures/dialects/tsql/declare_with_following_statements.yml +++ b/test/fixtures/dialects/tsql/declare_with_following_statements.yml @@ -3,159 +3,160 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 60f66371567e448c02d8ea3039d4cf4fd9ab619c766fc64c6d8369bf750cb94d +_hash: b38b8436fb6e83416b265978f28ba7795341b9d69d04287a55c8ef4c6f890501 file: batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROC - - object_reference: - - naked_identifier: Reporting - - dot: . - - naked_identifier: DeclareProblem - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - declare_segment: - - keyword: DECLARE - - parameter: '@startdate' - - keyword: AS - - data_type: - data_type_identifier: DATE - - statement_terminator: ; - - statement: - declare_segment: - keyword: DECLARE - parameter: '@DateNow' - data_type: - data_type_identifier: DATE - comparison_operator: - raw_comparison_operator: '=' - expression: - function: - function_name: - function_name_identifier: GETDATE - function_contents: - bracketed: - start_bracket: ( - end_bracket: ) - statement_terminator: ; - - statement: - declare_segment: - - keyword: DECLARE - - parameter: '@DateStart' - - data_type: - data_type_identifier: DATETIME2 - - comparison_operator: - raw_comparison_operator: '=' - - expression: - function: - function_name: - function_name_identifier: GETDATE - function_contents: - bracketed: - start_bracket: ( - end_bracket: ) - - comma: ',' - - parameter: '@DateEnd' - - data_type: - data_type_identifier: DATETIME2 - - comparison_operator: - raw_comparison_operator: '=' - - expression: - function: - function_name: - function_name_identifier: GETDATE - function_contents: - bracketed: - start_bracket: ( - end_bracket: ) - - statement: - declare_segment: - keyword: DECLARE - parameter: '@EOMONTH' - data_type: - data_type_identifier: DATE - comparison_operator: - raw_comparison_operator: '=' - expression: - bracketed: - start_bracket: ( - expression: - quoted_literal: "'1900-01-01'" - end_bracket: ) - - statement: - declare_segment: - keyword: DECLARE - parameter: '@USER' - data_type: - data_type_identifier: DATE - comparison_operator: - raw_comparison_operator: '=' - expression: - bare_function: SYSTEM_USER - statement_terminator: ; - - statement: - declare_segment: - keyword: DECLARE - parameter: '@CURRENTTIME' - data_type: - data_type_identifier: DATE - comparison_operator: - raw_comparison_operator: '=' - expression: - bare_function: CURRENT_TIMESTAMP - statement_terminator: ; - - statement: - set_segment: - keyword: SET - parameter: '@EOMONTH' - assignment_operator: - raw_comparison_operator: '=' - expression: - bracketed: - start_bracket: ( - expression: - quoted_literal: "'2000-01-01'" - end_bracket: ) - - statement: - set_segment: - keyword: SET - parameter: '@EOMONTH' - assignment_operator: - raw_comparison_operator: '=' - expression: - bracketed: - start_bracket: ( - expression: - quoted_literal: "'2001-01-01'" - end_bracket: ) - statement_terminator: ; - - statement: - if_then_statement: - if_clause: - keyword: IF + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROC + - object_reference: + - naked_identifier: Reporting + - dot: . + - naked_identifier: DeclareProblem + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + declare_segment: + - keyword: DECLARE + - parameter: '@startdate' + - keyword: AS + - data_type: + data_type_identifier: DATE + - statement_terminator: ; + - statement: + declare_segment: + keyword: DECLARE + parameter: '@DateNow' + data_type: + data_type_identifier: DATE + comparison_operator: + raw_comparison_operator: '=' expression: - - function: + function: + function_name: + function_name_identifier: GETDATE + function_contents: + bracketed: + start_bracket: ( + end_bracket: ) + statement_terminator: ; + - statement: + declare_segment: + - keyword: DECLARE + - parameter: '@DateStart' + - data_type: + data_type_identifier: DATETIME2 + - comparison_operator: + raw_comparison_operator: '=' + - expression: + function: function_name: - function_name_identifier: OBJECT_ID + function_name_identifier: GETDATE function_contents: bracketed: start_bracket: ( - expression: - quoted_literal: "'tempdb..#UP'" end_bracket: ) - - keyword: IS - - keyword: NOT - - null_literal: 'NULL' - statement: - drop_table_statement: - - keyword: DROP - - keyword: TABLE - - table_reference: - hash_identifier: '#UP' - - statement_terminator: ; - - keyword: END + - comma: ',' + - parameter: '@DateEnd' + - data_type: + data_type_identifier: DATETIME2 + - comparison_operator: + raw_comparison_operator: '=' + - expression: + function: + function_name: + function_name_identifier: GETDATE + function_contents: + bracketed: + start_bracket: ( + end_bracket: ) + - statement: + declare_segment: + keyword: DECLARE + parameter: '@EOMONTH' + data_type: + data_type_identifier: DATE + comparison_operator: + raw_comparison_operator: '=' + expression: + bracketed: + start_bracket: ( + expression: + quoted_literal: "'1900-01-01'" + end_bracket: ) + - statement: + declare_segment: + keyword: DECLARE + parameter: '@USER' + data_type: + data_type_identifier: DATE + comparison_operator: + raw_comparison_operator: '=' + expression: + bare_function: SYSTEM_USER + statement_terminator: ; + - statement: + declare_segment: + keyword: DECLARE + parameter: '@CURRENTTIME' + data_type: + data_type_identifier: DATE + comparison_operator: + raw_comparison_operator: '=' + expression: + bare_function: CURRENT_TIMESTAMP + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@EOMONTH' + assignment_operator: + raw_comparison_operator: '=' + expression: + bracketed: + start_bracket: ( + expression: + quoted_literal: "'2000-01-01'" + end_bracket: ) + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@EOMONTH' + assignment_operator: + raw_comparison_operator: '=' + expression: + bracketed: + start_bracket: ( + expression: + quoted_literal: "'2001-01-01'" + end_bracket: ) + - statement_terminator: ; + - statement: + if_then_statement: + if_clause: + keyword: IF + expression: + - function: + function_name: + function_name_identifier: OBJECT_ID + function_contents: + bracketed: + start_bracket: ( + expression: + quoted_literal: "'tempdb..#UP'" + end_bracket: ) + - keyword: IS + - keyword: NOT + - null_literal: 'NULL' + statement: + drop_table_statement: + - keyword: DROP + - keyword: TABLE + - table_reference: + hash_identifier: '#UP' + - statement_terminator: ; + - keyword: END diff --git a/test/fixtures/dialects/tsql/delete.yml b/test/fixtures/dialects/tsql/delete.yml index e07f0e1518a..adfe378f437 100644 --- a/test/fixtures/dialects/tsql/delete.yml +++ b/test/fixtures/dialects/tsql/delete.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 2432afab98214e095edba7cfb916f170a6681733d13b00b8c75639bf3228c300 +_hash: 2e331e3cca75d2ef01d27bc0bcff842a46d66f49250ead969821052c21a7c7fa file: - batch: statement: @@ -15,8 +15,8 @@ file: - dot: . - naked_identifier: SalesPersonQuotaHistory - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: delete_statement: @@ -35,8 +35,8 @@ file: raw_comparison_operator: '>' numeric_literal: '1000.00' - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: delete_statement: @@ -81,93 +81,94 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '3' + integer_literal: '3' end_bracket: ) end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: - statement: declare_segment: - - keyword: DECLARE - - naked_identifier: complex_cursor - - keyword: CURSOR - - keyword: FOR - - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - column_reference: - - naked_identifier: a - - dot: . - - naked_identifier: BusinessEntityID - from_clause: - keyword: FROM - from_expression: - from_expression_element: - table_expression: - table_reference: - - naked_identifier: HumanResources - - dot: . - - naked_identifier: EmployeePayHistory - alias_expression: - alias_operator: - keyword: AS - naked_identifier: a - where_clause: - keyword: WHERE - expression: - column_reference: - naked_identifier: RateChangeDate - comparison_operator: - - raw_comparison_operator: < - - raw_comparison_operator: '>' - bracketed: - start_bracket: ( - expression: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - function: - function_name: - function_name_identifier: MAX - function_contents: - bracketed: - start_bracket: ( - expression: - column_reference: - naked_identifier: RateChangeDate - end_bracket: ) - from_clause: - keyword: FROM - from_expression: - from_expression_element: - table_expression: - table_reference: - - naked_identifier: HumanResources - - dot: . - - naked_identifier: EmployeePayHistory - alias_expression: - alias_operator: - keyword: AS - naked_identifier: b - where_clause: - keyword: WHERE - expression: - - column_reference: - - naked_identifier: a - - dot: . - - naked_identifier: BusinessEntityID - - comparison_operator: - raw_comparison_operator: '=' - - column_reference: - - naked_identifier: b - - dot: . - - naked_identifier: BusinessEntityID - end_bracket: ) - statement_terminator: ; + keyword: DECLARE + naked_identifier: complex_cursor + cursor_definition: + - keyword: CURSOR + - keyword: FOR + - select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + - naked_identifier: a + - dot: . + - naked_identifier: BusinessEntityID + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: HumanResources + - dot: . + - naked_identifier: EmployeePayHistory + alias_expression: + alias_operator: + keyword: AS + naked_identifier: a + where_clause: + keyword: WHERE + expression: + column_reference: + naked_identifier: RateChangeDate + comparison_operator: + - raw_comparison_operator: < + - raw_comparison_operator: '>' + bracketed: + start_bracket: ( + expression: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + function: + function_name: + function_name_identifier: MAX + function_contents: + bracketed: + start_bracket: ( + expression: + column_reference: + naked_identifier: RateChangeDate + end_bracket: ) + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: HumanResources + - dot: . + - naked_identifier: EmployeePayHistory + alias_expression: + alias_operator: + keyword: AS + naked_identifier: b + where_clause: + keyword: WHERE + expression: + - column_reference: + - naked_identifier: a + - dot: . + - naked_identifier: BusinessEntityID + - comparison_operator: + raw_comparison_operator: '=' + - column_reference: + - naked_identifier: b + - dot: . + - naked_identifier: BusinessEntityID + end_bracket: ) + statement_terminator: ; - statement: open_cursor_statement: keyword: OPEN @@ -202,8 +203,8 @@ file: keyword: DEALLOCATE naked_identifier: complex_cursor - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: delete_statement: @@ -246,8 +247,8 @@ file: numeric_literal: '2500000.00' end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: delete_statement: @@ -307,8 +308,8 @@ file: raw_comparison_operator: '>' numeric_literal: '2500000.00' - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: delete_statement: @@ -372,7 +373,7 @@ file: - bracketed: start_bracket: ( expression: - numeric_literal: '20' + integer_literal: '20' end_bracket: ) - keyword: FROM - table_reference: @@ -388,8 +389,8 @@ file: raw_comparison_operator: < quoted_literal: "'20020701'" - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: delete_statement: @@ -413,7 +414,7 @@ file: select_clause_modifier: keyword: TOP expression: - numeric_literal: '10' + integer_literal: '10' select_clause_element: column_reference: naked_identifier: PurchaseOrderDetailID @@ -434,8 +435,8 @@ file: - keyword: ASC end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: delete_statement: @@ -455,10 +456,10 @@ file: naked_identifier: DepartmentID comparison_operator: raw_comparison_operator: '>' - numeric_literal: '16' + integer_literal: '16' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: delete_statement: @@ -472,8 +473,8 @@ file: WHERE DepartmentID = 18'" end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: delete_statement: @@ -489,8 +490,8 @@ file: - table_reference: naked_identifier: Department - end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: delete_statement: @@ -517,7 +518,7 @@ file: naked_identifier: DepartmentID comparison_operator: raw_comparison_operator: '=' - numeric_literal: '17' + integer_literal: '17' - statement_terminator: ; - statement: delete_statement: @@ -540,7 +541,7 @@ file: naked_identifier: ShoppingCartID comparison_operator: raw_comparison_operator: '=' - numeric_literal: '20621' + integer_literal: '20621' statement_terminator: ; - statement: declare_segment: @@ -565,7 +566,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -665,7 +666,7 @@ file: - dot: . - naked_identifier: ProductModelID - keyword: BETWEEN - - numeric_literal: '120' + - integer_literal: '120' - keyword: and - - numeric_literal: '130' + - integer_literal: '130' statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/delete_azure_synapse_analytics.yml b/test/fixtures/dialects/tsql/delete_azure_synapse_analytics.yml index e246e64ae6d..63070c6b19a 100644 --- a/test/fixtures/dialects/tsql/delete_azure_synapse_analytics.yml +++ b/test/fixtures/dialects/tsql/delete_azure_synapse_analytics.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: c0a9ed1e7a6d9e29a2859dda74b848edb7c0aef68dbfea288ec41f07be04aeb7 +_hash: e295294d0f6b4236e99c57836df2c796088a0c72a4fe412dfd94e0a12b110b31 file: batch: - statement: @@ -60,7 +60,7 @@ file: - naked_identifier: ColA comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' statement_terminator: ; - statement: delete_statement: @@ -222,9 +222,9 @@ file: select_clause_modifier: keyword: TOP expression: - numeric_literal: '1' + integer_literal: '1' select_clause_element: - numeric_literal: '1' + integer_literal: '1' from_clause: keyword: FROM from_expression: @@ -302,5 +302,5 @@ file: - naked_identifier: ColA comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/execute.yml b/test/fixtures/dialects/tsql/execute.yml index 4c2913d36b6..985e228dc11 100644 --- a/test/fixtures/dialects/tsql/execute.yml +++ b/test/fixtures/dialects/tsql/execute.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 8e92edc5714c409b37dc9cb648090c17447331c402a710bdba3dccdfeb01cd52 +_hash: b44bb276247dcbbab68f753a8a413e6eaf328f2abe27f4d12c600a01191b70a3 file: - batch: - statement: @@ -34,7 +34,7 @@ file: - dot: . - naked_identifier: ProcTestDefaults - expression: - numeric_literal: '68' + integer_literal: '68' - comma: ',' - expression: quoted_literal: "'B'" @@ -47,7 +47,7 @@ file: - dot: . - naked_identifier: ProcTestDefaults - expression: - numeric_literal: '68' + integer_literal: '68' - comma: ',' - expression: quoted_literal: "'C'" @@ -263,7 +263,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '10' + integer_literal: '10' end_bracket: ) - comparison_operator: raw_comparison_operator: '=' @@ -280,7 +280,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '10' + integer_literal: '10' end_bracket: ) comparison_operator: raw_comparison_operator: '=' @@ -288,23 +288,23 @@ file: null_literal: 'NULL' statement_terminator: ; - statement: - set_segment: + set_local_variable_segment: keyword: SET parameter: '@s1' assignment_operator: raw_comparison_operator: '=' expression: quoted_literal: "'select '" - statement_terminator: ; + - statement_terminator: ; - statement: - set_segment: + set_local_variable_segment: keyword: SET parameter: '@s2' assignment_operator: raw_comparison_operator: '=' expression: quoted_literal: "'123'" - statement_terminator: ; + - statement_terminator: ; - statement: execute_script_statement: keyword: EXECUTE @@ -342,7 +342,7 @@ file: - dot: . - naked_identifier: uspGetEmployeeManagers expression: - numeric_literal: '6' + integer_literal: '6' statement_terminator: ; - statement: execute_script_statement: @@ -355,7 +355,7 @@ file: comparison_operator: raw_comparison_operator: '=' expression: - numeric_literal: '6' + integer_literal: '6' statement_terminator: ; - statement: execute_script_statement: @@ -370,8 +370,8 @@ file: - parameter: '@ManagerID' - keyword: OUTPUT - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: execute_script_statement: @@ -383,10 +383,10 @@ file: comparison_operator: raw_comparison_operator: '=' expression: - numeric_literal: '6' + integer_literal: '6' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: declare_segment: @@ -414,7 +414,7 @@ file: - dot: . - naked_identifier: uspGetWhereUsedProductID - expression: - numeric_literal: '819' + integer_literal: '819' - comma: ',' - expression: parameter: '@CheckDate' @@ -476,7 +476,7 @@ file: - comparison_operator: raw_comparison_operator: '=' - expression: - numeric_literal: '6' + integer_literal: '6' - statement_terminator: ; - statement: declare_segment: @@ -489,7 +489,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '30' + integer_literal: '30' end_bracket: ) - comparison_operator: raw_comparison_operator: '=' @@ -576,7 +576,7 @@ file: quoted_literal: "'SELECT * FROM scott.emp WHERE MGR = ?'" comma: ',' expression: - numeric_literal: '7902' + integer_literal: '7902' end_bracket: ) - keyword: AT - object_reference: @@ -609,7 +609,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '15' + integer_literal: '15' end_bracket: ) - statement_terminator: ; - statement: @@ -625,7 +625,7 @@ file: - comparison_operator: raw_comparison_operator: '=' - expression: - numeric_literal: '2' + integer_literal: '2' - statement_terminator: ; - statement: execute_script_statement: @@ -647,7 +647,7 @@ file: - object_reference: naked_identifier: uspGetEmployeeManagers - expression: - numeric_literal: '16' + integer_literal: '16' - keyword: WITH - execute_option: - keyword: RESULT @@ -678,7 +678,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - keyword: NOT - keyword: 'NULL' @@ -691,7 +691,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - keyword: NOT - keyword: 'NULL' @@ -716,7 +716,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - keyword: NOT - keyword: 'NULL' @@ -729,7 +729,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - keyword: NOT - keyword: 'NULL' diff --git a/test/fixtures/dialects/tsql/fetch_cursor_statement.sql b/test/fixtures/dialects/tsql/fetch_cursor_statement.sql new file mode 100644 index 00000000000..fe933940991 --- /dev/null +++ b/test/fixtures/dialects/tsql/fetch_cursor_statement.sql @@ -0,0 +1,98 @@ +-- Using FETCH in a simple cursor +USE ADVENTUREWORKS2022; +GO +DECLARE CONTACT_CURSOR CURSOR FOR +SELECT LASTNAME FROM PERSON.PERSON +WHERE LASTNAME LIKE 'B%' +ORDER BY LASTNAME; + +OPEN CONTACT_CURSOR; + +-- Perform the first fetch. +FETCH NEXT FROM CONTACT_CURSOR; + +-- Check @@FETCH_STATUS to see if there are any more rows to fetch. +WHILE @@FETCH_STATUS = 0 + BEGIN + -- This is executed as long as the previous fetch succeeds. + FETCH NEXT FROM CONTACT_CURSOR; + END + +CLOSE CONTACT_CURSOR; +DEALLOCATE CONTACT_CURSOR; +GO + +-- Using FETCH to store values in variables +USE ADVENTUREWORKS2022; +GO +-- Declare the variables to store the values returned by FETCH. +DECLARE @LastName VARCHAR(50), @FirstName VARCHAR(50); + +DECLARE CONTACT_CURSOR CURSOR FOR +SELECT + LASTNAME, + FIRSTNAME +FROM PERSON.PERSON +WHERE LASTNAME LIKE 'B%' +ORDER BY LASTNAME, FIRSTNAME; + +OPEN CONTACT_CURSOR; + +-- Perform the first fetch and store the values in variables. +-- Note: The variables are in the same order as the columns +-- in the SELECT statement. + +FETCH NEXT FROM CONTACT_CURSOR +INTO @LastName, @FirstName; + +-- Check @@FETCH_STATUS to see if there are any more rows to fetch. +WHILE @@FETCH_STATUS = 0 + BEGIN + + -- Concatenate and display the current values in the variables. + PRINT 'Contact Name: ' + @FirstName + ' ' + @LastName + + -- This is executed as long as the previous fetch succeeds. + FETCH NEXT FROM CONTACT_CURSOR + INTO @LastName, @FirstName; + END + +CLOSE CONTACT_CURSOR; +DEALLOCATE CONTACT_CURSOR; +GO + +-- Declaring a SCROLL cursor and using the other FETCH options +USE ADVENTUREWORKS2022; +GO +-- Execute the SELECT statement alone to show the +-- full result set that is used by the cursor. +SELECT + LASTNAME, + FIRSTNAME +FROM PERSON.PERSON +ORDER BY LASTNAME, FIRSTNAME; + +-- Declare the cursor. +DECLARE @contact_cursor SCROLL CURSOR FOR +SELECT [LastName], [FirstName] FROM [Person].[Person] +ORDER BY [LastName], [FirstName]; + +OPEN contact_cursor; + +-- Fetch the last row in the cursor. +FETCH LAST FROM contact_cursor; + +-- Fetch the row immediately prior to the current row in the cursor. +FETCH PRIOR FROM contact_cursor; + +-- Fetch the second row in the cursor. +FETCH ABSOLUTE 2 FROM contact_cursor; + +-- Fetch the row that is three rows after the current row. +FETCH RELATIVE 3 FROM contact_cursor; + +-- Fetch the row that is two rows prior to the current row. +FETCH RELATIVE -2 FROM contact_cursor; + +CLOSE contact_cursor; +DEALLOCATE contact_cursor; diff --git a/test/fixtures/dialects/tsql/fetch_cursor_statement.yml b/test/fixtures/dialects/tsql/fetch_cursor_statement.yml new file mode 100644 index 00000000000..6d517685792 --- /dev/null +++ b/test/fixtures/dialects/tsql/fetch_cursor_statement.yml @@ -0,0 +1,360 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 76b88a6d72fb613db9df71b02500964c5cdb9a7a82a68bbc1435bc92d70b817c +file: +- batch: + statement: + use_statement: + keyword: USE + database_reference: + naked_identifier: ADVENTUREWORKS2022 + statement_terminator: ; + go_statement: + keyword: GO +- batch: + - statement: + declare_segment: + keyword: DECLARE + naked_identifier: CONTACT_CURSOR + cursor_definition: + - keyword: CURSOR + - keyword: FOR + - select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: LASTNAME + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: PERSON + - dot: . + - naked_identifier: PERSON + where_clause: + keyword: WHERE + expression: + column_reference: + naked_identifier: LASTNAME + keyword: LIKE + quoted_literal: "'B%'" + orderby_clause: + - keyword: ORDER + - keyword: BY + - column_reference: + naked_identifier: LASTNAME + statement_terminator: ; + - statement: + open_cursor_statement: + keyword: OPEN + naked_identifier: CONTACT_CURSOR + - statement_terminator: ; + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: NEXT + - keyword: FROM + - naked_identifier: CONTACT_CURSOR + - statement_terminator: ; + - statement: + while_statement: + keyword: WHILE + expression: + system_variable: '@@FETCH_STATUS' + comparison_operator: + raw_comparison_operator: '=' + integer_literal: '0' + statement: + begin_end_block: + - keyword: BEGIN + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: NEXT + - keyword: FROM + - naked_identifier: CONTACT_CURSOR + - statement_terminator: ; + - keyword: END + - statement: + close_cursor_statement: + keyword: CLOSE + naked_identifier: CONTACT_CURSOR + - statement_terminator: ; + - statement: + deallocate_cursor_statement: + keyword: DEALLOCATE + naked_identifier: CONTACT_CURSOR + - statement_terminator: ; + - go_statement: + keyword: GO +- batch: + statement: + use_statement: + keyword: USE + database_reference: + naked_identifier: ADVENTUREWORKS2022 + statement_terminator: ; + go_statement: + keyword: GO +- batch: + - statement: + declare_segment: + - keyword: DECLARE + - parameter: '@LastName' + - data_type: + data_type_identifier: VARCHAR + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '50' + end_bracket: ) + - comma: ',' + - parameter: '@FirstName' + - data_type: + data_type_identifier: VARCHAR + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '50' + end_bracket: ) + - statement_terminator: ; + - statement: + declare_segment: + keyword: DECLARE + naked_identifier: CONTACT_CURSOR + cursor_definition: + - keyword: CURSOR + - keyword: FOR + - select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + naked_identifier: LASTNAME + - comma: ',' + - select_clause_element: + column_reference: + naked_identifier: FIRSTNAME + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: PERSON + - dot: . + - naked_identifier: PERSON + where_clause: + keyword: WHERE + expression: + column_reference: + naked_identifier: LASTNAME + keyword: LIKE + quoted_literal: "'B%'" + orderby_clause: + - keyword: ORDER + - keyword: BY + - column_reference: + naked_identifier: LASTNAME + - comma: ',' + - column_reference: + naked_identifier: FIRSTNAME + statement_terminator: ; + - statement: + open_cursor_statement: + keyword: OPEN + naked_identifier: CONTACT_CURSOR + - statement_terminator: ; + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: NEXT + - keyword: FROM + - naked_identifier: CONTACT_CURSOR + - keyword: INTO + - parameter: '@LastName' + - comma: ',' + - parameter: '@FirstName' + - statement_terminator: ; + - statement: + while_statement: + keyword: WHILE + expression: + system_variable: '@@FETCH_STATUS' + comparison_operator: + raw_comparison_operator: '=' + integer_literal: '0' + statement: + begin_end_block: + - keyword: BEGIN + - statement: + print_statement: + keyword: PRINT + expression: + - quoted_literal: "'Contact Name: '" + - binary_operator: + + - parameter: '@FirstName' + - binary_operator: + + - quoted_literal: "' '" + - binary_operator: + + - parameter: '@LastName' + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: NEXT + - keyword: FROM + - naked_identifier: CONTACT_CURSOR + - keyword: INTO + - parameter: '@LastName' + - comma: ',' + - parameter: '@FirstName' + - statement_terminator: ; + - keyword: END + - statement: + close_cursor_statement: + keyword: CLOSE + naked_identifier: CONTACT_CURSOR + - statement_terminator: ; + - statement: + deallocate_cursor_statement: + keyword: DEALLOCATE + naked_identifier: CONTACT_CURSOR + - statement_terminator: ; + - go_statement: + keyword: GO +- batch: + statement: + use_statement: + keyword: USE + database_reference: + naked_identifier: ADVENTUREWORKS2022 + statement_terminator: ; + go_statement: + keyword: GO +- batch: + - statement: + select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + naked_identifier: LASTNAME + - comma: ',' + - select_clause_element: + column_reference: + naked_identifier: FIRSTNAME + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: PERSON + - dot: . + - naked_identifier: PERSON + orderby_clause: + - keyword: ORDER + - keyword: BY + - column_reference: + naked_identifier: LASTNAME + - comma: ',' + - column_reference: + naked_identifier: FIRSTNAME + statement_terminator: ; + - statement: + declare_segment: + - keyword: DECLARE + - parameter: '@contact_cursor' + - keyword: SCROLL + - keyword: CURSOR + - keyword: FOR + - select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + quoted_identifier: '[LastName]' + - comma: ',' + - select_clause_element: + column_reference: + quoted_identifier: '[FirstName]' + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - quoted_identifier: '[Person]' + - dot: . + - quoted_identifier: '[Person]' + orderby_clause: + - keyword: ORDER + - keyword: BY + - column_reference: + quoted_identifier: '[LastName]' + - comma: ',' + - column_reference: + quoted_identifier: '[FirstName]' + statement_terminator: ; + - statement: + open_cursor_statement: + keyword: OPEN + naked_identifier: contact_cursor + - statement_terminator: ; + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: LAST + - keyword: FROM + - naked_identifier: contact_cursor + - statement_terminator: ; + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: PRIOR + - keyword: FROM + - naked_identifier: contact_cursor + - statement_terminator: ; + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: ABSOLUTE + - numeric_literal: '2' + - keyword: FROM + - naked_identifier: contact_cursor + - statement_terminator: ; + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: RELATIVE + - numeric_literal: '3' + - keyword: FROM + - naked_identifier: contact_cursor + - statement_terminator: ; + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: RELATIVE + - sign_indicator: '-' + - numeric_literal: '2' + - keyword: FROM + - naked_identifier: contact_cursor + - statement_terminator: ; + - statement: + close_cursor_statement: + keyword: CLOSE + naked_identifier: contact_cursor + - statement_terminator: ; + - statement: + deallocate_cursor_statement: + keyword: DEALLOCATE + naked_identifier: contact_cursor + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/function_default_params.yml b/test/fixtures/dialects/tsql/function_default_params.yml index effd84eeea3..d9f9e8e681c 100644 --- a/test/fixtures/dialects/tsql/function_default_params.yml +++ b/test/fixtures/dialects/tsql/function_default_params.yml @@ -3,47 +3,48 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 73f2f93f13c48a72885f185a7c4a70c7e61e414b62902d00d852e59bb96d93b5 +_hash: 87f025e6890f5c7eb0030c5856906b301f85f8aa2496d90a5dcd5c4f18a31b5e file: batch: - create_procedure_statement: - - keyword: create - - keyword: or - - keyword: alter - - keyword: procedure - - object_reference: - naked_identifier: name - - procedure_parameter_list: - - parameter: '@param1' - - data_type: - data_type_identifier: nvarchar - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '10' - end_bracket: ) - - comparison_operator: - raw_comparison_operator: '=' - - expression: - quoted_literal: "'test'" - - comma: ',' - - parameter: '@param2' - - data_type: - data_type_identifier: int - - comparison_operator: - raw_comparison_operator: '=' - - expression: - numeric_literal: '21' - - keyword: as - - procedure_statement: - statement: - begin_end_block: - - keyword: begin - - statement: - return_segment: - keyword: return + statement: + create_procedure_statement: + - keyword: create + - keyword: or + - keyword: alter + - keyword: procedure + - object_reference: + naked_identifier: name + - procedure_parameter_list: + - parameter: '@param1' + - data_type: + data_type_identifier: nvarchar + bracketed_arguments: + bracketed: + start_bracket: ( expression: - numeric_literal: '1' - statement_terminator: ; - - keyword: end + integer_literal: '10' + end_bracket: ) + - comparison_operator: + raw_comparison_operator: '=' + - expression: + quoted_literal: "'test'" + - comma: ',' + - parameter: '@param2' + - data_type: + data_type_identifier: int + - comparison_operator: + raw_comparison_operator: '=' + - expression: + integer_literal: '21' + - keyword: as + - procedure_statement: + statement: + begin_end_block: + - keyword: begin + - statement: + return_segment: + keyword: return + expression: + integer_literal: '1' + statement_terminator: ; + - keyword: end diff --git a/test/fixtures/dialects/tsql/function_no_return.yml b/test/fixtures/dialects/tsql/function_no_return.yml index 176cb4d5fe0..25efd444f16 100644 --- a/test/fixtures/dialects/tsql/function_no_return.yml +++ b/test/fixtures/dialects/tsql/function_no_return.yml @@ -3,112 +3,113 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: bf7784bb5eda5e1f45d053f31abb531e108c9048c5b0a9fc1a870986bdb7fee7 +_hash: 51fd2eaf916746941e1e73f883857a1c6791e83bb7509e02fbccc62d45cc4f72 file: batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - naked_identifier: findjobs - - procedure_parameter_list: - parameter: '@nm' - data_type: - data_type_identifier: sysname - comparison_operator: - raw_comparison_operator: '=' - expression: - null_literal: 'NULL' - - keyword: AS - - procedure_statement: - statement: - if_then_statement: - - if_clause: - keyword: IF - expression: - parameter: '@nm' - keyword: IS - null_literal: 'NULL' - - statement: - begin_end_block: - - keyword: BEGIN - - statement: - print_statement: - keyword: PRINT - expression: - quoted_literal: "'You must give a user name'" - - statement: - return_segment: - keyword: RETURN - - keyword: END - - keyword: ELSE - - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - - keyword: SELECT - - select_clause_element: - column_reference: - - naked_identifier: o - - dot: . - - naked_identifier: name - - comma: ',' - - select_clause_element: - column_reference: - - naked_identifier: o - - dot: . - - naked_identifier: id - - comma: ',' - - select_clause_element: - column_reference: - - naked_identifier: o - - dot: . - - naked_identifier: uid - from_clause: - keyword: FROM - from_expression: - from_expression_element: - table_expression: - table_reference: - naked_identifier: sysobjects - alias_expression: - naked_identifier: o - join_clause: - - keyword: INNER - - keyword: JOIN - - from_expression_element: + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + naked_identifier: findjobs + - procedure_parameter_list: + parameter: '@nm' + data_type: + data_type_identifier: sysname + comparison_operator: + raw_comparison_operator: '=' + expression: + null_literal: 'NULL' + - keyword: AS + - procedure_statement: + statement: + if_then_statement: + - if_clause: + keyword: IF + expression: + parameter: '@nm' + keyword: IS + null_literal: 'NULL' + - statement: + begin_end_block: + - keyword: BEGIN + - statement: + print_statement: + keyword: PRINT + expression: + quoted_literal: "'You must give a user name'" + - statement: + return_segment: + keyword: RETURN + - keyword: END + - keyword: ELSE + - statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + - naked_identifier: o + - dot: . + - naked_identifier: name + - comma: ',' + - select_clause_element: + column_reference: + - naked_identifier: o + - dot: . + - naked_identifier: id + - comma: ',' + - select_clause_element: + column_reference: + - naked_identifier: o + - dot: . + - naked_identifier: uid + from_clause: + keyword: FROM + from_expression: + from_expression_element: table_expression: table_reference: - - naked_identifier: master - - dot: . - - dot: . - - naked_identifier: syslogins + naked_identifier: sysobjects alias_expression: - naked_identifier: l - - join_on_condition: - keyword: 'ON' - expression: - - column_reference: - - naked_identifier: o - - dot: . - - naked_identifier: uid - - comparison_operator: - raw_comparison_operator: '=' - - column_reference: - - naked_identifier: l - - dot: . - - naked_identifier: sid - where_clause: - keyword: WHERE - expression: - column_reference: - - naked_identifier: l - - dot: . - - naked_identifier: name - comparison_operator: - raw_comparison_operator: '=' - parameter: '@nm' - - keyword: END - - statement_terminator: ; + naked_identifier: o + join_clause: + - keyword: INNER + - keyword: JOIN + - from_expression_element: + table_expression: + table_reference: + - naked_identifier: master + - dot: . + - dot: . + - naked_identifier: syslogins + alias_expression: + naked_identifier: l + - join_on_condition: + keyword: 'ON' + expression: + - column_reference: + - naked_identifier: o + - dot: . + - naked_identifier: uid + - comparison_operator: + raw_comparison_operator: '=' + - column_reference: + - naked_identifier: l + - dot: . + - naked_identifier: sid + where_clause: + keyword: WHERE + expression: + column_reference: + - naked_identifier: l + - dot: . + - naked_identifier: name + comparison_operator: + raw_comparison_operator: '=' + parameter: '@nm' + - keyword: END + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/function_with_variable.yml b/test/fixtures/dialects/tsql/function_with_variable.yml index ab21f1f8810..5f292564e98 100644 --- a/test/fixtures/dialects/tsql/function_with_variable.yml +++ b/test/fixtures/dialects/tsql/function_with_variable.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: a4f778729ae8ba6dcd284c585c2f3167abdc3a32fadc7682c3c620a00161f1db +_hash: eeb2da18f3e19d2c9f51ad0881154353b1bc9bf3203c92de1338600a4d3d42c6 file: batch: statement: @@ -42,13 +42,13 @@ file: data_type: data_type_identifier: BIGINT - statement: - set_segment: + set_local_variable_segment: keyword: SET parameter: '@result' assignment_operator: raw_comparison_operator: '=' expression: - numeric_literal: '4' + integer_literal: '4' - statement: return_segment: keyword: RETURN diff --git a/test/fixtures/dialects/tsql/functions_a.yml b/test/fixtures/dialects/tsql/functions_a.yml index d3c245ebb6c..b6cd55a50a4 100644 --- a/test/fixtures/dialects/tsql/functions_a.yml +++ b/test/fixtures/dialects/tsql/functions_a.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 610e3a8885bb24b75c3624c2a831e5417a251003063d62117010328282521049 +_hash: 637c2e2a32c9698f23f64da4a21fa2b37c69c28ff1082463c9058df30bf7cfaa file: - batch: statement: @@ -38,7 +38,7 @@ file: naked_identifier: b - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) alias_expression: alias_operator: @@ -64,7 +64,7 @@ file: naked_identifier: s - comma: ',' - expression: - numeric_literal: '5' + integer_literal: '5' - end_bracket: ) - comma: ',' - expression: @@ -78,7 +78,7 @@ file: column_reference: naked_identifier: s binary_operator: + - numeric_literal: '6' + integer_literal: '6' end_bracket: ) - end_bracket: ) alias_expression: @@ -138,8 +138,8 @@ file: table_expression: table_reference: naked_identifier: tbl_b -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_function_statement: @@ -183,8 +183,8 @@ file: quoted_identifier: '[RandomDate]' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_function_statement: @@ -210,11 +210,11 @@ file: return_segment: keyword: RETURN expression: - numeric_literal: '2' + integer_literal: '2' statement_terminator: ; - keyword: END -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -281,5 +281,5 @@ file: keyword: IS null_literal: 'NULL' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/go_delimiters.yml b/test/fixtures/dialects/tsql/go_delimiters.yml index baef1e68ccc..12d4bafe685 100644 --- a/test/fixtures/dialects/tsql/go_delimiters.yml +++ b/test/fixtures/dialects/tsql/go_delimiters.yml @@ -3,10 +3,11 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: b5da83f2dfc435ece584287628e0fcc92d30a506e7f8ca3b44ac5f8deed4f9ff +_hash: de7346d12a00680dc8dfe9eec1d2934822c99e64198167eca2462f53144be32b file: -- go_statement: - keyword: GO +- batch: + go_statement: + keyword: GO - batch: statement: select_statement: @@ -22,10 +23,11 @@ file: table_expression: table_reference: naked_identifier: bar -- go_statement: - keyword: GO -- go_statement: - keyword: GO + go_statement: + keyword: GO +- batch: + go_statement: + keyword: GO - batch: statement: select_statement: @@ -41,12 +43,14 @@ file: table_expression: table_reference: naked_identifier: bar -- go_statement: - keyword: GO -- go_statement: - keyword: GO -- go_statement: - keyword: GO + go_statement: + keyword: GO +- batch: + go_statement: + keyword: GO +- batch: + go_statement: + keyword: GO - batch: statement: select_statement: @@ -62,5 +66,5 @@ file: table_expression: table_reference: naked_identifier: bar -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/grant_deny_revoke.yml b/test/fixtures/dialects/tsql/grant_deny_revoke.yml index 3880c7c0781..2ba8f619f07 100644 --- a/test/fixtures/dialects/tsql/grant_deny_revoke.yml +++ b/test/fixtures/dialects/tsql/grant_deny_revoke.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: f49b9b7af9353f7d07866b8964a00f9de08c3000e479e3d4a6349a5badd15bf9 +_hash: 69110a53371b8d7fb79e3e523200c61265e4d3c8a17ec9d371cf7480d98b7940 file: - batch: statement: @@ -21,8 +21,8 @@ file: - role_reference: naked_identifier: RosaQdM statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: use_statement: @@ -45,8 +45,8 @@ file: - role_reference: naked_identifier: Recruiting11 - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: access_statement: @@ -71,8 +71,8 @@ file: - keyword: GRANT - keyword: OPTION statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: access_statement: @@ -87,8 +87,8 @@ file: - role_reference: naked_identifier: RosaQdM statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: access_statement: @@ -103,8 +103,8 @@ file: - role_reference: quoted_identifier: '[AdventureWorks2012\RosaQdM]' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: create_role_statement: @@ -126,8 +126,8 @@ file: - role_reference: naked_identifier: newrole - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: access_statement: @@ -142,8 +142,8 @@ file: - role_reference: naked_identifier: Vendors statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: access_statement: @@ -158,8 +158,8 @@ file: - role_reference: naked_identifier: Vendors statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: access_statement: @@ -176,8 +176,8 @@ file: - role_reference: naked_identifier: RosaQdM statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: access_statement: @@ -194,8 +194,8 @@ file: - role_reference: naked_identifier: Recruiting11 statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: access_statement: @@ -218,5 +218,5 @@ file: naked_identifier: Wanida - keyword: CASCADE statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/hints.yml b/test/fixtures/dialects/tsql/hints.yml index 59408db74bd..6b2d7c02f8d 100644 --- a/test/fixtures/dialects/tsql/hints.yml +++ b/test/fixtures/dialects/tsql/hints.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 3a1902cc6ad1478fa1a51f3170e8b348c241f15e527959e4ea3f7300d3bc6907 +_hash: 524c430d1557fe70c1c5fab559ff7a11cf7b2bc3322124b3244447cc97bcceb5 file: - batch: statement: @@ -60,7 +60,7 @@ file: naked_identifier: TerritoryID comparison_operator: raw_comparison_operator: '=' - numeric_literal: '5' + integer_literal: '5' option_clause: keyword: OPTION bracketed: @@ -70,90 +70,91 @@ file: - keyword: JOIN end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - naked_identifier: dbo - - dot: . - - naked_identifier: RetrievePersonAddress - - procedure_parameter_list: - - parameter: '@city_name' - - data_type: - data_type_identifier: NVARCHAR - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '30' - end_bracket: ) - - comma: ',' - - parameter: '@postal_code' - - data_type: - data_type_identifier: NVARCHAR - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '15' - end_bracket: ) - - keyword: AS - - procedure_statement: - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - wildcard_expression: - wildcard_identifier: - star: '*' - from_clause: - keyword: FROM - from_expression: - from_expression_element: - table_expression: - table_reference: - - naked_identifier: Person - - dot: . - - naked_identifier: Address - where_clause: - keyword: WHERE - expression: - - column_reference: - naked_identifier: City - - comparison_operator: - raw_comparison_operator: '=' - - parameter: '@city_name' - - binary_operator: AND - - column_reference: - naked_identifier: PostalCode - - comparison_operator: - raw_comparison_operator: '=' - - parameter: '@postal_code' - option_clause: - keyword: OPTION + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - naked_identifier: dbo + - dot: . + - naked_identifier: RetrievePersonAddress + - procedure_parameter_list: + - parameter: '@city_name' + - data_type: + data_type_identifier: NVARCHAR + bracketed_arguments: bracketed: start_bracket: ( - query_hint_segment: - - keyword: OPTIMIZE - - keyword: FOR - - bracketed: - - start_bracket: ( - - parameter: '@city_name' - - comparison_operator: - raw_comparison_operator: '=' - - quoted_literal: "'Seattle'" - - comma: ',' - - parameter: '@postal_code' - - keyword: UNKNOWN - - end_bracket: ) + expression: + integer_literal: '30' + end_bracket: ) + - comma: ',' + - parameter: '@postal_code' + - data_type: + data_type_identifier: NVARCHAR + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '15' end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + - keyword: AS + - procedure_statement: + statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + wildcard_expression: + wildcard_identifier: + star: '*' + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: Person + - dot: . + - naked_identifier: Address + where_clause: + keyword: WHERE + expression: + - column_reference: + naked_identifier: City + - comparison_operator: + raw_comparison_operator: '=' + - parameter: '@city_name' + - binary_operator: AND + - column_reference: + naked_identifier: PostalCode + - comparison_operator: + raw_comparison_operator: '=' + - parameter: '@postal_code' + option_clause: + keyword: OPTION + bracketed: + start_bracket: ( + query_hint_segment: + - keyword: OPTIMIZE + - keyword: FOR + - bracketed: + - start_bracket: ( + - parameter: '@city_name' + - comparison_operator: + raw_comparison_operator: '=' + - quoted_literal: "'Seattle'" + - comma: ',' + - parameter: '@postal_code' + - keyword: UNKNOWN + - end_bracket: ) + end_bracket: ) + statement_terminator: ; + go_statement: + keyword: GO - batch: statement: with_compound_statement: @@ -291,8 +292,8 @@ file: numeric_literal: '2' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: set_expression: @@ -347,8 +348,8 @@ file: - keyword: UNION end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -393,7 +394,7 @@ file: naked_identifier: UnitPrice comparison_operator: raw_comparison_operator: < - numeric_literal: '5' + integer_literal: '5' groupby_clause: - keyword: GROUP - keyword: BY @@ -423,8 +424,8 @@ file: numeric_literal: '10' - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -469,7 +470,7 @@ file: naked_identifier: UnitPrice comparison_operator: raw_comparison_operator: < - numeric_literal: '5' + integer_literal: '5' groupby_clause: - keyword: GROUP - keyword: BY @@ -495,8 +496,8 @@ file: numeric_literal: '2' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -528,7 +529,7 @@ file: naked_identifier: PostalCode - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '98104' + - integer_literal: '98104' option_clause: keyword: OPTION bracketed: @@ -547,8 +548,8 @@ file: - end_bracket: ) - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -580,7 +581,7 @@ file: naked_identifier: PostalCode - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '98104' + - integer_literal: '98104' option_clause: keyword: OPTION bracketed: @@ -590,8 +591,8 @@ file: numeric_literal: '4199' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -623,7 +624,7 @@ file: naked_identifier: PostalCode - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '98104' + - integer_literal: '98104' option_clause: keyword: OPTION bracketed: @@ -637,8 +638,8 @@ file: numeric_literal: '4137' - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: update_statement: @@ -674,8 +675,8 @@ file: keyword: LIKE quoted_literal: "'BK-%'" statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -740,7 +741,7 @@ file: - naked_identifier: TotalDue comparison_operator: raw_comparison_operator: '>' - numeric_literal: '100' + integer_literal: '100' binary_operator: AND bracketed: start_bracket: ( @@ -751,7 +752,7 @@ file: - naked_identifier: OrderQty - comparison_operator: raw_comparison_operator: '>' - - numeric_literal: '5' + - integer_literal: '5' - binary_operator: OR - column_reference: - naked_identifier: d @@ -762,8 +763,8 @@ file: - numeric_literal: '1000.00' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -850,7 +851,7 @@ file: - naked_identifier: TotalDue comparison_operator: raw_comparison_operator: '>' - numeric_literal: '100' + integer_literal: '100' binary_operator: AND bracketed: start_bracket: ( @@ -861,7 +862,7 @@ file: - naked_identifier: OrderQty - comparison_operator: raw_comparison_operator: '>' - - numeric_literal: '5' + - integer_literal: '5' - binary_operator: OR - column_reference: - naked_identifier: d @@ -872,8 +873,8 @@ file: - numeric_literal: '1000.00' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -951,7 +952,7 @@ file: - naked_identifier: TotalDue comparison_operator: raw_comparison_operator: '>' - numeric_literal: '100' + integer_literal: '100' binary_operator: AND bracketed: start_bracket: ( @@ -962,7 +963,7 @@ file: - naked_identifier: OrderQty - comparison_operator: raw_comparison_operator: '>' - - numeric_literal: '5' + - integer_literal: '5' - binary_operator: OR - column_reference: - naked_identifier: d @@ -973,8 +974,8 @@ file: - numeric_literal: '1000.00' end_bracket: ) statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -999,8 +1000,8 @@ file: query_hint_segment: keyword: NOLOCK end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -1024,5 +1025,5 @@ file: query_hint_segment: keyword: NOLOCK end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/if_else.yml b/test/fixtures/dialects/tsql/if_else.yml index 80e44392718..82c946b8d4d 100644 --- a/test/fixtures/dialects/tsql/if_else.yml +++ b/test/fixtures/dialects/tsql/if_else.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 8607a11ed091582eb2c75b9a1b7a7d170112ffee6b2390f2c9688af774a36c44 +_hash: 20a079e8c2c658cced513e1214677d3729d549f0662c02625daf180e0ce7f1b0 file: batch: - statement: @@ -11,7 +11,7 @@ file: - if_clause: keyword: IF expression: - numeric_literal: '1' + integer_literal: '1' comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '=' @@ -38,7 +38,7 @@ file: naked_identifier: ProductKey comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' end_bracket: ) - statement: select_statement: @@ -77,7 +77,7 @@ file: naked_identifier: ProductKey comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' - keyword: ELSE - statement: select_statement: @@ -115,7 +115,7 @@ file: naked_identifier: ProductKey comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' - statement: if_then_statement: if_clause: @@ -158,11 +158,11 @@ file: hash_identifier: '#b' end_bracket: ) statement: - set_segment: + set_local_variable_segment: keyword: set parameter: '@var' assignment_operator: raw_comparison_operator: '=' expression: - numeric_literal: '1' - statement_terminator: ; + integer_literal: '1' + statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/if_else_begin_end.yml b/test/fixtures/dialects/tsql/if_else_begin_end.yml index ea7da13c1db..406b76868e0 100644 --- a/test/fixtures/dialects/tsql/if_else_begin_end.yml +++ b/test/fixtures/dialects/tsql/if_else_begin_end.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 6ede8bc950734e4f460c930ab13abafa579e442cb7f319f5e19748aa28d30447 +_hash: 70ab5c40351981bccf496268343085bf8d829232edf54b2fefc696e8eb74f29a file: batch: statement: @@ -11,7 +11,7 @@ file: - if_clause: keyword: IF expression: - numeric_literal: '1' + integer_literal: '1' comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '=' @@ -38,7 +38,7 @@ file: naked_identifier: ProductKey comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' end_bracket: ) - statement: begin_end_block: @@ -80,7 +80,7 @@ file: naked_identifier: ProductKey comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' - keyword: END - keyword: ELSE - statement: @@ -122,5 +122,5 @@ file: naked_identifier: ProductKey comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' - keyword: END diff --git a/test/fixtures/dialects/tsql/insert_statement.yml b/test/fixtures/dialects/tsql/insert_statement.yml index c6dd37ea434..73254b2fcdc 100644 --- a/test/fixtures/dialects/tsql/insert_statement.yml +++ b/test/fixtures/dialects/tsql/insert_statement.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 16df891b928c5d8c9d95f87eadca7ebd741602622fb956784bdde800ab4bcea1 +_hash: 6f840e30e4adf24c3a96f54c1eaf4f5a1dc948dde1cb76c0f7b43caff0e96ce5 file: - batch: statement: @@ -141,7 +141,7 @@ file: naked_identifier: YEAR_WEEK - comma: ',' - expression: - numeric_literal: '4' + integer_literal: '4' - end_bracket: ) - comma: ',' - expression: @@ -156,7 +156,7 @@ file: naked_identifier: YEAR_WEEK - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) - end_bracket: ) keyword: AS @@ -205,7 +205,7 @@ file: naked_identifier: YEAR_WEEK - comma: ',' - expression: - numeric_literal: '4' + integer_literal: '4' - end_bracket: ) - comma: ',' - expression: @@ -220,7 +220,7 @@ file: naked_identifier: YEAR_WEEK - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) - end_bracket: ) end_bracket: ) @@ -283,8 +283,8 @@ file: - naked_identifier: STAGE - dot: . - naked_identifier: ECDC_CASES -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: begin_end_block: @@ -344,8 +344,8 @@ file: naked_identifier: EmployeeTemp statement_terminator: ; - keyword: END -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: insert_statement: @@ -401,8 +401,8 @@ file: table_reference: naked_identifier: EmployeeTemp statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: insert_statement: @@ -436,8 +436,8 @@ file: raw_comparison_operator: '=' expression: quoted_literal: "'Picard'" -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: insert_statement: @@ -462,5 +462,5 @@ file: - comma: ',' - quoted_literal: "'James'" - end_bracket: ) -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/insert_with_identity_insert.yml b/test/fixtures/dialects/tsql/insert_with_identity_insert.yml index 03c71176799..ddf9b050cf5 100644 --- a/test/fixtures/dialects/tsql/insert_with_identity_insert.yml +++ b/test/fixtures/dialects/tsql/insert_with_identity_insert.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 252552cfe5864de52f3e01b4db756fa4e21bdf58b0f2d0468bdfffa4c65ea343 +_hash: 94aca89501c2a3274b02e9f5b094b60e1bfab8ef98aa36a828c22dfb08c4479b file: batch: - statement: @@ -32,9 +32,9 @@ file: keyword: VALUES bracketed: - start_bracket: ( - - numeric_literal: '1' + - integer_literal: '1' - comma: ',' - - numeric_literal: '2' + - integer_literal: '2' - end_bracket: ) - statement_terminator: ; - statement: diff --git a/test/fixtures/dialects/tsql/json_functions.yml b/test/fixtures/dialects/tsql/json_functions.yml index d9d0c3cae25..5e7d12af14f 100644 --- a/test/fixtures/dialects/tsql/json_functions.yml +++ b/test/fixtures/dialects/tsql/json_functions.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 3ae13d24b15b3833d9645ad5f737db733e900dbd565bca98af772df22af0cb4b +_hash: e54ee2107f49b062d4e9da45478ccd9f1acd2fed5669cca8328f2e30bb2d7968 file: batch: - statement: @@ -37,13 +37,13 @@ file: quoted_literal: "'a'" - comma: ',' - expression: - numeric_literal: '1' + integer_literal: '1' - comma: ',' - expression: quoted_literal: "'b'" - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) statement_terminator: ; - statement: @@ -87,7 +87,7 @@ file: - comma: ',' - quoted_literal: "'new'" - colon: ':' - - numeric_literal: '1' + - integer_literal: '1' - end_bracket: ) statement_terminator: ; - statement: @@ -136,10 +136,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '1' + integer_literal: '1' - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) - end_bracket: ) - statement: @@ -167,7 +167,7 @@ file: - start_bracket: ( - quoted_literal: "'type_id'" - colon: ':' - - numeric_literal: '1' + - integer_literal: '1' - comma: ',' - quoted_literal: "'name'" - colon: ':' @@ -184,7 +184,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '10' + integer_literal: '10' end_bracket: ) - comparison_operator: raw_comparison_operator: '=' @@ -198,7 +198,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '64' + integer_literal: '64' end_bracket: ) - comparison_operator: raw_comparison_operator: '=' @@ -312,7 +312,7 @@ file: - naked_identifier: is_user_process comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' statement_terminator: ; - statement: select_statement: @@ -341,7 +341,7 @@ file: - comma: ',' - quoted_literal: "'type'" - colon: ':' - - numeric_literal: '1' + - integer_literal: '1' - end_bracket: ) - end_bracket: ) statement_terminator: ; @@ -372,7 +372,7 @@ file: - comma: ',' - quoted_literal: "'type'" - colon: ':' - - numeric_literal: '1' + - integer_literal: '1' - end_bracket: ) - comma: ',' - expression: @@ -403,7 +403,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '64' + integer_literal: '64' end_bracket: ) comparison_operator: raw_comparison_operator: '=' @@ -428,7 +428,7 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '1' + integer_literal: '1' - comma: ',' - expression: parameter: '@id_value' @@ -502,5 +502,5 @@ file: - naked_identifier: is_user_process comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/merge.yml b/test/fixtures/dialects/tsql/merge.yml index e3a691bc4aa..3cd9ddfa593 100644 --- a/test/fixtures/dialects/tsql/merge.yml +++ b/test/fixtures/dialects/tsql/merge.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 0d3e1a239cfc078f09e11cf7d587ef50fa821012b42cb3e13079f6e3d457e410 +_hash: 07d4fe3480678462b502f76cca4c139e8990dd21b70cfc444680e8f76d0b3860 file: - batch: statement: @@ -31,7 +31,7 @@ file: - naked_identifier: rn - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - binary_operator: and - column_reference: - naked_identifier: dst @@ -84,8 +84,8 @@ file: - naked_identifier: src - dot: . - naked_identifier: e_date_from -- go_statement: - keyword: go + go_statement: + keyword: go - batch: statement: with_compound_statement: @@ -240,8 +240,8 @@ file: naked_identifier: cc_description - end_bracket: ) statement_terminator: ; -- go_statement: - keyword: go + go_statement: + keyword: go - batch: statement: merge_statement: @@ -414,7 +414,7 @@ file: naked_identifier: s_id comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' keyword: in bracketed: start_bracket: ( @@ -462,8 +462,8 @@ file: column_reference: naked_identifier: col2 statement_terminator: ; -- go_statement: - keyword: go + go_statement: + keyword: go - batch: statement: merge_statement: @@ -584,8 +584,8 @@ file: - table_reference: hash_identifier: '#MyTempTable' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: merge_statement: @@ -716,7 +716,7 @@ file: - comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '=' - - numeric_literal: '0' + - integer_literal: '0' - keyword: THEN - merge_delete_clause: keyword: DELETE @@ -796,8 +796,8 @@ file: - dot: . - naked_identifier: ModifiedDate statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: merge_statement: @@ -926,7 +926,7 @@ file: - comparison_operator: - raw_comparison_operator: '>' - raw_comparison_operator: '=' - - numeric_literal: '0' + - integer_literal: '0' - keyword: THEN - merge_update_clause: keyword: UPDATE @@ -966,7 +966,7 @@ file: - comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '=' - - numeric_literal: '0' + - integer_literal: '0' - keyword: THEN - merge_delete_clause: keyword: DELETE @@ -1003,8 +1003,8 @@ file: keyword: AS naked_identifier: PreviousQty statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: insert_statement: @@ -1113,8 +1113,8 @@ file: keyword: as naked_identifier: upd statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: merge_statement: @@ -1241,8 +1241,8 @@ file: - table_reference: hash_identifier: '#MyTempTable' statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: merge_statement: @@ -1389,7 +1389,7 @@ file: - comparison_operator: - raw_comparison_operator: '>' - raw_comparison_operator: '=' - - numeric_literal: '0' + - integer_literal: '0' - keyword: THEN - merge_update_clause: keyword: UPDATE @@ -1429,7 +1429,7 @@ file: - comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '=' - - numeric_literal: '0' + - integer_literal: '0' - keyword: THEN - merge_delete_clause: keyword: DELETE @@ -1466,8 +1466,8 @@ file: keyword: AS naked_identifier: PreviousQty statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: merge_statement: @@ -1484,7 +1484,7 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' alias_expression: alias_operator: keyword: AS diff --git a/test/fixtures/dialects/tsql/multi_statement.sql b/test/fixtures/dialects/tsql/multi_statement.sql new file mode 100644 index 00000000000..622168ed9ab --- /dev/null +++ b/test/fixtures/dialects/tsql/multi_statement.sql @@ -0,0 +1,3 @@ +; +; +SELECT * FROM my_table; diff --git a/test/fixtures/dialects/tsql/multi_statement.yml b/test/fixtures/dialects/tsql/multi_statement.yml new file mode 100644 index 00000000000..be80d90b701 --- /dev/null +++ b/test/fixtures/dialects/tsql/multi_statement.yml @@ -0,0 +1,26 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: df7c9fcf51527197f1ccba4995e3446588de3ed9093c4d616610d1c7b6adc446 +file: + batch: + - statement_terminator: ; + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + wildcard_expression: + wildcard_identifier: + star: '*' + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: my_table + statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/multi_statement_without_semicolon.yml b/test/fixtures/dialects/tsql/multi_statement_without_semicolon.yml index b359d6d45ae..8120597d97a 100644 --- a/test/fixtures/dialects/tsql/multi_statement_without_semicolon.yml +++ b/test/fixtures/dialects/tsql/multi_statement_without_semicolon.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 00434c5df2aba3c7d90dd38aa4ffc873f52105e27a1d2df9496025becb226785 +_hash: e54ad1f77e73e8c5d5591c9b3b8f9e56bd314fce5cfa93eded2d815d95cdb539 file: - batch: statement: @@ -20,8 +20,8 @@ file: table_expression: table_reference: naked_identifier: tbl1 -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -37,5 +37,5 @@ file: table_expression: table_reference: naked_identifier: tbl2 -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/multiple_semicolons.sql b/test/fixtures/dialects/tsql/multiple_semicolons.sql new file mode 100644 index 00000000000..931d9f96153 --- /dev/null +++ b/test/fixtures/dialects/tsql/multiple_semicolons.sql @@ -0,0 +1,17 @@ +-- Leading double semicolons before first statement +;;SELECT col1 FROM tbl1; + +-- Statement with trailing double semicolons +SELECT col2 FROM tbl2;; + +-- Multiple semicolons separating statements +SELECT col3 FROM tbl3;;;;SELECT col4 FROM tbl4; + +-- Mixed whitespace and semicolons +; ; ;SELECT col5 FROM tbl5; ; ; + +-- Many semicolons at end +SELECT col6 FROM tbl6;;;;;; + +-- Many semicolons at end and GOs +SELECT col6 FROM tbl6;GO;GO;; diff --git a/test/fixtures/dialects/tsql/multiple_semicolons.yml b/test/fixtures/dialects/tsql/multiple_semicolons.yml new file mode 100644 index 00000000000..1fde3a70a55 --- /dev/null +++ b/test/fixtures/dialects/tsql/multiple_semicolons.yml @@ -0,0 +1,137 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 3d89d35f50cd45feea41a21318f695538ba2a14ad8d901b0308ea84ea370cab5 +file: +- batch: + - statement_terminator: ; + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col1 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl1 + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col2 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl2 + statement_terminator: ; + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col3 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl3 + statement_terminator: ; + statement_terminator: ; + - statement_terminator: ; + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col4 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl4 + statement_terminator: ; + statement_terminator: ; + - statement_terminator: ; + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col5 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl5 + statement_terminator: ; + statement_terminator: ; + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col6 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl6 + statement_terminator: ; + statement_terminator: ; + - statement_terminator: ; + - statement_terminator: ; + - statement_terminator: ; + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: col6 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl6 + statement_terminator: ; + - go_statement: + keyword: GO + - statement_terminator: ; +- batch: + - go_statement: + keyword: GO + - statement_terminator: ; + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/nested_joins.yml b/test/fixtures/dialects/tsql/nested_joins.yml index a6f208d1649..fdb06123e87 100644 --- a/test/fixtures/dialects/tsql/nested_joins.yml +++ b/test/fixtures/dialects/tsql/nested_joins.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: e09eedf30ed29ce19cc60d5792c9a59fe7a64e75171aa1240e3d3196a3dd7828 +_hash: 1b63dbe755608c063321279aaaf139de28ae6cb84a9efa7c9ef2d11556b61612 file: - batch: statement: @@ -11,7 +11,7 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' alias_expression: alias_operator: keyword: AS @@ -66,15 +66,15 @@ file: - dot: . - naked_identifier: Bcd statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: select_statement: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' from_clause: keyword: FROM from_expression: @@ -241,7 +241,7 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' alias_expression: alias_operator: keyword: AS @@ -298,8 +298,8 @@ file: - dot: . - naked_identifier: Bcd statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: select_statement: diff --git a/test/fixtures/dialects/tsql/open_symmetric_key.yml b/test/fixtures/dialects/tsql/open_symmetric_key.yml index 3bc60560fb4..566ecc7a89a 100644 --- a/test/fixtures/dialects/tsql/open_symmetric_key.yml +++ b/test/fixtures/dialects/tsql/open_symmetric_key.yml @@ -3,61 +3,62 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 54f1c4f8d7b6c4dc1b306ef6e84b8c64f72b5df036861dea9dfe049f86ad370a +_hash: 4d6ed32d740ef1cae77c3bcdca9396148fe910ee1d1dd4e57b3232689aa167cd file: - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - naked_identifier: dbo - - dot: . - - naked_identifier: procedure_name - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - set_segment: - - keyword: SET - - keyword: NOCOUNT - - keyword: 'ON' - - statement_terminator: ; - - statement: - open_symmetric_key_statement: - - keyword: OPEN - - keyword: SYMMETRIC - - keyword: KEY - - object_reference: - quoted_identifier: '[Key01]' - - keyword: DECRYPTION - - keyword: BY - - keyword: CERTIFICATE - - object_reference: - quoted_identifier: '[Cert]' - - statement_terminator: ; - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - column_reference: - naked_identifier: column1 - from_clause: - keyword: FROM - from_expression: - from_expression_element: - table_expression: - table_reference: - - naked_identifier: sys - - dot: . - - naked_identifier: tables - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - naked_identifier: dbo + - dot: . + - naked_identifier: procedure_name + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + set_segment: + - keyword: SET + - keyword: NOCOUNT + - keyword: 'ON' + - statement_terminator: ; + - statement: + open_symmetric_key_statement: + - keyword: OPEN + - keyword: SYMMETRIC + - keyword: KEY + - object_reference: + quoted_identifier: '[Key01]' + - keyword: DECRYPTION + - keyword: BY + - keyword: CERTIFICATE + - object_reference: + quoted_identifier: '[Cert]' + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: column1 + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: sys + - dot: . + - naked_identifier: tables + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - statement: open_symmetric_key_statement: diff --git a/test/fixtures/dialects/tsql/openjson.yml b/test/fixtures/dialects/tsql/openjson.yml index f90d4f8ed34..2f3ffd3b1f2 100644 --- a/test/fixtures/dialects/tsql/openjson.yml +++ b/test/fixtures/dialects/tsql/openjson.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 6ac05f7d3868d577713bf0c9fd2bb14064734dfeda97fe0636bd3747732a926c +_hash: 53386a039d8feacad8152fe4e5054037b4918d9192976d44dced09dc9fbeaee5 file: batch: - statement: @@ -85,7 +85,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '3' + integer_literal: '3' end_bracket: ) - comma: ',' - column_reference: @@ -136,7 +136,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '200' + integer_literal: '200' end_bracket: ) - quoted_literal: "'$.Order.Number'" - comma: ',' @@ -154,7 +154,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '200' + integer_literal: '200' end_bracket: ) - quoted_literal: "'$.AccountNumber'" - comma: ',' @@ -229,7 +229,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) quoted_literal: "'$'" end_bracket: ) @@ -296,7 +296,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '500' + integer_literal: '500' end_bracket: ) - comma: ',' - column_reference: @@ -307,7 +307,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '500' + integer_literal: '500' end_bracket: ) - quoted_literal: "'$.postcode'" - comma: ',' @@ -370,7 +370,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - comma: ',' - column_reference: @@ -381,7 +381,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - comma: ',' - column_reference: @@ -407,7 +407,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - end_bracket: ) statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/openrowset.yml b/test/fixtures/dialects/tsql/openrowset.yml index 2bb41c51089..0be25883e14 100644 --- a/test/fixtures/dialects/tsql/openrowset.yml +++ b/test/fixtures/dialects/tsql/openrowset.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: ce469a0d8d36ac5394266038687470feed3f42c351aa2f2256f63407ab35663b +_hash: a20c572eef8c620d037c11bfbc0b8af93bb35f1ac20f8eeeda3f2ec6af60b7c5 file: - batch: statement: @@ -41,8 +41,8 @@ file: keyword: AS naked_identifier: a statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -75,8 +75,8 @@ file: keyword: AS naked_identifier: d statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -113,8 +113,8 @@ file: keyword: AS naked_identifier: d statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -146,8 +146,8 @@ file: keyword: AS naked_identifier: a statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -176,8 +176,8 @@ file: keyword: AS naked_identifier: DATA statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -206,8 +206,8 @@ file: keyword: AS naked_identifier: Document statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -249,8 +249,8 @@ file: keyword: AS naked_identifier: cars statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -259,7 +259,7 @@ file: select_clause_modifier: keyword: TOP expression: - numeric_literal: '10' + integer_literal: '10' select_clause_element: wildcard_expression: wildcard_identifier: @@ -285,8 +285,8 @@ file: alias_operator: keyword: as naked_identifier: rows -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -295,7 +295,7 @@ file: select_clause_modifier: keyword: TOP expression: - numeric_literal: '10' + integer_literal: '10' select_clause_element: wildcard_expression: wildcard_identifier: @@ -328,7 +328,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '5' + integer_literal: '5' end_bracket: ) - keyword: COLLATE - collation_reference: @@ -341,7 +341,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - keyword: COLLATE - collation_reference: @@ -360,8 +360,8 @@ file: alias_operator: keyword: as naked_identifier: rows -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -370,7 +370,7 @@ file: select_clause_modifier: keyword: TOP expression: - numeric_literal: '1' + integer_literal: '1' select_clause_element: wildcard_expression: wildcard_identifier: @@ -403,7 +403,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - comma: ',' - quoted_identifier: '[stateName_explicit_path]' @@ -413,7 +413,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - quoted_literal: "'$.stateName'" - comma: ',' @@ -424,7 +424,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - comma: ',' - quoted_identifier: '[countyName_explicit_path]' @@ -434,7 +434,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) - quoted_literal: "'$.COUNTYNAME'" - comma: ',' @@ -447,5 +447,5 @@ file: alias_operator: keyword: AS quoted_identifier: '[r]' -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/print.yml b/test/fixtures/dialects/tsql/print.yml index 9a4250ea64a..f0f3a1b81a1 100644 --- a/test/fixtures/dialects/tsql/print.yml +++ b/test/fixtures/dialects/tsql/print.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 0b4d19ca1ba6503fc63c2d7023df597e2aa76bd3fff30b9918ca52c6b6d7054b +_hash: 16b16e86cbb403bc0a01f634550962ba5e442f594b0ecbc1b5fe13dcad80359b file: batch: - statement: @@ -16,7 +16,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '20' + integer_literal: '20' end_bracket: ) comparison_operator: raw_comparison_operator: '=' @@ -52,7 +52,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) end_bracket: ) statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/raiserror.yml b/test/fixtures/dialects/tsql/raiserror.yml index 1932f31bac2..d23ef569ff9 100644 --- a/test/fixtures/dialects/tsql/raiserror.yml +++ b/test/fixtures/dialects/tsql/raiserror.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 029fcbb024458cf4a54b3cbdb1c5b0d447b5d6426ce1e4d4ccf8c5265a7fee33 +_hash: 8ecea85b4c0ed446b1bc2d36dab9eec4da660b70ec3e8d3bd1231b87f1c05f3f file: batch: - statement: @@ -13,15 +13,18 @@ file: - start_bracket: ( - numeric_literal: '15600' - comma: ',' - - numeric_literal: - sign_indicator: '-' - numeric_literal: '1' + - expression: + numeric_literal: + sign_indicator: '-' + numeric_literal: '1' - comma: ',' - - numeric_literal: - sign_indicator: '-' - numeric_literal: '1' + - expression: + numeric_literal: + sign_indicator: '-' + numeric_literal: '1' - comma: ',' - - quoted_literal: "'mysp_CreateCustomer'" + - expression: + quoted_literal: "'mysp_CreateCustomer'" - end_bracket: ) - statement_terminator: ; - statement: @@ -151,8 +154,9 @@ file: - comma: ',' - numeric_literal: '11' - comma: ',' - - numeric_literal: - sign_indicator: '-' - numeric_literal: '1' + - expression: + numeric_literal: + sign_indicator: '-' + numeric_literal: '1' - end_bracket: ) - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/replicate.yml b/test/fixtures/dialects/tsql/replicate.yml index 55efbc7d518..daa09f24d13 100644 --- a/test/fixtures/dialects/tsql/replicate.yml +++ b/test/fixtures/dialects/tsql/replicate.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: f9e4be1cf7752f39ca82f62cc70f98250c8695d27f87372723b9e0b4497aecd5 +_hash: d67b316df0440ff6e5b0fe9acaf0ce7a7c66debf44236b90f8d10e800922cb47 file: batch: - statement: @@ -22,7 +22,7 @@ file: quoted_literal: "'0'" - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' binary_operator: '-' function: function_name: @@ -55,7 +55,7 @@ file: quoted_literal: "'0'" - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' binary_operator: '-' function: function_name: @@ -93,11 +93,11 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '128' + integer_literal: '128' end_bracket: ) statement_terminator: ; - statement: - set_segment: + set_local_variable_segment: keyword: SET parameter: '@BinVar' assignment_operator: @@ -115,12 +115,13 @@ file: keyword: REPLICATE function_contents: bracketed: - start_bracket: ( - numeric_literal: '0x20' - comma: ',' - expression: - numeric_literal: '128' - end_bracket: ) + - start_bracket: ( + - expression: + binary_literal: '0x20' + - comma: ',' + - expression: + integer_literal: '128' + - end_bracket: ) keyword: AS data_type: data_type_identifier: varbinary @@ -128,7 +129,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '128' + integer_literal: '128' end_bracket: ) end_bracket: ) - statement_terminator: ; + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/select.yml b/test/fixtures/dialects/tsql/select.yml index 3e039c46e9b..05924dda4c1 100644 --- a/test/fixtures/dialects/tsql/select.yml +++ b/test/fixtures/dialects/tsql/select.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 8272450206c2b86996fda2b977fa3b1b22dd363b3c6c39a5986e6e4193c02ad0 +_hash: 2ec368d1aa4bf93da6cb107da1ed09a4a153bebe93b2921507a8239bfc4d5060 file: batch: - statement: @@ -17,162 +17,162 @@ file: - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'True'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: raw_comparison_operator: '>' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'False'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: raw_comparison_operator: < - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'False'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: '>' - raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'True'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: '>' - raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'True'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'True'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'True'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '>' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'False'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '>' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'False'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: '!' - raw_comparison_operator: < - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'Why is this a thing?'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: '!' - raw_comparison_operator: < - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'Or this sort of thing?'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: '!' - raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'False'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: '!' - raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'False'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: '!' - raw_comparison_operator: '>' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'NULL Handling, Probably'" - when_clause: - keyword: WHEN - expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: - raw_comparison_operator: '!' - raw_comparison_operator: '>' - - numeric_literal: '1' + - integer_literal: '1' - keyword: THEN - expression: quoted_literal: "'NULL Handling, Probably'" @@ -875,7 +875,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '1' + integer_literal: '1' keyword: as data_type: data_type_identifier: character @@ -884,7 +884,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '1' + integer_literal: '1' end_bracket: ) end_bracket: ) - comma: ',' @@ -929,7 +929,7 @@ file: keyword: default - comma: ',' - expression: - numeric_literal: '2' + integer_literal: '2' - end_bracket: ) from_clause: keyword: FROM @@ -949,7 +949,7 @@ file: - keyword: DISTINCT - keyword: TOP - expression: - numeric_literal: '5' + integer_literal: '5' select_clause_element: column_reference: naked_identifier: some_value diff --git a/test/fixtures/dialects/tsql/select_cross_apply.yml b/test/fixtures/dialects/tsql/select_cross_apply.yml index 04206bbe86f..3e649cff81e 100644 --- a/test/fixtures/dialects/tsql/select_cross_apply.yml +++ b/test/fixtures/dialects/tsql/select_cross_apply.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 70a659b03e18eb966422c6ae7e3ff75ac3840dd748eacbb124064e0baa82e65f +_hash: f588e314b64816b2b9568ffe9717ffe397064b543dcd4ec98bb70eabe10de2f7 file: batch: - statement: @@ -142,7 +142,7 @@ file: - naked_identifier: DeptMgrID comparison_operator: raw_comparison_operator: '=' - numeric_literal: '10' + integer_literal: '10' statement_terminator: ; - statement: select_statement: @@ -230,7 +230,7 @@ file: - naked_identifier: DepartmentId comparison_operator: raw_comparison_operator: '=' - numeric_literal: '10' + integer_literal: '10' statement_terminator: ; - statement: select_statement: diff --git a/test/fixtures/dialects/tsql/select_date_functions.yml b/test/fixtures/dialects/tsql/select_date_functions.yml index 7de5094ece5..7208f81116c 100644 --- a/test/fixtures/dialects/tsql/select_date_functions.yml +++ b/test/fixtures/dialects/tsql/select_date_functions.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: bbe4d3700aee81fbadf5534299ef5f204e99c5e8c105976dcc2da4f8aab8d4a3 +_hash: 4cddac3c5d9095ee30b99ec250033687fa91eb86532a921ccdbc967841a5fa2a file: batch: statement: @@ -270,7 +270,7 @@ file: - date_part: year - comma: ',' - expression: - numeric_literal: '2147483647' + integer_literal: '2147483647' - comma: ',' - expression: quoted_literal: "'20060731'" diff --git a/test/fixtures/dialects/tsql/select_for.sql b/test/fixtures/dialects/tsql/select_for.sql index 955f2d459d6..4b3b784e40b 100644 --- a/test/fixtures/dialects/tsql/select_for.sql +++ b/test/fixtures/dialects/tsql/select_for.sql @@ -49,6 +49,16 @@ FROM Production.ProductModel WHERE ProductModelID=122 OR ProductModelID=119 FOR XML PATH ('root'); +-- Per Issue #5567 +SELECT 0 ErrorCode +FOR XML PATH('Result'), TYPE + +SELECT 0 ErrorCode +FOR XML PATH('Result'), ROOT('RootName'), TYPE + +SELECT 0 ErrorCode +FOR XML PATH('Result'), TYPE, ROOT('RootName') + -- FOR BROWSE SELECT 1 AS a FOR BROWSE diff --git a/test/fixtures/dialects/tsql/select_for.yml b/test/fixtures/dialects/tsql/select_for.yml index bff483ae74a..a526c81faa7 100644 --- a/test/fixtures/dialects/tsql/select_for.yml +++ b/test/fixtures/dialects/tsql/select_for.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: eeca5acfbc969b788e1b66970470ed58514391d9232c51a024d64d3fdd6f6550 +_hash: 47a072e8ebd4a29ab9931979bd82178bd5475e916339440d64592b82401343fb file: - batch: statement: @@ -29,15 +29,15 @@ file: - keyword: JSON - keyword: AUTO statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' alias_expression: alias_operator: keyword: AS @@ -47,15 +47,15 @@ file: - keyword: JSON - keyword: PATH statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' alias_expression: alias_operator: keyword: AS @@ -66,8 +66,8 @@ file: - keyword: PATH - comma: ',' - keyword: WITHOUT_ARRAY_WRAPPER -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -136,15 +136,15 @@ file: - keyword: JSON - keyword: AUTO statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' alias_expression: alias_operator: keyword: AS @@ -164,8 +164,8 @@ file: - comma: ',' - keyword: INCLUDE_NULL_VALUES statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: select_statement: @@ -194,13 +194,13 @@ file: naked_identifier: ProductModelID - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '122' + - integer_literal: '122' - binary_operator: or - column_reference: naked_identifier: ProductModelID - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '119' + - integer_literal: '119' for_clause: - keyword: FOR - keyword: XML @@ -233,7 +233,7 @@ file: naked_identifier: ProductPhotoID comparison_operator: raw_comparison_operator: '=' - numeric_literal: '70' + integer_literal: '70' for_clause: - keyword: FOR - keyword: XML @@ -244,7 +244,7 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' alias_expression: alias_operator: keyword: as @@ -294,13 +294,13 @@ file: naked_identifier: ProductModelID - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '122' + - integer_literal: '122' - binary_operator: OR - column_reference: naked_identifier: ProductModelID - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '119' + - integer_literal: '119' for_clause: - keyword: FOR - keyword: XML @@ -315,7 +315,73 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '0' + alias_expression: + naked_identifier: ErrorCode + for_clause: + - keyword: FOR + - keyword: XML + - keyword: PATH + - bracketed: + start_bracket: ( + quoted_literal: "'Result'" + end_bracket: ) + - comma: ',' + - keyword: TYPE + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '0' + alias_expression: + naked_identifier: ErrorCode + for_clause: + - keyword: FOR + - keyword: XML + - keyword: PATH + - bracketed: + start_bracket: ( + quoted_literal: "'Result'" + end_bracket: ) + - comma: ',' + - keyword: ROOT + - bracketed: + start_bracket: ( + quoted_literal: "'RootName'" + end_bracket: ) + - comma: ',' + - keyword: TYPE + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '0' + alias_expression: + naked_identifier: ErrorCode + for_clause: + - keyword: FOR + - keyword: XML + - keyword: PATH + - bracketed: + start_bracket: ( + quoted_literal: "'Result'" + end_bracket: ) + - comma: ',' + - keyword: TYPE + - comma: ',' + - keyword: ROOT + - bracketed: + start_bracket: ( + quoted_literal: "'RootName'" + end_bracket: ) + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' alias_expression: alias_operator: keyword: AS @@ -323,5 +389,5 @@ file: for_clause: - keyword: FOR - keyword: BROWSE -- go_statement: - keyword: GO + - go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/select_named_window.yml b/test/fixtures/dialects/tsql/select_named_window.yml index 934ef38d420..b7948d3fe50 100644 --- a/test/fixtures/dialects/tsql/select_named_window.yml +++ b/test/fixtures/dialects/tsql/select_named_window.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 24dceed7a3e011ab5c6f65e97a705d9a988ca9bd6a99da65557acf056d3653b5 +_hash: 14f8011ab0491aa10933c6f6afe83b3543d8144f3327425e1367768a5eb3db6d file: batch: - statement: @@ -122,7 +122,7 @@ file: - comparison_operator: - raw_comparison_operator: < - raw_comparison_operator: '>' - - numeric_literal: '0' + - integer_literal: '0' named_window: keyword: WINDOW named_window_expression: @@ -276,9 +276,9 @@ file: keyword: IN bracketed: - start_bracket: ( - - numeric_literal: '43659' + - integer_literal: '43659' - comma: ',' - - numeric_literal: '43664' + - integer_literal: '43664' - end_bracket: ) named_window: keyword: WINDOW @@ -413,9 +413,9 @@ file: - keyword: IN - bracketed: - start_bracket: ( - - numeric_literal: '43659' + - integer_literal: '43659' - comma: ',' - - numeric_literal: '43664' + - integer_literal: '43664' - end_bracket: ) - binary_operator: AND - column_reference: @@ -518,9 +518,9 @@ file: - keyword: IN - bracketed: - start_bracket: ( - - numeric_literal: '43659' + - integer_literal: '43659' - comma: ',' - - numeric_literal: '43664' + - integer_literal: '43664' - end_bracket: ) - binary_operator: AND - column_reference: diff --git a/test/fixtures/dialects/tsql/select_pivot.yml b/test/fixtures/dialects/tsql/select_pivot.yml index 61cfc4fb00f..780749c739d 100644 --- a/test/fixtures/dialects/tsql/select_pivot.yml +++ b/test/fixtures/dialects/tsql/select_pivot.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 42bc55b8cb475283121f1b764e6cbc0c8ec49b0889a46566400f1073b355b7f4 +_hash: 68453e339c767419fe694e2226fa9c046ecca3c2a2fb7c13a3c59b75d7c9bbf6 file: - batch: - statement: @@ -125,8 +125,8 @@ file: table_reference: naked_identifier: pvt statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: select_statement: @@ -225,5 +225,5 @@ file: - dot: . - naked_identifier: MonthColumn statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/select_top.yml b/test/fixtures/dialects/tsql/select_top.yml index d7faa042348..ab18dbef5e5 100644 --- a/test/fixtures/dialects/tsql/select_top.yml +++ b/test/fixtures/dialects/tsql/select_top.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 79179b70d53285f84676528487a6a71ca11f416ec858ecdfa0c5909f1f467d30 +_hash: 0e83e439d8537e3a217e2edb9a9ce855eb646bed22849f13436e830e9739a3aa file: batch: - statement: @@ -13,7 +13,7 @@ file: select_clause_modifier: keyword: top expression: - numeric_literal: '1' + integer_literal: '1' select_clause_element: column_reference: - naked_identifier: t @@ -54,7 +54,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '10' + integer_literal: '10' end_bracket: ) - select_clause_element: column_reference: @@ -82,7 +82,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '10' + integer_literal: '10' end_bracket: ) - select_clause_element: column_reference: @@ -116,7 +116,7 @@ file: - bracketed: start_bracket: ( expression: - numeric_literal: '5' + integer_literal: '5' end_bracket: ) - keyword: PERCENT - select_clause_element: @@ -151,7 +151,7 @@ file: - bracketed: start_bracket: ( expression: - numeric_literal: '10' + integer_literal: '10' end_bracket: ) - keyword: PERCENT - keyword: WITH diff --git a/test/fixtures/dialects/tsql/sequence.yml b/test/fixtures/dialects/tsql/sequence.yml index d7a502d3ab0..cb3ee032edd 100644 --- a/test/fixtures/dialects/tsql/sequence.yml +++ b/test/fixtures/dialects/tsql/sequence.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: e0e8fd69019db0ed39c2baf5e6e04d8015b32483129f0e256d19de7838d1a0f7 +_hash: c4323152aa3d00f532c08d31c215e13a456982293f741a4aee205503766310f5 file: - batch: statement: @@ -20,8 +20,8 @@ file: - keyword: INCREMENT - keyword: BY - numeric_literal: '1' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_sequence_statement: @@ -39,10 +39,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '3' + integer_literal: '3' - comma: ',' - expression: - numeric_literal: '0' + integer_literal: '0' - end_bracket: ) - create_sequence_options_segment: - keyword: START diff --git a/test/fixtures/dialects/tsql/set_context_info.yml b/test/fixtures/dialects/tsql/set_context_info.yml index ecff4011ed5..3032adfecc4 100644 --- a/test/fixtures/dialects/tsql/set_context_info.yml +++ b/test/fixtures/dialects/tsql/set_context_info.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: ac90b1cbf372890a0cdd68884d7cb6035083f8dfde4433230a8afbae43d79000 +_hash: d60326cc9197d8b98aa2e1d3659cd40cebca9963acdd921edb07f0f294e8dcfb file: batch: - statement: @@ -22,11 +22,11 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '128' + integer_literal: '128' end_bracket: ) statement_terminator: ; - statement: - set_segment: + set_local_variable_segment: keyword: SET parameter: '@BinVar' assignment_operator: @@ -44,12 +44,13 @@ file: keyword: REPLICATE function_contents: bracketed: - start_bracket: ( - numeric_literal: '0x20' - comma: ',' - expression: - numeric_literal: '128' - end_bracket: ) + - start_bracket: ( + - expression: + binary_literal: '0x20' + - comma: ',' + - expression: + integer_literal: '128' + - end_bracket: ) keyword: AS data_type: data_type_identifier: varbinary @@ -57,10 +58,10 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '128' + integer_literal: '128' end_bracket: ) end_bracket: ) - statement_terminator: ; + - statement_terminator: ; - statement: set_context_info_statement: - keyword: SET diff --git a/test/fixtures/dialects/tsql/set_language.sql b/test/fixtures/dialects/tsql/set_language.sql new file mode 100644 index 00000000000..e265220543f --- /dev/null +++ b/test/fixtures/dialects/tsql/set_language.sql @@ -0,0 +1,4 @@ +SET LANGUAGE us_english; +SET LANGUAGE 'us_english'; +SET LANGUAGE [us_english]; +SET LANGUAGE British; diff --git a/test/fixtures/dialects/tsql/set_language.yml b/test/fixtures/dialects/tsql/set_language.yml new file mode 100644 index 00000000000..fd207955899 --- /dev/null +++ b/test/fixtures/dialects/tsql/set_language.yml @@ -0,0 +1,32 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 0d2358bc7632d29be0711f5536c0220f2f1731945fdb92498baf6de7b788e712 +file: + batch: + - statement: + set_language_statement: + - keyword: SET + - keyword: LANGUAGE + - naked_identifier: us_english + - statement_terminator: ; + - statement: + set_language_statement: + - keyword: SET + - keyword: LANGUAGE + - quoted_literal: "'us_english'" + - statement_terminator: ; + - statement: + set_language_statement: + - keyword: SET + - keyword: LANGUAGE + - quoted_identifier: '[us_english]' + - statement_terminator: ; + - statement: + set_language_statement: + - keyword: SET + - keyword: LANGUAGE + - naked_identifier: British + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/set_local_variable.sql b/test/fixtures/dialects/tsql/set_local_variable.sql new file mode 100644 index 00000000000..d4d347c873d --- /dev/null +++ b/test/fixtures/dialects/tsql/set_local_variable.sql @@ -0,0 +1,97 @@ +-- Print the value of a variable initialized by using SET +DECLARE @myVar CHAR(20); +SET @myVar = 'This is a test'; +SELECT @myVar; +GO + +-- Use a local variable assigned a value by using SET in a SELECT statement +DECLARE @state CHAR(25); +SET @state = N'Oregon'; +SELECT + CITY, + RTRIM(FIRSTNAME) + ' ' + RTRIM(LASTNAME) AS FULL_NAME +FROM HUMANRESOURCES.VEMPLOYEE +WHERE STATEPROVINCENAME = @state; + +-- Use a compound assignment for a local variable +DECLARE @NewBalance INT; +SET @NewBalance = 10; +SET @NewBalance = @NewBalance * 10; +SELECT @NewBalance; +GO + +-- Use SET with a global cursor +DECLARE MY_CURSOR CURSOR GLOBAL +FOR SELECT SHIP_DATE FROM PURCHASING.SHIPMETHOD +DECLARE @my_variable CURSOR; +SET @my_variable = MY_CURSOR; + +DEALLOCATE MY_CURSOR; +GO + +-- Define a cursor by using SET +DECLARE @CursorVar CURSOR; + +SET + @CursorVar = CURSOR SCROLL DYNAMIC + FOR + SELECT + LASTNAME, + FIRSTNAME + FROM ADVENTUREWORKS2022.HUMANRESOURCES.EMPLOYEE + WHERE LASTNAME LIKE 'B%'; + +OPEN @CursorVar; + +FETCH NEXT FROM @CursorVar; +WHILE @@FETCH_STATUS = 0 + BEGIN + FETCH NEXT FROM @CursorVar + END; + +CLOSE @CursorVar; +DEALLOCATE @CursorVar; +GO + +-- Assign a value from a query +USE ADVENTUREWORKS2022; +GO +DECLARE @rows INT; +SET @rows = (SELECT COUNT(*) FROM SALES.CUSTOMER); +SELECT @rows; +GO + +-- Single params +SET @param1 = 1 +; + +-- Multiple params +SET + @param1 = 1, + @param2 = 2 +; + +-- Comma separated params with comment with comma +SET @param1 = "test, test", + @param2 = 2 +; + +-- Params with expression +SET @param1 = ("test", "test"), + @param2 = 2 +; + +-- Assignment operators +SET @param1 += 1, + @param2 -= 2, + @param3 *= 3, + @param4 /= 4, + @param5 %= 5, + @param5 ^= 6, + @param5 &= 7, + @param5 |= 8 +; + +-- Param with sequence in expression +SET @param1 = (NEXT VALUE FOR [dbo].[sequence_name]) +; diff --git a/test/fixtures/dialects/tsql/set_local_variable.yml b/test/fixtures/dialects/tsql/set_local_variable.yml new file mode 100644 index 00000000000..ddb092452d9 --- /dev/null +++ b/test/fixtures/dialects/tsql/set_local_variable.yml @@ -0,0 +1,493 @@ +# YML test files are auto-generated from SQL files and should not be edited by +# hand. To help enforce this, the "hash" field in the file must match a hash +# computed by SQLFluff when running the tests. Please run +# `python test/generate_parse_fixture_yml.py` to generate them after adding or +# altering SQL files. +_hash: 5fc1f18065f3833fcf98078b3ed4a14e29e8f8ae8c18169d0b19c982769ca340 +file: +- batch: + - statement: + declare_segment: + keyword: DECLARE + parameter: '@myVar' + data_type: + data_type_identifier: CHAR + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '20' + end_bracket: ) + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@myVar' + assignment_operator: + raw_comparison_operator: '=' + expression: + quoted_literal: "'This is a test'" + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + parameter: '@myVar' + statement_terminator: ; + - go_statement: + keyword: GO +- batch: + - statement: + declare_segment: + keyword: DECLARE + parameter: '@state' + data_type: + data_type_identifier: CHAR + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '25' + end_bracket: ) + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@state' + assignment_operator: + raw_comparison_operator: '=' + expression: + quoted_literal: "N'Oregon'" + - statement_terminator: ; + - statement: + select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + naked_identifier: CITY + - comma: ',' + - select_clause_element: + expression: + - function: + function_name: + function_name_identifier: RTRIM + function_contents: + bracketed: + start_bracket: ( + expression: + column_reference: + naked_identifier: FIRSTNAME + end_bracket: ) + - binary_operator: + + - quoted_literal: "' '" + - binary_operator: + + - function: + function_name: + function_name_identifier: RTRIM + function_contents: + bracketed: + start_bracket: ( + expression: + column_reference: + naked_identifier: LASTNAME + end_bracket: ) + alias_expression: + alias_operator: + keyword: AS + naked_identifier: FULL_NAME + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: HUMANRESOURCES + - dot: . + - naked_identifier: VEMPLOYEE + where_clause: + keyword: WHERE + expression: + column_reference: + naked_identifier: STATEPROVINCENAME + comparison_operator: + raw_comparison_operator: '=' + parameter: '@state' + statement_terminator: ; + - statement: + declare_segment: + keyword: DECLARE + parameter: '@NewBalance' + data_type: + data_type_identifier: INT + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@NewBalance' + assignment_operator: + raw_comparison_operator: '=' + expression: + integer_literal: '10' + - statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@NewBalance' + assignment_operator: + raw_comparison_operator: '=' + expression: + parameter: '@NewBalance' + binary_operator: '*' + integer_literal: '10' + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + parameter: '@NewBalance' + statement_terminator: ; + - go_statement: + keyword: GO +- batch: + - statement: + declare_segment: + keyword: DECLARE + naked_identifier: MY_CURSOR + cursor_definition: + - keyword: CURSOR + - keyword: GLOBAL + - keyword: FOR + - select_statement: + select_clause: + keyword: SELECT + select_clause_element: + column_reference: + naked_identifier: SHIP_DATE + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: PURCHASING + - dot: . + - naked_identifier: SHIPMETHOD + - statement: + declare_segment: + - keyword: DECLARE + - parameter: '@my_variable' + - keyword: CURSOR + - statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@my_variable' + assignment_operator: + raw_comparison_operator: '=' + expression: + column_reference: + naked_identifier: MY_CURSOR + - statement_terminator: ; + - statement: + deallocate_cursor_statement: + keyword: DEALLOCATE + naked_identifier: MY_CURSOR + - statement_terminator: ; + - go_statement: + keyword: GO +- batch: + - statement: + declare_segment: + - keyword: DECLARE + - parameter: '@CursorVar' + - keyword: CURSOR + - statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@CursorVar' + comparison_operator: + raw_comparison_operator: '=' + cursor_definition: + - keyword: CURSOR + - keyword: SCROLL + - keyword: DYNAMIC + - keyword: FOR + - select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + naked_identifier: LASTNAME + - comma: ',' + - select_clause_element: + column_reference: + naked_identifier: FIRSTNAME + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: ADVENTUREWORKS2022 + - dot: . + - naked_identifier: HUMANRESOURCES + - dot: . + - naked_identifier: EMPLOYEE + where_clause: + keyword: WHERE + expression: + column_reference: + naked_identifier: LASTNAME + keyword: LIKE + quoted_literal: "'B%'" + statement_terminator: ; + - statement: + open_cursor_statement: + keyword: OPEN + parameter: '@CursorVar' + - statement_terminator: ; + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: NEXT + - keyword: FROM + - parameter: '@CursorVar' + - statement_terminator: ; + - statement: + while_statement: + keyword: WHILE + expression: + system_variable: '@@FETCH_STATUS' + comparison_operator: + raw_comparison_operator: '=' + integer_literal: '0' + statement: + begin_end_block: + - keyword: BEGIN + - statement: + fetch_cursor_statement: + - keyword: FETCH + - keyword: NEXT + - keyword: FROM + - parameter: '@CursorVar' + - keyword: END + statement_terminator: ; + - statement: + close_cursor_statement: + keyword: CLOSE + parameter: '@CursorVar' + - statement_terminator: ; + - statement: + deallocate_cursor_statement: + keyword: DEALLOCATE + parameter: '@CursorVar' + - statement_terminator: ; + - go_statement: + keyword: GO +- batch: + statement: + use_statement: + keyword: USE + database_reference: + naked_identifier: ADVENTUREWORKS2022 + statement_terminator: ; + go_statement: + keyword: GO +- batch: + - statement: + declare_segment: + keyword: DECLARE + parameter: '@rows' + data_type: + data_type_identifier: INT + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@rows' + assignment_operator: + raw_comparison_operator: '=' + expression: + bracketed: + start_bracket: ( + expression: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + function: + function_name: + function_name_identifier: COUNT + function_contents: + bracketed: + start_bracket: ( + star: '*' + end_bracket: ) + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: SALES + - dot: . + - naked_identifier: CUSTOMER + end_bracket: ) + - statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + parameter: '@rows' + statement_terminator: ; + - go_statement: + keyword: GO +- batch: + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@param1' + assignment_operator: + raw_comparison_operator: '=' + expression: + integer_literal: '1' + - statement_terminator: ; + - statement: + set_local_variable_segment: + - keyword: SET + - parameter: '@param1' + - assignment_operator: + raw_comparison_operator: '=' + - expression: + integer_literal: '1' + - comma: ',' + - parameter: '@param2' + - assignment_operator: + raw_comparison_operator: '=' + - expression: + integer_literal: '2' + - statement_terminator: ; + - statement: + set_local_variable_segment: + - keyword: SET + - parameter: '@param1' + - assignment_operator: + raw_comparison_operator: '=' + - expression: + column_reference: + quoted_identifier: '"test, test"' + - comma: ',' + - parameter: '@param2' + - assignment_operator: + raw_comparison_operator: '=' + - expression: + integer_literal: '2' + - statement_terminator: ; + - statement: + set_local_variable_segment: + - keyword: SET + - parameter: '@param1' + - assignment_operator: + raw_comparison_operator: '=' + - expression: + bracketed: + - start_bracket: ( + - column_reference: + quoted_identifier: '"test"' + - comma: ',' + - column_reference: + quoted_identifier: '"test"' + - end_bracket: ) + - comma: ',' + - parameter: '@param2' + - assignment_operator: + raw_comparison_operator: '=' + - expression: + integer_literal: '2' + - statement_terminator: ; + - statement: + set_local_variable_segment: + - keyword: SET + - parameter: '@param1' + - assignment_operator: + binary_operator: + + raw_comparison_operator: '=' + - expression: + integer_literal: '1' + - comma: ',' + - parameter: '@param2' + - assignment_operator: + binary_operator: '-' + raw_comparison_operator: '=' + - expression: + integer_literal: '2' + - comma: ',' + - parameter: '@param3' + - assignment_operator: + binary_operator: '*' + raw_comparison_operator: '=' + - expression: + integer_literal: '3' + - comma: ',' + - parameter: '@param4' + - assignment_operator: + binary_operator: / + raw_comparison_operator: '=' + - expression: + integer_literal: '4' + - comma: ',' + - parameter: '@param5' + - assignment_operator: + binary_operator: '%' + raw_comparison_operator: '=' + - expression: + integer_literal: '5' + - comma: ',' + - parameter: '@param5' + - assignment_operator: + binary_operator: ^ + raw_comparison_operator: '=' + - expression: + integer_literal: '6' + - comma: ',' + - parameter: '@param5' + - assignment_operator: + binary_operator: + ampersand: '&' + raw_comparison_operator: '=' + - expression: + integer_literal: '7' + - comma: ',' + - parameter: '@param5' + - assignment_operator: + binary_operator: + pipe: '|' + raw_comparison_operator: '=' + - expression: + integer_literal: '8' + - statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@param1' + assignment_operator: + raw_comparison_operator: '=' + expression: + bracketed: + start_bracket: ( + expression: + sequence_next_value: + - keyword: NEXT + - keyword: VALUE + - keyword: FOR + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[sequence_name]' + end_bracket: ) + - statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/set_statements.sql b/test/fixtures/dialects/tsql/set_statements.sql index 48958314fe3..65c31ba1942 100644 --- a/test/fixtures/dialects/tsql/set_statements.sql +++ b/test/fixtures/dialects/tsql/set_statements.sql @@ -1,35 +1,3 @@ SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; --- Single params -SET @param1 = 1 -; - --- Multiple params -SET @param1 = 1, - @param2 = 2 -; - --- Comma separated params with comment with comma -SET @param1 = "test, test", - @param2 = 2 -; - --- Params with expression -SET @param1 = ("test", "test"), - @param2 = 2 -; - --- Assignment operators -SET @param1 += 1, - @param2 -= 2, - @param3 *= 3, - @param4 /= 4, - @param5 %= 5, - @param5 ^= 6, - @param5 &= 7, - @param5 |= 8 -; - --- Param with sequence in expression -SET @param1 = (NEXT VALUE FOR [dbo].[SEQUENCE_NAME]) -; +DECLARE @BinaryVariable2 BINARY(2) = 0xFA; diff --git a/test/fixtures/dialects/tsql/set_statements.yml b/test/fixtures/dialects/tsql/set_statements.yml index fed3253d59a..2583177c91b 100644 --- a/test/fixtures/dialects/tsql/set_statements.yml +++ b/test/fixtures/dialects/tsql/set_statements.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: ad529eb73bf8da610ceddcbb5d0a7f5cbfa86bc470a92596bf7c4c82704278c1 +_hash: f6bad0bf899b761319fb4b73e547803469634de54af1ba37cde6b6b131b225c1 file: batch: - statement: @@ -16,145 +16,19 @@ file: - keyword: UNCOMMITTED - statement_terminator: ; - statement: - set_segment: - keyword: SET - parameter: '@param1' - assignment_operator: - raw_comparison_operator: '=' - expression: - numeric_literal: '1' - statement_terminator: ; - - statement: - set_segment: - - keyword: SET - - parameter: '@param1' - - assignment_operator: - raw_comparison_operator: '=' - - expression: - numeric_literal: '1' - - comma: ',' - - parameter: '@param2' - - assignment_operator: - raw_comparison_operator: '=' - - expression: - numeric_literal: '2' - - statement_terminator: ; - - statement: - set_segment: - - keyword: SET - - parameter: '@param1' - - assignment_operator: - raw_comparison_operator: '=' - - expression: - column_reference: - quoted_identifier: '"test, test"' - - comma: ',' - - parameter: '@param2' - - assignment_operator: - raw_comparison_operator: '=' - - expression: - numeric_literal: '2' - - statement_terminator: ; - - statement: - set_segment: - - keyword: SET - - parameter: '@param1' - - assignment_operator: - raw_comparison_operator: '=' - - expression: - bracketed: - - start_bracket: ( - - column_reference: - quoted_identifier: '"test"' - - comma: ',' - - column_reference: - quoted_identifier: '"test"' - - end_bracket: ) - - comma: ',' - - parameter: '@param2' - - assignment_operator: - raw_comparison_operator: '=' - - expression: - numeric_literal: '2' - - statement_terminator: ; - - statement: - set_segment: - - keyword: SET - - parameter: '@param1' - - assignment_operator: - binary_operator: + - raw_comparison_operator: '=' - - expression: - numeric_literal: '1' - - comma: ',' - - parameter: '@param2' - - assignment_operator: - binary_operator: '-' - raw_comparison_operator: '=' - - expression: - numeric_literal: '2' - - comma: ',' - - parameter: '@param3' - - assignment_operator: - binary_operator: '*' - raw_comparison_operator: '=' - - expression: - numeric_literal: '3' - - comma: ',' - - parameter: '@param4' - - assignment_operator: - binary_operator: / - raw_comparison_operator: '=' - - expression: - numeric_literal: '4' - - comma: ',' - - parameter: '@param5' - - assignment_operator: - binary_operator: '%' - raw_comparison_operator: '=' - - expression: - numeric_literal: '5' - - comma: ',' - - parameter: '@param5' - - assignment_operator: - binary_operator: ^ - raw_comparison_operator: '=' - - expression: - numeric_literal: '6' - - comma: ',' - - parameter: '@param5' - - assignment_operator: - binary_operator: - ampersand: '&' - raw_comparison_operator: '=' - - expression: - numeric_literal: '7' - - comma: ',' - - parameter: '@param5' - - assignment_operator: - binary_operator: - pipe: '|' - raw_comparison_operator: '=' - - expression: - numeric_literal: '8' - - statement_terminator: ; - - statement: - set_segment: - keyword: SET - parameter: '@param1' - assignment_operator: + declare_segment: + keyword: DECLARE + parameter: '@BinaryVariable2' + data_type: + data_type_identifier: BINARY + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '2' + end_bracket: ) + comparison_operator: raw_comparison_operator: '=' expression: - bracketed: - start_bracket: ( - expression: - sequence_next_value: - - keyword: NEXT - - keyword: VALUE - - keyword: FOR - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[SEQUENCE_NAME]' - end_bracket: ) + binary_literal: '0xFA' statement_terminator: ; diff --git a/test/fixtures/dialects/tsql/stored_procedure_begin_end.yml b/test/fixtures/dialects/tsql/stored_procedure_begin_end.yml index bf138169e35..f4aef74217a 100644 --- a/test/fixtures/dialects/tsql/stored_procedure_begin_end.yml +++ b/test/fixtures/dialects/tsql/stored_procedure_begin_end.yml @@ -3,277 +3,281 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 21356df263327efa381bdb326b08c823c86242dab0bb18cc5b26b1a2aba9f7b4 +_hash: 1ba792a3cd074bd377899c7aaf968073f7630fd0cf891b48ebf314366e9d1d06 file: - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - naked_identifier: dbo - - dot: . - - naked_identifier: Test_Begin_End - - keyword: AS - - procedure_statement: - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - quoted_literal: "'Weekend'" - statement_terminator: ; - - statement: - select_statement: - select_clause: - keyword: select - select_clause_element: - column_reference: - naked_identifier: a - from_clause: - keyword: from - from_expression: - from_expression_element: - table_expression: - table_reference: - naked_identifier: tbl1 + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - naked_identifier: dbo + - dot: . + - naked_identifier: Test_Begin_End + - keyword: AS + - procedure_statement: + statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + quoted_literal: "'Weekend'" statement_terminator: ; - - statement: - select_statement: - select_clause: - keyword: select - select_clause_element: - column_reference: - naked_identifier: b - from_clause: - keyword: from - from_expression: - from_expression_element: - table_expression: - table_reference: - naked_identifier: tbl2 - statement_terminator: ; - - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + column_reference: + naked_identifier: a + from_clause: + keyword: from + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl1 + statement_terminator: ; + - statement: + select_statement: + select_clause: + keyword: select + select_clause_element: + column_reference: + naked_identifier: b + from_clause: + keyword: from + from_expression: + from_expression_element: + table_expression: + table_reference: + naked_identifier: tbl2 + statement_terminator: ; + - keyword: END + statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[usp_process_tran_log]' - - procedure_parameter_list: - - parameter: '@out_vchCode' - - data_type: - data_type_identifier: uddt_output_code - - keyword: OUTPUT - - comma: ',' - - parameter: '@out_vchMsg' - - data_type: - data_type_identifier: uddt_output_msg - - keyword: OUTPUT - - comma: ',' - - parameter: '@in_debug' - - data_type: - data_type_identifier: INT - - comparison_operator: - raw_comparison_operator: '=' - - expression: - numeric_literal: '1' - - keyword: AS - - procedure_statement: - - statement: - set_segment: - - keyword: SET - - keyword: NOCOUNT - - keyword: 'ON' - - statement_terminator: ; - - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - quoted_literal: "'8'" - - keyword: END - - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[usp_process_tran_log]' + - procedure_parameter_list: + - parameter: '@out_vchCode' + - data_type: + data_type_identifier: uddt_output_code + - keyword: OUTPUT + - comma: ',' + - parameter: '@out_vchMsg' + - data_type: + data_type_identifier: uddt_output_msg + - keyword: OUTPUT + - comma: ',' + - parameter: '@in_debug' + - data_type: + data_type_identifier: INT + - comparison_operator: + raw_comparison_operator: '=' + - expression: + integer_literal: '1' + - keyword: AS + - procedure_statement: + - statement: + set_segment: + - keyword: SET + - keyword: NOCOUNT + - keyword: 'ON' + - statement_terminator: ; + - statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + quoted_literal: "'8'" + - keyword: END + - statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[usp_process_tran_log]' - - procedure_parameter_list: - - parameter: '@out_vchCode' - - data_type: - data_type_identifier: uddt_output_code - - keyword: OUTPUT - - comma: ',' - - parameter: '@out_vchMsg' - - data_type: - data_type_identifier: uddt_output_msg - - keyword: OUT - - comma: ',' - - parameter: '@in_debug' - - data_type: - data_type_identifier: INT - - comparison_operator: - raw_comparison_operator: '=' - - expression: - numeric_literal: '1' - - keyword: READONLY - - keyword: AS - - procedure_statement: - - statement: - set_segment: - - keyword: SET - - keyword: NOCOUNT - - keyword: 'ON' - - statement_terminator: ; - - statement: - begin_end_block: - - keyword: BEGIN - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - quoted_literal: "'8'" - - keyword: END - - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[usp_process_tran_log]' + - procedure_parameter_list: + - parameter: '@out_vchCode' + - data_type: + data_type_identifier: uddt_output_code + - keyword: OUTPUT + - comma: ',' + - parameter: '@out_vchMsg' + - data_type: + data_type_identifier: uddt_output_msg + - keyword: OUT + - comma: ',' + - parameter: '@in_debug' + - data_type: + data_type_identifier: INT + - comparison_operator: + raw_comparison_operator: '=' + - expression: + integer_literal: '1' + - keyword: READONLY + - keyword: AS + - procedure_statement: + - statement: + set_segment: + - keyword: SET + - keyword: NOCOUNT + - keyword: 'ON' + - statement_terminator: ; + - statement: + begin_end_block: + - keyword: BEGIN + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + quoted_literal: "'8'" + - keyword: END + - statement_terminator: ; + go_statement: + keyword: GO - batch: - create_procedure_statement: - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - quoted_identifier: '[dbo]' - - dot: . - - quoted_identifier: '[usp_process_tran_log]' - - procedure_parameter_list: - - parameter: '@out_vchCode' - - data_type: - data_type_identifier: uddt_output_code - - keyword: OUTPUT - - comma: ',' - - parameter: '@out_vchMsg' - - data_type: - data_type_identifier: uddt_output_msg - - keyword: OUTPUT - - comma: ',' - - parameter: '@in_debug' - - data_type: - data_type_identifier: INT - - comparison_operator: - raw_comparison_operator: '=' - - expression: - numeric_literal: '1' - - keyword: AS - - procedure_statement: - - statement: - set_segment: - - keyword: SET - - keyword: NOCOUNT - - keyword: 'ON' - - statement_terminator: ; - - statement: - begin_end_block: - - keyword: BEGIN - - statement: - try_catch: - - keyword: BEGIN - - keyword: TRY - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - quoted_literal: "'8'" - statement_terminator: ; - - keyword: END - - keyword: TRY - - keyword: BEGIN - - keyword: CATCH - - statement: - set_segment: - keyword: SET - parameter: '@v_nSysErrorNum' - assignment_operator: - raw_comparison_operator: '=' - expression: - function: - function_name: - function_name_identifier: ERROR_NUMBER - function_contents: - bracketed: - start_bracket: ( - end_bracket: ) - statement_terminator: ; - - statement: - set_segment: - keyword: SET - parameter: '@v_vchCode' - assignment_operator: - raw_comparison_operator: '=' - expression: - function: - function_name: - function_name_identifier: ERROR_LINE - function_contents: - bracketed: - start_bracket: ( - end_bracket: ) - statement_terminator: ; - - statement: - set_segment: - keyword: SET - parameter: '@v_vchMsg' - assignment_operator: - raw_comparison_operator: '=' - expression: - quoted_literal: "N'Missing control type.'" - statement_terminator: ; - - statement: - set_segment: - keyword: SET - parameter: '@v_vchMsg' - assignment_operator: - raw_comparison_operator: '=' - expression: - - parameter: '@v_vchMsg' - - binary_operator: + - - quoted_literal: "N' SQL Error = '" - - binary_operator: + - - function: - function_name: - function_name_identifier: ERROR_MESSAGE - function_contents: - bracketed: - start_bracket: ( - end_bracket: ) - statement_terminator: ; - - statement: - goto_statement: - keyword: GOTO - naked_identifier: ERROR_HANDLER - - statement_terminator: ; - - keyword: END - - keyword: CATCH - - keyword: END - - statement_terminator: ; -- go_statement: - keyword: GO + statement: + create_procedure_statement: + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + - quoted_identifier: '[dbo]' + - dot: . + - quoted_identifier: '[usp_process_tran_log]' + - procedure_parameter_list: + - parameter: '@out_vchCode' + - data_type: + data_type_identifier: uddt_output_code + - keyword: OUTPUT + - comma: ',' + - parameter: '@out_vchMsg' + - data_type: + data_type_identifier: uddt_output_msg + - keyword: OUTPUT + - comma: ',' + - parameter: '@in_debug' + - data_type: + data_type_identifier: INT + - comparison_operator: + raw_comparison_operator: '=' + - expression: + integer_literal: '1' + - keyword: AS + - procedure_statement: + - statement: + set_segment: + - keyword: SET + - keyword: NOCOUNT + - keyword: 'ON' + - statement_terminator: ; + - statement: + begin_end_block: + - keyword: BEGIN + - statement: + try_catch: + - keyword: BEGIN + - keyword: TRY + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + quoted_literal: "'8'" + statement_terminator: ; + - keyword: END + - keyword: TRY + - keyword: BEGIN + - keyword: CATCH + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@v_nSysErrorNum' + assignment_operator: + raw_comparison_operator: '=' + expression: + function: + function_name: + function_name_identifier: ERROR_NUMBER + function_contents: + bracketed: + start_bracket: ( + end_bracket: ) + - statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@v_vchCode' + assignment_operator: + raw_comparison_operator: '=' + expression: + function: + function_name: + function_name_identifier: ERROR_LINE + function_contents: + bracketed: + start_bracket: ( + end_bracket: ) + - statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@v_vchMsg' + assignment_operator: + raw_comparison_operator: '=' + expression: + quoted_literal: "N'Missing control type.'" + - statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@v_vchMsg' + assignment_operator: + raw_comparison_operator: '=' + expression: + - parameter: '@v_vchMsg' + - binary_operator: + + - quoted_literal: "N' SQL Error = '" + - binary_operator: + + - function: + function_name: + function_name_identifier: ERROR_MESSAGE + function_contents: + bracketed: + start_bracket: ( + end_bracket: ) + - statement_terminator: ; + - statement: + goto_statement: + keyword: GOTO + naked_identifier: ERROR_HANDLER + - statement_terminator: ; + - keyword: END + - keyword: CATCH + - keyword: END + - statement_terminator: ; + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/stored_procedure_simple.yml b/test/fixtures/dialects/tsql/stored_procedure_simple.yml index 8ed48f795fc..92061a7ebb0 100644 --- a/test/fixtures/dialects/tsql/stored_procedure_simple.yml +++ b/test/fixtures/dialects/tsql/stored_procedure_simple.yml @@ -3,25 +3,26 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 3910763517513e7ea6dbda1a8a1635760254af12f4a764e1db41d3b306fdf832 +_hash: 8a1bf8c74f2a5ec810e3c7af749965cb97fe62375bae63d35a84bf04cfc39471 file: batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROC - - object_reference: - naked_identifier: ProcedureName - - keyword: AS - - procedure_statement: - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - function: - function_name: - function_name_identifier: DB_NAME - function_contents: - bracketed: - start_bracket: ( - end_bracket: ) + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROC + - object_reference: + naked_identifier: ProcedureName + - keyword: AS + - procedure_statement: + statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + function: + function_name: + function_name_identifier: DB_NAME + function_contents: + bracketed: + start_bracket: ( + end_bracket: ) diff --git a/test/fixtures/dialects/tsql/stored_procedure_single_statement.yml b/test/fixtures/dialects/tsql/stored_procedure_single_statement.yml index be6d6ef32f2..fc4c47d1e79 100644 --- a/test/fixtures/dialects/tsql/stored_procedure_single_statement.yml +++ b/test/fixtures/dialects/tsql/stored_procedure_single_statement.yml @@ -3,311 +3,312 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 4cec33d7a30307ccab775ec70548a5db14c8f2998805f50e01a54d2fb05b5903 +_hash: 59da14abe8bdd1adfaca6881c93c53c42e3e217de28b03981366528059f4c909 file: batch: - create_procedure_statement: - - keyword: CREATE - - keyword: OR - - keyword: ALTER - - keyword: PROCEDURE - - object_reference: - - naked_identifier: DBO - - dot: . - - naked_identifier: SP_ECDC_CASES_INTER - - procedure_parameter_list: - bracketed: - - start_bracket: ( - - parameter: '@Apple' - - data_type: - data_type_identifier: '[int]' - - comma: ',' - - parameter: '@Orange' - - data_type: - data_type_identifier: varchar - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '100' - end_bracket: ) - - end_bracket: ) - - keyword: AS - - procedure_statement: - statement: - insert_statement: - - keyword: INSERT - - keyword: INTO - - table_reference: - - naked_identifier: INTER - - dot: . - - naked_identifier: ECDC_CASES - - bracketed: - - start_bracket: ( - - column_reference: - quoted_identifier: '[COUNTRY]' - - comma: ',' - - column_reference: - quoted_identifier: '[COUNTRY_CODE]' - - comma: ',' - - column_reference: - quoted_identifier: '[CONTINENT]' - - comma: ',' - - column_reference: - quoted_identifier: '[POPULATION]' - - comma: ',' - - column_reference: - quoted_identifier: '[INDICATOR]' - - comma: ',' - - column_reference: - quoted_identifier: '[WEEKLY_COUNT]' - - comma: ',' - - column_reference: - quoted_identifier: '[YEAR_WEEK]' - - comma: ',' - - column_reference: - quoted_identifier: '[WEEK_START]' - - comma: ',' - - column_reference: - quoted_identifier: '[WEEK_END]' - - comma: ',' - - column_reference: - quoted_identifier: '[RATE_14_DAY]' - - comma: ',' - - column_reference: - quoted_identifier: '[CUMULATIVE_COUNT]' - - comma: ',' - - column_reference: - quoted_identifier: '[SOURCE]' - - end_bracket: ) - - select_statement: - select_clause: - - keyword: SELECT - - select_clause_element: - column_reference: - quoted_identifier: '[COUNTRY]' + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: OR + - keyword: ALTER + - keyword: PROCEDURE + - object_reference: + - naked_identifier: DBO + - dot: . + - naked_identifier: SP_ECDC_CASES_INTER + - procedure_parameter_list: + bracketed: + - start_bracket: ( + - parameter: '@Apple' + - data_type: + data_type_identifier: '[int]' + - comma: ',' + - parameter: '@Orange' + - data_type: + data_type_identifier: varchar + bracketed_arguments: + bracketed: + start_bracket: ( + expression: + integer_literal: '100' + end_bracket: ) + - end_bracket: ) + - keyword: AS + - procedure_statement: + statement: + insert_statement: + - keyword: INSERT + - keyword: INTO + - table_reference: + - naked_identifier: INTER + - dot: . + - naked_identifier: ECDC_CASES + - bracketed: + - start_bracket: ( + - column_reference: + quoted_identifier: '[COUNTRY]' - comma: ',' - - select_clause_element: - column_reference: - quoted_identifier: '[COUNTRY_CODE]' + - column_reference: + quoted_identifier: '[COUNTRY_CODE]' - comma: ',' - - select_clause_element: - column_reference: - quoted_identifier: '[CONTINENT]' + - column_reference: + quoted_identifier: '[CONTINENT]' - comma: ',' - - select_clause_element: - function: - function_name: - keyword: CAST - function_contents: - bracketed: - start_bracket: ( - expression: - column_reference: - quoted_identifier: '[POPULATION]' - keyword: AS - data_type: - data_type_identifier: BIGINT - end_bracket: ) - alias_expression: - alias_operator: - keyword: AS - quoted_identifier: '[POPULATION]' + - column_reference: + quoted_identifier: '[POPULATION]' - comma: ',' - - select_clause_element: - column_reference: - quoted_identifier: '[INDICATOR]' + - column_reference: + quoted_identifier: '[INDICATOR]' - comma: ',' - - select_clause_element: - function: - function_name: - keyword: CAST - function_contents: - bracketed: - start_bracket: ( - expression: - column_reference: - quoted_identifier: '[WEEKLY_COUNT]' - keyword: AS - data_type: - data_type_identifier: BIGINT - end_bracket: ) - alias_expression: - alias_operator: - keyword: AS - quoted_identifier: '[WEEKLY_COUNT]' + - column_reference: + quoted_identifier: '[WEEKLY_COUNT]' - comma: ',' - - select_clause_element: - column_reference: - quoted_identifier: '[YEAR_WEEK]' + - column_reference: + quoted_identifier: '[YEAR_WEEK]' - comma: ',' - - select_clause_element: - function: - function_name: - keyword: CAST - function_contents: - bracketed: - start_bracket: ( - expression: - function: - function_name: - quoted_identifier: '[dbo]' - dot: . - function_name_identifier: '[CONVERT_ISO_WEEK_TO_DATETIME]' - function_contents: - bracketed: - - start_bracket: ( - - expression: - function: - function_name: - keyword: LEFT - function_contents: - bracketed: - - start_bracket: ( - - expression: - column_reference: - naked_identifier: YEAR_WEEK - - comma: ',' - - expression: - numeric_literal: '4' - - end_bracket: ) - - comma: ',' - - expression: - function: - function_name: - keyword: RIGHT - function_contents: - bracketed: - - start_bracket: ( - - expression: - column_reference: - naked_identifier: YEAR_WEEK - - comma: ',' - - expression: - numeric_literal: '2' - - end_bracket: ) - - end_bracket: ) - keyword: AS - data_type: - data_type_identifier: DATE - end_bracket: ) - alias_expression: - alias_operator: - keyword: AS - quoted_identifier: '[WEEK_START]' + - column_reference: + quoted_identifier: '[WEEK_START]' - comma: ',' - - select_clause_element: - function: - function_name: - keyword: CAST - function_contents: - bracketed: - start_bracket: ( - expression: - function: - function_name: - quoted_identifier: '[dbo]' - dot: . - function_name_identifier: '[WEEK_END]' - function_contents: - bracketed: - start_bracket: ( - expression: - function: - function_name: - quoted_identifier: '[dbo]' - dot: . - function_name_identifier: '[CONVERT_ISO_WEEK_TO_DATETIME]' - function_contents: - bracketed: - - start_bracket: ( - - expression: - function: - function_name: - keyword: LEFT - function_contents: - bracketed: - - start_bracket: ( - - expression: - column_reference: - naked_identifier: YEAR_WEEK - - comma: ',' - - expression: - numeric_literal: '4' - - end_bracket: ) - - comma: ',' - - expression: - function: - function_name: - keyword: RIGHT - function_contents: - bracketed: - - start_bracket: ( - - expression: - column_reference: - naked_identifier: YEAR_WEEK - - comma: ',' - - expression: - numeric_literal: '2' - - end_bracket: ) - - end_bracket: ) - end_bracket: ) - keyword: AS - data_type: - data_type_identifier: DATE - end_bracket: ) - alias_expression: - alias_operator: - keyword: AS - quoted_identifier: '[WEEK_END]' + - column_reference: + quoted_identifier: '[WEEK_END]' - comma: ',' - - select_clause_element: - function: - function_name: - keyword: CAST - function_contents: - bracketed: - start_bracket: ( - expression: - column_reference: - quoted_identifier: '[RATE_14_DAY]' - keyword: AS - data_type: - data_type_identifier: FLOAT - end_bracket: ) - alias_expression: - alias_operator: - keyword: AS - quoted_identifier: '[RATE_14_DAY]' + - column_reference: + quoted_identifier: '[RATE_14_DAY]' - comma: ',' - - select_clause_element: - function: - function_name: - keyword: CAST - function_contents: - bracketed: - start_bracket: ( - expression: - column_reference: - quoted_identifier: '[CUMULATIVE_COUNT]' - keyword: AS - data_type: - data_type_identifier: BIGINT - end_bracket: ) - alias_expression: - alias_operator: - keyword: AS - quoted_identifier: '[CUMULATIVE_COUNT]' + - column_reference: + quoted_identifier: '[CUMULATIVE_COUNT]' - comma: ',' - - select_clause_element: - column_reference: - quoted_identifier: '[SOURCE]' - from_clause: - keyword: FROM - from_expression: - from_expression_element: - table_expression: - table_reference: - - naked_identifier: STAGE - - dot: . - - naked_identifier: ECDC_CASES + - column_reference: + quoted_identifier: '[SOURCE]' + - end_bracket: ) + - select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + column_reference: + quoted_identifier: '[COUNTRY]' + - comma: ',' + - select_clause_element: + column_reference: + quoted_identifier: '[COUNTRY_CODE]' + - comma: ',' + - select_clause_element: + column_reference: + quoted_identifier: '[CONTINENT]' + - comma: ',' + - select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + column_reference: + quoted_identifier: '[POPULATION]' + keyword: AS + data_type: + data_type_identifier: BIGINT + end_bracket: ) + alias_expression: + alias_operator: + keyword: AS + quoted_identifier: '[POPULATION]' + - comma: ',' + - select_clause_element: + column_reference: + quoted_identifier: '[INDICATOR]' + - comma: ',' + - select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + column_reference: + quoted_identifier: '[WEEKLY_COUNT]' + keyword: AS + data_type: + data_type_identifier: BIGINT + end_bracket: ) + alias_expression: + alias_operator: + keyword: AS + quoted_identifier: '[WEEKLY_COUNT]' + - comma: ',' + - select_clause_element: + column_reference: + quoted_identifier: '[YEAR_WEEK]' + - comma: ',' + - select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + function: + function_name: + quoted_identifier: '[dbo]' + dot: . + function_name_identifier: '[CONVERT_ISO_WEEK_TO_DATETIME]' + function_contents: + bracketed: + - start_bracket: ( + - expression: + function: + function_name: + keyword: LEFT + function_contents: + bracketed: + - start_bracket: ( + - expression: + column_reference: + naked_identifier: YEAR_WEEK + - comma: ',' + - expression: + integer_literal: '4' + - end_bracket: ) + - comma: ',' + - expression: + function: + function_name: + keyword: RIGHT + function_contents: + bracketed: + - start_bracket: ( + - expression: + column_reference: + naked_identifier: YEAR_WEEK + - comma: ',' + - expression: + integer_literal: '2' + - end_bracket: ) + - end_bracket: ) + keyword: AS + data_type: + data_type_identifier: DATE + end_bracket: ) + alias_expression: + alias_operator: + keyword: AS + quoted_identifier: '[WEEK_START]' + - comma: ',' + - select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + function: + function_name: + quoted_identifier: '[dbo]' + dot: . + function_name_identifier: '[WEEK_END]' + function_contents: + bracketed: + start_bracket: ( + expression: + function: + function_name: + quoted_identifier: '[dbo]' + dot: . + function_name_identifier: '[CONVERT_ISO_WEEK_TO_DATETIME]' + function_contents: + bracketed: + - start_bracket: ( + - expression: + function: + function_name: + keyword: LEFT + function_contents: + bracketed: + - start_bracket: ( + - expression: + column_reference: + naked_identifier: YEAR_WEEK + - comma: ',' + - expression: + integer_literal: '4' + - end_bracket: ) + - comma: ',' + - expression: + function: + function_name: + keyword: RIGHT + function_contents: + bracketed: + - start_bracket: ( + - expression: + column_reference: + naked_identifier: YEAR_WEEK + - comma: ',' + - expression: + integer_literal: '2' + - end_bracket: ) + - end_bracket: ) + end_bracket: ) + keyword: AS + data_type: + data_type_identifier: DATE + end_bracket: ) + alias_expression: + alias_operator: + keyword: AS + quoted_identifier: '[WEEK_END]' + - comma: ',' + - select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + column_reference: + quoted_identifier: '[RATE_14_DAY]' + keyword: AS + data_type: + data_type_identifier: FLOAT + end_bracket: ) + alias_expression: + alias_operator: + keyword: AS + quoted_identifier: '[RATE_14_DAY]' + - comma: ',' + - select_clause_element: + function: + function_name: + keyword: CAST + function_contents: + bracketed: + start_bracket: ( + expression: + column_reference: + quoted_identifier: '[CUMULATIVE_COUNT]' + keyword: AS + data_type: + data_type_identifier: BIGINT + end_bracket: ) + alias_expression: + alias_operator: + keyword: AS + quoted_identifier: '[CUMULATIVE_COUNT]' + - comma: ',' + - select_clause_element: + column_reference: + quoted_identifier: '[SOURCE]' + from_clause: + keyword: FROM + from_expression: + from_expression_element: + table_expression: + table_reference: + - naked_identifier: STAGE + - dot: . + - naked_identifier: ECDC_CASES diff --git a/test/fixtures/dialects/tsql/stored_procedured_mixed_statements.yml b/test/fixtures/dialects/tsql/stored_procedured_mixed_statements.yml index ca1483486cf..97bffe257dd 100644 --- a/test/fixtures/dialects/tsql/stored_procedured_mixed_statements.yml +++ b/test/fixtures/dialects/tsql/stored_procedured_mixed_statements.yml @@ -3,155 +3,156 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 37c411f58e73aa807252c6eff57edf164fe38d89e906945a85a598540c22d54d +_hash: 5ca1f6514cbd5475004930865ed99cb510360651efcb034a34e63ce18f68fa9e file: batch: - create_procedure_statement: - - keyword: CREATE - - keyword: PROC - - object_reference: - - quoted_identifier: '[Reporting]' - - dot: . - - quoted_identifier: '[PowerPlan]' - - keyword: AS - - procedure_statement: - - statement: - declare_segment: - keyword: DECLARE - parameter: '@DATEFUNCTION' - data_type: - data_type_identifier: DATE - comparison_operator: - raw_comparison_operator: '=' - expression: - function: - function_name: - function_name_identifier: GETDATE - function_contents: + statement: + create_procedure_statement: + - keyword: CREATE + - keyword: PROC + - object_reference: + - quoted_identifier: '[Reporting]' + - dot: . + - quoted_identifier: '[PowerPlan]' + - keyword: AS + - procedure_statement: + - statement: + declare_segment: + keyword: DECLARE + parameter: '@DATEFUNCTION' + data_type: + data_type_identifier: DATE + comparison_operator: + raw_comparison_operator: '=' + expression: + function: + function_name: + function_name_identifier: GETDATE + function_contents: + bracketed: + start_bracket: ( + end_bracket: ) + - statement: + drop_table_statement: + - keyword: DROP + - keyword: TABLE + - table_reference: + - quoted_identifier: '[Reporting]' + - dot: . + - quoted_identifier: '[PowerPlan_BASE]' + - statement_terminator: ; + - statement: + declare_segment: + keyword: DECLARE + parameter: '@deadlock_var' + data_type: + data_type_identifier: NCHAR + bracketed_arguments: bracketed: start_bracket: ( + expression: + integer_literal: '3' end_bracket: ) - - statement: - drop_table_statement: - - keyword: DROP - - keyword: TABLE - - table_reference: - - quoted_identifier: '[Reporting]' - - dot: . - - quoted_identifier: '[PowerPlan_BASE]' - - statement_terminator: ; - - statement: - declare_segment: - keyword: DECLARE - parameter: '@deadlock_var' - data_type: - data_type_identifier: NCHAR - bracketed_arguments: - bracketed: - start_bracket: ( - expression: - numeric_literal: '3' - end_bracket: ) - statement_terminator: ; - - statement: - set_segment: - keyword: SET - parameter: '@deadlock_var' - assignment_operator: - raw_comparison_operator: '=' - expression: - quoted_literal: "N'LOW'" - statement_terminator: ; - - statement: - begin_end_block: - - keyword: BEGIN - - statement: - set_segment: - - keyword: SET - - keyword: NOCOUNT - - keyword: 'ON' - - statement: - set_segment: - - keyword: SET - - keyword: DEADLOCK_PRIORITY - - keyword: LOW - - statement: - set_segment: - - keyword: SET - - keyword: DEADLOCK_PRIORITY - - keyword: NORMAL - - statement: - set_segment: - - keyword: SET - - keyword: DEADLOCK_PRIORITY - - keyword: HIGH - - statement: - set_segment: - - keyword: SET - - keyword: DEADLOCK_PRIORITY - - parameter: '@deadlock_var' - - statement: - set_segment: - - keyword: SET - - keyword: DEADLOCK_PRIORITY - - numeric_literal: '10' - - statement: - set_segment: - - keyword: SET - - keyword: DEADLOCK_PRIORITY - - numeric_literal: - sign_indicator: '-' - numeric_literal: '5' - - statement: - select_statement: - select_clause: - keyword: SELECT - select_clause_element: - numeric_literal: '1' - - statement: - create_table_as_select_statement: - - keyword: CREATE - - keyword: TABLE - - table_reference: - hash_identifier: '#TempTest' - - table_distribution_index_clause: - keyword: WITH - bracketed: + statement_terminator: ; + - statement: + set_local_variable_segment: + keyword: SET + parameter: '@deadlock_var' + assignment_operator: + raw_comparison_operator: '=' + expression: + quoted_literal: "N'LOW'" + - statement_terminator: ; + - statement: + begin_end_block: + - keyword: BEGIN + - statement: + set_segment: + - keyword: SET + - keyword: NOCOUNT + - keyword: 'ON' + - statement: + set_segment: + - keyword: SET + - keyword: DEADLOCK_PRIORITY + - keyword: LOW + - statement: + set_segment: + - keyword: SET + - keyword: DEADLOCK_PRIORITY + - keyword: NORMAL + - statement: + set_segment: + - keyword: SET + - keyword: DEADLOCK_PRIORITY + - keyword: HIGH + - statement: + set_segment: + - keyword: SET + - keyword: DEADLOCK_PRIORITY + - parameter: '@deadlock_var' + - statement: + set_segment: + - keyword: SET + - keyword: DEADLOCK_PRIORITY + - numeric_literal: '10' + - statement: + set_segment: + - keyword: SET + - keyword: DEADLOCK_PRIORITY + - numeric_literal: + sign_indicator: '-' + numeric_literal: '5' + - statement: + select_statement: + select_clause: + keyword: SELECT + select_clause_element: + integer_literal: '1' + - statement: + create_table_as_select_statement: + - keyword: CREATE + - keyword: TABLE + - table_reference: + hash_identifier: '#TempTest' + - table_distribution_index_clause: + keyword: WITH + bracketed: + start_bracket: ( + table_distribution_clause: + - keyword: DISTRIBUTION + - comparison_operator: + raw_comparison_operator: '=' + - keyword: ROUND_ROBIN + comma: ',' + table_index_clause: + keyword: HEAP + end_bracket: ) + - keyword: AS + - bracketed: start_bracket: ( - table_distribution_clause: - - keyword: DISTRIBUTION - - comparison_operator: - raw_comparison_operator: '=' - - keyword: ROUND_ROBIN - comma: ',' - table_index_clause: - keyword: HEAP + select_statement: + select_clause: + - keyword: SELECT + - select_clause_element: + integer_literal: '2' + alias_expression: + alias_operator: + keyword: AS + naked_identifier: Two + - comma: ',' + - select_clause_element: + integer_literal: '3' + alias_expression: + alias_operator: + keyword: AS + naked_identifier: Three + - comma: ',' + - select_clause_element: + integer_literal: '4' + alias_expression: + alias_operator: + keyword: AS + naked_identifier: Four end_bracket: ) - - keyword: AS - - bracketed: - start_bracket: ( - select_statement: - select_clause: - - keyword: SELECT - - select_clause_element: - numeric_literal: '2' - alias_expression: - alias_operator: - keyword: AS - naked_identifier: Two - - comma: ',' - - select_clause_element: - numeric_literal: '3' - alias_expression: - alias_operator: - keyword: AS - naked_identifier: Three - - comma: ',' - - select_clause_element: - numeric_literal: '4' - alias_expression: - alias_operator: - keyword: AS - naked_identifier: Four - end_bracket: ) - - keyword: END + - keyword: END diff --git a/test/fixtures/dialects/tsql/system-variables.yml b/test/fixtures/dialects/tsql/system-variables.yml index ba620521103..7f9952def41 100644 --- a/test/fixtures/dialects/tsql/system-variables.yml +++ b/test/fixtures/dialects/tsql/system-variables.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 2157e88d8d683ea28e7a4362d18a121c05a29bc66ca4b8dc02657d787f45d099 +_hash: 4cd1eeca509cfeee9351ef5b487e4850de5b3ee9640472a42ad627a44771a30e file: - batch: - statement: @@ -29,7 +29,7 @@ file: naked_identifier: NationalIDNumber comparison_operator: raw_comparison_operator: '=' - numeric_literal: '123456789' + integer_literal: '123456789' - statement: if_then_statement: if_clause: @@ -38,7 +38,7 @@ file: system_variable: '@@ROWCOUNT' comparison_operator: raw_comparison_operator: '=' - numeric_literal: '0' + integer_literal: '0' statement: print_statement: keyword: PRINT @@ -53,7 +53,7 @@ file: system_variable: '@@ERROR' comparison_operator: raw_comparison_operator: '=' - numeric_literal: '547' + integer_literal: '547' statement: begin_end_block: - keyword: BEGIN @@ -64,8 +64,8 @@ file: quoted_literal: "N'A check constraint violation occurred.'" statement_terminator: ; - keyword: END -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: select_statement: @@ -78,16 +78,16 @@ file: keyword: AS quoted_identifier: "'Identity'" statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: print_statement: keyword: PRINT expression: system_variable: '@@TRANCOUNT' -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: select_statement: @@ -100,5 +100,5 @@ file: keyword: AS quoted_identifier: "'Packets Received'" statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/table_variables.yml b/test/fixtures/dialects/tsql/table_variables.yml index 86bee43c776..dc1edbe65c8 100644 --- a/test/fixtures/dialects/tsql/table_variables.yml +++ b/test/fixtures/dialects/tsql/table_variables.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 862b2714c5dba3bc89677f4191a6c8ab1c6135281db59a5ba2e5b9183b80c83c +_hash: d5343b53f0098c5d411c2794458e034ba830736a14f403ba4820a47b661f7ada file: batch: statement: @@ -26,6 +26,6 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - end_bracket: ) diff --git a/test/fixtures/dialects/tsql/temporal_tables.yml b/test/fixtures/dialects/tsql/temporal_tables.yml index 0f6cada7087..53a499e8c11 100644 --- a/test/fixtures/dialects/tsql/temporal_tables.yml +++ b/test/fixtures/dialects/tsql/temporal_tables.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: c6b1721989e1c1a27945606b69a0849014796d39f869e76969243459b0a0d603 +_hash: 133f6821f8c566a867edc5e4af101f1ed2bd0d8f1a9ec2d7e2d69a945df52100 file: - batch: - statement: @@ -217,7 +217,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -228,7 +228,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -239,10 +239,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -271,8 +271,8 @@ file: - end_bracket: ) - statement_terminator: ; - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -302,7 +302,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '50' + integer_literal: '50' end_bracket: ) column_constraint_segment: - keyword: NOT @@ -383,8 +383,8 @@ file: end_bracket: ) - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -404,7 +404,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -415,7 +415,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -426,10 +426,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -444,8 +444,8 @@ file: end_bracket: ) - statement_terminator: ; statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -465,7 +465,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -476,7 +476,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -487,10 +487,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -517,8 +517,8 @@ file: - end_bracket: ) - statement_terminator: ; statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -538,7 +538,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -549,7 +549,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -560,10 +560,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -596,8 +596,8 @@ file: end_bracket: ) - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -617,7 +617,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -628,7 +628,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -639,10 +639,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -691,8 +691,8 @@ file: end_bracket: ) - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -712,7 +712,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -723,7 +723,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -734,10 +734,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -760,8 +760,8 @@ file: end_bracket: ) - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -781,7 +781,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -792,7 +792,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -803,10 +803,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -831,8 +831,8 @@ file: - keyword: 'OFF' - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -852,7 +852,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -863,7 +863,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -874,10 +874,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -927,8 +927,8 @@ file: naked_identifier: constraint4 - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_table_statement: @@ -948,7 +948,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -959,7 +959,7 @@ file: bracketed: start_bracket: ( expression: - numeric_literal: '100' + integer_literal: '100' end_bracket: ) - comma: ',' - column_definition: @@ -970,10 +970,10 @@ file: bracketed: - start_bracket: ( - expression: - numeric_literal: '10' + integer_literal: '10' - comma: ',' - expression: - numeric_literal: '3' + integer_literal: '3' - end_bracket: ) - end_bracket: ) - table_option_statement: @@ -1018,5 +1018,5 @@ file: - end_bracket: ) - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/transaction.yml b/test/fixtures/dialects/tsql/transaction.yml index 9da0332c614..ae641b068ea 100644 --- a/test/fixtures/dialects/tsql/transaction.yml +++ b/test/fixtures/dialects/tsql/transaction.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: fd3b8479ff5e72d7996d7e9a7a1b284d2130dd66ea72112371626a50ab94b12c +_hash: e7d54ab2bb7fdd538c66ae10b2121cf135211f0c544a173cb3fa01acdc2756c0 file: batch: - statement: @@ -26,7 +26,7 @@ file: naked_identifier: JobCandidateID comparison_operator: raw_comparison_operator: '=' - numeric_literal: '13' + integer_literal: '13' - statement_terminator: ; - statement: transaction_statement: @@ -52,7 +52,7 @@ file: naked_identifier: JobCandidateID comparison_operator: raw_comparison_operator: '=' - numeric_literal: '13' + integer_literal: '13' - statement_terminator: ; - statement: transaction_statement: diff --git a/test/fixtures/dialects/tsql/triggers.yml b/test/fixtures/dialects/tsql/triggers.yml index ba0f959aa78..d5eae2abbb5 100644 --- a/test/fixtures/dialects/tsql/triggers.yml +++ b/test/fixtures/dialects/tsql/triggers.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 96633a795ee98a2b3cd19c5e41d5414cc4903d923a633eb661385fe896b4bd91 +_hash: 338d3d7ad69017f1e9b81e93287706284ed802a6b3cf5d2865056e6504e2b5f1 file: - batch: statement: @@ -34,8 +34,8 @@ file: - numeric_literal: '10' - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -88,8 +88,8 @@ file: - expression: quoted_literal: "'Reminder'" - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -124,7 +124,7 @@ file: end_bracket: ) comparison_operator: raw_comparison_operator: '=' - numeric_literal: '0' + integer_literal: '0' end_bracket: ) statement: return_segment: @@ -142,7 +142,7 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' + integer_literal: '1' from_clause: keyword: FROM from_expression: @@ -188,7 +188,7 @@ file: - naked_identifier: CreditRating comparison_operator: raw_comparison_operator: '=' - numeric_literal: '5' + integer_literal: '5' end_bracket: ) statement: begin_end_block: @@ -216,8 +216,8 @@ file: keyword: RETURN - keyword: END statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -241,7 +241,7 @@ file: system_variable: '@@ROWCOUNT' comparison_operator: raw_comparison_operator: '=' - numeric_literal: '0' + integer_literal: '0' end_bracket: ) statement: return_segment: @@ -261,8 +261,8 @@ file: - statement: transaction_statement: keyword: ROLLBACK -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_trigger: @@ -273,8 +273,8 @@ file: - keyword: 'ON' - keyword: DATABASE statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -298,9 +298,9 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' -- go_statement: - keyword: GO + integer_literal: '1' + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -325,9 +325,9 @@ file: select_clause: keyword: SELECT select_clause_element: - numeric_literal: '1' -- go_statement: - keyword: GO + integer_literal: '1' + go_statement: + keyword: GO - batch: statement: drop_trigger: @@ -339,8 +339,8 @@ file: - keyword: ALL - keyword: SERVER statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -409,7 +409,7 @@ file: naked_identifier: is_user_process - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' - binary_operator: AND - column_reference: naked_identifier: original_login_name @@ -419,15 +419,15 @@ file: end_bracket: ) - comparison_operator: raw_comparison_operator: '>' - - numeric_literal: '3' + - integer_literal: '3' statement: transaction_statement: keyword: ROLLBACK statement_terminator: ; - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -500,8 +500,8 @@ file: - naked_identifier: i - dot: . - naked_identifier: PK_L2_BALS -- go_statement: - keyword: go + go_statement: + keyword: go - batch: statement: disable_trigger: @@ -516,8 +516,8 @@ file: - naked_identifier: dbo - dot: . - naked_identifier: SP_BALS_L2_ATTRIBUTES -- go_statement: - keyword: go + go_statement: + keyword: go - batch: statement: create_trigger: @@ -590,8 +590,8 @@ file: - naked_identifier: i - dot: . - naked_identifier: PK_L2_BALS -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_trigger: @@ -600,8 +600,8 @@ file: - trigger_reference: naked_identifier: employee_insupd statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: drop_trigger: @@ -612,8 +612,8 @@ file: - keyword: 'ON' - keyword: DATABASE statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: disable_trigger: @@ -628,8 +628,8 @@ file: - naked_identifier: dbo - dot: . - naked_identifier: SP_BALS_L2_ATTRIBUTES -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: disable_trigger: @@ -640,8 +640,8 @@ file: - keyword: 'ON' - keyword: DATABASE statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -673,8 +673,8 @@ file: - numeric_literal: '10' - end_bracket: ) - statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: statement: create_trigger: @@ -736,5 +736,5 @@ file: - end_bracket: ) - keyword: END statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/try_catch.yml b/test/fixtures/dialects/tsql/try_catch.yml index 46b3966dec0..664d628a9fa 100644 --- a/test/fixtures/dialects/tsql/try_catch.yml +++ b/test/fixtures/dialects/tsql/try_catch.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 092dacfb7da71f95d1ac27c2db9f0318b02db23cb37afaf0fdb9e4119661175e +_hash: fbccbc41dd24d8bfe70f94604c97ea90d6d243b0c1c2f789b7941546dfaea40d file: - batch: statement: @@ -65,8 +65,8 @@ file: keyword: THROW - keyword: END - keyword: CATCH -- go_statement: - keyword: GO + go_statement: + keyword: GO - batch: - statement: throw_statement: diff --git a/test/fixtures/dialects/tsql/update.yml b/test/fixtures/dialects/tsql/update.yml index 553785eee4c..4bbe0fc3365 100644 --- a/test/fixtures/dialects/tsql/update.yml +++ b/test/fixtures/dialects/tsql/update.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: a1d84202124669863cfc26296b19136a7fb21c2ffb3c1e9bea329f7607e2a170 +_hash: aa742b5130da21297720aedd63f0f8b6b40e9150e51736b27a1d4a5cf1bc9bd6 file: batch: - statement: @@ -21,7 +21,7 @@ file: assignment_operator: raw_comparison_operator: '=' expression: - numeric_literal: '1' + integer_literal: '1' where_clause: keyword: where expression: @@ -75,7 +75,7 @@ file: binary_operator: + raw_comparison_operator: '=' expression: - numeric_literal: '1' + integer_literal: '1' from_clause: keyword: from from_expression: @@ -120,7 +120,7 @@ file: assignment_operator: raw_comparison_operator: '=' expression: - numeric_literal: '1' + integer_literal: '1' output_clause: - keyword: OUTPUT - wildcard_expression: @@ -136,4 +136,4 @@ file: naked_identifier: useless comparison_operator: raw_comparison_operator: '=' - numeric_literal: '1' + integer_literal: '1' diff --git a/test/fixtures/dialects/tsql/waitfor.yml b/test/fixtures/dialects/tsql/waitfor.yml index 04bc819bc6e..f2db55699f4 100644 --- a/test/fixtures/dialects/tsql/waitfor.yml +++ b/test/fixtures/dialects/tsql/waitfor.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 02172d4fd48d357bd7583d06bcbbfb00ef906891d5ae5df93dd5c293175dad73 +_hash: 063d40739dc60fa7fba55d14611655556f0511b51e241feecd4f560c35df26fb file: - batch: - statement: @@ -46,8 +46,8 @@ file: - statement_terminator: ; - keyword: END - statement_terminator: ; -- go_statement: - keyword: GO + - go_statement: + keyword: GO - batch: statement: begin_end_block: @@ -67,5 +67,5 @@ file: statement_terminator: ; - keyword: END statement_terminator: ; -- go_statement: - keyword: GO + go_statement: + keyword: GO diff --git a/test/fixtures/dialects/tsql/while_statement.yml b/test/fixtures/dialects/tsql/while_statement.yml index 51631eb0e96..069afce02be 100644 --- a/test/fixtures/dialects/tsql/while_statement.yml +++ b/test/fixtures/dialects/tsql/while_statement.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: 8abf6cf853a6b3e42fcef7ddf3e8c207f72aa1e176555baf9a04efadc50063c6 +_hash: f469a95b210e16fd7e3ee97313ad08ed1a9e8442214716151d51665a2f4f453f file: batch: statement: @@ -13,10 +13,10 @@ file: bracketed: start_bracket: ( expression: - - numeric_literal: '1' + - integer_literal: '1' - comparison_operator: raw_comparison_operator: '=' - - numeric_literal: '1' + - integer_literal: '1' end_bracket: ) statement: begin_end_block: diff --git a/test/fixtures/dialects/tsql/window_functions.yml b/test/fixtures/dialects/tsql/window_functions.yml index e1fd12d60e6..8688784ec51 100644 --- a/test/fixtures/dialects/tsql/window_functions.yml +++ b/test/fixtures/dialects/tsql/window_functions.yml @@ -3,7 +3,7 @@ # computed by SQLFluff when running the tests. Please run # `python test/generate_parse_fixture_yml.py` to generate them after adding or # altering SQL files. -_hash: bbb3c4c89f2e59ba5265dee316396e1ec222dd96735873bb59313661160a9936 +_hash: c56509ae7acfbf6289d14e48b3f249d21604a0180ae633043c88e58070ed271e file: batch: - statement: @@ -71,7 +71,7 @@ file: - keyword: PARTITION - keyword: BY - expression: - numeric_literal: '1' + integer_literal: '1' orderby_clause: - keyword: ORDER - keyword: BY @@ -127,7 +127,7 @@ file: quoted_literal: "'value'" - keyword: THEN - expression: - numeric_literal: '1' + integer_literal: '1' - keyword: END orderby_clause: - keyword: ORDER @@ -189,7 +189,7 @@ file: quoted_literal: "'value'" - keyword: THEN - expression: - numeric_literal: '1' + integer_literal: '1' - keyword: END - comma: ',' - column_reference: diff --git a/test/fixtures/rules/std_rule_cases/AM09.yml b/test/fixtures/rules/std_rule_cases/AM09.yml new file mode 100644 index 00000000000..98568a92e25 --- /dev/null +++ b/test/fixtures/rules/std_rule_cases/AM09.yml @@ -0,0 +1,59 @@ +rule: AM09 + +test_fail_limit_without_order_by: + fail_str: | + SELECT * + FROM foo + LIMIT 10; + +test_fail_limit_and_offset_without_order_by: + fail_str: | + SELECT * + FROM foo + LIMIT 10 + OFFSET 5; + configs: + core: + dialect: ansi + +test_pass_limit_with_order_by: + pass_str: | + SELECT * + FROM foo + ORDER BY id + LIMIT 10; + +test_pass_limit_and_offset_with_order_by: + pass_str: | + SELECT * + FROM foo + ORDER BY id + LIMIT 10 + OFFSET 5; + configs: + core: + dialect: postgres + +test_pass_no_limit_or_offset: + pass_str: | + SELECT * + FROM foo; + +test_fail_limit_with_order_by_in_subquery: + fail_str: | + SELECT * + FROM ( + SELECT * + FROM foo + LIMIT 10 + ) subquery; + +test_pass_limit_with_order_by_in_subquery: + pass_str: | + SELECT * + FROM ( + SELECT * + FROM foo + ORDER BY id + LIMIT 10 + ) subquery; diff --git a/test/fixtures/rules/std_rule_cases/CV05.yml b/test/fixtures/rules/std_rule_cases/CV05.yml index f4a63ed541e..0fc9fec3ccc 100644 --- a/test/fixtures/rules/std_rule_cases/CV05.yml +++ b/test/fixtures/rules/std_rule_cases/CV05.yml @@ -119,3 +119,13 @@ test_mysql_system_variable: configs: core: dialect: mysql + +test_tsql_variable_assignment: + pass_str: | + DECLARE @MyVariable VARCHAR(10); + + SELECT + @MyVariable = NULL; + configs: + core: + dialect: tsql diff --git a/test/fixtures/rules/std_rule_cases/CV11.yml b/test/fixtures/rules/std_rule_cases/CV11.yml index e6dbf91c7df..525636b1f52 100644 --- a/test/fixtures/rules/std_rule_cases/CV11.yml +++ b/test/fixtures/rules/std_rule_cases/CV11.yml @@ -336,6 +336,28 @@ test_pass_when_dialect_is_teradata: core: dialect: teradata +test_pass_when_dialect_is_athena: + pass_str: | + select cast(1 as varchar(10)) as bar + from foo; + configs: + core: + dialect: athena + rules: + convention.casting_style: + preferred_type_casting_style: shorthand + +test_pass_when_dialect_is_trino: + pass_str: | + select cast(1 as varchar(10)) as bar + from foo; + configs: + core: + dialect: trino + rules: + convention.casting_style: + preferred_type_casting_style: shorthand + test_fail_parenthesize_expression_when_config_shorthand_from_cast: fail_str: | select diff --git a/test/fixtures/rules/std_rule_cases/LT01-alignment.yml b/test/fixtures/rules/std_rule_cases/LT01-alignment.yml index f515a478c88..0170f5716bd 100644 --- a/test/fixtures/rules/std_rule_cases/LT01-alignment.yml +++ b/test/fixtures/rules/std_rule_cases/LT01-alignment.yml @@ -387,3 +387,90 @@ test_align_multiple_operators: binary_operator: spacing_before: align align_within: select_statement + +test_align_alias_with_jinja_source_positions: + # Alignment should respect source (visible) positions when templated content exists + # before the alias. The second line should align 'as' to the first, without + # padding to the length of the rendered template. + fail_str: | + select + {{ "longtemplated" }} as test_key, + b as b_col + fix_str: | + select + {{ "longtemplated" }} as test_key, + b as b_col + configs: + core: + templater: jinja + layout: + type: + alias_expression: + spacing_before: align + align_within: select_clause + align_scope: bracketed + +test_align_alias_with_jinja_both_lines_templated: + # Both lines have templated content before the alias. Alignment should + # still respect source (visible) positions. + fail_str: | + select + {{ "templ_1" }} as a, + {{ "t2" }} as bb + fix_str: | + select + {{ "templ_1" }} as a, + {{ "t2" }} as bb + configs: + core: + templater: jinja + layout: + type: + alias_expression: + spacing_before: align + align_within: select_clause + align_scope: bracketed + +test_align_alias_with_jinja_statement_scope: + # Alignment across a wider scope (select_statement) still uses source positions. + fail_str: | + select + {{ "xxx" }} as a, + col as b, + {{ "yyyyy" }} as c + from t + fix_str: | + select + {{ "xxx" }} as a, + col as b, + {{ "yyyyy" }} as c + from t + configs: + core: + templater: jinja + layout: + type: + alias_expression: + spacing_before: align + align_within: select_statement + align_scope: bracketed + +test_align_alias_with_jinja_force_templated_space: + # Force templated coordinate space via config override to ensure it is respected. + fail_str: | + select + {{ "templ" }} as a, + b as bb + # If we force templated, alignment should pad based on rendered lengths. + fix_str: | + select + {{ "templ" }} as a, + b as bb + configs: + core: + templater: jinja + layout: + type: + alias_expression: + # Force templated coordinate space via align suffix + spacing_before: align:alias_expression:select_clause:bracketed:templated diff --git a/test/fixtures/rules/std_rule_cases/ST03.yml b/test/fixtures/rules/std_rule_cases/ST03.yml index dd480173d19..0da17489e4f 100644 --- a/test/fixtures/rules/std_rule_cases/ST03.yml +++ b/test/fixtures/rules/std_rule_cases/ST03.yml @@ -459,3 +459,27 @@ test_pass_bigquery_unquoted_cte_quoted_ref: configs: core: dialect: bigquery + +test_fail_postgres_dml_ctes_not_flagged: + desc: Data-modifying CTEs should not be flagged in Postgres; only SELECT CTE is unused. + fail_str: | + WITH + cte_select AS ( + SELECT foo FROM t + ), + cte_insert AS ( + INSERT INTO t (foo) VALUES (1) + ), + cte_update AS ( + UPDATE t SET foo = 2 + ), + cte_delete AS ( + DELETE FROM t + ) + + SELECT 1 + configs: + core: + dialect: postgres + line_numbers: + - 2 diff --git a/test/rules/std_AM09_test.py b/test/rules/std_AM09_test.py new file mode 100644 index 00000000000..9589b52eaf5 --- /dev/null +++ b/test/rules/std_AM09_test.py @@ -0,0 +1,75 @@ +"""Tests the python routines within AM09.""" + +from types import SimpleNamespace + +import sqlfluff +from sqlfluff.rules.ambiguous.AM09 import Rule_AM09 + + +def test__rules__std_AM09_missing_order_by() -> None: + """Test case for LIMIT and OFFSET without ORDER BY.""" + sql = """ + SELECT * + FROM foo + LIMIT 10 OFFSET 5; + """ + result = sqlfluff.lint(sql) + + results_AM09 = [r for r in result if r["code"] == "AM09"] + assert len(results_AM09) == 1 + assert results_AM09[0]["description"] == ( + "LIMIT and OFFSET are used without ORDER BY," + " which may lead to non-deterministic results." + ) + + +def test__rules__std_AM09_with_order_by() -> None: + """Test case for LIMIT and OFFSET with ORDER BY.""" + sql = """ + SELECT * + FROM foo + ORDER BY id + LIMIT 10 OFFSET 5; + """ + result = sqlfluff.lint(sql) + + results_AM09 = [r for r in result if r["code"] == "AM09"] + assert len(results_AM09) == 0 + + +def test__rules__std_AM09_no_limit_or_offset() -> None: + """Test case for query without LIMIT or OFFSET.""" + sql = """ + SELECT * + FROM foo; + """ + result = sqlfluff.lint(sql) + + results_AM09 = [r for r in result if r["code"] == "AM09"] + assert len(results_AM09) == 0 + + +def test__rules__std_AM09_non_select_statement_integration() -> None: + """Integration-style lint: non-SELECT statements should not flag AM09.""" + sql = """ + CREATE TABLE foo (id INT, name TEXT); + """ + result = sqlfluff.lint(sql) + + # Ensure no AM09 violations are reported + results_AM09 = [r for r in result if r["code"] == "AM09"] + assert len(results_AM09) == 0 + + +def test__rules__std_AM09_eval_short_circuit_on_non_select_segment() -> None: + """Directly cover the guard that returns None for non-SELECT segments.""" + + class FakeSegment: + def is_type(self, _type: str) -> bool: + return False # not a select_statement + + fake_context = SimpleNamespace(segment=FakeSegment()) + + # Bypass BaseRule.__init__ (which requires code/description). + rule = Rule_AM09.__new__(Rule_AM09) + assert rule._eval(fake_context) is None diff --git a/test/rules/std_LT01_jinja_alignment_test.py b/test/rules/std_LT01_jinja_alignment_test.py new file mode 100644 index 00000000000..319c014abfa --- /dev/null +++ b/test/rules/std_LT01_jinja_alignment_test.py @@ -0,0 +1,271 @@ +"""Tests for LT01 alias alignment with Jinja templating. + +This ensures alignment uses source positions when templated content is present +so that alignment reflects what the user sees in the editor. +""" + +from __future__ import annotations + +import sqlfluff +from sqlfluff.core.config import FluffConfig + + +def _count_lt01(results: list[dict]) -> int: + return sum(1 for r in results if r.get("code") == "LT01") + + +def test_lt01_alias_alignment_with_jinja_uses_source_positions() -> None: + """Jinja before alias should not cause excessive padding (align by source).""" + sql = ( + "select\n" + " {{ generate_surrogate_key('test', ['a', 'b', 'c']) }} as test_key,\n" + " b as b_col\n" + "from {{ ref('test') }}\n" + ) + + # First lint should report LT01 (spacing around select + alias alignment). + cfg = FluffConfig.from_kwargs(dialect="ansi") + # Inject settings not supported by from_kwargs via child config and update + cfg._configs["core"]["templater"] = "jinja" + cfg._configs.setdefault("templater", {}).setdefault("jinja", {}).setdefault( + "context", {} + ).update( + { + "generate_surrogate_key": lambda *args: "surrogate_key_12345", + "ref": lambda x: f"my_schema.{x}", + } + ) + cfg._configs.setdefault("layout", {}).setdefault("type", {}).setdefault( + "alias_expression", {} + ).update( + { + "spacing_before": "align", + "align_within": "select_clause", + "align_scope": "bracketed", + } + ) + initial_results = sqlfluff.lint(sql, config=cfg, rules=["LT01"]) + assert _count_lt01(initial_results) >= 1 + + # Apply fixes. + fixed = sqlfluff.fix(sql, config=cfg, rules=["LT01"]) + + # After fixing, there should be no LT01 violations. + post_results = sqlfluff.lint(fixed, config=cfg, rules=["LT01"]) + assert _count_lt01(post_results) == 0 + + # Sanity: alignment should be reasonable. Check that both lines contain ' as '. + lines = fixed.splitlines() + assert any(" as " in line for line in lines) + + # Find the two select lines and verify the 'as' columns align by source index. + select_lines = [line for line in lines if " as " in line] + assert len(select_lines) >= 2 + first_as_col = select_lines[0].index(" as ") + second_as_col = select_lines[1].index(" as ") + assert first_as_col == second_as_col + + +def test_lt01_alias_alignment_with_jinja_coordinate_space_config_key() -> None: + """Coordinate space can be set via alignment_coordinate_space config key.""" + sql = "select\n" " {{ 'templ' }} as a,\n" " b as bb\n" + + cfg = FluffConfig.from_kwargs(dialect="ansi") + cfg._configs["core"]["templater"] = "jinja" + cfg._configs.setdefault("templater", {}).setdefault("jinja", {}).setdefault( + "context", {} + ) + # Force templated coordinate space via config key enrichment path + cfg._configs.setdefault("layout", {}).setdefault("type", {}).setdefault( + "alias_expression", {} + ).update( + { + "spacing_before": "align", + "align_within": "select_clause", + "align_scope": "bracketed", + "alignment_coordinate_space": "templated", + } + ) + + fixed = sqlfluff.fix(sql, config=cfg, rules=["LT01"]) + # With templated coordinate space, the second line pads less + lines = fixed.splitlines() + assert any(" as " in line for line in lines) + select_lines = [line for line in lines if " as " in line] + assert len(select_lines) == 2 + # Check that there is at least some padding before 'as' on second line + # but not necessarily aligned to the source position of the templated value. + first_as_col = select_lines[0].index(" as ") + second_as_col = select_lines[1].index(" as ") + assert second_as_col <= first_as_col + + +def test_lt01_alias_alignment_non_rendered_longer_than_template() -> None: + """Non-rendered column longer than template should align correctly.""" + sql = "select\n" ' {{ "xxx" }} as a,\n' " fooooooooo as b\n" "from t\n" + + cfg = FluffConfig.from_kwargs(dialect="ansi") + cfg._configs["core"]["templater"] = "jinja" + cfg._configs.setdefault("templater", {}).setdefault("jinja", {}).setdefault( + "context", {} + ) + cfg._configs.setdefault("layout", {}).setdefault("type", {}).setdefault( + "alias_expression", {} + ).update( + { + "spacing_before": "align", + "align_within": "select_clause", + "align_scope": "bracketed", + } + ) + + # First lint should report LT01 violations + initial_results = sqlfluff.lint(sql, config=cfg, rules=["LT01"]) + assert _count_lt01(initial_results) >= 1 + + # Apply fixes + fixed = sqlfluff.fix(sql, config=cfg, rules=["LT01"]) + + # After fixing, there should be no LT01 violations + post_results = sqlfluff.lint(fixed, config=cfg, rules=["LT01"]) + assert _count_lt01(post_results) == 0 + + # Verify alignment: both 'as' keywords should align by source position + lines = fixed.splitlines() + select_lines = [line for line in lines if " as " in line] + assert len(select_lines) == 2 + + first_as_col = select_lines[0].index(" as ") + second_as_col = select_lines[1].index(" as ") + assert first_as_col == second_as_col + + +def test_lt01_alias_alignment_source_coordinate_space_explicit() -> None: + """Test explicit source coordinate space setting with templated content.""" + sql = "select\n" " {{ var1 }} as col1,\n" " b as col2\n" "from table1\n" + + cfg = FluffConfig.from_kwargs(dialect="ansi") + cfg._configs["core"]["templater"] = "jinja" + cfg._configs.setdefault("templater", {}).setdefault("jinja", {}).setdefault( + "context", {} + ).update({"var1": "some_value"}) + + # Force source coordinate space via config + cfg._configs.setdefault("layout", {}).setdefault("type", {}).setdefault( + "alias_expression", {} + ).update( + { + "spacing_before": "align", + "align_within": "select_clause", + "align_scope": "bracketed", + "alignment_coordinate_space": "source", + } + ) + + fixed = sqlfluff.fix(sql, config=cfg, rules=["LT01"]) + post_results = sqlfluff.lint(fixed, config=cfg, rules=["LT01"]) + assert _count_lt01(post_results) == 0 + + +def test_lt01_alias_alignment_edge_case_no_segments_on_line() -> None: + """Edge case: no segments found on current line should be handled gracefully.""" + # This creates a scenario that might trigger the edge case + sql = "select\n" "\n" " col1 as a,\n" " col2 as b\n" "from t\n" + + cfg = FluffConfig.from_kwargs(dialect="ansi") + cfg._configs.setdefault("layout", {}).setdefault("type", {}).setdefault( + "alias_expression", {} + ).update( + { + "spacing_before": "align", + "align_within": "select_clause", + "align_scope": "bracketed", + } + ) + + # This should handle the edge case gracefully + fixed = sqlfluff.fix(sql, config=cfg, rules=["LT01"]) + post_results = sqlfluff.lint(fixed, config=cfg, rules=["LT01"]) + # Should not crash and should not produce LT01 violations + assert isinstance(fixed, str) + assert _count_lt01(post_results) == 0 + + +def test_lt01_alias_alignment_target_segment_not_found() -> None: + """Edge case: target segment not found in current line should be handled.""" + # This creates a complex scenario that might trigger the target not found case + sql = ( + "select\n" + " case when 1=1\n" + " then col1 end as a,\n" + " col2 as b\n" + "from t\n" + ) + + cfg = FluffConfig.from_kwargs(dialect="ansi") + cfg._configs.setdefault("layout", {}).setdefault("type", {}).setdefault( + "alias_expression", {} + ).update( + { + "spacing_before": "align", + "align_within": "select_clause", + "align_scope": "bracketed", + } + ) + + # This should handle the target not found case gracefully + fixed = sqlfluff.fix(sql, config=cfg, rules=["LT01"]) + post_results = sqlfluff.lint(fixed, config=cfg, rules=["LT01"]) + # Should not crash and should not produce LT01 violations + assert isinstance(fixed, str) + assert _count_lt01(post_results) == 0 + + +def test_lt01_alias_alignment_templated_next_segment() -> None: + """Templated next segment should be detected and aligned by source positions.""" + sql = "select\n" " col1 as a,\n" " {{ col2 }} as b\n" + + cfg = FluffConfig.from_kwargs(dialect="ansi") + cfg._configs["core"]["templater"] = "jinja" + cfg._configs.setdefault("templater", {}).setdefault("jinja", {}).setdefault( + "context", {} + ).update({"col2": "column_two"}) + cfg._configs.setdefault("layout", {}).setdefault("type", {}).setdefault( + "alias_expression", {} + ).update( + { + "spacing_before": "align", + "align_within": "select_clause", + "align_scope": "bracketed", + } + ) + + # This should trigger the templated content detection for next_seg + fixed = sqlfluff.fix(sql, config=cfg, rules=["LT01"]) + post_results = sqlfluff.lint(fixed, config=cfg, rules=["LT01"]) + assert _count_lt01(post_results) == 0 + + +def test_lt01_alias_alignment_templated_siblings() -> None: + """Templated siblings should be detected and aligned by source positions.""" + sql = "select\n" " {{ col1 }} as a,\n" " col2 as b,\n" " {{ col3 }} as c\n" + + cfg = FluffConfig.from_kwargs(dialect="ansi") + cfg._configs["core"]["templater"] = "jinja" + cfg._configs.setdefault("templater", {}).setdefault("jinja", {}).setdefault( + "context", {} + ).update({"col1": "column_one", "col3": "column_three"}) + cfg._configs.setdefault("layout", {}).setdefault("type", {}).setdefault( + "alias_expression", {} + ).update( + { + "spacing_before": "align", + "align_within": "select_clause", + "align_scope": "bracketed", + } + ) + + # This should trigger templated content detection for siblings + fixed = sqlfluff.fix(sql, config=cfg, rules=["LT01"]) + post_results = sqlfluff.lint(fixed, config=cfg, rules=["LT01"]) + assert _count_lt01(post_results) == 0 diff --git a/test/rules/std_ST12_test.py b/test/rules/std_ST12_test.py new file mode 100644 index 00000000000..5c978512bc8 --- /dev/null +++ b/test/rules/std_ST12_test.py @@ -0,0 +1,114 @@ +"""Tests for ST12 (structure.consecutive_semicolons).""" + +import sqlfluff +from sqlfluff.core.config import FluffConfig + + +def test__rules__std_ST12_basic_patterns(): + """Test basic consecutive semicolon patterns.""" + # Test cases: (SQL, expected_violation_count) + cases = [ + ("SELECT 1;", 0), # Single semicolon - no violation + (";SELECT 1;", 0), # Leading semicolon - no violation + (";;SELECT 1;", 1), # Double leading - violation + ("SELECT 1;;;", 1), # Triple trailing - violation + ("SELECT 1; ; ;", 1), # Spaced consecutive - violation + ("SELECT 1;;;;", 1), # Many consecutive - violation + ] + + for sql, expected_count in cases: + result = sqlfluff.lint(sql, rules=["ST12"]) + actual_count = len([r for r in result if r["code"] == "ST12"]) + assert actual_count == expected_count, f"SQL: {sql!r}" + + +def test__rules__std_ST12_complex_multistatement(): + """Test complex multi-statement scenarios.""" + sql = ( + ";;SELECT col1 FROM tbl1;\n" + "SELECT col2 FROM tbl2;;\n" + "SELECT col3 FROM tbl3;;;;SELECT col4 FROM tbl4;\n" + "; ; ;SELECT col5 FROM tbl5; ; ;\n" + "SELECT col6 FROM tbl6;;;;;;\n" + "SELECT col6 FROM tbl6;;;\n" + ) + + result = sqlfluff.lint(sql, rules=["ST12"]) + violations = [r for r in result if r["code"] == "ST12"] + + # Should detect 7 distinct runs of consecutive semicolons + assert len(violations) == 7 + # Each violation should be at a unique position + positions = {(v["start_line_no"], v["start_line_pos"]) for v in violations} + assert len(positions) == 7 + + +def test__rules__std_ST12_fix_functionality(): + """Test that ST12 fixes work correctly.""" + sql = "SELECT 1;; SELECT 2;;; SELECT 3;" + + result = sqlfluff.fix(sql, rules=["ST12"]) + + # Should have made changes + assert result != sql + # Should have fewer semicolons + assert result.count(";") < sql.count(";") + # Should have no violations after fixing + fixed_violations = sqlfluff.lint(result, rules=["ST12"]) + assert len(fixed_violations) == 0 + + +def test__rules__std_ST12_whitespace_handling(): + """Test that whitespace between semicolons is handled correctly.""" + sql = "SELECT 1;\n\n;SELECT 2;" + result = sqlfluff.lint(sql, rules=["ST12"]) + violations = [r for r in result if r["code"] == "ST12"] + + # Semicolons separated by newlines should still be flagged + assert len(violations) == 1 + + +def test__rules__std_ST12_no_semicolon(): + """Test that no semicolon results in no violations.""" + sql = "SELECT 1" + result = sqlfluff.lint(sql, rules=["ST12"]) + violations = [r for r in result if r["code"] == "ST12"] + + # No semicolons means no violations + assert len(violations) == 0 + + +def test__rules__std_ST12_comments_break_runs(): + """Test that comments between semicolons break consecutive runs.""" + sql = "SELECT 1; /* comment */ ; SELECT 2;" + result = sqlfluff.lint(sql, rules=["ST12"]) + violations = [r for r in result if r["code"] == "ST12"] + + # Comments should break the run, so no violations + assert len(violations) == 0 + + +def test__rules__std_ST12_templated_loop_no_false_positive(): + """Templated loops rendering full statements should not trigger ST12.""" + sql = """ + {% for i in range(3) %} + SELECT {{ i }}; + {% endfor %} + """ + cfg = FluffConfig(overrides={"dialect": "ansi", "templater": "jinja"}) + result = sqlfluff.lint(sql, rules=["ST12"], config=cfg) + violations = [r for r in result if r["code"] == "ST12"] + assert violations == [] + + +def test__rules__std_ST12_templated_consecutive_semicolons_detected(): + """Actual consecutive semicolons in templated output must still be flagged.""" + sql = """ + {% for _ in range(2) %} + ;SELECT 1;; + {% endfor %} + """ + cfg = FluffConfig(overrides={"dialect": "ansi", "templater": "jinja"}) + result = sqlfluff.lint(sql, rules=["ST12"], config=cfg) + violations = [r for r in result if r["code"] == "ST12"] + assert len(violations) == 1