Zeichenfolgen und Unicode verarbeiten

Microsoft SQL bietet mehrere Zeichenkettentypen, die der mssql-python-Treiber auf Python-Objekte str abbildet. Die wichtigste Entscheidung ist, ob varchar (nicht-Unicode) oder nvarchar (Unicode) verwendet werden soll:

  • Verwenden nvarchar Sie, wenn Ihre Daten Zeichen außerhalb von ASCII enthalten könnten, wie Namen, Adressen oder nutzergenerierte Inhalte in einer beliebigen Sprache.
  • Verwenden varchar Sie, wenn die Daten ausschließlich ASCII sind (Codes, Identifikatoren, E-Mail-Adressen) und Sie Speicherplatz sparen möchten. varchar verwendet 1 Byte pro Zeichen; nvarchar verwendet 2 Bytes pro Zeichen.
SQL-Typ Unicode Max. Länge Python-Typ
char(n) No 8.000 str
varchar(n) No 8.000 str
varchar(max) No 2 GB str
nchar(n) Ja 4,000 str
nvarchar(n) Ja 4,000 str
nvarchar(max) Ja 2 GB str
text No 2 GB (veraltet) str
ntext Ja 2 GB (veraltet) str

Grundlegende Zeichenfolgenoperationen

Der Treiber ordnet alle Microsoft-SQL-String-Typen Python-Objekten str zu.

Strings einfügen und abrufen

Verwenden Sie parametrisierte Abfragen, um sicher String-Daten aus der Datenbank einzufügen und abzurufen.

import mssql_python

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

# Create temp table for demo
cursor.execute("""
    CREATE TABLE #StringDemo (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        Name NVARCHAR(100),
        Email NVARCHAR(200)
    )
""")

# Insert string data
cursor.execute(
    "INSERT INTO #StringDemo (Name, Email) VALUES (%(name)s, %(email)s)",
    {"name": "Alice Smith", "email": "alice@example.com"}
)
conn.commit()

# Retrieve string data
cursor.execute("SELECT Name, Email FROM #StringDemo WHERE ID = 1")
row = cursor.fetchone()
print(row.Name)   # 'Alice Smith'
print(row.Email)  # 'alice@example.com'

Zeichenketten mit Spezialzeichen

Behandeln Sie Anführungszeichen, spitze Klammern und andere Sonderzeichen in Zeichenfolgen mithilfe parametrisierter Abfragen.

# Quotes and special characters handled automatically
cursor.execute("""
    CREATE TABLE #Notes (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        Title NVARCHAR(200),
        Content NVARCHAR(MAX)
    )
""")
cursor.execute(
    "INSERT INTO #Notes (Title, Content) VALUES (%(title)s, %(content)s)",
    {
        "title": "O'Brien's Report",
        "content": 'Contains "quotes" and special chars: <>&'
    }
)
conn.commit()

Unicode-Unterstützung

Verwende nvarchar-Spalten und Pythonstr, um Text in jeder Sprache zu speichern und abzurufen.

Unicode-Text speichern

Fügen Sie Unicode-Inhalte ein, indem Sie Python-Strings an parametrisierte Abfragen übergeben; der Treiber kodiert sie als UTF-16LE für nvarchar-Spalten.

# International characters - use nvarchar columns
cursor.execute("""
    CREATE TABLE #Messages (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        Content NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #Messages (Content) VALUES (%(msg)s)
""", {"msg": "Hello 你好 مرحبا שלום 🎉"})

cursor.execute("SELECT Content FROM #Messages WHERE ID = 1")
row = cursor.fetchone()
print(row.Content)  # 'Hello 你好 مرحبا שלום 🎉'

Unicode in verschiedenen Schriften

Unterstützt mehrere Sprachen und Skripte in einer einzigen Tabelle durch Verwendung von nvarchar-Spalten und Masseneinfügungen.

messages = [
    {"lang": "English", "text": "Hello, World!"},
    {"lang": "Chinese", "text": "你好，世界！"},
    {"lang": "Japanese", "text": "こんにちは世界！"},
    {"lang": "Korean", "text": "안녕하세요, 세상!"},
    {"lang": "Arabic", "text": "مرحبا بالعالم!"},
    {"lang": "Hebrew", "text": "שלום עולם!"},
    {"lang": "Russian", "text": "Привет мир!"},
    {"lang": "Greek", "text": "Γειά σου Κόσμε!"},
    {"lang": "Emoji", "text": "👋🌍✨🎉"},
]

