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

get_objects_lib/objects/dependencies.py

@@ -0,0 +1,162 @@
+from dataclasses import dataclass
+
+import sqlglot
+from sqlglot import exp
+
+from get_objects_lib.dialect import SqlServer
+from get_objects_lib.dialect.expressions import ExecParameter
+from get_objects_lib.objects.header import find_object_header, quote_name
+
+PROCEDURE = 'procedure'
+FUNCTION = 'function'
+# Sin catalogo no se puede distinguir una tabla de una vista
+TABLE_OR_VIEW = 'table_or_view'
+
+# Tablas virtuales de un trigger
+TRIGGER_PSEUDO_TABLES = {'inserted', 'deleted'}
+
+# Funciones de tabla del sistema que se parsean igual que una de usuario
+BUILTIN_TABLE_FUNCTIONS = {
+    'STRING_SPLIT', 'OPENJSON', 'OPENXML', 'OPENQUERY', 'OPENROWSET', 'OPENDATASOURCE',
+    'GENERATE_SERIES', 'CHANGETABLE', 'CONTAINSTABLE', 'FREETEXTTABLE',
+}
+
+
+@dataclass(frozen=True)
+class ObjectRef:
+    kind: str
+    name: str
+    schema: str | None = None
+    catalog: str | None = None
+    server: str | None = None  # servidor vinculado: servidor.base.esquema.objeto
+
+    def __str__(self) -> str:
+        return '.'.join(quote_name(p) for p in (self.server, self.catalog, self.schema, self.name) if p)
+
+    @property
+    def _key(self) -> tuple:
+        # SQL Server no distingue mayusculas; sin esquema se asume dbo
+        return (
+            self.kind,
+            (self.server or '').lower(),
+            (self.catalog or '').lower(),
+            (self.schema or 'dbo').lower(),
+            self.name.lower(),
+        )
+
+
+def get_dependencies(sql: str) -> list[ObjectRef]:
+    """
+    Procedimientos, funciones y tablas/vistas que usa un query o la
+    definicion de un objeto, en orden de aparicion y sin repetidos.
+
+    No ve lo que se ejecuta con SQL dinamico (EXEC(@sql), sp_executesql).
+    Ignora tablas temporales, variables de tabla, CTEs, alias, inserted /
+    deleted de los triggers y el propio objeto que se esta definiendo. En un
+    trigger, la tabla a la que pertenece cuenta como dependencia.
+    """
+    header = find_object_header(sql)
+    if header:
+        statements = header.statements
+        own = ObjectRef(PROCEDURE, header.name, header.schema)._key[1:]
+    else:
+        statements = sqlglot.parse(sql, read=SqlServer)
+        own = None
+
+    refs: dict[tuple, ObjectRef] = {}
+    for statement in statements:
+        if statement is None:
+            continue
+
+        aliases = {a.name.lower() for a in statement.find_all(exp.TableAlias) if a.name}
+        ctes = {c.alias_or_name.lower() for c in statement.find_all(exp.CTE)}
+
+        for node in statement.walk(bfs=False):
+            ref = _reference(node, aliases, ctes)
+            if ref and ref._key[1:] != own:
+                refs.setdefault(ref._key, ref)
+
+    return list(refs.values())
+
+
+def _reference(node: exp.Expr, aliases: set[str], ctes: set[str]) -> ObjectRef | None:
+    # EXEC dbo.sp ... / EXEC sp_executesql ...
+    if isinstance(node, exp.Execute):
+        target = node.this
+        if isinstance(target, exp.Table) and _is_name(target.this):
+            return _from_table(PROCEDURE, target)
+        return None
+
+    # dbo.fn(...) en cualquier expresion, incluido CROSS/OUTER APPLY
+    if isinstance(node, exp.Dot) and isinstance(node.expression, exp.Anonymous):
+        parts = _identifier_parts(node.this)
+        if not parts or any(p.lower() in aliases for p in parts):
+            # T.c.value(...), x.nodes(...): metodos XML sobre una columna o alias
+            return None
+        schema, catalog = parts[-1], (parts[-2] if len(parts) > 1 else None)
+        return ObjectRef(FUNCTION, node.expression.name, schema, catalog)
+
+    # fn(...) sin esquema en un APPLY
+    if isinstance(node, exp.Lateral) and isinstance(node.this, exp.Anonymous):
+        return _function_without_schema(node.this)
+
+    if not isinstance(node, exp.Table):
+        return None
+
+    # FROM dbo.fn(...) / FROM fn(...)
+    if isinstance(node.this, exp.Anonymous):
+        if isinstance(node.args.get('db'), ExecParameter):
+            return None  # @xml.nodes(...)
+        if node.db:
+            return _from_table(FUNCTION, node, name=node.this.name)
+        return _function_without_schema(node.this)
+
+    if not _is_name(node.this) or node.this.args.get('temporary'):
+        return None  # @tabla, #temporal
+    if node.find_ancestor(exp.Execute) or _is_create_target(node):
+        return None
+    if not node.db and (node.name.lower() in ctes or node.name.lower() in aliases):
+        return None  # CTE, o UPDATE v ... FROM Venta v
+    if not node.db and node.name.lower() in TRIGGER_PSEUDO_TABLES:
+        return None  # inserted / deleted de un trigger
+
+    return _from_table(TABLE_OR_VIEW, node)
+
+
+def _is_name(node: exp.Expr) -> bool:
+    """Identificador, o esquema.objeto de un nombre de cuatro partes."""
+    if isinstance(node, exp.Dot):
+        return isinstance(node.this, exp.Identifier) and isinstance(node.expression, exp.Identifier)
+    return isinstance(node, exp.Identifier)
+
+
+def _from_table(kind: str, table: exp.Table, name: str | None = None) -> ObjectRef:
+    if isinstance(table.this, exp.Dot):
+        # servidor.base.esquema.objeto: Table(this=Dot(esquema, objeto), db=base, catalog=servidor)
+        return ObjectRef(
+            kind, table.this.expression.name, table.this.this.name, table.db or None, table.catalog or None,
+        )
+    return ObjectRef(kind, name or table.name, table.db or None, table.catalog or None)
+
+
+def _function_without_schema(func: exp.Anonymous) -> ObjectRef | None:
+    if func.name.upper() in BUILTIN_TABLE_FUNCTIONS:
+        return None
+    return ObjectRef(FUNCTION, func.name)
+
+
+def _identifier_parts(node: exp.Expr) -> list[str] | None:
+    """dbo -> ['dbo']; Otra.dbo -> ['Otra', 'dbo']; cualquier otra cosa -> None."""
+    if isinstance(node, exp.Identifier):
+        return [node.name]
+    if isinstance(node, exp.Dot):
+        left, right = _identifier_parts(node.this), _identifier_parts(node.expression)
+        return left + right if left and right else None
+    return None
+
+
+def _is_create_target(table: exp.Table) -> bool:
+    parent = table.parent
+    if isinstance(parent, (exp.UserDefinedFunction, exp.StoredProcedure)):
+        parent = parent.parent
+    return isinstance(parent, exp.Create) and parent.this in (table, table.parent)

