Execute queries with mssql-python

Az mssql-python illezőprogram kurzormódszereket biztosít SQL lekérdezések végrehajtásához, paraméterezett lekérdezésekhez, batch műveletekhez és előkészített utasításokhoz.

Egyszerű lekérdezésvégrehajtás

Használj kurzor execute() módszerét SQL utasítások futtatására:

import mssql_python

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

cursor.execute("SELECT Name, ListPrice FROM Production.Product WHERE Color = 'Black'")
rows = cursor.fetchall()

for row in rows:
    print(row.Name, row.ListPrice)

cursor.close()
conn.close()

Paraméteres lekérdezések

Mindig használjon paraméteres lekérdezéseket az SQL-injektálás megakadályozásához. Az illesztőprogram alapértelmezett paramétere pyformat (elnevezett helykitöltők), de támogatja qmark (pozíciós helykitöltőket) is. Használja a(z) qmark elemet az ODBC {CALL} escape-szekvenciákhoz.

Pyformat stílus (alapértelmezett)

Használj név szerinti helykitöltőket szintaxissal %(name)s , és adj át egy szótárt:

cursor.execute(
    "SELECT Name, ListPrice FROM Production.Product WHERE Color = %(color)s AND ListPrice > %(price)s",
    {"color": "Black", "price": 10.00}
)

Qmark stílusa

Használj pozíciós helykitöltőket a(z) ? használatával, és adj át egy tuple-t vagy listát:

cursor.execute(
    "SELECT Name, ListPrice FROM Production.Product WHERE ProductSubcategoryID = ? AND ListPrice > ?",
    (1, 10.00)
)

Az illesztőprogram automatikusan felismeri a paraméter stílusát az SQL lekérdezésed és paramétertípusok alapján.

INSERT, UPDATE, DELETE műveletek

Adatmódosító utasításokhoz használj paraméterezett lekérdezéseket, és kötelezzük el a tranzakciót:

cursor.execute("CREATE TABLE #ExecDemo (Name NVARCHAR(50), CategoryID INT, Price DECIMAL(10,2))")
cursor.execute(
    "INSERT INTO #ExecDemo (Name, CategoryID, Price) VALUES (%(name)s, %(category)s, %(price)s)",
    {"name": "New Product", "category": 1, "price": 19.99}
)
conn.commit()

print(f"Rows affected: {cursor.rowcount}")

Kötegelt végrehajtás executemany() segítségével

Használd executemany() hatékonyan több sor beillesztésére. Az illesztőprogram oszloponkénti paraméterkötést alkalmaz a nagy teljesítmény érdekében:

products = [
    {"name": "Product A", "category": 1, "price": 10.00},
    {"name": "Product B", "category": 1, "price": 15.00},
    {"name": "Product C", "category": 2, "price": 20.00},
]

cursor.execute("CREATE TABLE #BatchDemo (Name NVARCHAR(50), CategoryID INT, Price DECIMAL(10,2))")
cursor.executemany(
    "INSERT INTO #BatchDemo (Name, CategoryID, Price) VALUES (%(name)s, %(category)s, %(price)s)",
    products
)
conn.commit()

print(f"Rows inserted: {cursor.rowcount}")

Qmark stílussal:

products = [
    ("Product A", 1, 10.00),
    ("Product B", 1, 15.00),
    ("Product C", 2, 20.00),
]

cursor.execute("CREATE TABLE #QmarkDemo (Name NVARCHAR(50), CategoryID INT, Price DECIMAL(10,2))")
cursor.executemany(
    "INSERT INTO #QmarkDemo (Name, CategoryID, Price) VALUES (?, ?, ?)",
    products
)
conn.commit()

Több utasításos kötegelt végrehajtás

Használd batch_execute() a kapcsolaton több különböző utasítás végrehajtásához egyetlen hívásban:

results, cursor = conn.batch_execute(
    [
        "CREATE TABLE #BatchExec (Name NVARCHAR(50), CategoryID INT)",
        "INSERT INTO #BatchExec (Name, CategoryID) VALUES (%(name)s, %(cat)s)",
        "SELECT COUNT(*) FROM #BatchExec"
    ],
    [
        None,                                 # No params for CREATE
        {"name": "New Item", "cat": 1},       # Params for INSERT
        None                                  # No params for SELECT
    ]
)

print(f"CREATE result: {results[0]}")
print(f"INSERT affected: {results[1]} rows")
print(f"Row count: {results[2][0][0]}")

