Schemaupptäckt med mssql-python

Kursorklassen mssql-python tillhandahåller nio metadatametoder som mappas till ODBC-katalogfunktioner. Använd dessa metoder för att programmatiskt upptäcka tabeller, kolumner, lagrade procedurer, nycklar och index. De hjälper dig att bygga datadrivna applikationer som anpassar sig till databasschemat vid körning, såsom migreringsverktyg, kodgeneratorer eller admininstrumentpaneler.

Metod ODBC-funktion Returns När det bör användas
tables() SQLTables Information om tabeller och vyer. Inventariedatabaser. Validera tabellens existens innan frågor.
columns() SQLColumns Kolumndetaljer. Generera DDL, bygg dynamiska frågor eller mappa kolumner till kod.
procedures() SQLProcedures Information om lagrade procedurer. Upptäck tillgängliga API:er. Generera omslutande funktioner för proceduranrop.
primaryKeys() SQLPrimaryKeys Primärnyckelkolumner. Identifiera unika radidentifierare för UPDATE/DELETE operationer.
foreignKeys() SQLForeignKeys Utländska nyckelrelationer. Kartlägg tabellrelationer, bestäm raderingsordning för saneringsskript.
statistics() SQLStatistics Index och statistikinformation. Kontrollera indextäckning för prestandaoptimering.
rowIdColumns() SQLSpecialColumns (ROWID) Kolumner med unika rad-ID:n. Hitta de bästa kolumnerna att använda för att identifiera specifika rader.
rowVerColumns() SQLSpecialColumns (ROWVER) Kolumner för radversionering. Implementera optimistisk samtidighet (upptäck samtidiga ändringar).
getTypeInfo() SQLGetTypeInfo Information om datatyp. Upptäck stödda typer för plattformsoberoende kompatibilitet.

Varje metod returnerar en markör som du kan iterera för att komma åt resultaten.

Tables

Lista tabeller och vyer i databasen:

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)

tabell()-parametrar

Följande parametrar styr identifiering av tabeller:

Parameter Beskrivning
table Tabellnamnsmönster (stöder jokertecknen % och _).
catalog Katalog- (databas)namn.
schema Schemanamnsmönster.
tableType Filtrera efter typ: TABLE, VIEW, SYSTEM TABLE, GLOBAL TEMPORARY, LOCAL TEMPORARY, ALIAS, , . SYNONYM

tabell() resultatkolumner

Metoden tables() returnerar följande kolumner för varje tabell eller vy:

Column Beskrivning
table_cat Katalog- (databas)namn.
table_schem Namn på schema.
table_name Tabell- eller vynamn.
table_type TABLE, VIEW, SYSTEM TABLE, GLOBAL TEMPORARY, LOCAL TEMPORARY, , ALIAS, . SYNONYM
remarks Beskrivning eller kommentarer.

Kontrollera om det finns en tabell

Verifiera att en tabell finns innan du frågar den:

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

Columns

Hämta kolumninformation för tabeller:

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

kolumn()-parametrar

Filter för att förfina kolumnupptäckten:

Parameter Beskrivning
table Tabellnamnsmönster.
catalog Katalog- (databas)namn.
schema Mönster för schemanamn.
column Kolumnnamnsmönster.

kolumner() resultatkolumner

Metoden returnerar columns() detaljerad information om varje kolumn:

Column Beskrivning
table_cat, table_schem, table_name Platsidentifierare.
column_name Kolumnnamn.
data_type SQL-datatypkod.
type_name Datatypnamn (till exempel varchar, ). int
column_size Maximal längd eller precision.
buffer_length Buffertstorlek för överföringar.
decimal_digits Skala för numeriska typer.
nullable 0 för INTE NULL, 1 för nullbar.
column_def Standardvärde.
ordinal_position Kolumnposition (1-baserad).
is_nullable "YES" eller "NO".

Lagrade procedurer

Upptäck lagrade metoder:

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

parametrar för procedurer()

Filtrera lagrade procedurer efter namn eller schema:

Parameter Beskrivning
procedure Procedurnamnsmönster.
catalog Katalog- (databas)namn.
schema Schemanamnsmönster.

procedurer() resultatkolumner

Metoden procedures() returnerar metadata för varje lagrad procedur:

Column Beskrivning
procedure_cat, procedure_schem Platsidentifierare.
procedure_name Procedurnamn.
num_input_params Antal ingångsparametrar.
num_output_params Antal utgångsparametrar.
num_result_sets Antal resultatuppsättningar.
remarks Description.
procedure_type Typindikator.

Primärnycklar

Hämta primärnyckelkolumner för en tabell:

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

parametrar för primaryKeys()

Parametrar för att hämta primärnyckelinformation:

Parameter Beskrivning
table Tabellnamn (krävs).
catalog Katalog- (databas)namn.
schema Namn på schema.

primaryKeys() resultatkolumner

Metoden primaryKeys() returnerar följande information:

Column Beskrivning
table_cat, table_schem, table_name Platsidentifierare.
column_name Kolumn i den primära nyckeln.
key_seq Position i flerkolumnsnyckeln (ettbaserad).
pk_name Primärnyckelbegränsningens namn.

Främmande nycklar

Upptäck utländska nyckelrelationer:

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

Parametrar för foreignKeys()

Specificera primärnyckel- eller främmande nyckeltabeller för att upptäcka relationer:

Parameter Beskrivning
table Namn på primärnyckeltabell.
catalog Katalog för primärnycklar.
schema Primärnyckelschema.
foreignTable Tabellnamn för främmande nyckel.
foreignCatalog Främmande nyckelkatalog.
foreignSchema Främmande nyckelschema.

foreignKeys() resultatkolumner

Metoden foreignKeys() returnerar följande kolumner som beskriver relationer:

Column Beskrivning
pktable_cat, pktable_schem, pktable_name Referens (primär) tabell.
pkcolumn_name Referenskolumn.
fktable_cat, fktable_schem, fktable_name Referenstabell (utländsk).
fkcolumn_name Referenskolumn.
key_seq Position i nyckel med flera kolumner.
update_rule Åtgärd på UPDATE.
delete_rule Åtgärd för DELETE.
fk_name Främmande nyckelbegränsningsnamn.
pk_name Primärnyckelbegränsningens namn.

Index och statistik

Få indexinformation till en tabell:

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

Konfigurera indexupptäckt med dessa filter:

Parameter Standardinställning Beskrivning
table (required) Tabellnamn.
catalog None Katalog- (databas)namn.
schema None Namn på schema.
unique Falskt Returnera endast unika index.
quick Sann Hoppa över kostsam hämtning av kardinalitet/sidor.

statistik() resultatkolumner

Metoden statistics() returnerar index- och statistikinformation:

Column Beskrivning
table_cat, table_schem, table_name Platsidentifierare.
non_unique 0 för unik, 1 för icke-unik.
index_name Indexets namn.
type Typ av index.
ordinal_position Kolumnposition i index.
column_name Kolumnnamn.
asc_or_desc A för uppstigande, D för nedåtgående.
cardinality Uppskattat antal rader.
pages Antal sidor

Radidentifierarkolumner

Hitta kolumner som unikt identifierar en rad:

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

Denna metod returnerar den bästa uppsättningen kolumner för att unikt identifiera en rad, vilket kan vara primärnyckeln eller ett unikt index.

Kolumner för radversion

Hitta kolumner som automatiskt uppdateras när något radvärde ändras. Använd radversionskolumner för optimistisk samtidighetskontroll, där du läser en rads version, gör ändringar och sedan verifierar att den aktuella radversionen är densamma innan du skriver:

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

Resultatet inkluderar rowversion/timestamp vanligtvis kolumner som används för optimistisk samtidighet.

Information om datatyp

Få information om stödda SQL-datatyper:

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

Valfria parametrar för att filtrera stödda SQL-typer:

Parameter Beskrivning
sqlType SQL-typkonstant (utelämna för alla typer).

Säkerhetsfrågor

Caution

Dessa metoder exponerar metadata från databasens schema. Även om metoderna i sig är säkra att köra, avslöjar den returnerade informationen din databasstruktur (tabellnamn, kolumnnamn, relationer, datatyper).

  • Exponera inte rå metadata för opålitliga användare.
  • Sanera eller filtrera resultat i flerklientprogram.
  • Begränsa åtkomsten i externa applikationer.

Exempel: Generera en schemarapport

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

Relaterat innehåll

  • Last updated on