JSON adatot használj mssql-python-szal

A Microsoft SQL 2016 és újabb verziók, valamint az Azure SQL JSON támogatást nyújtanak oszlopokon működő funkciókon keresztülnvarchar. Az mssql-python illesztőprogram normál Python stringként küldi és kapja a JSON-t. Ön megteheti:

• Tárold a JSON-t karakterláncként a nvarchar oszlopokban.
• Kérdezze le a JSON-adatokat útvonalkifejezésekkel a(z) JSON_VALUE, JSON_QUERY és OPENJSON használatával.
• Transzformáljuk a relációs adatokat JSON-ra a .FOR JSON
• Elemezze a JSON-t relációs formátumba a(z) OPENJSON használatával.

Megjegyzés:

A Microsoft SQL a JSON adatokat nvarchar oszlopokban tárolja, nem dedikált JSON oszloptípusban. Az mssql-python illesztőprogram normál stringként küldi és fogadja a JSON-t. Használd a Python beépített json modulját a kliens oldalon serializálni és deserializálni.

Tárolja a JSON adatokat

Alakítsa a Python-szótárakat karakterláncokká a(z) json.dumps() használatával, mielőtt beszúrná őket az nvarchar oszlopokba.

JSON-karakterlánc beszúrása

Tárolj egy Python szótárt JSON szövegként egy adatbázis táblában:

import json
import mssql_python

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

# Create table with JSON column
cursor.execute("""
    CREATE TABLE #JsonProducts (
        ProductID INT IDENTITY PRIMARY KEY,
        Name NVARCHAR(100),
        JsonData NVARCHAR(MAX)
    )
""")

# Python dict to JSON string
product_data = {
    "name": "Widget Pro",
    "specs": {
        "weight": 2.5,
        "dimensions": {"width": 10, "height": 5, "depth": 3}
    },
    "tags": ["electronics", "gadgets", "bestseller"]
}

cursor.execute("""
    INSERT INTO #JsonProducts (Name, JsonData)
    VALUES (%(name)s, %(json)s)
""", {"name": "Widget Pro", "json": json.dumps(product_data)})
conn.commit()

JSON érvényesítése beszúráskor

Használja a ISJSON() függvényt a JSON szintaxisának validálására a következő beillesztés előtt:

data = {"name": "Widget", "specs": {"weight": 1.5}}

cursor.execute("""
    CREATE TABLE #JsonValidate (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonValidate (Name, JsonData)
    SELECT %(name)s, %(json)s
    WHERE ISJSON(%(json)s) = 1
""", {"name": "Widget", "json": json.dumps(data)})

if cursor.rowcount == 0:
    raise ValueError("Invalid JSON data")

JSON-adatok lekérdezése

Használd a Microsoft SQL JSON útfüggvényeit, hogy értékeket nyerj ki a szerverről, mielőtt visszaküldenéd azokat a kliensnek.

Skalárértékek kinyerése

Egyedi értékek kinyerésére használják JSON_VALUE :

# Create table with sample JSON data
cursor.execute("""
    CREATE TABLE #JsonExtract (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonExtract (Name, JsonData) VALUES (
        'Widget Pro',
        '{"name":"Widget Pro","specs":{"weight":2.5,"dimensions":{"width":10,"height":5,"depth":3}},"tags":["electronics","gadgets"]}'
    )
""")

cursor.execute("""
    SELECT 
        Name,
        JSON_VALUE(JsonData, '$.specs.weight') AS Weight,
        JSON_VALUE(JsonData, '$.specs.dimensions.width') AS Width
    FROM #JsonExtract
    WHERE JSON_VALUE(JsonData, '$.name') = %(name)s
""", {"name": "Widget Pro"})

row = cursor.fetchone()
print(f"Weight: {row.Weight}, Width: {row.Width}")

Objektumok vagy tömbök kivonása

Használd JSON_QUERY tárgyakhoz és tömbökhöz.

cursor.execute("""
    CREATE TABLE #JsonQuery (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonQuery (Name, JsonData) VALUES (
        'Widget Pro',
        '{"specs":{"weight":2.5,"color":"blue"},"tags":["electronics","gadgets"]}'
    )
""")