Előkészített lekérdezések

Az illesztőprogram alapértelmezés szerint előkészíti a lekérdezéseket (use_prepare=True). Ha ugyanazt az SQL stringet többször ugyanazon kurzoron futtatod, a driver automatikusan újrahasználja a felkészített utasítást a következő hívásoknál:

# First execution prepares the statement
cursor.execute(
    "SELECT Name, ListPrice FROM Production.Product WHERE ProductSubcategoryID = %(subcategory_id)s",
    {"subcategory_id": 1},
)
rows1 = cursor.fetchall()

# Same SQL string on same cursor → driver reuses the prepared plan
cursor.execute(
    "SELECT Name, ListPrice FROM Production.Product WHERE ProductSubcategoryID = %(subcategory_id)s",
    {"subcategory_id": 2},
)
rows2 = cursor.fetchall()

Hogy kihagyjuk az előkészületet, és helyette a közvetlen végrehajtást használjuk:

cursor.execute(
    "SELECT Name, ListPrice FROM Production.Product WHERE ProductSubcategoryID = 1",
    use_prepare=False  # Uses SQLExecDirectW instead of SQLPrepareW
)

Kapcsolatszintű végrehajtás

Egyszerű, egyszeri lekérdezésekhez közvetlenül a kapcsolaton használd execute() :

# Creates cursor, executes, and returns cursor
cursor = conn.execute("SELECT TOP 10 Name, ListPrice FROM Production.Product")
rows = cursor.fetchall()
cursor.close()

Tárolt eljárások

Hívja meg a tárolt eljárásokat a EXECUTE vagy az ODBC {CALL} escape szintaxis használatával. A kimeneti paraméterekről, több eredményhalmazról és tranzakciós mintákról információért lásd: Tárolt eljárások.

cursor.execute(
    "EXECUTE dbo.uspGetManagerEmployees @BusinessEntityID = %(business_entity_id)s",
    {"business_entity_id": 16}
)
rows = cursor.fetchall()

Állítsa be a bemeneti méreteket

setinputsizes() Használd a paramétertípusok explicit bejelentésére, ami javíthatja a batch műveletek teljesítményét:

cursor.setinputsizes([
    (mssql_python.SQL_WVARCHAR, 50, 0),   # NVARCHAR(50)
    (mssql_python.SQL_INTEGER, 0, 0),     # INT
])

cursor.executemany(
    "SELECT ProductID, Name FROM Production.Product WHERE Name LIKE ? AND ProductSubcategoryID = ?",
    [("Road%", 2), ("Mountain%", 1)]
)

Megjegyzés:

Nem minden SQL-típuskonstans működik a(z) setinputsizes() elemmel. SQL_WVARCHAR és SQL_INTEGER megbízhatóak. Tizedes értékekhez használjuk az illesztőprogram automatikus típuskövetkeztetését , nem SQL_DECIMALpedig , amelynek ismert problémája van (GitHub #503).

Hibakezelés

Csomagolj be adatbázis műveleteket try-except blokkokban:

try:
    cursor.execute("CREATE TABLE #ErrDemo (Name NVARCHAR(50) NOT NULL)")
    cursor.execute("INSERT INTO #ErrDemo (Name) VALUES (%(name)s)", {"name": None})
    conn.commit()
except mssql_python.IntegrityError as e:
    print(f"Constraint violation: {e}")
    conn.rollback()
except mssql_python.ProgrammingError as e:
    print(f"SQL error: {e}")
    conn.rollback()

Bevált gyakorlatok

  1. Mindig használj paraméterezett lekérdezéseket az SQL injektálásának megakadályozására.
  2. Használd a tömeges másolást tömeges beszúrásokhoz több execute() hívás helyett.
  3. Kifejezetten véglegesítse a tranzakciókat, amikor kikapcsolja az automatikus véglegesítést.
  4. Zárd le a kurzorokat és kapcsolatokat , amikor elvégezted az erőforrások felszabadítását.
  5. Használjon kontextuskezelőket az automatikus erőforrás-tisztításhoz:
with mssql_python.connect(connection_string) as conn:
    with conn.cursor() as cursor:
        cursor.execute("SELECT TOP 5 Name, ListPrice FROM Production.Product")
        rows = cursor.fetchall()
# Connection and cursor automatically closed

Kapcsolódó tartalom

  • Last updated on