Abflachungsfähigkeiten für verschachtelte Array-Strukturen mit mehrschichtigen Schichten in PYSPARK

In diesem Artikel wird eingehend untersucht, wie komplexes, mehrschichtiges verschachteltes Array (Struct (Array)) Strukturen in Array (struktur) in pyspark effizient abgeflacht werden kann. Durch die Kombination von Spark SQLs Transformation höherer Ordnung und Abflachungsfunktionen können wir innere Strukturfelder anmutig extrahieren und sie mit äußeren Feldern zusammenführen, letztendlich die Vereinfachung des Zielmusters erreichen, die Komplexität traditioneller Ausbeutungs- und Gruppenby-Kombinationen vermeiden und eine deklarative und skalierbare Lösung bieten.

Komplexe verschachtelte Strukturen und Ziele verstehen

Beim Umgang mit Big Data begegnen wir häufig Datenrahmen, die komplexe verschachtelte Datentypen enthalten. Ein gemeinsames Szenario ist eine Spalte, die eine Struktur des Typ -Arrays (Struktur (Array (struktur)))) wie:

 Wurzel
 |- a: Integer (nullable = true)
 |- Liste: Array (nullable = true)
 | |- Element: struct (enthältNull = true)
 | | |- b: Integer (nullable = true)
 | | |- sub_list: array (nullable = true)
 | | | |- Element: struct (enthältNull = true)
 | | | | |- c: Ganzzahl (nullable = true)
 | | | | |- foo: string (nullable = true)

Unser Ziel ist es, diese mehrschichtige Verschachtelungsstruktur in ein Array (Struct) -Form zu vereinfachen, dh die Felder C und Foo in sub_list in die Struktur in der Liste und die Verschachtelung von sub_list zu beseitigen:

 Wurzel
 |- a: Integer (nullable = true)
 |- Liste: Array (nullable = true)
 | |- Element: struct (enthältNull = true)
 | | |- b: Integer (nullable = true)
 | | |- c: Ganzzahl (nullable = true)
 | | |- foo: String (Nullierbar wahr)

Dieser Abflachungsprozess ist für die nachfolgende Datenanalyse und -verarbeitung von entscheidender Bedeutung.

Herausforderungen und Einschränkungen traditioneller Ansätze

Herkömmliche Abflachungsmethoden umfassen normalerweise die Exploit -Funktion, die jedes Element im Array in eine separate Zeile erweitert. Wenn Sie für die obige Struktur direkt Exploit verwenden, kann es mehrere Exploit -Operationen erfordern und dann über Groupby und Collect_List reaggieren, was angesichts tieferer Verschachtelung äußerst komplex und ineffizient werden kann. Obwohl die folgenden Methoden wirksam sind, sind sie in komplexen Szenarien teuer, wenn sie in komplexen Szenarien aufrechterhalten werden:

 von pyspark.sql import sparkaSession
von pyspark.sql.funktionen importieren inline, expr, sammeln Sie_list, struktur

# Angenommen, DF ist Ihr Datenrahmen
# df.select ("a", inline ("list") \
# .Select (expr ("*"), inline ("sub_list") \
# .drop ("sub_list") \
# .Groupby ("a") \
# .agg (sammel_list (struktur ("b", "c", "foo")). alias ("list"))

Dieser Ansatz erfordert, dass wir alle Nistniveaus auf die Zeilenebene "erhöhen" und dann aggregieren, was zu unserer erwarteten "Bottom-up "- oder" In-Place "-Transformationsphilosophie steht. Wir bevorzugen eine Lösung, die direkt in einem Array arbeiten kann, ohne die Anzahl der Datenframezeilen zu ändern.

PYSPARK -Lösung: Die Kombination von Transformation und Abflachung

PYSPARK 3.x führt Funktionen höherer Ordnung wie Transformationen ein, die die Verarbeitungsleistung komplexer Datentypen (insbesondere Arrays) erheblich verbessern. Durch die Kombination von Transformation und Abflachung können wir die oben genannten Probleme anmutig lösen.

Mit der Transformationsfunktion können wir eine benutzerdefinierte Transformationslogik auf jedes Element im Array anwenden und ein neues Array zurückgeben. Wenn es um mehrschichtige Verschachtelung geht, können wir verschachtelte Transformationen verwenden, um Schicht für Schicht zu verarbeiten.

Kernlogik :

1. Umwandlung für innere Ebenen : Verwandeln Sie zunächst die innerste Sub_List. Für jedes Element in sub_list (d. H. Eine Struktur, die C und Foo enthält) kombinieren wir es mit dem B -Feld in der äußeren Struktur, um eine neue abgeflachte Struktur zu erstellen.
2. Außenkonvertierung : Dieser Transformationsschritt erzeugt eine Array (Array (Struct)) Struktur.
3. Abflachen : Verwenden Sie schließlich die Flachfunktion, um die Struktur Array (Array (Struct)) in ein einzelnes Array (Struktur) zusammenzuführen.

Beispielcode :

Zunächst erstellen wir einen simulierten Datenrahmen, um zu demonstrieren:

 von pyspark.sql import sparkaSession
von pyspark.sql.funktionen import col, transformieren, flach, struktur
von pyspark.sql.types import Strukturtyp, structfield, ArrayType, IntegerType, StringType

# Initialisieren Sie SparkSession
Spark = SparkSession.builder.Appname ("FlattenNestedArrayStruct"). GetorCreate ()

