get-objects-lib 0.1.0__py3-none-any.whl

get_objects_lib/__init__.py

@@ -0,0 +1,12 @@
+"""Parser y generador de T-SQL sobre sqlglot, y analisis de objetos de SQL Server."""
+from get_objects_lib.dialect import SqlServer
+from get_objects_lib.objects import ObjectHeader, ObjectRef, find_object_header, get_dependencies, standardize_object
+
+__all__ = [
+    'SqlServer',
+    'ObjectHeader',
+    'ObjectRef',
+    'find_object_header',
+    'get_dependencies',
+    'standardize_object',
+]

get_objects_lib/dialect/__init__.py

@@ -0,0 +1,3 @@
+from get_objects_lib.dialect.dialect import SqlServer
+
+__all__ = ['SqlServer']

get_objects_lib/dialect/dialect.py

@@ -0,0 +1,11 @@
+from sqlglot.dialects.tsql import TSQL
+
+from get_objects_lib.dialect.parser.sql_server import SqlServerParser
+from get_objects_lib.dialect.tokenizer import SqlServerTokenizer
+from get_objects_lib.dialect.generator import SqlServerGenerator
+
+
+class SqlServer(TSQL):
+    Tokenizer = SqlServerTokenizer
+    Parser = SqlServerParser
+    Generator = SqlServerGenerator

get_objects_lib/dialect/expressions.py

@@ -0,0 +1,116 @@
+from sqlglot import exp
+
+
+class ExecParameter(exp.Parameter):
+    arg_types = {"this": True, "expression": False, "output": False}
+
+
+class ReturnStatement(exp.Return):
+    """RETURN como sentencia; el valor es opcional (RETURN a secas)."""
+    arg_types = {"this": False}
+
+
+class BatchSeparator(exp.Expression):
+    """GO [n]: separa lotes; this es el numero de repeticiones."""
+    arg_types = {"this": False}
+
+
+class LoopControl(exp.Expression):
+    """BREAK / CONTINUE dentro de un WHILE; this es la palabra clave."""
+    arg_types = {"this": True}
+
+
+class Print(exp.Expression):
+    arg_types = {"this": True}
+
+
+class RaiseError(exp.Expression):
+    """RAISERROR (mensaje, severidad, estado [, args]) [WITH opciones]"""
+    arg_types = {"expressions": True, "options": False}
+
+
+class Throw(exp.Expression):
+    """THROW [numero, mensaje, estado]; sin argumentos relanza el error."""
+    arg_types = {"expressions": False}
+
+
+class SaveTransaction(exp.Expression):
+    """SAVE TRAN[SACTION] nombre"""
+    arg_types = {"this": True}
+
+
+class BeginEnd(exp.Expression):
+    """Bloque BEGIN ... END suelto (sin IF/WHILE/procedimiento que lo contenga)."""
+    arg_types = {"this": True}
+
+
+class TryCatch(exp.Expression):
+    """BEGIN TRY ... END TRY BEGIN CATCH ... END CATCH"""
+    arg_types = {"this": True, "catch": True}
+
+
+class DeclareCursor(exp.Expression):
+    """DECLARE nombre CURSOR [opciones] FOR select [FOR UPDATE [OF columnas] | FOR READ ONLY]"""
+    arg_types = {"this": True, "options": False, "expression": True, "for_update": False, "columns": False, "read_only": False}
+
+
+class CursorStatement(exp.Expression):
+    """OPEN / CLOSE / DEALLOCATE [GLOBAL] cursor"""
+    arg_types = {"kind": True, "this": True, "global_": False}
+
+
+class FetchCursor(exp.Expression):
+    """FETCH [NEXT | PRIOR | FIRST | LAST | ABSOLUTE n | RELATIVE n] [FROM] cursor [INTO @variables]"""
+    arg_types = {"this": True, "direction": False, "count": False, "global_": False, "into": False}
+
+
+class Top(exp.Expression):
+    """TOP (n) [PERCENT] de un DELETE / UPDATE; se guarda en su arg "limit"."""
+    arg_types = {"this": True, "percent": False}
+
+
+class Label(exp.Expression):
+    """Etiqueta de GOTO: "Nombre:"."""
+    arg_types = {"this": True}
+
+
+class Goto(exp.Expression):
+    arg_types = {"this": True}
+
+
+class WaitFor(exp.Expression):
+    """WAITFOR DELAY | TIME expresion"""
+    arg_types = {"kind": True, "this": True}
+
+
+class CompoundAssignment(exp.Expression):
+    """@a += 1, col -= 2, ...; op es el operador sin el "=" (+, -, *, /, %, &, |, ^)."""
+    arg_types = {"this": True, "expression": True, "op": True}
+
+
+class TriggerSpec(exp.Expression):
+    """
+    Encabezado de un trigger de T-SQL: ON tabla [WITH opciones]
+    {FOR | AFTER | INSTEAD OF} eventos [NOT FOR REPLICATION]
+    """
+    arg_types = {"table": True, "options": False, "timing": True, "events": True, "not_for_replication": False}
+
+
+class ExecuteAt(exp.Execute):
+    """EXEC (sql [, parametros]) AT servidor_vinculado"""
+    arg_types = {**exp.Execute.arg_types, "at": True}
+
+
+class InlineIndex(exp.Expression):
+    """
+    Indice en la definicion de una tabla: INDEX nombre [UNIQUE]
+    [CLUSTERED | NONCLUSTERED] (columnas) [INCLUDE (...)] [WHERE ...] [WITH (...)]
+    """
+    arg_types = {
+        "this": True, "unique": False, "clustered": False, "expressions": True,
+        "include": False, "where": False, "options": False,
+    }
+
+
+class AlterObject(exp.Create):
+    """ALTER PROCEDURE/FUNCTION/VIEW/TRIGGER: misma estructura que su CREATE."""