cursor.execute("""
    CREATE TABLE #Greetings (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        Language NVARCHAR(50),
        Message NVARCHAR(200)
    )
""")
cursor.executemany("""
    INSERT INTO #Greetings (Language, Message) VALUES (%(lang)s, %(text)s)
""", messages)
conn.commit()

Stellen Sie nvarchar-Spalten für Unicode sicher.

Definiere Spalten immer als nvarchar statt varchar, wenn deine Daten möglicherweise nicht-ASCII-Zeichen enthalten.

-- For Unicode data, always use nvarchar, not varchar
CREATE TABLE #UnicodeDemo (
    ID INT IDENTITY PRIMARY KEY,
    Name NVARCHAR(100),        -- Supports Unicode
    Description NVARCHAR(MAX)  -- Supports large Unicode text
);

Überlegungen zur Saitenlänge

Wählen Sie zwischen Typen mit fester und variabler Länge, je nachdem, wie konsistent Ihre Datenlängen sind.

Feste versus variable Länge

Microsoft SQL char(n) ergänzt Werte mit nachlaufenden Spaces bis zur deklarierten Länge. Dieses Aufpolstern verschwendet Speicher für Daten variabler Länge, kann aber die Leistung für Spalten mit fester Breite verbessern, wie z. B. Ländercodes. Verwenden Sie varchar(n) für die meisten Spalten mit Zeichenfolgen.

Das folgende Beispiel zeigt den Unterschied darin, wie gepolsterte und nicht gepolsterte Spalten die Datenabrufe handhaben:

# char(6) pads to fixed length
cursor.execute(
    "SELECT StateProvinceCode FROM Person.StateProvince WHERE StateProvinceID = 1"
)  # nchar(6) column
row = cursor.fetchone()
print(repr(row.StateProvinceCode))  # 'AB    ' - right-padded with spaces

# nvarchar stores actual length
cursor.execute(
    "SELECT Name FROM Person.StateProvince WHERE StateProvinceID = 1"
)  # nvarchar column
row = cursor.fetchone()
print(repr(row.Name))  # 'Alberta' - no padding

Nachgestellte Leerzeichen verarbeiten

Beim Abrufen von Daten aus CHAR-Spalten mit fester Länge verwenden Sie rstrip(), um die von Microsoft SQL Server hinzugefügten Auffüllleerzeichen zu entfernen.

# Strip trailing spaces from char columns
cursor.execute("SELECT ProductNumber FROM Production.Product")
for row in cursor:
    code = row.ProductNumber.rstrip()  # Remove trailing spaces
    print(f"Code: '{code}'")

Große Zeichenfolgen (MAX-Typen)

Die und-Typen nvarchar(max)varchar(max) unterstützen Strings bis zu 2 GB, ideal zum Speichern großer Textdokumente, JSON- oder XML-Inhalte.

# Large text content
large_content = "x" * 100000  # 100K characters

cursor.execute("""
    CREATE TABLE #Documents (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        Content NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #Documents (Content) VALUES (%(content)s)
""", {"content": large_content})

cursor.execute("SELECT Content FROM #Documents WHERE ID = 1")
row = cursor.fetchone()
print(len(row.Content))  # 100000

Saitenvergleich und Kollation

Das Vergleichsverhalten von Microsoft SQL-Strings hängt vom Sortierungsset in der Datenbank oder Spalte ab.

Groß- und Kleinschreibung

Der Vergleich von Microsoft SQL-Strings hängt von der Sortierung ab. Standardmäßig verwenden die meisten Datenbanken eine kleinschreibungsunsensitive Kollierung, aber man kann dies mit der Klausel COLLATE überschreiben.

# Case-insensitive collation (default for many databases)
cursor.execute("SELECT * FROM Person.Person WHERE LastName = %(name)s", {"name": "smith"})
# Might match 'Smith', 'SMITH', 'smith' depending on collation

# For case-sensitive comparison
cursor.execute("""
    SELECT * FROM Person.Person 
    WHERE LastName COLLATE Latin1_General_CS_AS = %(name)s
""", {"name": "Smith"})

Mustervergleich mit LIKE

Verwenden Sie den LIKE-Operator mit Wildcard-Zeichen, um nach Zeichenfolgenmustern zu suchen; maskieren Sie Sonderzeichen durch Klammernotation, um Literalzeichen abzugleichen.