get_objects_lib/objects/header.py

@@ -0,0 +1,160 @@
+import re
+from dataclasses import dataclass
+
+import sqlglot
+from sqlglot import exp, TokenType
+
+from get_objects_lib.dialect import SqlServer
+from get_objects_lib.dialect.parser.base import BaseParser
+
+OBJECT_TOKENS = (TokenType.PROCEDURE, TokenType.FUNCTION, TokenType.VIEW, TokenType.TRIGGER)
+
+# Codigos de tipo de sys.objects / OBJECT_ID
+PROCEDURE = 'P'
+VIEW = 'V'
+SCALAR_FUNCTION = 'FN'
+INLINE_FUNCTION = 'IF'
+TABLE_FUNCTION = 'TF'
+TRIGGER = 'TR'
+
+KIND_KEYWORDS = {
+    PROCEDURE: 'PROCEDURE',
+    VIEW: 'VIEW',
+    SCALAR_FUNCTION: 'FUNCTION',
+    INLINE_FUNCTION: 'FUNCTION',
+    TABLE_FUNCTION: 'FUNCTION',
+    TRIGGER: 'TRIGGER',
+}
+
+
+@dataclass(frozen=True)
+class ObjectHeader:
+    """CREATE/ALTER de un procedimiento, funcion, vista o trigger dentro de un script."""
+    type_code: str
+    name: str
+    schema: str | None
+    # Posiciones en el texto original
+    start: int       # inicio del CREATE/ALTER
+    body_start: int  # justo despues de PROCEDURE/FUNCTION/VIEW
+    end: int         # antes del GO que cierra el lote (o fin del texto)
+    statement: exp.Create
+    # Todas las sentencias del lote: en T-SQL el cuerpo llega hasta el GO
+    statements: tuple[exp.Expr, ...] = ()
+
+    @property
+    def keyword(self) -> str:
+        return KIND_KEYWORDS[self.type_code]
+
+    @property
+    def full_name(self) -> str:
+        return '.'.join(quote_name(p) for p in (self.schema, self.name) if p)
+
+
+# Palabras reservadas de T-SQL (docs de SQL Server, "Reserved Keywords")
+RESERVED_KEYWORDS = set('''
+ADD ALL ALTER AND ANY AS ASC AUTHORIZATION BACKUP BEGIN BETWEEN BREAK BROWSE BULK BY CASCADE CASE
+CHECK CHECKPOINT CLOSE CLUSTERED COALESCE COLLATE COLUMN COMMIT COMPUTE CONSTRAINT CONTAINS
+CONTAINSTABLE CONTINUE CONVERT CREATE CROSS CURRENT CURRENT_DATE CURRENT_TIME CURRENT_TIMESTAMP
+CURRENT_USER CURSOR DATABASE DBCC DEALLOCATE DECLARE DEFAULT DELETE DENY DESC DISK DISTINCT
+DISTRIBUTED DOUBLE DROP DUMP ELSE END ERRLVL ESCAPE EXCEPT EXEC EXECUTE EXISTS EXIT EXTERNAL FETCH
+FILE FILLFACTOR FOR FOREIGN FREETEXT FREETEXTTABLE FROM FULL FUNCTION GOTO GRANT GROUP HAVING
+HOLDLOCK IDENTITY IDENTITY_INSERT IDENTITYCOL IF IN INDEX INNER INSERT INTERSECT INTO IS JOIN KEY
+KILL LEFT LIKE LINENO LOAD MERGE NATIONAL NOCHECK NONCLUSTERED NOT NULL NULLIF OF OFF OFFSETS ON
+OPEN OPENDATASOURCE OPENQUERY OPENROWSET OPENXML OPTION OR ORDER OUTER OVER PERCENT PIVOT PLAN
+PRECISION PRIMARY PRINT PROC PROCEDURE PUBLIC RAISERROR READ READTEXT RECONFIGURE REFERENCES
+REPLICATION RESTORE RESTRICT RETURN REVERT REVOKE RIGHT ROLLBACK ROWCOUNT ROWGUIDCOL RULE SAVE
+SCHEMA SECURITYAUDIT SELECT SEMANTICKEYPHRASETABLE SEMANTICSIMILARITYDETAILSTABLE
+SEMANTICSIMILARITYTABLE SESSION_USER SET SETUSER SHUTDOWN SOME STATISTICS SYSTEM_USER TABLE
+TABLESAMPLE TEXTSIZE THEN TO TOP TRAN TRANSACTION TRIGGER TRUNCATE TRY_CONVERT TSEQUAL UNION UNIQUE
+UNPIVOT UPDATE UPDATETEXT USE USER VALUES VARYING VIEW WAITFOR WHEN WHERE WHILE WITH WITHIN
+WRITETEXT
+'''.split())
+
+
+def quote_name(part: str) -> str:
+    """Corchetes solo si el nombre no es un identificador simple o es palabra reservada."""
+    if re.fullmatch(r'[A-Za-z_][A-Za-z0-9_@$#]*', part) and part.upper() not in RESERVED_KEYWORDS:
+        return part
+    return f"[{part.replace(']', ']]')}]"
+
+
+def split_batches(sql: str) -> list[tuple[int, int]]:
+    """
+    (inicio, fin) de cada lote del script, sin los GO. Se usan los tokens (no
+    el texto) para no cortar en un GO dentro de un string o un comentario.
+    """
+    tokens = SqlServer().tokenize(sql)
+    batches, start, i = [], 0, 0
+    while i < len(tokens):
+        length = BaseParser._batch_separator_length(tokens, i)
+        if length:
+            batches.append((start, tokens[i].start))
+            start = tokens[i + length - 1].end + 1
+            i += length
+        else:
+            i += 1
+    batches.append((start, len(sql)))
+    return batches
+
+
+def find_object_header(sql: str) -> ObjectHeader | None:
+    for start, end in split_batches(sql):
+        header = _find_in_batch(sql, start, end)
+        if header:
+            return header
+    return None
+
+
+def _find_in_batch(sql: str, batch_start: int, batch_end: int) -> ObjectHeader | None:
+    tokens = SqlServer().tokenize(sql[batch_start:batch_end])
+
+    for i, token in enumerate(tokens):
+        is_create = token.token_type == TokenType.CREATE
+        is_alter = (
+            token.token_type == TokenType.ALTER
+            and not (i > 0 and tokens[i - 1].token_type == TokenType.OR)
+        )
+        if not (is_create or is_alter):
+            continue
+
+        j = i + 1
+        # CREATE OR ALTER
+        if is_create and j + 1 < len(tokens) and tokens[j].token_type == TokenType.OR:
+            j += 2
+        if j >= len(tokens) or tokens[j].token_type not in OBJECT_TOKENS:
+            continue
+
+        start = batch_start + token.start
+        statements = [s for s in sqlglot.parse(sql[start:batch_end], read=SqlServer) if s]
+        statement = statements[0]
+        if not isinstance(statement, exp.Create):
+            return None
+
+        table = statement.this if isinstance(statement.this, exp.Table) else statement.this.this
+        return ObjectHeader(
+            type_code=_type_code(statement),
+            name=table.name,
+            schema=table.db or None,
+            start=start,
+            body_start=batch_start + tokens[j].end + 1,
+            end=batch_end,
+            statement=statement,
+            statements=tuple(statements),
+        )
+
+    return None
+
+
+def _type_code(statement: exp.Create) -> str:
+    kind = statement.kind
+    if kind in ('PROCEDURE', 'PROC'):
+        return PROCEDURE
+    if kind == 'VIEW':
+        return VIEW
+    if kind == 'TRIGGER':
+        return TRIGGER
+
+    returns = statement.find(exp.ReturnsProperty)
+    if not returns or not returns.args.get('is_table'):
+        return SCALAR_FUNCTION
+    return TABLE_FUNCTION if returns.args.get('table') else INLINE_FUNCTION

