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

get_objects_lib/dialect/parser/sql_server.py

@@ -0,0 +1,512 @@
+import typing as t
+
+from sqlglot import exp, TokenType
+from sqlglot.parser import Parser
+
+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.parser.non_semicolon import NonSemiColonParser
+
+
+# sqlglot normaliza estas funciones para traducir entre dialectos y al generar
+# T-SQL las cambia: SYSDATETIME() -> GETDATE() (menos precision), SUSER_SNAME()
+# -> CURRENT_USER() (otro dato), DATENAME -> FORMAT, DATEDIFF/EOMONTH con CAST
+# agregados. Se dejan como funciones genericas para conservarlas tal cual.
+PRESERVED_FUNCTIONS = (
+    "DATEDIFF", "DATEDIFF_BIG", "DATENAME", "EOMONTH", "SYSDATETIME", "SUSER_SNAME", "SUSER_NAME", "SPACE",
+)
+
+
+class SqlServerParser(NonSemiColonParser):
+    # sqlglot escribe UNCOMITTED (con una M) y no tiene SNAPSHOT
+    TRANSACTION_CHARACTERISTICS = {
+        **NonSemiColonParser.TRANSACTION_CHARACTERISTICS,
+        "ISOLATION": (
+            ("LEVEL", "READ", "UNCOMMITTED"), ("LEVEL", "READ", "COMMITTED"), ("LEVEL", "REPEATABLE", "READ"),
+            ("LEVEL", "SNAPSHOT"), ("LEVEL", "SERIALIZABLE"),
+        ),
+    }
+
+    FUNCTIONS = {k: v for k, v in NonSemiColonParser.FUNCTIONS.items() if k not in PRESERVED_FUNCTIONS}
+
+    ALTER_AS_CREATE = (TokenType.PROCEDURE, TokenType.FUNCTION, TokenType.VIEW, TokenType.TRIGGER)
+
+    # UPDATE(columna) dentro de un trigger
+    FUNC_TOKENS = {*NonSemiColonParser.FUNC_TOKENS, TokenType.UPDATE}
+
+    def _parse_alter(self) -> exp.Expr:
+        # sqlglot solo sabe alterar tablas; con PROCEDURE/FUNCTION cae a
+        # Command. Su sintaxis es la misma que la del CREATE, asi que
+        # reutilizamos _parse_create (self._prev sigue siendo el ALTER).
+        if not self._match_set(self.ALTER_AS_CREATE, advance=False):
+            return super()._parse_alter()
+
+        create = self._parse_create()
+        if not isinstance(create, exp.Create):
+            return create
+
+        return self.expression(AlterObject(**create.args))
+
+    def _parse_create(self) -> exp.Create | exp.Command:
+        # CREATE [OR ALTER] TRIGGER: sqlglot no soporta la sintaxis de T-SQL
+        index = self._index
+        replace = self._match_pair(TokenType.OR, TokenType.ALTER)
+        if self._match(TokenType.TRIGGER):
+            return self._parse_trigger(replace)
+        self._retreat(index)
+
+        create = super()._parse_create()
+        if not isinstance(create, exp.Create):
+            return create
+
+        # Si el cuerpo BEGIN ... END empieza con RETURN, sqlglot envuelve el
+        # bloque completo en un Return; el Return real ya esta dentro del bloque.
+        body = create.args.get("expression")
+        if isinstance(body, exp.Return) and isinstance(body.this, exp.Block):
+            create.set("expression", body.this)
+
+        # Con los parametros entre parentesis sqlglot arma un
+        # UserDefinedFunction aunque sea un PROCEDURE.
+        if create.kind in ("PROCEDURE", "PROC") and isinstance(create.this, exp.UserDefinedFunction):
+            create.set("this", exp.StoredProcedure(**create.this.args))
+
+        return create
+
+    def _parse_field_def(self) -> exp.Expr | None:
+        # INDEX nombre (...) en CREATE TABLE / DECLARE @t TABLE: sqlglot lo
+        # tomaba como una columna llamada INDEX
+        if self._match(TokenType.INDEX):
+            return self._parse_inline_index()
+        return super()._parse_field_def()
+
+    def _parse_inline_index(self) -> InlineIndex:
+        this = self._parse_id_var(any_token=False)
+        unique = self._match(TokenType.UNIQUE)
+        clustered = self._match_texts(('CLUSTERED', 'NONCLUSTERED')) and self._prev.text.upper()
+        expressions = self._parse_wrapped_csv(self._parse_ordered)
+        include = self._parse_wrapped_csv(self._parse_id_var) if self._match_text_seq('INCLUDE') else None
+        where = self._parse_where()
+        options = self._parse_wrapped_csv(self._parse_expression) if self._match(TokenType.WITH) else None
+        return self.expression(InlineIndex(
+            this=this, unique=unique, clustered=clustered or None, expressions=expressions,
+            include=include, where=where, options=options,
+        ))
+
+    def _parse_trigger(self, replace: bool) -> exp.Create:
+        this = self._parse_table_parts()
+        self._match(TokenType.ON)
+        if self._match_text_seq('ALL', 'SERVER'):
+            table = exp.var('ALL SERVER')
+        elif self._match(TokenType.DATABASE):
+            table = exp.var('DATABASE')
+        else:
+            table = self._parse_table_parts()
+
+        options = self._parse_csv(self._parse_procedure_option) if self._match(TokenType.WITH) else None
+
+        if self._match_text_seq('INSTEAD', 'OF'):
+            timing = 'INSTEAD OF'
+        else:
+            self._match_texts(('FOR', 'AFTER'))
+            timing = self._prev.text.upper()
+
+        events = self._parse_csv(lambda: self._parse_var(any_token=True))
+        not_for_replication = self._match_text_seq('NOT', 'FOR', 'REPLICATION')
+
+        self._match(TokenType.ALIAS)
+        begin = self._match(TokenType.BEGIN)
+        body = self._parse_block()
+
+        spec = TriggerSpec(
+            table=table, options=options or None, timing=timing, events=events,
+            not_for_replication=not_for_replication,
+        )
+        return self.expression(exp.Create(
+            this=this, kind='TRIGGER', replace=replace, expression=body, begin=begin,
+            properties=exp.Properties(expressions=[spec]),
+        ))
+
+    def _parse_user_defined_function_expression(self) -> exp.Expr | None:
+        # En T-SQL el BEGIN ... END de una funcion es un bloque de sentencias,
+        # igual que el de un procedimiento. sqlglot ya consumio el BEGIN y,
+        # si la primera sentencia es RETURN, tambien ese RETURN.
+        prev_index = self._index - 2
+        if (
+            self._prev.text.upper() == "RETURN"
+            and prev_index >= 0
+            and self._tokens[prev_index].token_type == TokenType.BEGIN
+        ):
+            self._retreat(self._index - 1)
+
+        if self._prev.token_type == TokenType.BEGIN:
+            return self._parse_block()
+
+        return super()._parse_user_defined_function_expression()
+
+    def _parse_statement(self) -> exp.Expr | None:
+        # Sentencias que no modelamos: la sentencia completa como Command
+        if self._curr and (
+            self._curr.token_type == TokenType.COMMAND
+            or self._is_generic_command(self._curr, self._next)
+            or (self._curr.token_type == TokenType.EXECUTE and self._next and self._next.token_type == TokenType.ALIAS)
+        ):
+            self._advance()
+            return self._parse_known_command(self._prev)
+
+        # El separador de lotes ya viene aislado en su propio chunk
+        if self._curr and self._batch_separator_length(self._tokens, self._index):
+            self._advance()
+            count = self._parse_number() if self._curr else None
+            return self.expression(BatchSeparator(this=count))
+
+        if self._curr and self._curr.token_type == TokenType.DECLARE and self._is_word(self._peek(2), 'CURSOR'):
+            return self._parse_declare_cursor()
+
+        if self._curr and self._curr.token_type == TokenType.FETCH:
+            return self._parse_fetch_cursor()
+
+        if self._is_word(self._curr, 'OPEN', 'CLOSE', 'DEALLOCATE'):
+            kind = self._curr.text.upper()
+            self._advance()
+            global_ = self._match_text_seq('GLOBAL')
+            return self.expression(CursorStatement(kind=kind, this=self._parse_cursor_name(), global_=global_))
+
+        # BEGIN TRY ... END TRY BEGIN CATCH ... END CATCH
+        if self._is_word(self._curr, 'BEGIN') and self._is_word(self._next, 'TRY'):
+            return self._parse_try_catch()
+
+        # BEGIN ... END suelto (BEGIN TRAN lo resuelve STATEMENT_PARSERS)
+        if self._curr and self._is_begin(self._curr, self._next):
+            self._advance()
+            return self.expression(BeginEnd(this=self._parse_block()))
+
+        keyword = self._curr.text.upper() if self._curr and self._curr.token_type == TokenType.VAR else None
+
+        if self._curr and self._is_label(self._curr, self._prev, self._next):
+            self._advance(2)  # nombre y ":"
+            return self.expression(Label(this=exp.to_identifier(self._tokens[self._index - 2].text)))
+
+        if keyword == "GOTO":
+            self._advance()
+            return self.expression(Goto(this=self._parse_id_var(any_token=True)))
+
+        if keyword == "WAITFOR" and self._is_word(self._next, "DELAY", "TIME"):
+            self._advance(2)
+            return self.expression(WaitFor(kind=self._prev.text.upper(), this=self._parse_expression()))
+
+        if keyword == "PRINT":
+            self._advance()
+            return self.expression(Print(this=self._parse_expression()))
+
+        if keyword == "RAISERROR":
+            self._advance()
+            expressions = self._parse_wrapped_csv(self._parse_expression)
+            options = self._parse_csv(self._parse_var) if self._match(TokenType.WITH) else None
+            return self.expression(RaiseError(expressions=expressions, options=options))
+
+        if keyword == "THROW":
+            self._advance()
+            return self.expression(Throw(expressions=self._parse_csv(self._parse_expression) if self._curr else None))
+
+        if keyword == "SAVE" and self._next and self._next.text.upper() in ("TRAN", "TRANSACTION"):
+            self._advance(2)
+            return self.expression(SaveTransaction(this=self._parse_id_var() or self._parse_primary_or_var()))
+
+        if keyword in ("BREAK", "CONTINUE"):
+            self._advance()
+            return self.expression(LoopControl(this=self._prev.text.upper()))
+
+        # RETURN [expresion]: el chunk termina donde termina la sentencia,
+        # asi que lo que quede en el es su valor.
+        if self._curr and self._curr.token_type == TokenType.VAR and self._curr.text.upper() == "RETURN":
+            self._advance()
+            this = self._parse_expression() if self._curr else None
+            return self.expression(ReturnStatement(this=this))
+
+        return super()._parse_statement()
+
+    def _peek(self, offset: int):
+        index = self._index + offset
+        return self._tokens[index] if index < len(self._tokens) else None
+
+    def _parse_cursor_name(self) -> exp.Expr | None:
+        if self._match(TokenType.PARAMETER):
+            return self._parse_parameter()
+        return self._parse_id_var(any_token=True)
+
+    def _parse_declare_cursor(self) -> DeclareCursor:
+        self._advance()  # DECLARE
+        this = self._parse_id_var(any_token=True)
+        self._match_text_seq('CURSOR')
+
+        options = []
+        while self._curr and self._curr.token_type != TokenType.FOR:
+            options.append(self._parse_var(any_token=True))
+        self._match(TokenType.FOR)
+        query = self._parse_select()
+
+        for_update = read_only = False
+        columns = None
+        if self._match(TokenType.FOR):
+            if self._match_text_seq('READ', 'ONLY'):
+                read_only = True
+            elif self._match(TokenType.UPDATE):
+                for_update = True
+                if self._match_text_seq('OF'):
+                    columns = self._parse_csv(self._parse_column)
+
+        return self.expression(DeclareCursor(
+            this=this, options=options or None, expression=query,
+            for_update=for_update, columns=columns, read_only=read_only,
+        ))
+
+    def _parse_fetch_cursor(self) -> FetchCursor:
+        self._advance()  # FETCH
+        direction = count = None
+        if self._match_texts(('NEXT', 'PRIOR', 'FIRST', 'LAST')):
+            direction = self._prev.text.upper()
+        elif self._match_texts(('ABSOLUTE', 'RELATIVE')):
+            direction = self._prev.text.upper()
+            count = self._parse_term()
+        self._match(TokenType.FROM)
+
+        global_ = self._match_text_seq('GLOBAL')
+        this = self._parse_cursor_name()
+        into = self._parse_csv(self._parse_primary_or_var) if self._match(TokenType.INTO) else None
+
+        return self.expression(FetchCursor(this=this, direction=direction, count=count, global_=global_, into=into))
+
+    def _parse_known_command(self, start) -> exp.Command:
+        """
+        Como _parse_as_command de sqlglot, pero sin su aviso de "unsupported
+        syntax": estas sentencias se dejan como Command a proposito.
+        """
+        while self._curr:
+            self._advance()
+        text = self._find_sql(start, self._prev)
+        return exp.Command(this=text[:len(start.text)], expression=text[len(start.text):])
+
+    def _parse_try_catch(self) -> TryCatch:
+        self._advance(2)  # BEGIN TRY
+        try_block = self._parse_block()
+        self._match_text_seq('TRY')
+
+        # BEGIN CATCH viene en el siguiente chunk
+        if not self._curr and self._chunk_index < len(self._chunks):
+            self._advance_chunk()
+        if not self._match_text_seq('BEGIN', 'CATCH'):
+            self.raise_error('Expected BEGIN CATCH after END TRY')
+        catch_block = self._parse_block()
+        self._match_text_seq('CATCH')
+
+        return self.expression(TryCatch(this=try_block, catch=catch_block))
+
+    # Opciones de PROCEDURE / FUNCTION / VIEW que sqlglot no conoce
+    EXTRA_OBJECT_OPTIONS = (("RETURNS", "NULL", "ON", "NULL", "INPUT"), ("CALLED", "ON", "NULL", "INPUT"), ("VIEW_METADATA",))
+
+    def _parse_with_property(self) -> exp.Expr | None | list[exp.Expr]:
+        # sqlglot revisa los atributos de vista (SCHEMABINDING, ENCRYPTION) antes
+        # que la lista de opciones: con "WITH SCHEMABINDING, EXECUTE AS ..." se
+        # queda solo con la primera y deja la coma.
+        is_list = self._next is not None and self._next.token_type == TokenType.COMMA
+        if is_list or self._is_word(self._curr, "RETURNS", "CALLED", "VIEW_METADATA"):
+            return self.expression(exp.WithProcedureOptions(expressions=self._parse_csv(self._parse_procedure_option)))
+        return super()._parse_with_property()
+
+    def _parse_procedure_option(self) -> exp.Expr | None:
+        for words in self.EXTRA_OBJECT_OPTIONS:
+            if self._match_text_seq(*words):
+                return exp.var(" ".join(words))
+        return super()._parse_procedure_option()
+
+    def _match_compound_assignment(self) -> str | None:
+        """Token "+=", "-=", ... (el tokenizer los une); devuelve el operador."""
+        if self._curr and self._curr.token_type == TokenType.EQ and self._curr.text != "=":
+            self._advance()
+            return self._prev.text[:-1]
+        return None
+
+    def _parse_equality(self) -> exp.Expr | None:
+        # UPDATE ... SET col += 1 / SELECT @a += 1
+        this = self._parse_comparison()
+        op = self._match_compound_assignment()
+        if op:
+            return self.expression(CompoundAssignment(this=this, expression=self._parse_comparison(), op=op))
+
+        while self._match_set(self.EQUALITY):
+            comments = self._prev_comments
+            this = self.expression(
+                self.EQUALITY[self._prev.token_type](this=this, expression=self._parse_comparison()),
+                comments=comments,
+            )
+        return this
+
+    def _parse_set_item_assignment(self, kind: str | None = None) -> exp.Expr | None:
+        # SET @a += 1
+        index = self._index
+        left = self._parse_primary() or self._parse_column()
+        op = left and self._match_compound_assignment()
+        if op:
+            value = self.expression(CompoundAssignment(this=left, expression=self._parse_assignment(), op=op))
+            return self.expression(exp.SetItem(this=value, kind=kind))
+        self._retreat(index)
+        return super()._parse_set_item_assignment(kind)
+
+    def _parse_condition(self) -> exp.Expr | None:
+        # sqlglot espera "(expresion)" completa: falla con IF (SELECT ...) > 0
+        # y con IF (@a > 0) AND @b = 1. Una expresion normal cubre ambos.
+        return self._parse_expression()
+
+    # Pistas de tabla que T-SQL acepta sin WITH: FROM Venta (NOLOCK)
+    TABLE_HINT_WORDS = {
+        "NOLOCK", "READUNCOMMITTED", "READCOMMITTED", "READCOMMITTEDLOCK", "REPEATABLEREAD", "SERIALIZABLE",
+        "SNAPSHOT", "UPDLOCK", "XLOCK", "TABLOCK", "TABLOCKX", "PAGLOCK", "ROWLOCK", "NOWAIT", "READPAST",
+        "HOLDLOCK", "NOEXPAND", "FORCESEEK", "FORCESCAN", "KEEPIDENTITY", "KEEPDEFAULTS",
+        "IGNORE_CONSTRAINTS", "IGNORE_TRIGGERS",
+    }
+
+    def _is_hint_list(self, index: int) -> bool:
+        """tokens[index] abre "(hint[, hint...])" solo con pistas de tabla."""
+        tokens = self._tokens
+        if index >= len(tokens) or tokens[index].token_type != TokenType.L_PAREN:
+            return False
+        index += 1
+        while index + 1 < len(tokens) and tokens[index].text.upper() in self.TABLE_HINT_WORDS:
+            if tokens[index + 1].token_type == TokenType.R_PAREN:
+                return True
+            if tokens[index + 1].token_type != TokenType.COMMA:
+                return False
+            index += 2
+        return False
+
+    def _parse_table_part(self, schema: bool = False) -> exp.Expr | None:
+        # "Venta (NOLOCK)" no es la llamada a una funcion Venta
+        if self._curr and self._is_hint_list(self._index + 1):
+            return self._parse_id_var(any_token=False)
+        return super()._parse_table_part(schema)
+
+    def _parse_table_alias(self, alias_tokens=None) -> exp.TableAlias | None:
+        # "Venta (NOLOCK)" sin alias: no es un alias con lista de columnas
+        if self._is_hint_list(self._index):
+            return None
+
+        # "Venta v (NOLOCK)": el parentesis no es la lista de columnas del alias
+        offset = 2 if self._curr and self._curr.token_type == TokenType.ALIAS else 1
+        if self._curr and self._is_hint_list(self._index + offset):
+            self._match(TokenType.ALIAS)
+            alias = self._parse_id_var(any_token=False, tokens=alias_tokens or self.TABLE_ALIAS_TOKENS)
+            if alias:
+                return self.expression(exp.TableAlias(this=alias))
+        return super()._parse_table_alias(alias_tokens)
+
+    def _parse_table_hints(self) -> list[exp.Expr] | None:
+        if self._is_hint_list(self._index):
+            self._advance()  # (
+            hint = self.expression(exp.WithTableHint(expressions=self._parse_csv(lambda: self._parse_var(any_token=True))))
+            self._match_r_paren()
+            return [hint]
+        return super()._parse_table_hints()
+
+    def _parse_alias(self, this: exp.Expr | None, explicit: bool = False) -> exp.Expr | None:
+        # "IF @ID IS NULL RETURN" / "IF ... EXEC ...": una palabra que abre la
+        # siguiente sentencia no es un alias implicito de la expresion anterior.
+        if self._curr and self._is_open_token(self._curr):
+            return this
+
+        return super()._parse_alias(this, explicit)
+
+    def _parse_top(self) -> Top | None:
+        if not self._match(TokenType.TOP):
+            return None
+        this = self._parse_wrapped(self._parse_expression)
+        return self.expression(Top(this=this, percent=self._match(TokenType.PERCENT)))
+
+    def _parse_delete(self) -> exp.Delete:
+        # DELETE TOP (n): sqlglot toma "TOP (n)" como una tabla con alias
+        top = self._parse_top()
+        delete = super()._parse_delete()
+        if top:
+            delete.set("limit", top)
+        return delete
+
+    def _parse_update(self) -> exp.Update:
+        top = self._parse_top()
+        update = super()._parse_update()
+        if top:
+            update.set("limit", top)
+        return update
+
+    def _parse_insert(self) -> exp.Insert:
+        # INSERT ... EXEC: sqlglot no lo soporta; el EXEC es el origen de los datos
+        insert = super()._parse_insert()
+        if isinstance(insert, exp.Insert) and not insert.expression and self._match(TokenType.EXECUTE):
+            insert.set("expression", self._parse_execute())
+        return insert
+
+    def _parse_execute(self) -> exp.Execute:
+        # EXEC (<expresion>) es SQL dinamico: un string, N'...', una variable
+        # o una concatenacion. sqlglot lo intenta leer como nombre de tabla.
+        if self._match(TokenType.L_PAREN, advance=False):
+            # EXEC ('sql', @p1, ...) AT servidor: con servidor vinculado puede
+            # llevar parametros dentro del parentesis
+            expressions = self._parse_wrapped_csv(self._parse_expression)
+            this = exp.Paren(this=expressions[0]) if len(expressions) == 1 else exp.Tuple(expressions=expressions)
+            if self._match_text_seq('AT'):
+                return self.expression(ExecuteAt(this=this, at=self._parse_id_var(any_token=True)))
+            return self.expression(exp.Execute(this=this))
+
+        return super()._parse_execute()
+
+    def _parse_parameter(self) -> exp.Parameter:
+        this = self._parse_identifier() or self._parse_primary_or_var()
+        # El tokenizer marca el nombre como IDENTIFIER (ver SqlServerTokenizer)
+        if isinstance(this, exp.Identifier):
+            this = exp.var(this.name)
+        # OUTPUT se tokeniza como RETURNING; OUT es su forma corta
+        output = self._match(TokenType.RETURNING) or self._match_text_seq("OUT")
+
+        return self.expression(ExecParameter(this=this, output=output))
+
+    def _parse_batch_statements(
+            self,
+            parse_method: t.Callable[[Parser], exp.Expr | None],
+            sep_first_statement: bool = True,
+            top_level: bool = False,
+    ) -> list[exp.Expr | None]:
+        # Un bloque IF/WHILE "sin BEGIN" (bodyless) solo se distingue de un
+        # cuerpo BEGIN...END real por el token que se consumio justo antes de
+        # entrar aqui. Si quien nos llamo (p.ej. _parse_create) ya hizo match
+        # de su propio BEGIN antes de invocar _parse_block, self._prev es ese
+        # BEGIN, y NO debemos tomar el atajo de una sola sentencia: es un
+        # bloque real de varias sentencias, solo que su BEGIN ya fue
+        # consumido por el llamador.
+        prev_was_begin = self._block_already_opened()
+
+        if (
+            not top_level
+            and not prev_was_begin
+            and self._is_open_token(self._curr, self._prev, self._next)
+        ):
+            result = [parse_method(self)]
+
+            # Una sentencia bodyless nunca avanza mas alla de su propio chunk.
+            # Miramos el siguiente chunk para decidir que hacer con el antes
+            # de devolver el control a quien nos llamo.
+            if (
+                not self._curr
+                and self._chunk_index < len(self._chunks)
+                and self._chunks[self._chunk_index]
+            ):
+                next_chunk = self._chunks[self._chunk_index]
+                first_token = next_chunk[0]
+
+                if first_token.token_type == TokenType.ELSE:
+                    # Pertenece al _parse_if que nos envuelve - lo cargamos
+                    # para que su propio self._match(TokenType.ELSE) lo vea.
+                    self._advance_chunk()
+
+            return result
+
+        return super()._parse_batch_statements(parse_method, sep_first_statement, top_level=top_level)