# Wildcard searches
search_term = "Road"
cursor.execute("""
    SELECT Name FROM Production.Product WHERE Name LIKE %(pattern)s
""", {"pattern": f"%{search_term}%"})

# Escape special characters in search
def escape_like(value: str) -> str:
    """Escape LIKE wildcards in search value."""
    return value.replace("[", "[[]").replace("%", "[%]").replace("_", "[_]")

search = "100%"
cursor.execute("""
    SELECT Name FROM Production.Product WHERE Name LIKE %(pattern)s
""", {"pattern": f"%{escape_like(search)}%"})

Kodierungsüberlegungen

Das Codierungsverhalten hängt vom Typ der Microsoft-SQL-Spalte und der Quellkollektion ab.

Kodierungsannahmen und Unicode-Standardeinstellungen

Der Treiber mssql-python übernimmt die Codierung automatisch basierend auf dem Spaltentyp von Microsoft SQL. Standardmäßig werden String-Parameter als UTF-16LE für nvarchar-Spalten und gemäß der Datenbank-Sortierung für varchar-Spalten gesendet:

Spaltentyp Drahtkodierung Python-Ergebnis
nvarchar, nchar, ntext UTF-16LE str (entschlüsselt vom Fahrer)
varchar, char, text Datenbank- oder Spalten-Kodierung str (vom Treiber unter Verwendung der Quellkodierung decodiert)

Python-Strings sind intern immer Unicode. Wenn du einen Parameter str übergibst, kodiert der Treiber ihn für den Ziel-Spaltentyp. Standardmäßig sendet der Treiber String-Parameter als nvarchar (Unicode), was sicherstellt, dass Zeichen unabhängig von der Datenbank-Sortierung erhalten bleiben. Für varchar Spalten gilt UTF-8 nur, wenn die Datenbank oder Spalte eine UTF-8-fähige Sortierung verwendet.

Wenn Ihre Spalte den Typ varchar hat und Sie Nicht-Unicode-Daten senden müssen, damit sie genau dem Spaltentyp entsprechen (zum Beispiel, um Warnungen zu impliziten Konvertierungen zu vermeiden), verwenden Sie setinputsizes(), um die Standardeinstellung zu überschreiben:

import mssql_python

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

# Create temp table for demo
cursor.execute("CREATE TABLE #AsciiTable (Code VARCHAR(100))")

cursor.setinputsizes([(mssql_python.SQL_VARCHAR, 100, 0)])
cursor.execute(
    "INSERT INTO #AsciiTable (Code) VALUES (?)",
    ("ABC123",)
)
conn.commit()

Für die meisten Anwendungen ist das Standardverhalten korrekt. Überschreiben Sie nur, wenn Sie in Abfrageplänen Warnungen zu impliziten Konvertierungen sehen oder mit einer bestimmten varchar-Kollation übereinstimmen müssen.

Verbindungskodierung

Der mssql-python-Treiber übernimmt automatisch die Kodierung der Verbindung basierend auf der Microsoft SQL Server-Version und -Konfiguration. Da Python-Strings Unicode sind, kodiert der Treiber sie entsprechend (UTF-8 oder UTF-16) für den Zieldatentyp. Du musst die Verbindungscodierung nicht manuell konfigurieren.

VARCHAR-Spalten mit veralteten Kollationen

Datenbanken mit Windows-1252 (CP1252) Kollektionen, wie Latin1_General_CI_AS, speichern erweiterte lateinische Zeichen (zum Beispiel €, ™, und akzentuierte Zeichen) in varchar Spalten mit CP1252-Codierung. Der Fahrer dekodiert diese Zeichen auf allen Plattformen korrekt.

Dieser Unterschied ist für plattformübergreifende Bereitstellungen wichtig: Die gleichen varchar Daten, die auf Windows korrekt gelesen werden, lesen sich auch unter Linux korrekt, ohne dass eine spezielle Konfiguration erforderlich ist.

# Create a temp table with a varchar column and insert extended Latin characters
cursor.execute("CREATE TABLE #Products (Name VARCHAR(100))")
cursor.execute("INSERT INTO #Products (Name) VALUES (%(name)s)", {"name": "Café €100 ™"})
conn.commit()

