Aller au contenu principal
Dernière mise à jour le

Lire et écrire des données XML à l'aide de la bibliothèque spark-xml

important

Cette documentation a été retirée et pourrait ne pas être mise à jour. Les produits, services ou technologies mentionnés dans ce contenu ne sont pas officiellement approuvés ou testés par Databricks.

Alternativement, la prise en charge native du format de fichier XML est disponible en Public Preview. Voir Lire et écrire des fichiers XML.

Cet article décrit comment lire et écrire un fichier XML en tant que source de données Apache Spark.

Exigences​

  1. Créez la bibliothèque spark-xml en tant que bibliothèque Maven. Pour la coordonnée Maven, spécifiez :

    • Databricks Runtime 7.x et versions supérieures : com.databricks:spark-xml_2.12:<release>

    Consultez les versions de spark-xml pour la dernière version de <release>.

  2. Installez la bibliothèque sur un cluster.

Exemple​

L'exemple de cette section utilise le fichier XML books.

  1. Récupérez le fichier XML des livres :

    Bash
    $ wget https://github.com/databricks/spark-xml/raw/master/src/test/resources/books.xml

  2. Téléchargez le fichier vers DBFS.

Lire et écrire des données XML​

SQL
/*Infer schema*/

CREATE TABLE books
USING xml
OPTIONS (path "dbfs:/books.xml", rowTag "book")

/*Specify column names and types*/

CREATE TABLE books (author string, description string, genre string, _id string, price double, publish_date string, title string)
USING xml
OPTIONS (path "dbfs:/books.xml", rowTag "book")

Options​

  • Lire l'article

    • path: Emplacement des fichiers XML. Accepte les expressions glob Hadoop standard.

    • rowTag: La balise de ligne à traiter comme une ligne. Par exemple, dans ce code XML <books><book><book>...</books>, la valeur serait book. La valeur par default est ROW.

    • samplingRatio: Taux d'échantillonnage pour l'inférence de schéma (0,0 à 1). default is 1. Les types possibles sont StructType, ArrayType, StringType, LongType, DoubleType, BooleanType, TimestampType et NullType, à moins que vous ne fournissiez un schéma.

    • excludeAttribute: Si les attributs doivent être exclus des éléments. La valeur par default est false.

    • nullValue: La valeur à traiter comme une valeur null. La valeur par default est "".

    • mode: Le mode pour gérer les enregistrements corrompus. default est PERMISSIVE.

      • PERMISSIVE:

        • Lorsqu'il rencontre un enregistrement corrompu, il définit tous les champs sur null et place la chaîne malformée dans un nouveau champ configuré par columnNameOfCorruptRecord.
        • Lorsqu'il rencontre un champ du mauvais type de données, il définit le champ incriminé sur null.

      • DROPMALFORMED: ignore les enregistrements corrompus.

      • FAILFAST: lève une exception lorsqu’il détecte des enregistrements corrompus.

    • inferSchema: si true, tente d'inférer un type approprié pour chaque colonne DataFrame résultante, comme un type booléen, numérique ou de date. Si false, toutes les colonnes résultantes sont de type chaîne de caractères. La valeur par default est true.

    • columnNameOfCorruptRecord: le nom du nouveau champ où les chaînes mal formées sont stockées. default est _corrupt_record.

    • attributePrefix: Le préfixe des attributs afin de différencier les attributs et les éléments. C'est le préfixe pour les noms de champ. default est _.

    • valueTag: Le tag utilisé pour la valeur lorsqu'il y a des attributs dans un élément qui n'a pas d'éléments enfants. default est _VALUE.

    • charset: default à UTF-8 mais peut être défini sur d'autres noms de jeu de caractères valides.

    • ignoreSurroundingSpaces: si les espaces blancs entourant les valeurs doivent être ignorés. La valeur par default est false.

    • rowValidationXSDPath: Chemin d'accès à un fichier XSD utilisé pour valider le XML de chaque ligne. Les lignes qui ne parviennent pas à valider sont traitées comme des erreurs d'analyse, comme ci-dessus. Le XSD n'affecte pas le schéma fourni ou inféré. Si le même chemin local n'est pas déjà visible sur les exécuteurs du cluster, alors le XSD et tout autre élément dont il dépend devraient être ajoutés aux exécuteurs Spark avec SparkContext.addFile. Dans ce cas, pour utiliser le XSD local /foo/bar.xsd, appelez addFile("/foo/bar.xsd") et transmettez "bar.xsd" en tant que rowValidationXSDPath.

  • Écriture

    • path: emplacement pour écrire des fichiers.
    • rowTag: La balise de ligne à traiter comme une ligne. Par exemple, dans ce code XML <books><book><book>...</books>, la valeur serait book. La valeur par default est ROW.
    • rootTag: La balise racine à traiter comme la racine. Par exemple, dans ce code XML <books><book><book>...</books>, la valeur serait books. La valeur par default est ROWS.
    • nullValue: La valeur à écrire null valeur. La valeur par default est la chaîne "null". Lorsque "null", il n'écrit pas d'attributs et d'éléments pour les champs.
    • attributePrefix: Le préfixe pour les attributs afin de différencier les attributs et les éléments. C'est le préfixe pour les noms de champ. default est _.
    • valueTag: Le tag utilisé pour la valeur lorsqu'il y a des attributs dans un élément qui n'a pas d'éléments enfants. default est _VALUE.
    • compression: Codec de compression à utiliser lors de l'enregistrement dans un fichier. Doit être le nom entièrement qualifié d'une classe implémentant org.apache.hadoop.io.compress.CompressionCodec ou l'un des noms courts insensibles à la casse (bzip2, gzip, lz4 et snappy). Par default, il n'y a pas de compression.