cursor.execute("""
    SELECT 
        Name,
        JSON_QUERY(JsonData, '$.specs') AS Specs,
        JSON_QUERY(JsonData, '$.tags') AS Tags
    FROM #JsonQuery
""")

for row in cursor:
    specs = json.loads(row.Specs) if row.Specs else {}
    tags = json.loads(row.Tags) if row.Tags else []
    print(f"{row.Name}: {specs}, Tags: {tags}")

JSON-tömb elemzése sorokká

Bővítsük ki a JSON tömböt sorokra a következőképpen OPENJSON:

cursor.execute("""
    CREATE TABLE #JsonArray (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonArray (Name, JsonData) VALUES 
        ('Widget Pro', '{"tags":["electronics","gadgets","bestseller"]}'),
        ('Gadget X', '{"tags":["tools","gadgets"]}')
""")

cursor.execute("""
    SELECT p.Name, t.value AS Tag
    FROM #JsonArray p
    CROSS APPLY OPENJSON(p.JsonData, '$.tags') t
""")

for row in cursor:
    print(f"Product: {row.Name}, Tag: {row.Tag}")

JSON-objektum felosztása oszlopokra

Az egyes mezőket JSON-objektumokból a(z) JSON_VALUE() használatával nyerje ki, és az eredményeket alakítsa a megfelelő SQL-típusokra.

cursor.execute("""
    CREATE TABLE #JsonCols (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonCols (Name, JsonData) VALUES (
        'Widget Pro',
        '{"name":"Widget Pro","specs":{"weight":2.5,"dimensions":{"width":10,"height":5}}}'
    )
""")

cursor.execute("""
    SELECT 
        p.ProductID,
        j.name AS ProductName,
        j.weight,
        j.width,
        j.height
    FROM #JsonCols p
    CROSS APPLY OPENJSON(p.JsonData)
    WITH (
        name NVARCHAR(100) '$.name',
        weight DECIMAL(5,2) '$.specs.weight',
        width INT '$.specs.dimensions.width',
        height INT '$.specs.dimensions.height'
    ) j
""")

JSON adatok módosítása

Használd JSON_MODIFY egy adott útvonal frissítésére egy JSON dokumentumban anélkül, hogy az egész értéket újraírnánk.

JSON érték frissítése

Módosítson egyetlen JSON-tulajdonságot a(z) JSON_MODIFY használatával:

cursor.execute("""
    CREATE TABLE #JsonMod (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonMod (Name, JsonData) VALUES (
        'Widget Pro',
        '{"specs":{"weight":2.5,"dimensions":{"width":10}},"tags":["electronics"]}'
    )
""")

cursor.execute("""
    UPDATE #JsonMod
    SET JsonData = JSON_MODIFY(JsonData, '$.specs.weight', %(weight)s)
    WHERE ProductID = %(id)s
""", {"weight": 3.0, "id": 1})
conn.commit()

Hozzáadni a JSON tulajdonságot

Új tulajdonság bekerülése egy meglévő JSON objektumba:

cursor.execute("""
    CREATE TABLE #JsonAdd (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonAdd (Name, JsonData) VALUES (
        'Widget Pro', '{"specs":{"weight":2.5}}'
    )
""")

cursor.execute("""
    UPDATE #JsonAdd
    SET JsonData = JSON_MODIFY(JsonData, '$.specs.color', %(color)s)
    WHERE ProductID = %(id)s
""", {"color": "blue", "id": 1})

Távolítsa el a JSON tulajdonságot

Törölj egy tulajdonságot egy JSON-objektumból úgy, hogy NULL értékre állítod.

cursor.execute("""
    CREATE TABLE #JsonRem (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonRem (Name, JsonData) VALUES (
        'Widget Pro', '{"specs":{"weight":2.5,"color":"blue"}}'
    )
""")

cursor.execute("""
    UPDATE #JsonRem
    SET JsonData = JSON_MODIFY(JsonData, '$.specs.color', NULL)
    WHERE ProductID = %(id)s
""", {"id": 1})

Hozzáfűzés a JSON-tömbhöz

Új értéket adj hozzá egy JSON tömb végéhez az utasítással append a :JSON_MODIFY