# CP1252 characters in varchar columns are decoded correctly on all platforms
cursor.execute("SELECT Name FROM #Products WHERE Name LIKE '%€%'")
for row in cursor:
    print(row.Name)  # Correct on both Windows and Linux

Wenn dein Schema es zulässt, vermeidet das Migrieren varchar von Spalten auf nvarchar Kodierungsambiguität vollständig und unterstützt alle Unicode-Zeichen.

Dateicodierung

Beim Lesen von Dateien, die in die Datenbank eingefügt werden sollen, geben Sie die passende Codierung an, um Unicode-Inhalte zu erhalten.

# Reading files with explicit encoding
def insert_file_content(cursor, conn, file_path: str, encoding: str = "utf-8"):
    with open(file_path, "r", encoding=encoding) as f:
        content = f.read()
    
    cursor.execute(
        "INSERT INTO #FileContent (Content) VALUES (%(content)s)",
        {"content": content}
    )
    conn.commit()

Häufige Operationen mit Zeichenfolgen

Diese Beispiele behandeln gängige Stringmanipulationsmuster sowohl in Python als auch in SQL.

Verkettung

Du kannst Strings entweder in Python vor dem Einfügen oder mit den SQL-String-Operatoren auf dem Server aneinanderreihen.

# Concatenate in Python before insert
first_name = "Alice"
last_name = "Smith"
full_name = f"{first_name} {last_name}"

cursor.execute("""
    CREATE TABLE #ConcatDemo (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        FullName NVARCHAR(200)
    )
""")
cursor.execute(
    "INSERT INTO #ConcatDemo (FullName) VALUES (%(name)s)",
    {"name": full_name}
)

# Or concatenate in SQL
cursor.execute("""
    SELECT FirstName + ' ' + LastName AS FullName FROM Person.Person
""")

Zeichenfolgenformatierung

Formatieren Sie in Python, um Strings mit Währung, Padding oder Ausrichtung anzuzeigen, bevor Sie sie den Nutzern zeigen.

from decimal import Decimal

# Format for display
cursor.execute("SELECT Name, ListPrice FROM Production.Product WHERE ListPrice > 0")
for row in cursor.fetchall()[:5]:
    print(f"{row.Name}: ${row.ListPrice:.2f}")

# Pad strings
cursor.execute("SELECT ProductNumber FROM Production.Product")
for row in cursor.fetchall()[:5]:
    padded = row.ProductNumber.ljust(15)  # Left-justify, pad to 15 chars
    print(f"[{padded}]")

NULL versus leere Zeichenfolge

Microsoft SQL behandelt NULL und leere Zeichenkette ('') als unterschiedliche Werte. NULL bedeutet "unbekannt", während leere Zeichenkette "bekannt als leer" bedeutet. Wähle eine Konvention für deine Bewerbung und bleib konsequent. Die meisten Anwendungen verwenden NULL für fehlende optionale Felder.

Das folgende Beispiel zeigt, wie man zwischen NULL und leerer Zeichenkette unterscheiden kann:

# NULL is different from empty string
cursor.execute("""
    CREATE TABLE #NullDemo (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        Name NVARCHAR(100),
        MiddleName NVARCHAR(100)
    )
""")
cursor.execute("""
    INSERT INTO #NullDemo (Name, MiddleName) 
    VALUES (%(name)s, %(middle)s)
""", {"name": "Alice", "middle": None})  # NULL

cursor.execute("""
    INSERT INTO #NullDemo (Name, MiddleName) 
    VALUES (%(name)s, %(middle)s)
""", {"name": "Bob", "middle": ""})  # Empty string

# Query differences
cursor.execute("SELECT * FROM #NullDemo WHERE MiddleName IS NULL")
cursor.execute("SELECT * FROM #NullDemo WHERE MiddleName = ''")

Trimmoperationen

Verwenden Sie die String-Methoden von Python, um führenden, nachgestellten oder beiderseitigen Leerraum aus Werten zu entfernen, die aus der Datenbank abgerufen wurden.

cursor.execute("SELECT Name FROM Production.Product")
for row in cursor:
    # Remove whitespace
    trimmed = row.Name.strip()  # Both ends
    left_trimmed = row.Name.lstrip()
    right_trimmed = row.Name.rstrip()

JSON-Stringdaten

Speichern Sie JSON-Dokumente in nvarchar(max)-Spalten und fragen Sie sie mit den JSON-Funktionen von Microsoft SQL ab.