# Definieren Sie das anfängliche Schema
Inner_struct_schema = structType ([[
    Structfield ("c", IntegerType (), wahr),
    Structfield ("foo", stringType (), true)
]))
OUTER_STRUCT_SCHEMA = STRUCTTYPE ([[
    Structfield ("b", IntegerType (), wahr),
    Structfield ("sub_list", arrayType (inner_struct_schema), true)
]))
df_schema = structType ([[
    Structfield ("a", IntegerType (), wahr),
    Structfield ("list", arrayType (outter_struct_schema), true)
]))

# Beispieldaten erstellen = [
    (1, [
        {"B": 10, "sub_list": [{"c": 100, "foo": "x"}, {"c": 101, "foo": "y"}]},
        {"B": 20, "sub_list": [{"c": 200, "foo": "z"}]}
    ]),,
    (2, [
        {"B": 30, "sub_list": [{"c": 300, "foo": "w"}]}
    ]))
]

DF = Spark.Createdataframe (Daten, Schema = df_schema)
df.printschema ()
df.show (truncate = false)

# Überflacher Logik anwenden DF_FLATTENED = df.withColumn (
    "Liste",
    flach (
        verwandeln(
            col ("Liste"), # äußeres Array (Array von Strukturen)
            Lambda X: Transform
                Lambda y: struct (x.getfield ("b"). alias ("b"), y.getfield ("c"). alias ("c"), y.getfield ("foo"). alias ("foo"),
            ),
        )
    ),
)

DF_FLATTENED.PRINTSCHEMA ()
df_flattened.show (truncate = false)

# Stop SparkSession
Spark.Stop ()

Code analysieren

1. df.withcolumn ("list", ...): Wir entscheiden, die List -Spalte so zu ändern, dass die abgeflachten Ergebnisse enthalten sind.
2. Transformation (col ("Liste"), Lambda X: ...): Dies ist die äußere Transformation. Es iteriert jedes Strukturelement in der List -Spalte, die wir als x nennen. Die Art von x ist struktur (b: int, sub_list: array (struktur (c: int, foo: string))).
3. Transformation (X.getfield ("sub_list"), lambda y: ...): Dies ist die innere Transformation. Es wirkt auf das Feld sub_list in x. sub_list ist ein Array, dessen Elemente (eine Struktur (C: int, foo: String)) Y genannt werden.
4. struct (x.getfield ("b"). alias ("b"), y.getfield ("c"). alias ("c"), y.getfield ("foo"). alias ("foo"): In der inneren Transformation bauen wir eine neue Struktur auf.
   • X.getfield ("B"): Holen Sie sich das B -Feld von der äußeren Struktur x.
   • Y.Getfield ("C"): Holen Sie sich das C -Feld aus der inneren Struktur y.
   • Y.Getfield ("Foo"): Holen Sie sich das Foo -Feld aus der inneren Struktur Y.
   • alias ("b"), alias ("c"), alias ("foo") werden verwendet, um sicherzustellen, dass der neu generierte Feldname korrekt ist. Diese Strukturfunktion erzeugt eine abgeflachte Struktur für jedes y -Element in sub_list. Daher ist das Ergebnis der inneren Transformation ein Array (Struktur (b: int, c: int, foo: string)).
5. Intermediate -Ergebnis : Die äußere Transformation sammelt alle diese Arrays (Struktur), sodass ihre endgültige Ausgabe ein Array ist (Array (Struktur (b: int, c: int, foo: string)).
6. Abflachen (...): Schließlich flacht die Flachfunktion die Struktur des Array (Array (struktur)) in ein einzelnes Array (Struktur (B: int, C: int, foo: String)), das genau das ist, was wir von einem Schema erwarten.

Notizen und Best Practices

• Feldname : Stellen Sie sicher, dass die in Getfield () und struct () verwendeten Feldnamen genau mit dem Namen im tatsächlichen Schema übereinstimmen.
• NULL VALIERVERBEITUNG : Die Transformationsfunktion verarbeitet natürlich leere Elemente im Array. Wenn sub_list leer ist, gibt die innere Transformation ein leeres Array zurück. Wenn die Liste leer ist, gibt die äußere Transformation auch ein leeres Array zurück. Abflachende Griffe leere Arrays ebenfalls sicher.
• Leistung : Transformation ist eine integrierte Funktion höherer Ordnung für Spark SQL, die normalerweise eine bessere Leistung hat als benutzerdefinierte UDFs (benutzerdefinierte Funktionen), da sie in Spark Catalyst Optimizer optimiert werden kann.
• Lesbarkeit : Während verschachtelte Transformationen sehr leistungsfähig sind, kann die Übersteuerung die Lesbarkeit des Codes verringern. Für komplexere Szenarien sollten Sie die Transformationslogik in mehrere Schritte aufteilen oder detaillierte Kommentare hinzufügen.
• Universalität : Dieses transformierende Flachmuster kann auf tiefere Niststrukturen verallgemeinert werden und nur das Nistnestniveau der Transformation erhöhen.

Zusammenfassen

Indem wir die Transformations- und Abflachungsfunktionen von Pyspark geschickt kombinieren, können wir komplexe mehrschichtige Array-Strukturen (Struct (Array (Struct))) in deklarative und effiziente Weise in leichter zu verarbeitende Array-Strukturen (Struct) -Strukturen verflachten. Dieser Ansatz vermeidet die Komplexität traditioneller Exploit- und Groupby -Kombinationen und eignet sich besonders für Szenarien, in denen fein transformierende Elemente innerhalb von Arrays erforderlich sind. Es ist ein sehr nützlicher Trick, wenn es sich um komplexe halbstrukturierte Daten in Spark befasst.

Das obige ist der detaillierte Inhalt vonAbflachungsfähigkeiten für verschachtelte Array-Strukturen mit mehrschichtigen Schichten in PYSPARK. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!