get_objects_lib/dialect/text_utils.py

@@ -0,0 +1,22 @@
+class StrUtilMixin:
+    @staticmethod
+    def _clean_spaces(text):
+        text = ' '.join(text.split())
+
+        for r in ('( ', ' )', '[ ', ' ]'):
+            text = text.replace(r, r.strip())
+
+        return text
+
+    @staticmethod
+    def _clean_lines(text: str):
+        return '\n'.join([l for l in text.splitlines() if l])
+
+    @staticmethod
+    def _flat(text: str):
+        text = text.replace('\n', ' ')
+        return StrUtilMixin._clean_spaces(text)
+
+    @staticmethod
+    def _set_tab(text: str, index: int = 0):
+        return '\n'.join([f'{index * '\t'}{l}' for l in text.splitlines()])

get_objects_lib/dialect/tokenizer.py

@@ -0,0 +1,51 @@
+from sqlglot import TokenType
+from sqlglot.tokens import Token
+from sqlglot.dialects.tsql import TSQL
+
+
+class SqlServerTokenizer(TSQL.Tokenizer):
+    # Un token de COMMANDS al inicio del script (o tras ";") se traga el resto
+    # como un solo string. El parser maneja FETCH y los COMMAND (UPDATE
+    # STATISTICS, ...) dentro de su propia sentencia.
+    COMMANDS = TSQL.Tokenizer.COMMANDS - {TokenType.END, TokenType.FETCH, TokenType.COMMAND}
+
+    # Como COMMAND, GO y PRINT se tragan el resto del script despues de un
+    # ";" (o al inicio). Los dejamos como VAR y el parser los reconoce.
+    KEYWORDS = {k: v for k, v in TSQL.Tokenizer.KEYWORDS.items() if k not in ("GO", "PRINT")}
+
+    # Operador pegado a "=": asignacion compuesta (SET @i += 1)
+    COMPOUND_OPERATORS = {
+        TokenType.PLUS, TokenType.DASH, TokenType.STAR, TokenType.SLASH,
+        TokenType.MOD, TokenType.AMP, TokenType.PIPE, TokenType.CARET,
+    }
+
+    def tokenize(self, sql: str) -> list[Token]:
+        # Une "+" "=" en un solo token EQ con texto "+=" (lo mismo para -= *= ...)
+        tokens = []
+        for token in super().tokenize(sql):
+            prev = tokens[-1] if tokens else None
+            if (
+                token.token_type == TokenType.EQ
+                and prev is not None
+                and prev.token_type in self.COMPOUND_OPERATORS
+                and prev.end + 1 == token.start
+            ):
+                tokens[-1] = Token(
+                    TokenType.EQ, prev.text + token.text, prev.line, prev.col, prev.start, token.end, prev.comments,
+                )
+                continue
+
+            # Nombre de variable (@End, @If, @Begin...): IDENTIFIER para que no
+            # se confunda con la palabra clave; el parser lo convierte en Var.
+            if (
+                prev is not None
+                and prev.token_type == TokenType.PARAMETER
+                and prev.end + 1 == token.start
+                and token.token_type != TokenType.PARAMETER
+            ):
+                token = Token(
+                    TokenType.IDENTIFIER, token.text, token.line, token.col, token.start, token.end, token.comments,
+                )
+
+            tokens.append(token)
+        return tokens

get_objects_lib/objects/__init__.py

@@ -0,0 +1,3 @@
+from get_objects_lib.objects.dependencies import ObjectRef, get_dependencies
+from get_objects_lib.objects.header import ObjectHeader, find_object_header
+from get_objects_lib.objects.standardize import standardize_object