Store JSON als nvarchar

Serialisiere Python-Wörterbücher zu JSON-Strings und füge sie in nvarchar-Spalten ein; hole sie ab und deserialisiere sie wieder in Python-Objekte.

import json

data = {"name": "Alice", "scores": [95, 87, 91], "active": True}
json_string = json.dumps(data)

cursor.execute("""
    CREATE TABLE #Configs (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        ConfigData NVARCHAR(MAX)
    )
""")
cursor.execute("""
    INSERT INTO #Configs (ConfigData) VALUES (%(data)s)
""", {"data": json_string})

# Retrieve and parse
cursor.execute("SELECT ConfigData FROM #Configs WHERE ID = 1")
row = cursor.fetchone()
config = json.loads(row.ConfigData)
print(config["name"])  # 'Alice'

Verwenden Sie Microsoft SQL JSON-Funktionen

Verwenden Sie die JSON-Funktionen von Microsoft SQL, um JSON-Daten direkt in Abfragen zu parsen und zu filtern, anstatt im Client-Code.

import json

data = {"name": "Alice", "scores": [95, 87, 91], "active": True}

cursor.execute("""
    CREATE TABLE #Configs (
        ID INT IDENTITY(1,1) PRIMARY KEY,
        ConfigData NVARCHAR(MAX)
    )
""")
cursor.execute(
    "INSERT INTO #Configs (ConfigData) VALUES (%(data)s)",
    {"data": json.dumps(data)}
)
conn.commit()

cursor.execute("""
    SELECT JSON_VALUE(ConfigData, '$.name') AS Name
    FROM #Configs
    WHERE JSON_VALUE(ConfigData, '$.active') = 'true'
""")
for row in cursor:
    print(row.Name)  # 'Alice'

Volltextsuche

Verwenden LIKE Sie für Mustererkennung oder aktivieren Sie einen Volltextindex für eine fortgeschrittenere Textsuche.

Volltextabfragen

Der LIKE Operator mit Wildcard-Mustern bietet eine einfache Alternative zur Volltextsuche, wenn kein Volltextindex verfügbar ist.

# Using CONTAINS (requires full-text index on the table)
cursor.execute("""
    SELECT JobTitle FROM HumanResources.Employee
    WHERE JobTitle LIKE %(search)s
""", {"search": "%Engineer%"})

# Pattern-based search as an alternative to full-text
cursor.execute("""
    SELECT Name FROM Production.Product
    WHERE Name LIKE %(search)s
""", {"search": "%Mountain%"})

Bewährte Methoden

Wenden Sie diese Richtlinien an, um Stringdaten korrekt über Sprachen und Kodierungen hinweg zu handhaben.

Verwenden Sie nvarchar für internationale Daten

Wenn du unsicher bist, ob eine Spalte Unicode enthalten könnte, benutze nvarchar. Die Speicherkosten sind moderat und verhindern Datenverlust durch Zeichenkonvertierung.

Das folgende Beispiel zeigt den Unterschied zwischen der Definition von Spalten für Unicode und nur ASCII-Daten:

-- Good: supports any language
CREATE TABLE #UserProfile (
    Name NVARCHAR(100),
    Bio NVARCHAR(MAX)
);

-- Limited: ASCII/Latin only
CREATE TABLE #UserProfileAscii (
    Name VARCHAR(100),
    Bio VARCHAR(MAX)
);

Zeichenkettenlänge überprüfen

Überprüfen Sie die Zeichenkettenlänge in Python vor dem Einfügen, um Trunkationsfehler zu vermeiden und den Benutzern aussagekräftige Fehlermeldungen zu geben.

def safe_insert(cursor, name: str, max_length: int = 100):
    """Insert with length validation."""
    if len(name) > max_length:
        raise ValueError(f"Name exceeds {max_length} characters")
    
    cursor.execute(
        "INSERT INTO #UserProfile (Name) VALUES (%(name)s)",
        {"name": name}
    )

Binär-Strings separat behandeln

Unterscheide zwischen Textstrings (Pythonstr, SQLnvarchar) und Binärdaten (Pythonbytes, SQLvarbinary), um Codierungsprobleme zu vermeiden.

binary_data = b'\x00\x01\x02'  # bytes - use varbinary
text_data = "Hello"            # str - use nvarchar

Verwandte Inhalte

  • Last updated on