Prend en charge l'utilisation du nom raccourci ; Vous pouvez utiliser xml au lieu de com.databricks.spark.xml.

Prise en charge de XSD​

Vous pouvez valider des lignes individuelles par rapport à un schéma XSD à l'aide de rowValidationXSDPath.

Vous utilisez l'utilitaire com.databricks.spark.xml.util.XSDToSchema pour extraire un schéma de DataFrame Spark à partir de certains fichiers XSD. Il prend en charge uniquement les types simples, complexes et de séquence, uniquement les fonctionnalités XSD de base, et est expérimental.

Scala
import com.databricks.spark.xml.util.XSDToSchema
import java.nio.file.Paths

val schema = XSDToSchema.read(Paths.get("/path/to/your.xsd"))
val df = spark.read.schema(schema)....xml(...)

Analysez un XML imbriqué​

Bien que principalement utilisée pour convertir un fichier XML en DataFrame, vous pouvez également utiliser la méthode from_xml pour analyser le XML dans une colonne de type chaîne dans un DataFrame existant et l'ajouter comme nouvelle colonne avec les résultats analysés sous forme de struct avec :

Scala
import com.databricks.spark.xml.functions.from_xml
import com.databricks.spark.xml.schema_of_xml
import spark.implicits._

val df = ... /// DataFrame with XML in column 'payload'
val payloadSchema = schema_of_xml(df.select("payload").as[String])
val parsed = df.withColumn("parsed", from_xml($"payload", payloadSchema))
remarque

  • mode:

    • S'il est défini sur PERMISSIVE, default, le mode d'analyse utilise par défaut DROPMALFORMED. Si vous incluez une colonne dans le schéma de from_xml qui correspond à columnNameOfCorruptRecord, le mode PERMISSIVE génère des enregistrements mal formés pour cette colonne dans la structure résultante.
    • Si défini sur DROPMALFORMED, les valeurs XML qui ne sont pas analysées correctement donnent une valeur null pour la colonne. Aucune ligne n'est supprimée.

  • from_xml convertit les tableaux de chaînes contenant du XML en tableaux de structs analysées. Utilisez schema_of_xml_array au lieu de.

  • from_xml_string est une alternative à utiliser dans les UDF qui opère directement sur une chaîne de caractères au lieu d'une colonne.

Règles de conversion​

En raison des différences structurelles entre les DataFrames et le XML, il existe des règles de conversion des données XML en DataFrame et des données DataFrame en données XML. Vous pouvez désactiver le traitement des attributs avec l'option excludeAttribute.

Convertir XML en DataFrame​

  • Attributs : Les attributs sont convertis en champs avec le préfixe spécifié dans l'option attributePrefix. Si attributePrefix est _, le document

    XML
    <one myOneAttrib="AAAA">
        <two>two</two>
        <three>three</three>
    </one>

    produit le schéma :

    root
     |-- _myOneAttrib: string (nullable = true)
     |-- two: string (nullable = true)
     |-- three: string (nullable = true)

  • Si un élément a des attributs mais pas d'éléments enfants, la valeur de l'attribut est placée dans un champ séparé spécifié dans l'option valueTag. Si valueTag est _VALUE, le document

    XML
    <one>
        <two myTwoAttrib="BBBBB">two</two>
        <three>three</three>
    </one>

    produit le schéma :

    root
     |-- two: struct (nullable = true)
     |    |-- _VALUE: string (nullable = true)
     |    |-- _myTwoAttrib: string (nullable = true)
     |-- three: string (nullable = true)

Convertir un DataFrame en XML​

L'écriture d'un fichier XML à partir d'un DataFrame ayant un champ ArrayType avec son élément comme ArrayType aurait un champ imbriqué supplémentaire pour l'élément. Cela ne se produirait pas lors de la lecture et de l'écriture de données XML, mais lors de l'écriture d'un DataFrame lu à partir d'autres sources. Par conséquent, l'aller-retour en lecture et écriture de fichiers XML a la même structure, mais il est possible qu'un DataFrame lu à partir d'autres sources ait une structure différente lors de l'écriture.

Un DataFrame avec le schéma :

 |-- a: array (nullable = true)
 |    |-- element: array (containsNull = true)
 |    |    |-- element: string (containsNull = true)

et données :

+------------------------------------+
|                                   a|
+------------------------------------+
|[WrappedArray(aa), WrappedArray(bb)]|
+------------------------------------+

produit le fichier XML :

XML
<a>
  <item>aa</item>
</a>
<a>
  <item>bb</item>
</a>
Sur cette page