get_objects_lib/objects/standardize.py

@@ -0,0 +1,72 @@
+from sqlglot import exp
+
+from get_objects_lib.dialect.expressions import TriggerSpec
+from get_objects_lib.objects.header import (
+    INLINE_FUNCTION, PROCEDURE, SCALAR_FUNCTION, TABLE_FUNCTION, TRIGGER, VIEW, find_object_header, quote_name,
+)
+
+# CREATE minimo de cada tipo. Debe ser del mismo tipo que el objeto real:
+# ALTER FUNCTION no puede cambiar una funcion escalar a una de tabla, ni una
+# de tabla en linea a una de varias sentencias.
+STUBS = {
+    PROCEDURE: 'CREATE PROCEDURE {name} AS RETURN 0;',
+    VIEW: 'CREATE VIEW {name} AS SELECT 1 AS Stub;',
+    SCALAR_FUNCTION: 'CREATE FUNCTION {name}() RETURNS INT AS BEGIN RETURN NULL END;',
+    INLINE_FUNCTION: 'CREATE FUNCTION {name}() RETURNS TABLE AS RETURN SELECT 1 AS Stub;',
+    TABLE_FUNCTION: 'CREATE FUNCTION {name}() RETURNS @Stub TABLE (Stub INT) AS BEGIN RETURN END;',
+    # Misma tabla, momento y eventos: un trigger AFTER no se puede crear sobre
+    # una vista ni un INSTEAD OF repetido sobre la misma accion
+    TRIGGER: 'CREATE TRIGGER {name} ON {table} {timing} {events} AS RETURN;',
+}
+
+
+def standardize_object(sql: str, ansi_nulls: bool = False, quoted_identifier: bool = False) -> str:
+    """
+    Convierte el CREATE / ALTER / CREATE OR ALTER de un procedimiento, funcion
+    o vista a la forma estandar: crea un objeto minimo si no existe y despues
+    aplica el ALTER con la definicion real.
+
+    El cuerpo se copia tal cual del texto original (sin regenerarlo); lo que
+    haya antes del CREATE/ALTER (comentarios, SET, GO) se descarta.
+    """
+    header = find_object_header(sql)
+    if header is None:
+        raise ValueError('No se encontro un CREATE/ALTER de PROCEDURE, FUNCTION, VIEW o TRIGGER')
+
+    name = header.full_name
+    stub = STUBS[header.type_code].format(name=name, **_trigger_parts(header))
+    body = sql[header.body_start:header.end].rstrip()
+    # Mismo fin de linea que el script original (CRLF en archivos de SSMS)
+    newline = '\r\n' if '\r\n' in sql else '\n'
+
+    return newline.join([
+        f'SET ANSI_NULLS {"ON" if ansi_nulls else "OFF"};',
+        'GO',
+        f'SET QUOTED_IDENTIFIER {"ON" if quoted_identifier else "OFF"};',
+        'GO',
+        f"IF OBJECT_ID(N'{_escape(name)}', N'{header.type_code}') IS NULL",
+        f"    EXEC (N'{_escape(stub)}');",
+        'GO',
+        f'ALTER {header.keyword}{body}',
+        'GO',
+        '',
+    ])
+
+
+def _trigger_parts(header) -> dict[str, str]:
+    if header.type_code != TRIGGER:
+        return {}
+    spec = header.statement.find(TriggerSpec)
+    table = spec.args['table']
+    if not isinstance(table, exp.Table):
+        # ON DATABASE / ON ALL SERVER: no estan en sys.objects (OBJECT_ID)
+        raise ValueError('Los triggers DDL (ON DATABASE / ALL SERVER) no estan soportados')
+    return {
+        'table': '.'.join(quote_name(p) for p in (table.catalog, table.db, table.name) if p),
+        'timing': spec.args['timing'],
+        'events': ', '.join(e.name for e in spec.args['events']),
+    }
+
+
+def _escape(text: str) -> str:
+    return text.replace("'", "''")