get_objects_lib/dialect/generator.py

@@ -0,0 +1,231 @@
+from sqlglot import exp
+from sqlglot.dialects.tsql import TSQL
+
+from get_objects_lib.dialect.expressions import (
+    AlterObject, BatchSeparator, BeginEnd, CursorStatement, DeclareCursor, ExecParameter, FetchCursor, Goto, Label, Top, TryCatch, WaitFor, CompoundAssignment, TriggerSpec, ExecuteAt, InlineIndex, LoopControl, Print, RaiseError, ReturnStatement,
+    SaveTransaction, Throw,
+)
+from get_objects_lib.dialect.text_utils import StrUtilMixin
+
+
+class SqlServerGenerator(TSQL.Generator, StrUtilMixin):
+    # T-SQL se escribe INT; sqlglot lo genera como INTEGER
+    TYPE_MAPPING = {**TSQL.Generator.TYPE_MAPPING, exp.DataType.Type.INT: "INT"}
+
+    TRANSFORMS = {
+        **TSQL.Generator.TRANSFORMS,
+        ExecParameter: lambda self, e: (
+            f'@{self.sql(e, "this")} {"OUTPUT" if e.args.get("output") else ""}'.strip()
+        ),
+        AlterObject: lambda self, e: self.alterobject_sql(e),
+        ReturnStatement: lambda self, e: f'RETURN {self.sql(e, "this")}'.strip(),
+        BatchSeparator: lambda self, e: f'GO {self.sql(e, "this")}'.strip(),
+        LoopControl: lambda self, e: e.this,
+        Print: lambda self, e: f'PRINT {self.sql(e, "this")}',
+        RaiseError: lambda self, e: self.raiseerror_sql(e),
+        InlineIndex: lambda self, e: self.inlineindex_sql(e),
+        ExecuteAt: lambda self, e: f'{self.execute_sql(e)} AT {self.sql(e, "at")}',
+        BeginEnd: lambda self, e: self.beginend_sql(e),
+        TryCatch: lambda self, e: self.trycatch_sql(e),
+        Label: lambda self, e: f'{self.sql(e, "this")}:',
+        CompoundAssignment: lambda self, e: f'{self.sql(e, "this")} {e.args["op"]}= {self.sql(e, "expression")}',
+        Goto: lambda self, e: f'GOTO {self.sql(e, "this")}',
+        WaitFor: lambda self, e: f'WAITFOR {e.args["kind"]} {self.sql(e, "this")}',
+        DeclareCursor: lambda self, e: self.declarecursor_sql(e),
+        CursorStatement: lambda self, e: self.cursorstatement_sql(e),
+        FetchCursor: lambda self, e: self.fetchcursor_sql(e),
+        SaveTransaction: lambda self, e: f'SAVE TRANSACTION {self.sql(e, "this")}',
+        Throw: lambda self, e: f'THROW {self.expressions(e, flat=True)}'.strip(),
+    }
+
+    def _move_ctes_to_top_level(self, expression):
+        # sqlglot sube los CTE anidados de un CREATE al nivel superior (para
+        # CREATE TABLE ... AS SELECT). En el cuerpo BEGIN ... END de un
+        # procedimiento o funcion cada sentencia tiene su propio CTE.
+        if isinstance(expression, exp.Create) and isinstance(expression.expression, exp.Block):
+            return expression
+        return super()._move_ctes_to_top_level(expression)
+
+    def inlineindex_sql(self, expression: InlineIndex) -> str:
+        unique = " UNIQUE" if expression.args.get("unique") else ""
+        clustered = f" {expression.args['clustered']}" if expression.args.get("clustered") else ""
+        include = self.expressions(expression, key="include", flat=True)
+        include = f" INCLUDE ({include})" if include else ""
+        where = self.sql(expression, "where").strip()
+        where = f" {where}" if where else ""
+        options = self.expressions(expression, key="options", flat=True)
+        options = f" WITH ({options})" if options else ""
+        columns = self.expressions(expression, flat=True)
+        return f"INDEX {self.sql(expression, 'this')}{unique}{clustered} ({columns}){include}{where}{options}"
+
+    def insert_sql(self, expression: exp.Insert) -> str:
+        # sqlglot solo escribe DEFAULT VALUES cuando RETURNING va al final; en
+        # T-SQL el OUTPUT va antes y DEFAULT VALUES se perdia
+        sql = super().insert_sql(expression)
+        if expression.args.get("default") and not sql.rstrip().endswith("DEFAULT VALUES"):
+            sql = f"{sql.rstrip()} DEFAULT VALUES"
+        return sql
+
+    def anonymous_sql(self, expression: exp.Anonymous) -> str:
+        # sqlglot pasa a mayusculas las funciones que no conoce salvo las
+        # calificadas con Dot; dbo.fn(...) en un FROM (Table) o fn(...) en un
+        # APPLY tambien son funciones de usuario: se dejan como se escribieron.
+        return self.func(self.sql(expression, "this"), *expression.expressions, normalize=False)
+
+    def returnsproperty_sql(self, expression: exp.ReturnsProperty) -> str:
+        # TSQL usa str(table), que genera con el dialecto por defecto y no
+        # conoce ExecParameter (RETURNS @t TABLE (...)).
+        table = self.sql(expression, "table")
+        table = f"{table} " if table else ""
+        return f"RETURNS {table}{self.sql(expression, 'this')}"
+
+    def create_sql(self, expression: exp.Create) -> str:
+        if expression.kind == "TRIGGER":
+            return self._trigger_sql(expression)
+        return super().create_sql(expression)
+
+    def _trigger_sql(self, expression: exp.Create) -> str:
+        spec = expression.find(TriggerSpec)
+        replace = " OR ALTER" if expression.args.get("replace") else ""
+        options = self.expressions(spec, key="options", flat=True)
+        options = f" WITH {options}" if options else ""
+        events = self.expressions(spec, key="events", flat=True)
+        not_for_replication = " NOT FOR REPLICATION" if spec.args.get("not_for_replication") else ""
+        begin = " BEGIN" if expression.args.get("begin") else ""
+        return (
+            f"CREATE{replace} TRIGGER {self.sql(expression, 'this')} ON {self.sql(spec, 'table')}{options}"
+            f" {spec.args['timing']} {events}{not_for_replication} AS{begin}{self.sep()}{self.sql(expression, 'expression')}"
+        )
+
+    def alterobject_sql(self, expression: AlterObject) -> str:
+        sql = self.create_sql(expression)
+        return f"ALTER{sql[len('CREATE'):]}"
+
+    def select_sql(self, expression: exp.Select) -> str:
+        sql = super().select_sql(expression)
+        if len(sql) < 100: sql = self._flat(sql)
+        return sql
+
+    def exists_sql(self, expression: exp.Exists) -> str:
+        sql = super().exists_sql(expression)
+        if len(sql) < 100: sql = self._flat(sql)
+        return sql
+
+    def block_sql(self, expression: exp.Block) -> str:
+        lines = [self.sql(e) for e in expression.expressions]
+        return "\n".join(line for line in lines if line)
+
+    def _block_body_and_end(self, block: exp.Block | None) -> tuple[str, str]:
+        if not block: return "", ""
+
+        expressions = list(block.expressions)
+        end = ""
+        if expressions and isinstance(expressions[-1], exp.EndStatement):
+            end = self.sql(expressions.pop())
+
+        lines = [self.sql(e) for e in expressions]
+        body = "\n".join(line for line in lines if line)
+        return body, end
+
+    def ifblock_sql(self, expression: exp.IfBlock) -> str:
+        this = self.sql(expression, "this")
+
+        true_expressions = getattr(expression.args.get('true'), 'expressions', [])
+        true_body, true_end = self._block_body_and_end(expression.args.get('true'))
+
+        true_sql = self.indent(true_body, level=1)
+        if len(true_expressions) != 1:
+            true_sql = f"BEGIN\n{self.indent(true_body, level=1)}"
+            if true_end:
+                true_sql = f"{true_sql}\n{true_end}"
+
+        false_expressions = getattr(expression.args.get('false'), 'expressions', [])
+        false_body, false_end = self._block_body_and_end(expression.args.get('false'))
+
+        if false_body or false_end:
+            if len(false_expressions) == 1:
+                false_sql = f"\nELSE\n{self.indent(false_body, level=1)}"
+            else:
+                false_sql = f"\nELSE\nBEGIN\n{self.indent(false_body, level=1)}"
+                if false_end:
+                    false_sql = f"{false_sql}\n{false_end}"
+        else:
+            false_sql = ""
+
+        return f"IF {this}\n{true_sql}{false_sql}"
+
+    def declarecursor_sql(self, expression: DeclareCursor) -> str:
+        options = self.expressions(expression, key="options", sep=" ")
+        options = f" {options}" if options else ""
+        sql = f"DECLARE {self.sql(expression, 'this')} CURSOR{options} FOR {self.sql(expression, 'expression')}"
+        if expression.args.get("read_only"):
+            return f"{sql} FOR READ ONLY"
+        if expression.args.get("for_update"):
+            columns = self.expressions(expression, key="columns", flat=True)
+            return f"{sql} FOR UPDATE OF {columns}" if columns else f"{sql} FOR UPDATE"
+        return sql
+
+    def cursorstatement_sql(self, expression: CursorStatement) -> str:
+        global_ = "GLOBAL " if expression.args.get("global_") else ""
+        return f"{expression.args['kind']} {global_}{self.sql(expression, 'this')}"
+
+    def fetchcursor_sql(self, expression: FetchCursor) -> str:
+        direction = expression.args.get("direction")
+        count = self.sql(expression, "count")
+        direction = f"{direction} {count} " if count else f"{direction} " if direction else ""
+        global_ = "GLOBAL " if expression.args.get("global_") else ""
+        into = self.expressions(expression, key="into", flat=True)
+        into = f" INTO {into}" if into else ""
+        return f"FETCH {direction}FROM {global_}{self.sql(expression, 'this')}{into}"
+
+    def _with_top(self, expression: exp.Delete | exp.Update, keyword: str, generate) -> str:
+        # T-SQL: DELETE TOP (n) ... / UPDATE TOP (n) ..., no LIMIT al final
+        top = expression.args.get("limit")
+        if not isinstance(top, Top):
+            return generate(expression)
+        expression = expression.copy()
+        expression.set("limit", None)
+        percent = " PERCENT" if top.args.get("percent") else ""
+        sql = generate(expression)
+        return f"{keyword} TOP ({self.sql(top, 'this')}){percent}{sql[len(keyword):]}"
+
+    def delete_sql(self, expression: exp.Delete) -> str:
+        return self._with_top(expression, "DELETE", super().delete_sql)
+
+    def update_sql(self, expression: exp.Update) -> str:
+        return self._with_top(expression, "UPDATE", super().update_sql)
+
+    def trycatch_sql(self, expression: TryCatch) -> str:
+        try_body, _ = self._block_body_and_end(expression.this)
+        catch_body, _ = self._block_body_and_end(expression.args.get("catch"))
+        return (
+            f"BEGIN TRY\n{self.indent(try_body, level=1)}\nEND TRY\n"
+            f"BEGIN CATCH\n{self.indent(catch_body, level=1)}\nEND CATCH"
+        )
+
+    def beginend_sql(self, expression: BeginEnd) -> str:
+        body, end = self._block_body_and_end(expression.this)
+        return f"BEGIN\n{self.indent(body, level=1)}\n{end}"
+
+    def raiseerror_sql(self, expression: RaiseError) -> str:
+        options = self.expressions(expression, key="options", flat=True)
+        options = f" WITH {options}" if options else ""
+        return f"RAISERROR({self.expressions(expression, flat=True)}){options}"
+
+    def whileblock_sql(self, expression: exp.WhileBlock) -> str:
+        # TSQL siempre escribe "WHILE c BEGIN cuerpo" sin END; igual que en
+        # ifblock_sql, BEGIN ... END solo si el cuerpo original lo tenia.
+        this = self.sql(expression, "this")
+        block = expression.args.get("body")
+        body, end = self._block_body_and_end(block)
+        if len(getattr(block, "expressions", [])) == 1:
+            return f"WHILE {this}\n{self.indent(body, level=1)}"
+
+        sql = f"WHILE {this}\nBEGIN\n{self.indent(body, level=1)}"
+        return f"{sql}\n{end}" if end else sql
+
+    def generate(self, expression: exp.Expr, copy: bool = True) -> str:
+        # Sin reemplazar ';' por saltos de linea: romperia los literales que
+        # lo contienen (EXEC (N'CREATE ... AS RETURN 0;')).
+        sql = super().generate(expression, copy)
+        return self._clean_lines(sql)

