Descoberta de esquema com mssql-python

A classe de cursor do mssql-python fornece nove métodos de metadados que correspondem a funções do catálogo ODBC. Use esses métodos para descobrir tabelas, colunas, procedimentos armazenados, chaves e índices programaticamente. Eles ajudam a construir aplicações orientadas por dados que se adaptam ao esquema do banco de dados em tempo de execução, como ferramentas de migração, geradores de código ou painéis administrativos.

Cada método retorna um cursor que você pode iterar para acessar os resultados.

Tables

Tabelas de listas e visualizações no banco de dados:

cursor = conn.cursor()

# List all tables
for row in cursor.tables():
    print(f"{row.table_schem}.{row.table_name} ({row.table_type})")

# Filter by name (supports wildcards % and _)
for row in cursor.tables(table="Product%"):
    print(row.table_name)

# Filter by schema
for row in cursor.tables(schema="Sales"):
    print(row.table_name)

# Filter by type
for row in cursor.tables(tableType="TABLE"):  # Excludes views
    print(row.table_name)

parâmetros tables()

Os seguintes parâmetros controlam a descoberta da tabela:

colunas do resultado de tables()

O tables() método retorna as seguintes colunas para cada tabela ou visualização:

Verifique se existe uma tabela

Verifique se existe uma tabela antes de consultá-la:

if cursor.tables(table="Product", schema="Production").fetchone():
    print("Product table exists")
else:
    print("Product table not found")

Columns

Obter informações das colunas de tabelas:

# All columns in a table
for row in cursor.columns(table="Product", schema="Production"):
    print(f"{row.column_name}: {row.type_name}({row.column_size})")
    print(f"  Nullable: {row.nullable}, Position: {row.ordinal_position}")

# Filter by column name
for row in cursor.columns(table="Product", schema="Production", column="List%"):
    print(row.column_name)

Parâmetros column()

Filtros para refinar a localização de colunas:

columns() colunas de resultado

O columns() método retorna informações detalhadas sobre cada coluna:

Procedimentos armazenados

Conheça os procedimentos armazenados:

# List all procedures
for row in cursor.procedures():
    print(f"{row.procedure_schem}.{row.procedure_name}")

# Filter by name pattern
for row in cursor.procedures(procedure="Get%"):
    print(row.procedure_name)

parâmetros de procedures()

Filtre procedimentos armazenados por nome ou esquema:

colunas de resultado de procedures()

O procedures() método retorna metadados para cada procedimento armazenado:

Chaves primárias

Obtenha as colunas de chave primária de uma tabela:

for row in cursor.primaryKeys(table="Product", schema="Production"):
    print(f"PK column: {row.column_name} (position {row.key_seq})")
    print(f"Constraint name: {row.pk_name}")

parâmetros primaryKeys()

Parâmetros para recuperar informações de chave primária:

Colunas de resultados primaryKeys()

O primaryKeys() método retorna as seguintes informações:

Chaves estrangeiras

Descubra relacionamentos de chave estrangeira:

# Foreign keys from a table (outbound references)
for row in cursor.foreignKeys(table="SalesOrderDetail", schema="Sales"):
    print(f"FK {row.fk_name}:")
    print(f"  {row.fktable_name}.{row.fkcolumn_name}")
    print(f"  -> {row.pktable_name}.{row.pkcolumn_name}")

# Foreign keys to a table (inbound references)
for row in cursor.foreignKeys(foreignTable="Product", foreignSchema="Production"):
    print(f"{row.fktable_name} references Product")

parâmetros foreignKeys()

Especifique tabelas de chave primária ou estrangeira para descobrir relacionamentos:

Colunas de resultados foreignKeys()

O foreignKeys() método retorna as seguintes colunas descrevendo relacionamentos:

Índices e estatísticas

Obter informações sobre índices de uma tabela:

# All indexes on a table
for row in cursor.statistics(table="Product", schema="Production"):
    if row.index_name:  # Skip table statistics row
        print(f"Index: {row.index_name}")
        print(f"  Column: {row.column_name} (position {row.ordinal_position})")
        print(f"  Unique: {not row.non_unique}")

# Only unique indexes
for row in cursor.statistics(table="Product", schema="Production", unique=True):
    print(f"Unique index: {row.index_name}")

parâmetros de statistics()

Configure a descoberta de índice com estes filtros:

Colunas de resultado de statistics()

O statistics() método retorna informações de índice e estatísticas:

Colunas de identificadores de linha

Encontre colunas que identifiquem uma linha de forma única:

for row in cursor.rowIdColumns(table="Product", schema="Production"):
    print(f"Row ID column: {row.column_name} ({row.type_name})")

Esse método retorna o melhor conjunto de colunas para identificar unicamente uma linha, que pode ser a chave primária ou um índice único.

Colunas de versão da linha

Encontre colunas que sejam atualizadas automaticamente quando qualquer valor de linha muda. Use colunas de versão de linha para controle otimista de concorrência, onde você lê a versão de uma linha, faz alterações e depois verifica se a versão atual da linha é a mesma antes de escrever:

for row in cursor.rowVerColumns(table="Product", schema="Production"):
    print(f"Version column: {row.column_name}")

O resultado normalmente inclui rowversion/timestamp colunas usadas para concorrência otimista.

Informações de tipo de dados

Obtenha informações sobre tipos de dados SQL suportados:

# All supported types
for row in cursor.getTypeInfo():
    print(f"{row.type_name}: {row.data_type}")
    print(f"  Max size: {row.column_size}")
    print(f"  Nullable: {row.nullable}")

# Specific type
for row in cursor.getTypeInfo(sqlType=mssql_python.SQL_VARCHAR):
    print(f"VARCHAR max size: {row.column_size}")

parâmetros getTypeInfo()

Parâmetros opcionais para filtrar os tipos de SQL suportados:

Considerações de segurança

Exemplo: Gerar um relatório de esquema

def describe_table(conn, table_name):
    """Generate a schema description for a table."""
    cursor = conn.cursor()
    
    print(f"\n=== {table_name} ===\n")
    
    # Columns
    print("Columns:")
    for col in cursor.columns(table=table_name):
        nullable = "NULL" if col.nullable else "NOT NULL"
        print(f"  {col.column_name}: {col.type_name}({col.column_size}) {nullable}")
    
    # Primary key
    print("\nPrimary Key:")
    pk_cols = cursor.primaryKeys(table=table_name).fetchall()
    if pk_cols:
        pk_names = ", ".join(row.column_name for row in pk_cols)
        print(f"  {pk_cols[0].pk_name}: ({pk_names})")
    else:
        print("  (none)")
    
    # Foreign keys
    print("\nForeign Keys:")
    for fk in cursor.foreignKeys(table=table_name):
        print(f"  {fk.fk_name}: {fk.fkcolumn_name} -> {fk.pktable_name}.{fk.pkcolumn_name}")
    
    # Indexes
    print("\nIndexes:")
    for idx in cursor.statistics(table=table_name):
        if idx.index_name:
            unique = "UNIQUE " if not idx.non_unique else ""
            print(f"  {unique}{idx.index_name}: {idx.column_name}")

# Usage
describe_table(conn, "Product")

Conteúdo relacionado

• Executar consultas
• Obter dados
• Gerenciamento do cursor