get_objects_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,231 @@
+Metadata-Version: 2.3
+Name: get-objects-lib
+Version: 0.1.0
+Summary: Extrae objetos referenciados en scripts T-SQL
+Keywords: sql,tsql,sqlglot
+Author: Ivan-Rosales
+Author-email: 61328655+Ivan-Rosales@users.noreply.github.com
+Requires-Python: >=3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Dist: sqlglot (>=30.18.0,<31.0.0)
+Project-URL: Repository, https://gitlabv2.intelisis-solutions.com:8008/TICS/Interfaces/utilidades/get_objects_lib
+Description-Content-Type: text/markdown
+
+# get-objects-lib
+
+Parser y generador de **T-SQL (SQL Server)** construido sobre [sqlglot](https://github.com/tobymao/sqlglot),
+pensado para scripts reales: sin `;` entre sentencias, con `GO`, bloques `BEGIN ... END`,
+procedimientos, funciones, vistas y triggers. Encima del dialecto hay un paquete (`objects`) para
+analizar objetos:
+
+- **`get_dependencies`**: qué procedimientos, funciones y tablas/vistas usa un query u objeto.
+- **`standardize_object`**: convierte un `CREATE` / `ALTER` / `CREATE OR ALTER` a una forma estándar
+  que se puede ejecutar siempre (crea un objeto mínimo si no existe y luego aplica el `ALTER`).
+
+## Instalación
+
+Requiere Python 3.14 y [Poetry](https://python-poetry.org/).
+
+```bash
+poetry install
+```
+
+Los ejemplos y las pruebas se corren desde la raíz del proyecto.
+
+## Uso
+
+### Dialecto: parsear y generar T-SQL
+
+```python
+import sqlglot
+from get_objects_lib import SqlServer
+
+sql = """
+IF @Modo = 1
+    EXEC dbo.spProcesar @ID
+ELSE
+BEGIN
+    UPDATE Venta SET Estatus = 'X' WHERE ID = @ID
+    PRINT 'actualizado'
+END
+"""
+
+for statement in sqlglot.parse(sql, read=SqlServer):
+    print(repr(statement))                 # árbol de expresiones
+    print(statement.sql(dialect=SqlServer))  # de vuelta a T-SQL
+```
+
+`sqlglot.parse` devuelve una sentencia por elemento. Un `GO` aparece como su propia sentencia
+(`BatchSeparator`).
+
+### Dependencias de un objeto o query
+
+```python
+from get_objects_lib import get_dependencies
+
+for ref in get_dependencies(sql):
+    print(ref.kind, ref)   # p.ej. "procedure dbo.spProcesar", "table_or_view Venta"
+```
+
+Cada resultado es un `ObjectRef(kind, name, schema, catalog, server)`:
+
+| `kind` | Qué detecta |
+|---|---|
+| `procedure` | `EXEC proc`, `EXEC @r = proc`, `INSERT ... EXEC proc`, `sp_executesql` |
+| `function` | `dbo.fn(...)` en cualquier expresión, funciones de tabla en `FROM` y `CROSS/OUTER APPLY` |
+| `table_or_view` | tablas y vistas (sin catálogo no se pueden distinguir), incluida la tabla de un trigger |
+
+- Salen en orden de aparición y sin repetidos. Sin esquema se asume `dbo`, así que `SendHttp` y
+  `dbo.SendHttp` cuentan una sola vez.
+- Se ignoran: tablas temporales (`#t`, `##t`), variables de tabla (`@t`), CTEs, alias,
+  `inserted`/`deleted` de los triggers, métodos XML (`T.c.value(...)`), funciones de tabla del
+  sistema (`STRING_SPLIT`, `OPENJSON`, ...) y el propio objeto que se está definiendo.
+- Si el script define un objeto, se analiza todo su lote (hasta el `GO`), como hace SQL Server.
+- Soporta nombres de hasta cuatro partes (`servidor.base.esquema.objeto`).
+
+### Forma estándar de un objeto
+
+```python
+from get_objects_lib import standardize_object
+
+print(standardize_object(sql))                           # SET ... OFF por defecto
+print(standardize_object(sql, ansi_nulls=True, quoted_identifier=True))
+```
+
+Para un script como:
+
+```sql
+SET ANSI_NULLS ON;
+GO
+-- Comentario de encabezado
+CREATE PROCEDURE [dbo].[spEjemplo] @ID INT
+AS
+BEGIN
+    SELECT * FROM Venta WHERE ID = @ID
+END
+GO
+```
+
+genera:
+
+```sql
+SET ANSI_NULLS OFF;
+GO
+SET QUOTED_IDENTIFIER OFF;
+GO
+IF OBJECT_ID(N'dbo.spEjemplo', N'P') IS NULL
+    EXEC (N'CREATE PROCEDURE dbo.spEjemplo AS RETURN 0;');
+GO
+ALTER PROCEDURE [dbo].[spEjemplo] @ID INT
+AS
+BEGIN
+    SELECT * FROM Venta WHERE ID = @ID
+END
+GO
+```
+
+- Acepta `CREATE`, `ALTER` y `CREATE OR ALTER` de procedimientos, funciones, vistas y triggers.
+- **El cuerpo se copia tal cual** del texto original (comentarios y formato incluidos); lo que va
+  antes del `CREATE`/`ALTER` y los lotes posteriores (p.ej. un `GRANT` tras el `GO`) se descartan.
+- El `CREATE` mínimo es del mismo tipo que el objeto real, porque `ALTER` no puede cambiarlo:
+
+  | Tipo (`OBJECT_ID`) | Objeto mínimo |
+  |---|---|
+  | `P` procedimiento | `CREATE PROCEDURE x AS RETURN 0;` |
+  | `V` vista | `CREATE VIEW x AS SELECT 1 AS Stub;` |
+  | `FN` función escalar | `CREATE FUNCTION x() RETURNS INT AS BEGIN RETURN NULL END;` |
+  | `IF` función de tabla en línea | `CREATE FUNCTION x() RETURNS TABLE AS RETURN SELECT 1 AS Stub;` |
+  | `TF` función de tabla de varias sentencias | `CREATE FUNCTION x() RETURNS @Stub TABLE (Stub INT) AS BEGIN RETURN END;` |
+  | `TR` trigger | `CREATE TRIGGER x ON tabla <momento> <eventos> AS RETURN;` (misma tabla, momento y eventos) |
+
+- El nombre va sin corchetes salvo que los necesite (espacios, palabras reservadas: `dbo.[Order]`).
+- Respeta el fin de línea del script (CRLF en archivos de SSMS).
+- Lanza `ValueError` si el script no define un objeto, o si es un trigger DDL (`ON DATABASE`).
+
+## Qué cubre el dialecto
+
+Además de lo que ya soporta el T-SQL de sqlglot, el dialecto `SqlServer` maneja:
+
+- **Separación de sentencias sin `;`** y lotes con `GO` / `GO n` (solo en su línea; no dentro de
+  strings o comentarios).
+- **Control de flujo**: `IF` / `ELSE IF` / `ELSE` con y sin `BEGIN`, condiciones con subconsultas
+  (`IF (SELECT COUNT(*) ...) > 0`), `WHILE`, `BREAK`, `CONTINUE`, `RETURN [expr]`, `GOTO` y
+  etiquetas, bloques `BEGIN ... END` sueltos, `BEGIN TRY ... END CATCH`, `WAITFOR`.
+- **Objetos**: `CREATE` / `ALTER` / `CREATE OR ALTER` de procedimientos (con o sin paréntesis en
+  los parámetros, `OUTPUT`/`OUT`), funciones escalares y de tabla, vistas y triggers; opciones
+  `WITH RECOMPILE`, `SCHEMABINDING`, `EXECUTE AS`, `RETURNS NULL ON NULL INPUT`, etc.
+- **Sentencias**: `EXEC` con parámetros con nombre, valor de retorno, SQL dinámico (`EXEC (...)`,
+  `EXEC (...) AT servidor`), `INSERT ... EXEC`, `INSERT ... SELECT`, `DEFAULT VALUES`,
+  `DELETE/UPDATE TOP (n)`, `MERGE`, CTEs, cursores (`DECLARE ... CURSOR`, `OPEN`, `FETCH`, `CLOSE`,
+  `DEALLOCATE`), transacciones (`BEGIN TRAN`, `COMMIT`, `ROLLBACK`, `SAVE TRAN`), `PRINT`,
+  `RAISERROR`, `THROW`, asignaciones compuestas (`+=`, `-=`, ...), `SET TRANSACTION ISOLATION LEVEL`.
+- **Tablas**: pistas con y sin `WITH` (`FROM Venta (NOLOCK)`), índices en línea en `CREATE TABLE`
+  y `DECLARE @t TABLE`.
+- **Comandos no modelados** (`DBCC`, `BULK INSERT`, `UPDATE STATISTICS`, `ENABLE/DISABLE TRIGGER`,
+  `EXECUTE AS`, `REVERT`, `CHECKPOINT`, ...) se conservan como `Command` de su sentencia.
+- **Generación fiel a T-SQL**: no reemplaza funciones (`SYSDATETIME`, `SUSER_SNAME`, `DATENAME`,
+  `DATEDIFF`, ...), conserva el nombre de las funciones de usuario y escribe `INT`.
+
+### Expresiones propias
+
+Definidas en [`get_objects_lib/dialect/expressions.py`](get_objects_lib/dialect/expressions.py):
+`AlterObject`, `BatchSeparator`, `BeginEnd`, `CompoundAssignment`, `CursorStatement`, `DeclareCursor`,
+`ExecParameter`, `ExecuteAt`, `FetchCursor`, `Goto`, `InlineIndex`, `Label`, `LoopControl`, `Print`,
+`RaiseError`, `ReturnStatement`, `SaveTransaction`, `Throw`, `Top`, `TriggerSpec`, `TryCatch`, `WaitFor`.
+
+## Estructura
+
+```
+get_objects_lib/                 paquete instalable; expone SqlServer, get_dependencies,
+│                                standardize_object, ObjectRef, ObjectHeader, find_object_header
+├── dialect/
+│   ├── dialect.py               dialecto SqlServer (une tokenizer, parser y generador)
+│   ├── tokenizer.py             GO/PRINT/FETCH sin tragarse el script, +=, nombres de variables
+│   ├── expressions.py           expresiones propias de T-SQL
+│   ├── generator.py             generacion de T-SQL
+│   ├── text_utils.py
+│   └── parser/
+│       ├── non_semicolon.py     separa el script en sentencias (chunks) sin depender de ;
+│       ├── base.py              reglas de inicio de sentencia y de bloques
+│       └── sql_server.py        parseo de cada construccion de T-SQL
+└── objects/
+    ├── header.py                encabezado del objeto (CREATE/ALTER, tipo, nombre, lote)
+    ├── dependencies.py          get_dependencies
+    └── standardize.py           standardize_object
+tests/                           pruebas; ver tests/README.md
+├── golden.py                    utilidades y generacion de resultados esperados
+├── test_*.py
+└── fixtures/
+    ├── dialect/                 scripts del parser/generador + expected/
+    └── objects/                 scripts de objetos + expected/
+```
+
+## Pruebas
+
+```bash
+poetry run python -m unittest
+```
+
+Son pruebas *golden*: cada script de `tests/fixtures/` se compara con sus resultados esperados en
+`expected/` (árbol, SQL generado, dependencias y forma estándar), y además todos los scripts deben
+cumplir propiedades generales (el SQL generado es estable, el árbol es el mismo con CRLF, unidos con
+`GO` conservan sus sentencias). Los casos se descubren solos.
+
+Para agregar un caso: crea el script en `tests/fixtures/dialect/` o `tests/fixtures/objects/`, genera
+sus resultados esperados con `poetry run python -m tests.golden <script>.sql`, **revísalos a mano** y
+agrégalo al catálogo de [`tests/README.md`](tests/README.md), que describe qué cubre cada caso.
+
+## Limitaciones y decisiones de diseño
+
+- **Cuerpo de un procedimiento sin `BEGIN`**: en SQL Server llega hasta el `GO`; el parser toma una
+  sola sentencia (o hasta el `END` si tiene `BEGIN`). `get_dependencies` sí analiza todo el lote.
+- **Un objeto por script**: si un script define varios, `standardize_object` y `get_dependencies`
+  toman el primero.
+- **SQL dinámico**: lo que se ejecuta con `EXEC (@sql)` o `sp_executesql` no se analiza.
+- **Comandos no modelados** (`Command`): su contenido no se analiza para dependencias (p.ej. la
+  tabla de un `BULK INSERT`).
+- **Normalizaciones del generador** (equivalentes en T-SQL): agrega `AS` en los alias, escribe
+  `WITH (NOLOCK)` aunque el original no tenga `WITH`, `OUT` como `OUTPUT`, `IS NOT NULL` como
+  `NOT ... IS NULL`, y agrega alias a las columnas de tablas derivadas y CTEs (`SELECT ID AS ID`).
+

get_objects_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+get_objects_lib/__init__.py,sha256=KjA6O95xtpO2bxmip7zmQq1WemcMBk4sEEvlA1qVixY,407
+get_objects_lib/dialect/__init__.py,sha256=icwyd8tPZh_aapJoVyKcFAriIU624Bvx1BQHOdIApLE,82
+get_objects_lib/dialect/dialect.py,sha256=c6a3ABNzWImM6emwhg_QK4lek5eKPQdd7GSTes6OZhg,375
+get_objects_lib/dialect/expressions.py,sha256=w1A_ygewfG8mW-tae8CJYyvdp8sNzcviPJs_ClXdXKM,3645
+get_objects_lib/dialect/generator.py,sha256=ZecR-6REKWxmuItDNFSixX-2lW02NDNpK10buz5UVNc,11897
+get_objects_lib/dialect/parser/__init__.py,sha256=DNYPQkU45SXYSqf_-3MqNiRh17mlSmqe0prkdRh2Jtk,104
+get_objects_lib/dialect/parser/base.py,sha256=iGVJN-hWXecxjX9bSaBrwBJvftcg_tr5I0jRjK-7eF0,11535
+get_objects_lib/dialect/parser/non_semicolon.py,sha256=jvEkuNbyyk6WBjaKesXxNbVHh_vgYwhmvC4Xei9zYQ0,7677
+get_objects_lib/dialect/parser/sql_server.py,sha256=oUr1mEE75NgRfPNKAXxf_1lePF0f133s7nq_o_DE1sA,23863
+get_objects_lib/dialect/text_utils.py,sha256=bzwC9fctYgE0NGOAgJ5INjjCNzizfDejlAiQ0yG3YlM,624
+get_objects_lib/dialect/tokenizer.py,sha256=xNkNRSoKJQ4v1HugzoUEIvhvCb323wiaeSsP1ZjCO-4,2265
+get_objects_lib/objects/__init__.py,sha256=WPasqsK1SbjGTGBmveqj2FaJjoa5NW99CF0WzMzPY4g,223
+get_objects_lib/objects/dependencies.py,sha256=B4EY-G9KMTgLS6LmN7kAht0DmCKkuHBsXbh5QaxJ09c,6363
+get_objects_lib/objects/header.py,sha256=QALNGQrwDE82VAkPvgR1WWvGACtX2KJBv5rqEQFSVF4,6076
+get_objects_lib/objects/standardize.py,sha256=cMan6pcTVunyvkC7PP3dcfD5jnQp8SHQcGmU0Imyit8,3112
+get_objects_lib-0.1.0.dist-info/METADATA,sha256=bCwMFnQcJ1pFY9IN9P3DWEg9e5pnyPKIl5pDZS_95X4,10320
+get_objects_lib-0.1.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+get_objects_lib-0.1.0.dist-info/RECORD,,

get_objects_lib-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.1
+Root-Is-Purelib: true
+Tag: py3-none-any