Pular para o conteúdo principal

Ler e gravar XML uso de dados na spark-xml biblioteca

important

Essa documentação foi descontinuada e pode não estar atualizada. O produto, serviço ou tecnologia mencionados em seu conteúdo não são oficialmente endossados ou testados pelo site Databricks.

O suporte ao formato de arquivo XML nativo está disponível como uma visualização pública. Consulte Ler e gravar arquivos XML.

Este artigo descreve como ler e gravar um arquivo XML como uma Apache Spark fonte de dados.

Requisitos​

  1. Crie a biblioteca spark-xml como uma biblioteca Maven. Para a coordenada Maven, especifique:

    • com.databricks:spark-xml_2.12:<release>

    Veja os lançamentos da spark-xml para obter a versão mais recente de <release>.

  2. Instale a biblioteca em um cluster.

Exemplo​

O exemplo nesta seção usa o arquivo XML do livro.

  1. Recupere o arquivo XML do livro:

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

  2. Faça o upload do arquivo para o DBFS.

Leia e grave dados 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")

Opções​

  • Ler

    • path: Localização dos arquivos XML. Aceita expressões padrão de globbing do Hadoop.

    • rowTag: A tag de linha a ser tratada como uma linha. Por exemplo, nesse XML <books><book><book>...</books>, o valor seria book. O padrão é ROW.

    • samplingRatio: Razão de amostragem para inferir o esquema (0,0 ~ 1). O padrão é 1. Os tipos possíveis são StructType, ArrayType, StringType, LongType, DoubleType, BooleanType, TimestampType e NullType, a menos que você forneça um esquema.

    • excludeAttribute: se os atributos dos elementos devem ser excluídos. O padrão é falso.

    • nullValue: O valor a ser tratado como um valor null. O padrão é "".

    • mode: O modo de lidar com registros corrompidos. O padrão é PERMISSIVE.

      • PERMISSIVE:

        • Quando encontra um registro corrompido, define todos os campos como null e coloca as cadeias de caracteres malformadas em um novo campo configurado por columnNameOfCorruptRecord.
        • Quando ele encontra um campo do tipo de dados errado, define o campo ofensivo como null.

      • DROPMALFORMED: ignora registros corrompidos.

      • FAILFAST: lança uma exceção quando detecta registros corrompidos.

    • inferSchemaSe true, tenta inferir um tipo apropriado para cada coluna DataFrame resultante, como um tipo booleano, numérico ou de data. Se false, todas as colunas resultantes serão do tipo strings. O padrão é true.

    • columnNameOfCorruptRecord: O nome do novo campo em que strings malformado é armazenado. O padrão é _corrupt_record.

    • attributePrefix: O prefixo dos atributos para diferenciar atributos e elementos. Esse é o prefixo para nomes de campo. O padrão é _.

    • valueTag: a tag usada para o valor quando há atributos em um elemento que não tem elementos secundários. O padrão é _VALUE.

    • charset: padrão para UTF-8, mas pode ser definido para outros nomes de charset válidos.

    • ignoreSurroundingSpaces: se os espaços em branco ao redor dos valores devem ou não ser ignorados. O padrão é falso.

    • rowValidationXSDPath: caminho para um arquivo XSD usado para validar o XML de cada linha. As linhas que falham na validação são tratadas como erros de análise, conforme descrito acima. De outra forma, o XSD não afeta o esquema fornecido ou inferido. Se o mesmo caminho local ainda não estiver visível no executor no clustering, o XSD e quaisquer outros dos quais ele dependa deverão ser adicionados ao executor Spark com SparkContext.addFile. Nesse caso, para usar o XSD /foo/bar.xsd local, chame addFile("/foo/bar.xsd") e passe "bar.xsd" como rowValidationXSDPath.

  • Gravar

    • path: Local para gravar arquivos.
    • rowTag: A tag de linha a ser tratada como uma linha. Por exemplo, nesse XML <books><book><book>...</books>, o valor seria book. O padrão é ROW.
    • rootTag: A etiqueta raiz a ser tratada como raiz. Por exemplo, nesse XML <books><book><book>...</books>, o valor seria books. O padrão é ROWS.
    • nullValue: O valor para escrever o valor null. O padrão são as cadeias de caracteres "null". Quando "null", ele não escreve atributos e elementos para campos.
    • attributePrefix: O prefixo dos atributos para diferenciar atributos e elementos. Esse é o prefixo para nomes de campo. O padrão é _.
    • valueTag: a tag usada para o valor quando há atributos em um elemento que não tem elementos secundários. O padrão é _VALUE.
    • compression: codec de compressão a ser usado ao salvar em um arquivo. Deve ser o nome totalmente qualificado de uma classe que implementa org.apache.hadoop.io.compress.CompressionCodec ou um dos nomes curtos que não diferenciam maiúsculas de minúsculas (bzip2, gzip, lz4 e snappy). O padrão é sem compressão.

