Scoperta dello schema con mssql-python

La classe cursore mssql-python fornisce nove metodi di metadati che si mappano alle funzioni del catalogo ODBC. Usa questi metodi per scoprire tabelle, colonne, stored procedure, chiavi e indici in modo programmativo. Ti aiutano a costruire applicazioni basate sui dati che si adattano allo schema del database in runtime, come strumenti di migrazione, generatori di codice o dashboard amministrative.

Ogni metodo restituisce un cursore che puoi iterare per accedere ai risultati.

Tables

Elenca le tabelle e le viste nel database:

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)

parametri di tables()

I seguenti parametri controllano la scoperta della tabella:

Colonne dei risultati delle tabelle()

Il tables() metodo restituisce le seguenti colonne per ogni tabella o vista:

Controlla se esiste una tabella

Verifica che una tabella esista prima di interrogarla:

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

Colonne

Recupera le informazioni sulle colonne per le tabelle:

# 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)

Parametri di columns()

Filtri per affinare la scoperta delle colonne:

colonne di risultato di columns()

Il columns() metodo restituisce informazioni dettagliate su ogni colonna:

Procedure memorizzate

Scopri le procedure archiviate:

# 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)

parametri di procedures()

Filtra le procedure memorizzate per nome o schema:

Colonne del risultato di procedures()

Il procedures() metodo restituisce i metadati per ogni procedura memorizzata:

Chiavi primarie

Ottieni le colonne chiave primarie per una tabella:

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}")

parametri di primaryKeys()

Parametri per recuperare le informazioni chiave primarie:

colonne dei risultati primaryKeys()

Il primaryKeys() metodo restituisce le seguenti informazioni:

Chiavi esterne

Scopri le relazioni con le chiavi estere:

# 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")

parametri di foreignKeys()

Specifica le tabelle delle chiavi primarie o esterne per scoprire le relazioni:

colonne dei risultati foreignKeys()

Il foreignKeys() metodo restituisce le seguenti colonne che descrivono le relazioni:

Indici e statistiche

Ottieni informazioni sull'indice per una tabella:

# 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}")

parametri statistici()

Configura la scoperta degli indici con questi filtri:

Statistica() Colonne dei risultati

Il statistics() metodo restituisce informazioni su indice e statistiche:

Colonne di identificazione della riga

Trova colonne che identificano in modo univoco una riga:

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

Questo metodo restituisce il miglior insieme di colonne per identificare univocamente una riga, che potrebbe essere la chiave primaria o un indice univoco.

Colonne della versione riga

Trova colonne che vengono aggiornate automaticamente quando cambia il valore di una riga. Usa le colonne delle versioni della riga per un controllo ottimista della concorrenza, dove leggi la versione di una riga, apporti modifiche e poi verifichi che la versione corrente della riga sia la stessa prima di scrivere:

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

Il risultato include tipicamente le colonne rowversion/timestamp utilizzate per la concorrenza ottimistica.

Informazioni sul tipo di dati

Ottieni informazioni sui tipi di dati SQL supportati:

# 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}")

parametri di getTypeInfo()

Parametri opzionali per filtrare i tipi SQL supportati:

Considerazioni relative alla sicurezza

Esempio: Generare un report sullo schema

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")

Contenuti correlati

• Esecuzione delle query
• Recupero dati
• Gestione del cursore