Schema-Entdeckung mit mssql-python

Die mssql-python-Cursor-Klasse stellt neun Metadatenmethoden bereit, die ODBC-Katalogfunktionen zugeordnet sind. Nutzen Sie diese Methoden, um Tabellen, Spalten, gespeicherte Prozeduren, Schlüssel und Indizes programmatisch zu entdecken. Sie helfen Ihnen, datenbasierte Anwendungen zu erstellen, die sich zur Laufzeit an das Datenbankschema anpassen, wie Migrationstools, Codegeneratoren oder Admin-Dashboards.

Jede Methode gibt einen Cursor zurück, den du iterieren kannst, um auf die Ergebnisse zuzugreifen.

Tables

Listen Sie Tabellen und Ansichten in der Datenbank auf:

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)

tables()-Parameter

Die folgenden Parameter steuern die Tabellenerkennung:

tables()-Ergebnisspalten

Die Methode tables() liefert für jede Tabelle oder Ansicht folgende Spalten zurück:

Prüfe, ob eine Tabelle existiert

Überprüfen Sie, dass eine Tabelle existiert, bevor Sie sie abfragen:

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

Columns

Spalteninformationen für Tabellen abrufen:

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

Parameter von columns()

Filter zum Verfeinern der Erkennung von Spalten:

columns() Ergebnisspalten

Die Methode columns() liefert detaillierte Informationen zu jeder Spalte:

Gespeicherte Prozeduren

Entdecken Sie gespeicherte Verfahren:

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

Verfahren()-Parameter

Filtern Sie gespeicherte Prozeduren nach Namen oder Schema:

Ergebnisspalten von procedures()

Die Methode procedures() liefert Metadaten für jedes gespeicherte Verfahren zurück:

Primärschlüssel

Rufen Sie die Primärschlüsselspalten einer Tabelle ab:

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

primaryKeys()-Parameter

Parameter zum Abruf von primären Schlüsselinformationen:

primärKeys()-Ergebnisspalten

Die Methode primaryKeys() liefert folgende Informationen:

Fremdschlüssel

Entdecken Sie Fremdschlüsselbeziehungen:

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

foreignKeys()-Parameter

Spezifizieren Sie Primärschlüssel- oder Fremdschlüsseltabellen, um Zusammenhänge zu entdecken:

foreignKeys()-Ergebnisspalten

Die Methode foreignKeys() liefert folgende Spalten zurück, die Beziehungen beschreiben:

Indizes und Statistiken

Erhalten Sie Indexinformationen für eine Tabelle:

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

statistik()-Parameter

Konfigurieren Sie die Indexerkennung mit diesen Filtern:

Ergebnisspalten von statistics()

Die Methode statistics() liefert Index- und Statistikinformationen:

Zeilen-Identifikator-Spalten

Finden Sie Spalten, die eine Zeile eindeutig identifizieren:

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

Diese Methode liefert die beste Spaltenmenge zurück, um eine Zeile eindeutig zu identifizieren, die entweder der Primärschlüssel oder ein eindeutiger Index sein kann.

Spalten der Zeilenversion

Finden Sie Spalten, die automatisch aktualisiert werden, wenn sich ein Zeilenwert ändert. Verwenden Sie Zeilenversionsspalten für optimistische Nebenläufigkeitskontrolle, bei der Sie die Version einer Zeile lesen, Änderungen vornehmen und dann überprüfen, ob die aktuelle Zeilenversion gleich ist, bevor Sie schreiben:

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

Das Ergebnis umfasst typischerweise rowversion/timestamp Spalten, die für optimistische Nebenläufigkeit verwendet werden.

Datentypinformationen

Erhalten Sie Informationen zu unterstützten SQL-Datentypen:

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

getTypeInfo()-Parameter

Optionale Parameter zum Filtern unterstützter SQL-Typen:

Sicherheitsüberlegungen

Beispiel: Erstellen Sie einen Schema-Bericht

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

Verwandte Inhalte

• Abfragen ausführen
• Abrufen von Daten
• Cursorverwaltung