Suporta o uso de nomes abreviados; Você pode usar xml em vez de com.databricks.spark.xml.

Suporte XSD​

Você pode validar linhas individuais em um esquema XSD usando rowValidationXSDPath.

O senhor usa as utilidades com.databricks.spark.xml.util.XSDToSchema para extrair um esquema Spark DataFrame de alguns arquivos XSD. Ele suporta apenas tipos simples, complexos e de sequência, apenas funcionalidades básicas de XSD, e é experimental.

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(...)

Analisar XML aninhado​

Embora seja usado principalmente para converter um arquivo XML em um DataFrame, o senhor também pode usar o método from_xml para analisar XML em uma coluna com valor de cadeia de caracteres em um DataFrame existente e adicioná-lo como uma nova coluna com resultados analisados como uma estrutura com:

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))
nota

  • mode:

    • Se for definido como PERMISSIVE, o default, o modo de análise terá como padrão DROPMALFORMED. Se você incluir uma coluna no esquema para from_xml que corresponda a columnNameOfCorruptRecord, o modo PERMISSIVE exibirá registros malformados para essa coluna na estrutura resultante.
    • Se definido como DROPMALFORMED, os valores XML que não são analisados corretamente resultam em um valor null para a coluna. Nenhuma linha é descartada.

  • from_xml converte matrizes de strings contendo XML em matrizes de structs analisadas. Em vez disso, use schema_of_xml_array.

  • from_xml_string é uma alternativa para uso em UDFs que operam diretamente em uma cadeia de caracteres em vez de uma coluna.

Regras de conversão​

Devido às diferenças estruturais entre DataFrames e XML, existem algumas regras de conversão de dados XML para DataFrame e de DataFrame para dados XML. Você pode desativar o tratamento de atributos com a opção excludeAttribute.

Converter XML em DataFrame​

  • Atributos: os atributos são convertidos como campos com o prefixo especificado na opção attributePrefix. Se attributePrefix for _, o documento

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

    produz o esquema:

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

  • Se um elemento tiver atributos, mas nenhum elemento secundário, o valor do atributo será colocado em um campo separado especificado na opção valueTag. Se valueTag for _VALUE, o documento

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

    produz o esquema:

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

Converter DataFrame em XML​

A gravação de um arquivo XML a partir do DataFrame com um campo ArrayType com seu elemento como ArrayType teria um campo aninhado adicional para o elemento. Isso não aconteceria na leitura e gravação de dados XML, mas na gravação de um DataFrame lido de outras fontes. Portanto, a ida e volta na leitura e gravação de arquivos XML tem a mesma estrutura, mas a gravação de um DataFrame lido de outras fontes pode ter uma estrutura diferente.

Um DataFrame com o esquema:

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

e dados:

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

produz o arquivo XML:

XML
<a>
  <item>aa</item>
</a>
<a>
  <item>bb</item>
</a>
Última atualização em