cursor.execute("""
    CREATE TABLE #JsonAppend (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonAppend (Name, JsonData) VALUES (
        'Widget Pro', '{"tags":["electronics","gadgets"]}'
    )
""")

cursor.execute("""
    UPDATE #JsonAppend
    SET JsonData = JSON_MODIFY(
        JsonData, 
        'append $.tags', 
        %(tag)s
    )
    WHERE ProductID = %(id)s
""", {"tag": "new-arrival", "id": 1})

Relációs adatok átalakítása JSON-ra

A FOR JSON záradék a lekérdezési eredményeket JSON stringjévé alakítja a szerver oldalon.

JSON AUTO ESETÉN

Generálj JSON lekérdezési eredményekből:

cursor.execute("""
    SELECT TOP 5 o.SalesOrderID, p.LastName AS CustomerName, o.TotalDue
    FROM Sales.SalesOrderHeader o
    JOIN Sales.Customer c ON o.CustomerID = c.CustomerID
    JOIN Person.Person p ON c.PersonID = p.BusinessEntityID
    FOR JSON AUTO
""")

# Result is a single string containing JSON
json_result = cursor.fetchval()
orders = json.loads(json_result)
print(json.dumps(orders, indent=2))

A JSON PATH SZÁMÁRA

Szerezz nagyobb kontrollt a JSON szerkezet felett:

cursor.execute("""
    SELECT 
        o.SalesOrderID AS 'order.id',
        o.OrderDate AS 'order.date',
        p.LastName AS 'customer.name',
        e.EmailAddress AS 'customer.email'
    FROM Sales.SalesOrderHeader o
    JOIN Sales.Customer c ON o.CustomerID = c.CustomerID
    JOIN Person.Person p ON c.PersonID = p.BusinessEntityID
    JOIN Person.EmailAddress e ON p.BusinessEntityID = e.BusinessEntityID
    WHERE o.SalesOrderID = %(id)s
    FOR JSON PATH, WITHOUT_ARRAY_WRAPPER
""", {"id": 43659})

json_result = cursor.fetchval()
order = json.loads(json_result)
# Structure: {"order": {"id": 43659, "date": "..."}, "customer": {"name": "...", "email": "..."}}

Beágyazott JSON

Adatstruktúrák lekérdezése beágyazott JSON-tömböket és -objektumokat tartalmazó adatokban, alalekérdezések és a(z) FOR JSON használatával hierarchikus JSON-kimenet létrehozásához.

cursor.execute("""
    SELECT TOP 3
        c.CustomerID,
        p.LastName AS CustomerName,
        (SELECT TOP 3 o.SalesOrderID, o.TotalDue
         FROM Sales.SalesOrderHeader o
         WHERE o.CustomerID = c.CustomerID
         FOR JSON PATH) AS Orders
    FROM Sales.Customer c
    JOIN Person.Person p ON c.PersonID = p.BusinessEntityID
    WHERE c.PersonID IS NOT NULL
    FOR JSON PATH
""")

json_result = cursor.fetchval()
customers = json.loads(json_result)
# Each customer has nested Orders array

Python integrációs minták

Ezek a minták megmutatják, hogyan lehet Python absztrakciókat építeni JSON-alapú táblákon.

A tároló minta JSON-nal

Valósíts meg egy adathozzáférési réteget, amely sorozatosítja és deserializálja a Python objektumokat JSON oszlopokba, így típusbiztos felületet biztosít az adatbázishoz.

from dataclasses import dataclass, asdict
from typing import Optional
import json

@dataclass
class ProductSpecs:
    weight: float
    color: str
    dimensions: dict

@dataclass
class Product:
    id: Optional[int]
    name: str
    specs: ProductSpecs