get_objects_lib/dialect/parser/__init__.py

@@ -0,0 +1,3 @@
+from get_objects_lib.dialect.parser.sql_server import SqlServerParser
+
+__all__ = ['SqlServerParser']

get_objects_lib/dialect/parser/base.py

@@ -0,0 +1,278 @@
+from typing import List, Callable
+
+from sqlglot import exp, Parser
+from sqlglot.dialects.tsql import TSQL
+from sqlglot.tokens import Token, TokenType
+
+
+class BaseParser(TSQL.Parser):
+    OPEN_TOKENS = [
+        TokenType.SET,
+        TokenType.ELSE,
+        TokenType.DECLARE,
+        TokenType.EXECUTE,
+        TokenType.SELECT,
+        TokenType.UPDATE,
+        TokenType.DELETE,
+        TokenType.INSERT,
+        TokenType.CREATE,
+        TokenType.COMMIT,
+        TokenType.ROLLBACK,
+        TokenType.TRUNCATE,
+        TokenType.DROP,
+        TokenType.MERGE,
+        TokenType.USE,
+    ]
+
+    OPEN_KEYWORDS = [
+        'RETURN',
+        'OPEN',
+        'IF',
+        'WHILE',
+        'BREAK',
+        'CONTINUE',
+        'PRINT',
+        'RAISERROR',
+        'THROW',
+        'SAVE',
+        'CLOSE',
+        'DEALLOCATE',
+        'GOTO',
+        'WAITFOR',
+    ]
+
+    # Sentencias que sqlglot no modela; se parsean como Command. Son palabras
+    # reservadas: no pueden ser nombres sin corchetes.
+    GENERIC_COMMANDS = ('DBCC', 'BULK', 'REVERT', 'CHECKPOINT', 'KILL', 'RECONFIGURE', 'SHUTDOWN', 'DENY')
+
+    # DROP TABLE IF EXISTS: ese IF es parte del DROP, no una sentencia
+    OBJECT_KIND_TOKENS = (
+        TokenType.TABLE, TokenType.PROCEDURE, TokenType.VIEW, TokenType.FUNCTION, TokenType.INDEX,
+        TokenType.TRIGGER, TokenType.SCHEMA, TokenType.SEQUENCE, TokenType.DATABASE,
+    )
+
+    # BEGIN TRAN / BEGIN DISTRIBUTED TRANSACTION es una sentencia, no un bloque
+    TRANSACTION_WORDS = ('TRAN', 'TRANSACTION', 'DISTRIBUTED')
+
+    # ALTER solo abre sentencia si le sigue uno de estos objetos; asi no se
+    # parten "CREATE OR ALTER" ni "ALTER TABLE t ALTER COLUMN c".
+    ALTER_OBJECTS = [
+        TokenType.PROCEDURE,
+        TokenType.FUNCTION,
+        TokenType.VIEW,
+        TokenType.TABLE,
+        TokenType.TRIGGER,
+    ]
+
+    @staticmethod
+    def _is_word(token: Token | None, *words: str) -> bool:
+        """Palabra clave sin comillas: 'end' o [End] no cuentan como END."""
+        return (
+            token is not None
+            and token.token_type not in (TokenType.STRING, TokenType.NATIONAL_STRING, TokenType.IDENTIFIER)
+            and token.text.upper() in words
+        )
+
+    @staticmethod
+    def _is_begin(token: Token, _next: Token | None = None) -> bool:
+        if not BaseParser._is_word(token, 'BEGIN'):
+            return False
+        return not BaseParser._is_begin_transaction(token, _next)
+
+    @staticmethod
+    def _is_begin_transaction(token: Token, _next: Token | None) -> bool:
+        return BaseParser._is_word(token, 'BEGIN') and BaseParser._is_word(_next, *BaseParser.TRANSACTION_WORDS)
+
+    @staticmethod
+    def _is_end(token: Token) -> bool:
+        return BaseParser._is_word(token, 'END')
+
+    @staticmethod
+    def _batch_separator_length(tokens: List[Token], index: int) -> int:
+        """
+        Tokens que ocupa un GO en tokens[index] (GO o GO n), o 0 si no lo es.
+        GO solo separa lotes cuando va solo en su linea.
+        """
+        token = tokens[index]
+        if token.token_type != TokenType.VAR or token.text.upper() != 'GO':
+            return 0
+        if index > 0 and tokens[index - 1].line == token.line:
+            return 0
+
+        length = 1
+        _next = tokens[index + 1] if index + 1 < len(tokens) else None
+        if _next and _next.line == token.line and _next.token_type == TokenType.NUMBER:
+            length = 2
+        after = tokens[index + length] if index + length < len(tokens) else None
+        if after and after.line == token.line:
+            return 0
+        return length
+
+    @staticmethod
+    def _is_trigger_event(token: Token, _prev: Token | None) -> bool:
+        return (
+            token.token_type in (TokenType.INSERT, TokenType.UPDATE, TokenType.DELETE)
+            and _prev is not None
+            and (BaseParser._is_word(_prev, 'AFTER', 'OF') or _prev.token_type == TokenType.COMMA)
+        )
+
+    @staticmethod
+    def _is_generic_command(token: Token, _next: Token | None) -> bool:
+        if token.token_type != TokenType.VAR:
+            return False
+        if token.text.upper() in BaseParser.GENERIC_COMMANDS:
+            return True
+        # ENABLE / DISABLE no son reservadas: solo con TRIGGER
+        return token.text.upper() in ('ENABLE', 'DISABLE') and _next is not None and _next.token_type == TokenType.TRIGGER
+
+    @staticmethod
+    def _is_label(token: Token, _prev: Token | None, _next: Token | None) -> bool:
+        """Etiqueta de GOTO: "Nombre:" al inicio de su linea."""
+        return (
+            token.token_type == TokenType.VAR
+            and _next is not None and _next.token_type == TokenType.COLON and _next.line == token.line
+            and (_prev is None or _prev.line != token.line)
+        )
+
+    @staticmethod
+    def _starts_cte(tokens: List[Token], index: int) -> bool:
+        """
+        WITH nombre AS ( ... o WITH nombre (columnas) AS ( ...: inicio de un CTE.
+        Descarta WITH (NOLOCK), WITH NOWAIT, WITH RECOMPILE AS, etc.
+        """
+        def at(i):
+            return tokens[i] if i < len(tokens) else None
+
+        if tokens[index].token_type != TokenType.WITH:
+            return False
+        i = index + 1
+        name = at(i)
+        if name is None or name.token_type in (TokenType.L_PAREN, TokenType.STRING):
+            return False
+        i += 1
+        if at(i) is not None and at(i).token_type == TokenType.L_PAREN:
+            # lista de columnas
+            depth = 0
+            while at(i) is not None:
+                depth += {TokenType.L_PAREN: 1, TokenType.R_PAREN: -1}.get(at(i).token_type, 0)
+                i += 1
+                if depth == 0:
+                    break
+        return (
+            at(i) is not None and at(i).token_type == TokenType.ALIAS
+            and at(i + 1) is not None and at(i + 1).token_type == TokenType.L_PAREN
+        )
+
+    @staticmethod
+    def _is_open_token(token: Token, _prev: Token | None = None, _next: Token | None = None) -> bool:
+        if (
+            token.token_type == TokenType.EXECUTE
+            and _prev is not None and _prev.token_type in (TokenType.WITH, TokenType.COMMA)
+            and _next is not None and _next.token_type == TokenType.ALIAS
+        ):
+            return False  # WITH [RECOMPILE,] EXECUTE AS ... de un procedimiento o funcion
+        if token.token_type == TokenType.INSERT and BaseParser._is_word(_prev, 'BULK'):
+            return False  # BULK INSERT
+        if BaseParser._is_trigger_event(token, _prev):
+            return False  # AFTER INSERT, UPDATE, DELETE de un trigger
+        if token.token_type == TokenType.UPDATE and _next is not None and _next.token_type == TokenType.L_PAREN:
+            return False  # funcion UPDATE(columna) de un trigger
+        if token.token_type in BaseParser.OPEN_TOKENS or token.token_type == TokenType.COMMAND:
+            return True
+        if BaseParser._is_generic_command(token, _next):
+            return True
+        if token.token_type == TokenType.VAR and token.text.upper() == 'THROW':
+            # THROW no es reservada (puede ser una columna): solo abre sentencia
+            # sin argumentos o con THROW numero/@variable, ...
+            return _next is None or _next.line != token.line or _next.token_type in (TokenType.NUMBER, TokenType.PARAMETER)
+        if token.token_type == TokenType.VAR and token.text.upper() in BaseParser.OPEN_KEYWORDS:
+            return not (token.text.upper() == 'IF' and _prev is not None and _prev.token_type in BaseParser.OBJECT_KIND_TOKENS)
+        if BaseParser._is_begin_transaction(token, _next):
+            return True
+        if BaseParser._is_word(token, 'BEGIN') and BaseParser._is_word(_next, 'TRY'):
+            return True  # BEGIN TRY: sentencia TRY/CATCH (p.ej. cuerpo de un IF sin BEGIN)
+        if BaseParser._is_label(token, _prev, _next):
+            return True
+        if token.token_type == TokenType.FETCH:
+            # FETCH de cursor, no el de ORDER BY ... OFFSET n ROWS FETCH NEXT
+            return not BaseParser._is_word(_prev, 'ROWS', 'ROW')
+        if token.token_type == TokenType.ALTER:
+            after_or = _prev is not None and _prev.token_type == TokenType.OR
+            return not after_or and _next is not None and _next.token_type in BaseParser.ALTER_OBJECTS
+        return False
+
+    def _is_block_without_begin(self, raw_tokens: List[Token], index: int) -> bool:
+        tokens_to_check = []
+
+        # Profundidad, no booleano: en "(a IN (1, 2) UNION SELECT ...)" el
+        # primer ")" no cierra el parentesis exterior.
+        depth = 0
+        for i, token in enumerate(raw_tokens[index + 1:], start=index + 1):
+            if token.token_type == TokenType.L_PAREN:
+                depth += 1
+
+            _next = raw_tokens[i + 1] if i + 1 < len(raw_tokens) else None
+            if self._is_open_token(token, raw_tokens[i - 1], _next) and not depth:
+                break
+
+            if not depth:
+                tokens_to_check.append(token)
+
+            if token.token_type == TokenType.R_PAREN and depth:
+                depth -= 1
+
+        return not any(
+            self._is_begin(t, tokens_to_check[i + 1] if i + 1 < len(tokens_to_check) else None)
+            for i, t in enumerate(tokens_to_check)
+        )
+
+    def _block_already_opened(self) -> bool:
+        """El BEGIN (o BEGIN TRY / BEGIN CATCH) del bloque ya fue consumido."""
+        if self._prev and self._prev.token_type == TokenType.BEGIN:
+            return True
+        before = self._tokens[self._index - 2] if self._index >= 2 else None
+        return self._is_word(self._prev, 'TRY', 'CATCH') and self._is_word(before, 'BEGIN')
+
+    def _parse_batch_statements(
+            self,
+            parse_method: Callable[[Parser], exp.Expr | None],
+            sep_first_statement: bool = True,
+            top_level: bool = False,
+    ) -> list[exp.Expr | None]:
+        expressions = []
+
+        if sep_first_statement:
+            # Si quien nos llama ya consumio el BEGIN del bloque (p.ej.
+            # _parse_create), un BEGIN aqui es un bloque anidado, no el nuestro.
+            if not self._block_already_opened():
+                self._match(TokenType.BEGIN)
+            # Si el chunk termina en el BEGIN no hay sentencia: no agregar None
+            first = parse_method(self)
+            if first is not None or top_level:
+                expressions.append(first)
+
+        chunks_length = len(self._chunks)
+        while self._chunk_index < chunks_length:
+            self._advance_chunk()
+
+            if not top_level and self._match(TokenType.ELSE, advance=False):
+                return expressions
+
+            if (
+                expressions
+                and self._curr
+                and self._curr.token_type == TokenType.END
+                and (not self._next or self._next.token_type == TokenType.ELSE or self._is_word(self._next, 'TRY', 'CATCH'))
+            ):
+                self._advance()
+                expressions.append(exp.EndStatement())
+                return expressions
+
+            expressions.append(parse_method(self))
+
+            if self._index < self._tokens_size:
+                self.raise_error("Invalid expression / Unexpected token")
+
+            self.check_errors()
+
+        return expressions