Migrace z pymssql na mssql-python

Ovladač mssql-python je první oficiální ovladač Microsoftu pro Python pro Microsoft SQL. Pokud preferujete možnost ovladačů spravovaných Microsoft, nabízí:

• Žádná závislost na FreeTDS.
• Více současných kurzorů na jedno připojení.
• Vestavěné sdružování připojení.
• Podpora moderního Python 3.10+.
• Nativní Microsoft Entra autentizace.
• Řádkové objekty s přístupem k atributům ve výchozím nastavení.

Hlavní rozdíly

funkce	pymssql	mssql-python
Styl parametrů	format (%s, %d)	qmark(?) a pyformat ()%(name)s
Domorodá knihovna	FreeTDS	DDBC (v balíčku)
Sdílení připojení	Externí	Vestavěný
Kurzory na každé spojení	1	Multiple
Minimální verze Pythonu	3.6	3.10
callproc()	Podporováno	Není implementováno
as_dict kurzor	Extension	Řádkové objekty (výchozí)
Hromadné kopírování	conn.bulk_copy()	cursor.bulkcopy()
Výchozí automatické potvrzení	Off	Off

Základní migrační kroky

Následující kroky procházejí nejčastější změny potřebné k migraci aplikace pymssql do mssql-python.

1. Aktualizovat importy

Nahraďte import pymssql za mssql_python:

Před (pymssql):

import pymssql

Po (mssql-python):

import mssql_python

2. Aktualizovat volání připojení

PymsSQL používá poziční argumenty. Ovladač mssql-python používá připojovací řetězec nebo klíčové slovní argumenty:

Předtím (pymssql, poziční argumenty):

conn = pymssql.connect("<server>", "<user>", "<password>", "<database>")

Před (pymssql, argumenty klíčových slov):

conn = pymssql.connect(
    host=r"<server>\<instance>",
    user="<login>",
    password="<password>",
    database="<database>"
)

Po (mssql-python, připojovací řetězec):

conn = mssql_python.connect(
    "Server=<server>;"
    "Database=<database>;"
    "UID=<username>;"
    "PWD=<password>;"
    "Encrypt=yes;"
)

Po dokončení (mssql-python, doporučeno pro Microsoft Entra):

conn = mssql_python.connect(
    "Server=<server>.database.windows.net;"
    "Database=<database>;"
    "Authentication=ActiveDirectoryDefault;"
    "Encrypt=yes;"
)

3. Aktualizovat markery parametrů

PymsSQL používá %s a %d formátuje zástupné symboly. Ovladač mssql-python používá ? (qmark) nebo %(name)s (pyformat):

Před (pymssql):

cursor.execute("SELECT * FROM Person.Person WHERE BusinessEntityID = %d AND FirstName = %s", (user_id, name))

After (mssql-python, qmark styl):

user_id, name = 1, "Ken"
cursor.execute("SELECT * FROM Person.Person WHERE BusinessEntityID = ? AND FirstName = ?", (user_id, name))
print(cursor.fetchone())

cursor.execute(
    "SELECT * FROM Person.Person WHERE BusinessEntityID = %(id)s AND FirstName = %(name)s",
    {"id": user_id, "name": name}
)
print(cursor.fetchone())

4. Aktualizovat executemany

Aktualizujte zástupné symboly SQL z %s/%d na ? nebo %(name)s:

Před (pymssql):

cursor.execute("CREATE TABLE #Persons (ID INT, Name NVARCHAR(50), Department NVARCHAR(50))")
cursor.executemany(
    "INSERT INTO #Persons VALUES (%d, %s, %s)",
    [(1, "John", "Sales"), (2, "Jane", "Marketing")]
)

After (mssql-python, qmark styl):

cursor.execute("IF OBJECT_ID('#Persons') IS NOT NULL DROP TABLE #Persons")
cursor.execute("CREATE TABLE #Persons (ID INT, Name NVARCHAR(50), Department NVARCHAR(50))")
cursor.executemany(
    "INSERT INTO #Persons VALUES (?, ?, ?)",
    [(1, "John", "Sales"), (2, "Jane", "Marketing")]
)
cursor.execute("SELECT * FROM #Persons")
for row in cursor:
    print(row)