class ProductRepository:
    def __init__(self, connection):
        self.conn = connection
        cursor = self.conn.cursor()
        cursor.execute("""
            IF OBJECT_ID('#JsonRepo') IS NULL
                CREATE TABLE #JsonRepo (
                    ProductID INT IDENTITY PRIMARY KEY,
                    Name NVARCHAR(100),
                    JsonData NVARCHAR(MAX)
                )
        """)
        self.conn.commit()
    
    def save(self, product: Product) -> int:
        cursor = self.conn.cursor()
        specs_json = json.dumps(asdict(product.specs))
        
        if product.id:
            cursor.execute("""
                UPDATE #JsonRepo SET Name = %(name)s, JsonData = %(json)s
                WHERE ProductID = %(id)s
            """, {"name": product.name, "json": specs_json, "id": product.id})
        else:
            cursor.execute("""
                INSERT INTO #JsonRepo (Name, JsonData)
                OUTPUT INSERTED.ProductID
                VALUES (%(name)s, %(json)s)
            """, {"name": product.name, "json": specs_json})
            product.id = cursor.fetchval()
        
        self.conn.commit()
        return product.id
    
    def get(self, product_id: int) -> Optional[Product]:
        cursor = self.conn.cursor()
        cursor.execute("""
            SELECT ProductID, Name, JsonData FROM #JsonRepo WHERE ProductID = %(id)s
        """, {"id": product_id})
        
        row = cursor.fetchone()
        if row is None:
            return None
        
        specs_data = json.loads(row.JsonData)
        return Product(
            id=row.ProductID,
            name=row.Name,
            specs=ProductSpecs(**specs_data)
        )

Csatlakozz az adatbázishoz, majd létrehozd a tárolót, és használd azt a termék mentésére és visszakeresésére. A save() metódus az INSERT ágat követi, ha a id értéke None, egyébként pedig a UPDATE ágat:

conn = mssql_python.connect(connection_string)

repo = ProductRepository(conn)

# id is None, so save() inserts a new row and returns the generated ProductID.
product = Product(
    id=None,
    name="Widget Pro",
    specs=ProductSpecs(weight=2.5, color="black", dimensions={"width": 10, "height": 5})
)
product_id = repo.save(product)
print(f"Saved product {product_id}")

# Read the product back into a typed Product object.
loaded = repo.get(product_id)
print(loaded)

conn.close()

A tároló a(z) #JsonRepo helyi ideiglenes táblát az átadott kapcsolat hatókörében hozza létre, ezért a(z) save() és a(z) get() ugyanazt a kapcsolatot kell hogy használja. A tábla törlődik, amikor a kapcsolat lezárul.

Hatékonyan kezelni a nagy JSON eredményeket

Ha a JSON eredmények nagyok, hozd be őket több sorban részekben.

def fetch_json_in_parts(cursor, query: str, params: dict) -> list:
    """Handle JSON results that might span multiple rows."""
    cursor.execute(query, params)
    
    # FOR JSON might split large results across rows
    json_parts = []
    for row in cursor:
        json_parts.append(row[0])
    
    # Combine parts
    json_string = "".join(json_parts)
    return json.loads(json_string) if json_string else []

# Usage
data = fetch_json_in_parts(cursor, "SELECT TOP 100 * FROM Production.Product FOR JSON AUTO", {})

Konvertáld a lekérdezési eredményeket JSON-ra Python-ban

A relációs lekérdezés JSON formátumba történő átalakítása Python-ban úgy történik, hogy minden sort szótárrá konvertálunk, majd JSON-ra soroljuk.

def query_to_json(cursor, query: str, params: dict = None) -> str:
    """Execute query and return results as JSON string."""
    cursor.execute(query, params or {})
    columns = [col[0] for col in cursor.description]
    
    rows = []
    for row in cursor:
        rows.append(dict(zip(columns, row)))
    
    return json.dumps(rows, default=str, indent=2)

# Usage
json_output = query_to_json(cursor, "SELECT TOP 5 ProductID, Name, ListPrice FROM Production.Product WHERE ProductSubcategoryID = %(cat)s", {"cat": 1})
print(json_output)

JSON-adatok indexelése

Hozz létre egy kiszámított oszlopot, amelyet egy JSON útkifejezés támogat, hogy az út indexelhető legyen.

Indexszel ellátott számított oszlop

Definiáljunk egy kiszámított oszlopot, amely kinyer egy JSON értéket, és alkalmazz rá indexet a gyakran lekérdezett JSON útvonalakon történő hatékony szűréshez. A következő példa állandó táblát hoz létre, hozzáad egy tartós kiszámított oszlopot a JSON $.specs.weight útra, és indexet hoz hozzá.