5. Používejte atributy řádků místo kurzorů as_dict

PymsSQL vyžaduje as_dict=True přístup ke sloupcům podle názvu. Ovladač mssql-python vrací Row objekty, které ve výchozím nastavení podporují přístup jak k atributům, tak indexům:

Před (pymssql):

cursor = conn.cursor(as_dict=True)
cursor.execute("SELECT BusinessEntityID, FirstName FROM Person.Person WHERE FirstName = %s", ("John",))
for row in cursor:
    print("ID=%d, Name=%s" % (row["BusinessEntityID"], row["FirstName"]))

Po (mssql-python, výchozí přístup k atributům):

cursor = conn.cursor()
cursor.execute("SELECT BusinessEntityID, FirstName FROM Person.Person WHERE FirstName = ?", ("John",))
for row in cursor:
    print(f"ID={row.BusinessEntityID}, Name={row.FirstName}")
    # Index access also works: row[0], row[1]

Migrace uložených procedur

Ovladač mssql-python neimplementuje callproc(). Místo toho použijte příkazy EXECUTE.

Použijte EXECUTE pro uložené procedury

PymsSQL podporuje callproc(), ale ovladač MSSQL-Python ne. Místo toho použijte EXECUTE :

Před (pymssql):

cursor.callproc("uspGetEmployeeManagers", (5,))
for row in cursor:
    print(row)

Po (mssql-python):

cursor.execute("EXECUTE dbo.uspGetEmployeeManagers @BusinessEntityID = ?", (5,))
for row in cursor:
    print(row)

Výstupní parametry

Použijte T-SQL proměnné k zachycení výstupních hodnot místo spoléhání se na callproc() výstupní parametry:

Před (pymssql):

cursor.callproc("GetProductCount", (category_id,))
count = cursor.fetchval()

Po (mssql-python, T-SQL proměnné):

cursor.execute("""
    DECLARE @count INT;
    SELECT @count = COUNT(*) FROM Production.Product
    WHERE ProductSubcategoryID = ?;
    SELECT @count AS ProductCount;
""", (1,))
product_count = cursor.fetchval()
print(f"Product count: {product_count}")

Hromadná migrace kopií

pymssql volá na připojení bulk_copy(). Ovladač mssql-python volá na kurzoru bulkcopy() s více možnostmi:

Před (pymssql):

conn.bulk_copy("##BulkDemo", [(1, 2)] * 1000)
conn.commit()

Po (mssql-python):

cursor = conn.cursor()
cursor.execute("CREATE TABLE ##BulkDemo (Col1 INT, Col2 INT)")
conn.commit()
result = cursor.bulkcopy("##BulkDemo", [(1, 2)] * 1000)
print(f"Copied {result['rows_copied']} rows")
conn.commit()
cursor.execute("DROP TABLE ##BulkDemo")
conn.commit()

Metoda mssql-python bulkcopy() podporuje batch_size, timeout, column_mappings, keep_identity, check_constraints, table_lock, keep_nulls, fire_triggers a use_internal_transaction. Podrobnosti najdete v části Hromadné kopírování.

Více kurzorů

PymsSQL povoluje pouze jeden aktivní kurzor na jedno připojení. Ovladač mssql-python podporuje více souběžných kurzorů:

Před (pymssql):

c1 = conn.cursor()
c1.execute("SELECT TOP 5 * FROM Person.Person")
c2 = conn.cursor()
c2.execute("SELECT TOP 5 * FROM Sales.SalesOrderHeader")
c1.fetchall()

Po (mssql-python):

c1 = conn.cursor()
c1.execute("SELECT TOP 5 BusinessEntityID, FirstName FROM Person.Person")
persons = c1.fetchall()

c2 = conn.cursor()
c2.execute("SELECT TOP 5 SalesOrderID FROM Sales.SalesOrderHeader")
orders = c2.fetchall()
print(f"Persons: {len(persons)}, Orders: {len(orders)}")

Sdílení připojení