cursor.execute("""
    IF OBJECT_ID('dbo.ProductCatalog', 'U') IS NOT NULL
        DROP TABLE dbo.ProductCatalog
""")
cursor.execute("""
    CREATE TABLE dbo.ProductCatalog (
        ProductID   INT IDENTITY PRIMARY KEY,
        Name        NVARCHAR(100),
        JsonData    NVARCHAR(MAX)
    )
""")

# Insert sample rows with JSON data
rows = [
    ("Widget Pro",   '{"specs":{"weight":2.5,"color":"blue"}}'),
    ("Gadget X",     '{"specs":{"weight":0.8,"color":"red"}}'),
    ("Heavy Duty",   '{"specs":{"weight":9.1,"color":"gray"}}'),
]
cursor.executemany(
    "INSERT INTO dbo.ProductCatalog (Name, JsonData) VALUES (%(name)s, %(json)s)",
    [{"name": n, "json": j} for n, j in rows]
)
conn.commit()

# Add a persisted computed column that extracts weight from JSON
cursor.execute("""
    ALTER TABLE dbo.ProductCatalog
    ADD ProductWeight AS CAST(JSON_VALUE(JsonData, '$.specs.weight') AS DECIMAL(5,2)) PERSISTED
""")

# Index the computed column for efficient range queries
cursor.execute("""
    CREATE INDEX IX_ProductCatalog_Weight
    ON dbo.ProductCatalog (ProductWeight)
""")
conn.commit()

Lekérdezés indexelt számított oszlop használatával

Szűrjön közvetlenül a számított oszlop alapján. A lekérdezési motor az indexet használja ahelyett, hogy minden JSON dokumentumot átszkennelne és parziálna.

cursor.execute("""
    SELECT Name, ProductWeight
    FROM dbo.ProductCatalog
    WHERE ProductWeight > %(min_weight)s
    ORDER BY ProductWeight
""", {"min_weight": 1.0})

for row in cursor:
    print(f"{row.Name}: {row.ProductWeight} kg")

# Cleanup
cursor.execute("DROP TABLE dbo.ProductCatalog")
conn.commit()

Válasszon relációs oszlopok és JSON tárolás között

Relációs oszlopokat akkor használjunk, ha az adatoknak fix sémája van, referenciális integritásra van szüksége, részt vesz a JOIN-ekben, vagy gyakran megjelenik a WHERE klauzulákban. Használj JSON oszlopokat (nvarchar(max)) akkor amikor az adatok ritkák, sorok között változnak, vagy rugalmas konfigurációt vagy metaadatokat képviselnek.

Mikor kell szerveroldali és kliensoldali JSON feldolgozást használni

Használd a Microsoft SQL JSON függvényeket (JSON_VALUE, JSON_QUERY, OPENJSON), amikor a JSON mezők között szűrni, indexelni vagy aggregálni kell anélkül, hogy minden sort a klienshez kellene hozni. Ez a választás akkor érvényes, ha csak egy részhalmaza felel meg a kritériumaidnak, vagy amikor a JSON útvonalakon kiszámított oszlopindexeket szeretnél.

Használj kliens oldali Python feldolgozást (json.loads()), amikor egész dokumentumokat letöltesz, és az alkalmazáslogikában dolgozod fel őket. Ez a megközelítés akkor működik, ha teljes dokumentumra van szükséged, és nem szűrsz a JSON mezőkre az adatbázisban.

Dokumentum-stílusú munkafolyamatok

Amikor az alkalmazás egész dokumentumokat tárol és lekér, használj Python-oldali serializációt, és kezeld a JSON oszlopot átlátszatlan tárhelyként. Dolgozd fel és kérdezze a dokumentumokat Python-ban a teljes JSON foltok lekérésével és deserializálásával:

import json

# Create the settings table
cursor.execute("""
    CREATE TABLE #Settings (
        UserID INT PRIMARY KEY,
        ConfigJson NVARCHAR(MAX)
    )
""")

# Store a configuration document
config = {
    "theme": "dark",
    "notifications": {"email": True, "sms": False},
    "custom_fields": {"department": "Engineering", "cost_center": "CC-100"}
}

cursor.execute(
    "INSERT INTO #Settings (UserID, ConfigJson) VALUES (%(uid)s, %(cfg)s)",
    {"uid": 1, "cfg": json.dumps(config)}
)

# Retrieve and process in Python
cursor.execute("SELECT ConfigJson FROM #Settings WHERE UserID = %(uid)s", {"uid": 1})
row = cursor.fetchone()
config = json.loads(row.ConfigJson)
print(config["notifications"]["email"])  # True

Server-side JSON queries

Használd a Microsoft SQL JSON funkciókat, amikor szűrődnöd, indexelned vagy aggregálnod kell a JSON mezők között anélkül, hogy minden sort lehoznál. Ez a megközelítés hatékonyabb, mint az összes sor Pythonba való betöltése a memóriában történő szűréshez:

• JSON_VALUE skaláris értékeket nyer ki, és vissza tudja állítani a kiszámított oszlopindexeket.
• JSON_QUERY objektumokat és tömböket vonnak ki.
• OPENJSON a JSON-t sorokra bontja JOIN-khez és aggregáláshoz.
• JSON_MODIFY Frissíti a konkrét útvonalakat anélkül, hogy az egész dokumentumot újraírnánk.

# Filter by a JSON field server-side
cursor.execute("""
    SELECT UserID, ConfigJson
    FROM #Settings
    WHERE JSON_VALUE(ConfigJson, '$.custom_fields.department') = %(dept)s
""", {"dept": "Engineering"})

Gyakran lekérdezett JSON útvonalaknál hozz létre egy kiszámított oszlopot indexkel:

ALTER TABLE Settings
ADD Department AS JSON_VALUE(ConfigJson, '$.custom_fields.department');

CREATE INDEX IX_Settings_Department ON Settings(Department);

Bevált gyakorlatok

Ezeket az irányelveket alkalmazzuk a JSON oszlopok megbízható használatához.

Validáld a JSON tárolás előtt

Ellenőrizd a JSON és a táblázat/oszlop azonosítókat tárolás előtt, hogy elkerüld az injekciós támadásokat.

def store_json_safely(cursor, table: str, json_column: str, data: dict):
    """Store JSON with validation."""
    # Validate identifiers to prevent SQL injection
    import re
    if not re.match(r'^[A-Za-z_][A-Za-z0-9_.]*$', table):
        raise ValueError(f"Invalid table name: {table}")
    if not re.match(r'^[A-Za-z_][A-Za-z0-9_]*$', json_column):
        raise ValueError(f"Invalid column name: {json_column}")

    json_str = json.dumps(data)
    
    # Check if valid JSON in Microsoft SQL
    cursor.execute("SELECT ISJSON(%(json)s)", {"json": json_str})
    if cursor.fetchval() != 1:
        raise ValueError("Invalid JSON")
    
    cursor.execute(f"INSERT INTO {table} ({json_column}) VALUES (%(json)s)", {"json": json_str})

Ne használd túl a JSON-t

Használj JSON oszlopokat rugalmas vagy ritka adatokhoz, például felhasználói preferenciákhoz vagy egyedi mezőkhez. Relációs oszlopokat használj a következőkhöz:

• Gyakran lekérdezett adatok.
• Olyan adatok, amelyekhez referenciális integritás szükséges.
• A WHERE klauzulákban használt oszlopok.

A None/NULL megfelelő kezelése

Kezeld a hiányzó vagy opcionális JSON mezőket úgy, hogy NULL értékeket adsz be olyan oszlopokhoz, amelyekben nincs adat.

cursor.execute("""
    CREATE TABLE #JsonOpt (
        ProductID INT IDENTITY, Name NVARCHAR(100), JsonData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #JsonOpt (Name, JsonData) VALUES (
        'Widget Pro', '{"required_field":"value"}'
    )
""")

cursor.execute("""
    SELECT 
        Name,
        JSON_VALUE(JsonData, '$.optional_field') AS OptionalValue
    FROM #JsonOpt
""")

for row in cursor:
    # JSON_VALUE returns NULL if path doesn't exist
    value = row.OptionalValue or "default"
    print(f"{row.Name}: {value}")

Kapcsolódó tartalom

• Adattípus-leképezések
• String és Unicode kezelés
• Microsoft SQL JSON dokumentáció