PymsSQL nemá vestavěné pooling. Ovladač mssql-python ho automaticky zahrnuje:

Před (pymssql, vyžaduje se externí pool):

from dbutils.pooled_db import PooledDB
pool = PooledDB(pymssql, host="server", user="user", password="pwd", database="db")
conn = pool.connection()

Po (mssql-python, pooling je automatický):

conn = mssql_python.connect(connection_string)
conn.close()

Zpracování chyb

Ovladač mssql-python používá stejnou hierarchii výjimek jako pymssql, takže většina obslužných nástrojů výjimek vyžaduje pouze změnu názvu modulu:

Před (pymssql):

try:
    cursor.execute(query)
except pymssql.OperationalError as e:
    print(f"Operation failed: {e}")
except pymssql.InterfaceError as e:
    print(f"Interface error: {e}")

Po (mssql-python):

try:
    cursor = conn.cursor()
    cursor.execute("SELECT TOP 1 * FROM Production.Product")
    row = cursor.fetchone()
    print(row)
except mssql_python.OperationalError as e:
    print(f"Operation failed: {e}")
except mssql_python.InterfaceError as e:
    print(f"Interface error: {e}")

Příklad dokončení migrace

Následující ukazuje stejnou funkci napsanou v pymssql a následně přepsánou v mssql-python.

Předtím (pymssql)

Tato verze používá poziční argumenty funkce connect, as_dict=True a značky parametrů %d:

import pymssql

def get_orders(customer_id: int):
    conn = pymssql.connect("<server>", "<user>", "<password>", "<database>")
    cursor = conn.cursor(as_dict=True)

    cursor.execute("""
        SELECT TOP 10 SalesOrderID, OrderDate, TotalDue
        FROM Sales.SalesOrderHeader
        WHERE CustomerID = %d
        ORDER BY OrderDate DESC
    """, (customer_id,))

    orders = []
    for row in cursor:
        orders.append({
            "id": row["SalesOrderID"],
            "date": row["OrderDate"],
            "total": row["TotalDue"]
        })

    cursor.close()
    conn.close()
    return orders

Po (mssql-python)

Klíčové strukturální změny jsou značky parametrů, styl spojení a přístup k řádkům:

import mssql_python

def get_orders(customer_id: int):
    conn = mssql_python.connect(
        "Server=<server>;"
        "Database=<database>;"
        "UID=<username>;"
        "PWD=<password>;"
    )
    cursor = conn.cursor()

    cursor.execute("""
        SELECT TOP 10 SalesOrderID, OrderDate, TotalDue
        FROM Sales.SalesOrderHeader
        WHERE CustomerID = ?
        ORDER BY OrderDate DESC
    """, (customer_id,))

    orders = []
    for row in cursor:
        orders.append({
            "id": row.SalesOrderID,
            "date": row.OrderDate,
            "total": row.TotalDue
        })

    cursor.close()
    conn.close()
    return orders

Strukturální změny jsou:

1. import pymssql → import mssql_python.
2. Poziční argumenty připojení → připojovací řetězec s klíčovými slovy.
3. %d Značka parametru → ?.
4. cursor(as_dict=True) → cursor() s přístupem k atributům (row.SalesOrderID místo row["SalesOrderID"]).

Kontrolní seznam

• [ ] Aktualizovat importy z pymssql do .mssql_python
• [ ] Převádějte volání spojení z pozičních argumentů na řetězce spojů.
• [ ] Převeďte %s/%d parametrické značky na ? nebo %(name)s.
• [ ] Použijte EXECUTE příkazy pro volání uložených procedur.
• [ ] Používejte Row přístup k atributům místo as_dict=True kurzorů.
• [ ] Migrovat conn.bulk_copy() na cursor.bulkcopy().
• [ ] Odstraňte konfiguraci externího připojení pro pooling.
• [ ] Odstraňte FreeTDS z požadavků na nasazení.
• [ ] Aktualizace názvů tříd při zpracování výjimek.
• [ ] Otestujte všechny dotazy a uložené procedury.

Související obsah

• Migrujte z pyodbc
• Installation
• Připojovací řetězce
• Provádění dotazů
• Uložené procedury