XML dosyalarını okuma ve yazma

Genişletilebilir biçimlendirme dili (XML), verileri metin biçiminde biçimlendirmeye, depolamaya ve paylaşmaya yönelik bir işaretleme dilidir. Belgelerden rastgele veri yapılarına kadar değişen verileri seri hale getirmek için bir dizi kural tanımlar.

Azure Databricks otomatik şema çıkarımı ve evrimi, satır etiketi yapılandırması, XSD doğrulaması ve gibi from_xmlSQL ifadeleri dahil olmak üzere Apache Spark ile hem okuma hem de yazma için XML'yi destekler. Yerel XML desteği, harici JAR dosyaları gerektirmeden Auto Loader, read_files ve COPY INTO ile birlikte çalışır.

Prerequisites

XML dosya biçimi desteği Databricks Runtime 14.3 ve üzerini gerektirir.

Options

.option() ve .options()'ün DataFrameReader ve DataFrameWriter yöntemlerini XML veri kaynaklarını yapılandırmak için kullanın. Desteklenen seçeneklerin tam listesi için bkz DataFrameReader . XML seçenekleri ve DataFrameWriter XML seçenekleri.

XML kayıtlarını ayrıştırma

XML spesifikasyonu, iyi biçimlendirilmiş bir yapıyı zorunlu kılar. Ancak, bu belirtim hemen tablosal bir formata eşlenemez. rowTag DataFrame öğesine eşlenen XML öğesini belirtmek için Row seçeneğini belirtmeniz gerekir. rowTag öğesi en üst düzey structolur. öğesinin rowTag alt öğeleri, en üst düzey structalanının alanları haline gelir.

Bu kaydın şemasını belirtebilir veya otomatik olarak çıkarılmalarını sağlayabilirsiniz. Ayrıştırıcı yalnızca rowTag öğelerini incelediğinden, DTD ve dış varlıklar filtrelenir.

Aşağıdaki örneklerde farklı rowTag seçenekleri kullanılarak xml dosyasının şema çıkarımı ve ayrıştırılması gösterilmektedir:

Piton

xmlString = """
  <reviews>
    <review id="r001">
      <author>Alice</author>
      <rating>5</rating>
      <comment>Amazing stay, highly recommend!</comment>
    </review>
    <review id="r002">
      <author>Bob</author>
      <rating>4</rating>
      <comment>Great location, very comfortable</comment>
    </review>
  </reviews>"""

xmlPath = "/Volumes/<catalog>/<schema>/<volume>/reviews.xml"
dbutils.fs.put(xmlPath, xmlString, True)

Scala programlama dili

val xmlString = """
  <reviews>
    <review id="r001">
      <author>Alice</author>
      <rating>5</rating>
      <comment>Amazing stay, highly recommend!</comment>
    </review>
    <review id="r002">
      <author>Bob</author>
      <rating>4</rating>
      <comment>Great location, very comfortable</comment>
    </review>
  </reviews>"""
val xmlPath = "/Volumes/<catalog>/<schema>/<volume>/reviews.xml"
dbutils.fs.put(xmlPath, xmlString)

XML dosyasını rowTag seçeneğiyle "reviews" olarak okuyun:

Piton

df = spark.read.option("rowTag", "reviews").format("xml").load(xmlPath)
df.printSchema()
df.show(truncate=False)

Scala programlama dili

val df = spark.read.option("rowTag", "reviews").xml(xmlPath)
df.printSchema()
df.show(truncate=false)

SQL

SELECT * FROM read_files(
  '/Volumes/<catalog>/<schema>/<volume>/reviews.xml',
  format => 'xml',
  rowTag => 'reviews'
)

Çıktı:

root
|-- review: array (nullable = true)
| |-- element: struct (containsNull = true)
| | |-- _id: string (nullable = true)
| | |-- author: string (nullable = true)
| | |-- comment: string (nullable = true)
| | |-- rating: string (nullable = true)

+----------------------------------------------------------------------------------------+
|review                                                                                  |
+----------------------------------------------------------------------------------------+
|[{r001, Alice, Amazing stay, highly recommend!, 5}, {r002, Bob, Great location..., 4}] |
+----------------------------------------------------------------------------------------+

XML dosyasını rowTag ile "review" olarak okuyun:

Piton

df = spark.read.option("rowTag", "review").format("xml").load(xmlPath)
# Infers four top-level fields and parses `review` in separate rows:

Scala programlama dili

val df = spark.read.option("rowTag", "review").xml(xmlPath)
// Infers four top-level fields and parses `review` in separate rows:

SQL

SELECT * FROM read_files(
  '/Volumes/<catalog>/<schema>/<volume>/reviews.xml',
  format => 'xml',
  rowTag => 'review'
)

Çıktı:

root
|-- _id: string (nullable = true)
|-- author: string (nullable = true)
|-- comment: string (nullable = true)
|-- rating: string (nullable = true)

+----+------+--------------------------------+------+
|_id |author|comment                         |rating|
+----+------+--------------------------------+------+
|r001|Alice |Amazing stay, highly recommend! |5     |
|r002|Bob   |Great location, very comfortable|4     |
+----+------+--------------------------------+------+

XSD ile XML kayıtlarını doğrulama

İsteğe bağlı olarak her satır düzeyi XML kaydını bir XML Şema Tanımı (XSD) ile doğrulayabilirsiniz. Seçeneğinde rowValidationXSDPath XSD dosyası belirtilir. XSD, sağlanan veya çıkarılmış şemayı başka şekilde etkilemez. Doğrulamada başarısız olan bir kayıt "bozuk" olarak işaretlenir ve seçenek bölümünde açıklanan bozuk kayıt işleme modu seçeneğine göre işlenir.

XSDToSchema kullanarak bir XSD dosyasından Spark DataFrame şeması ayıklayabilirsiniz. Yalnızca basit, karmaşık ve sıra türlerini destekler ve yalnızca temel XSD işlevlerini destekler.

import org.apache.spark.sql.execution.datasources.xml.XSDToSchema
import org.apache.hadoop.fs.Path

val xsdPath = "/Volumes/<catalog>/<schema>/<volume>/reviews.xsd"
val xsdString = """<?xml version="1.0" encoding="UTF-8" ?>
  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="review">
      <xs:complexType>
        <xs:sequence>
          <xs:element name="author" type="xs:string" />
          <xs:element name="rating" type="xs:integer" />
          <xs:element name="comment" type="xs:string" />
        </xs:sequence>
        <xs:attribute name="id" type="xs:string" use="required" />
      </xs:complexType>
    </xs:element>
  </xs:schema>"""

dbutils.fs.put(xsdPath, xsdString, true)

val schema1 = XSDToSchema.read(xsdString)
val schema2 = XSDToSchema.read(new Path(xsdPath))

Aşağıdaki tabloda XSD veri türlerinin Spark veri türlerine dönüştürülmesi gösterilmektedir:

İç içe geçmiş XML ayrıştırma

Var olan bir DataFrame'deki dize değerine sahip sütunda yer alan XML verileri, şemayı ve ayrıştırılmış sonuçları yeni schema_of_xml sütunları olarak döndüren from_xml ve struct tarafından ayrıştırılabilir. schema_of_xml ve from_xml öğelerine bağımsız değişken olarak geçirilen XML verileri, iyi oluşturulmuş tek bir XML kaydı olmalıdır.

XML şeması

Spark şemasını bir XML dizesinden çıkarsamak için kullanın schema_of_xml . XML sütunlarını ayrıştırmak için sonucu from_xml öğesine iletin.

Söz dizimi: schema_of_xml(xmlStr [, options])

Sütun adlarının XML öğesi ve öznitelik adlarından türetildiği n dize alanı içeren bir yapının tanımını tutan bir STRING döndürür. Alan değerleri türetilmiş biçimlendirilmiş SQL türlerini barındırır.

from_xml

XML kayıtlarını içeren bir STRING sütununu bir yapıda ayrıştırmak için kullanın from_xml . Doğrudan bir şema sağlayın veya schema_of_xml çıktısını kullanın.

Söz dizimi: from_xml(xmlStr, schema [, options])

Şema tanımıyla eşleşen alan adlarını ve türlerini içeren bir yapı döndürür. Şema, içinde kullanıldığı gibi virgülle ayrılmış sütun adı ve veri türü çiftleri olarak tanımlanmalıdır, örneğin CREATE TABLE. Seçenekler bölümünde gösterilen çoğu seçenek aşağıdaki özel durumlar için geçerlidir:

• rowTag: Yalnızca bir XML kaydı olduğundan seçeneği rowTag geçerli değildir.
• mode (varsayılan: PERMISSIVE): Ayrıştırma sırasında bozuk kayıtlarla ilgilenmek için bir moda izin verir.
  • PERMISSIVE: Bozuk bir kayıtla karşılaştığında, hatalı biçimlendirilmiş dizeyi columnNameOfCorruptRecord tarafından yapılandırılan bir alana yerleştirir ve hatalı biçimlendirilmiş alanları null olarak ayarlar. Bozuk kayıtları tutmak için, kullanıcı tanımlı şemada columnNameOfCorruptRecord adlı bir dize türü alanı ayarlayabilirsiniz. Bir şemanın alanı yoksa, ayrıştırma sırasında bozuk kayıtları bırakır. Bir şema çıkarıldığında, bir çıktı şemasına örtük olarak bir columnNameOfCorruptRecord alanı ekler.
  • FAILFAST: Bozuk kayıtlarla karşılaştığında bir özel durum fırlatır.

Örnekler

Bir XML dize sütununu ayrıştırmak için, şemayı çıkarmak üzere schema_of_xml kullanın, ardından bunu from_xml öğesine geçirin:

Piton

from pyspark.sql.functions import from_xml, schema_of_xml, lit, col

xml_data = """
  <review id="r001">
    <author>Alice</author>
    <rating>5</rating>
    <comment>Amazing stay, highly recommend!</comment>
  </review>
"""

df = spark.createDataFrame([(1, xml_data)], ["review_id", "payload"])
schema = schema_of_xml(df.select("payload").limit(1).collect()[0][0])
parsed = df.withColumn("parsed", from_xml(col("payload"), schema))
parsed.printSchema()
parsed.show()

Scala programlama dili

import org.apache.spark.sql.functions.{from_xml, schema_of_xml, lit}

val xmlData = """
  <review id="r001">
    <author>Alice</author>
    <rating>5</rating>
    <comment>Amazing stay, highly recommend!</comment>
  </review>""".stripMargin

val df = Seq((1, xmlData)).toDF("review_id", "payload")
val schema = schema_of_xml(xmlData)
val parsed = df.withColumn("parsed", from_xml($"payload", schema))
parsed.printSchema()
parsed.show()

SQL'de satır içi XML'yi ayrıştırmak için:

SELECT from_xml('
  <review id="r001">
    <author>Alice</author>
    <rating>5</rating>
    <comment>Amazing stay, highly recommend!</comment>
  </review>',
  schema_of_xml('
  <review id="r001">
    <author>Alice</author>
    <rating>5</rating>
    <comment>Amazing stay, highly recommend!</comment>
  </review>')
);

XML ve DataFrame yapıları arasında dönüştürme

DataFrame ile XML arasındaki yapı farklılıkları nedeniyle, XML verilerinden DataFrame'a ve DataFrame'dan XML verilerine dönüştürmeye ilişkin bazı kurallar vardır. excludeAttribute seçeneğiyle özniteliklerin işlenmesinin devre dışı bırakılabileceğini unutmayın.

XML'den DataFrame'e dönüştürme

XML okurken Azure Databricks XML öğelerini ve özniteliklerini aşağıdaki kurallara göre DataFrame alanlarına eşler.

Öznitelikler, başlık ön ekine attributePrefixsahip alanlar olarak dönüştürülür.

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

Bu, aşağıdaki şemayı oluşturur:

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

Öznitelik(ler) veya alt öğe(ler) içeren bir öğedeki karakter verileri, valueTag alanına ayrıştırılır. Karakter verilerinin birden çok tekrarı varsa, valueTag alan bir array türe dönüştürülür.

<one>
  <two myTwoAttrib="BBBBB">two</two>
  some value between elements
  <three>three</three>
  some other value between elements
</one>

Bu, aşağıdaki şemayı oluşturur:

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

DataFrame'den XML'ye dönüştürme

XML'ye Bir DataFrame yazarken, DataFrame ve XML veri modelleri arasındaki farklar nedeniyle bazı iç içe geçmiş yapılar özel işleme gerektirir.

DataFrame, öğe türü de ArrayTypeolan bir ArrayType alan içeriyorsa, bunu XML'ye yazmak, XML dosyalarını yuvarlarken bulunmayan fazladan bir iç içe yerleştirme düzeyi oluşturur. Bu yalnızca XML dışından alınan DataFrame'leri etkiler; XML dosyalarını okumak ve yazmak özgün yapıyı korur.

Örneğin, aşağıdaki şemaya sahip bir DataFrame:

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

ve aşağıdaki veriler:

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

aşağıdaki XML çıkışını üretir:

<a>
  <item>aa</item>
</a>
<a>
  <item>bb</item>
</a>

içindeki DataFrame adlandırılmamış dizinin öğe adı seçeneğiyle arrayElementName belirtilir (Varsayılan: item).

Kurtarılan veri sütununu etkinleştirme

Kurtarılan veri sütunu, ETL sırasında veri kaybı yaşamamanızı sağlar. Kayıttaki bir veya daha fazla alan aşağıdaki sorunlardan birine sahip olduğundan ayrıştırılamayan verileri yakalar:

• Sağlanan şemada yok.
• Sağlanan şemanın veri türüyle eşleşmiyor.
• Sağlanan şemadaki alan adlarıyla büyük/küçük harf uyuşmazlığı var.

Kurtarılan veri sütunu, kurtarılan sütunları ve kaydın kaynak dosya yolunu içeren bir JSON belgesi olarak döndürülür.

Kurtarılan veri sütununu etkinleştirmek için, okuma sırasında rescuedDataColumn seçeneğini bir sütun adına ayarlayın:

Piton

df = spark.read.option("rescuedDataColumn", "_rescued_data").format("xml").load("/Volumes/<catalog>/<schema>/<volume>/reviews_xml")

Scala programlama dili

val df = spark.read.option("rescuedDataColumn", "_rescued_data").format("xml").load("/Volumes/<catalog>/<schema>/<volume>/reviews_xml")

SQL

SELECT * FROM read_files(
  '/Volumes/<catalog>/<schema>/<volume>/reviews_xml',
  format => 'xml',
  rowTag => 'review',
  rescuedDataColumn => '_rescued_data'
)

Kurtarılan veri sütunundan kaynak dosya yolunu kaldırmak için şunu ayarlayın:

spark.conf.set("spark.databricks.sql.rescuedDataColumn.filePath.enabled", "false")

XML ayrıştırıcısı kayıtları ayrıştırırken üç modu destekler: PERMISSIVE, DROPMALFORMEDve FAILFAST. rescuedDataColumn ile birlikte kullanıldığında, veri türü uyuşmazlıkları kayıtların DROPMALFORMED modunda atılmasına veya FAILFAST modunda hata oluşturmasına neden olmaz. Yalnızca bozuk kayıtlar (eksik veya yanlış biçimlendirilmiş XML) bırakılır veya hata oluşturur.

Otomatik Yükleyici ile şemayı çıkarsama ve geliştirme

Bu konu başlığı ve ilgili seçenekler hakkında ayrıntılı bilgi için bkz. Otomatik Yükleyicişema çıkarımı ve evrimini yapılandırma . Otomatik Yükleyici'yi, yüklenen XML verilerinin şemasını otomatik olarak algılayarak veri şemasını açıkça bildirmeden tabloları başlatmanıza ve yeni sütunlar kullanıma sunulduğunda tablo şemasını geliştirmenize olanak tanıyacak şekilde yapılandırabilirsiniz. Bu, şema değişikliklerini zaman içinde el ile izleme ve uygulama gereksinimini ortadan kaldırır.

Varsayılan olarak, Otomatik Yükleyici şema çıkarımı, tür uyuşmazlıkları nedeniyle şema evrimi sorunlarından kaçınmayı arar. Veri türlerini (JSON, CSV ve XML) kodlamamış biçimler için Otomatik Yükleyici, XML dosyalarındaki iç içe yerleştirilmiş alanlar da dahil olmak üzere tüm sütunları dize olarak çıkarsar. Apache Spark DataFrameReader şema çıkarımı için farklı bir davranış kullanır ve örnek verilere göre XML kaynaklarındaki sütunlar için veri türlerini seçer. Otomatik Yükleyici ile bu davranışı etkinleştirmek için cloudFiles.inferColumnTypes seçeneğini trueolarak ayarlayın.

Otomatik Yükleyici, verilerinizi işlerken yeni sütunların eklenmesini algılar. Otomatik Yükleyici yeni bir sütun algıladığında akış UnknownFieldException ile durur. Akışınız bu hatayı oluşturmadan önce, Otomatik Yükleyici en son mikro veri toplu işleminde şema çıkarımını gerçekleştirir ve şemanın sonuna yeni sütunları birleştirerek şema konumunu en son şemayla güncelleştirir. Mevcut sütunların veri türleri değişmeden kalır. Otomatik Yükleyici, seçeneğinde ayarladığınız şema evrimiiçin farklı modlarını destekler.

şema ipuçlarını kullanarak, bildiğiniz ve çıkarım yapılan bir şemada beklediğiniz şema bilgilerini zorunlu kılabilirsiniz. Sütunun belirli bir veri türünde olduğunu biliyorsanız veya daha genel bir veri türü (örneğin, tamsayı yerine çift) seçmek istiyorsanız, SQL şema belirtimi söz dizimini kullanarak sütun veri türleri için dize olarak rastgele sayıda ipucu sağlayabilirsiniz. Kurtarılan veri sütunu etkinleştirildiğinde, şemanın dışında bir durumda adlandırılan alanlar _rescued_data sütununa yüklenir. readerCaseSensitive seçeneğini false olarak ayarlayarak bu davranışı değiştirebilirsiniz; bu durumda Auto Loader verileri büyük/küçük harf duyarsız biçimde okur.

Usage

Aşağıdaki örneklerde Spark DataFrame API'sini ve SQL'i kullanarak XML dosyalarını okuma ve yazma işlemini göstermek için Wanderbricks veri kümesi kullanılır.

XML okuma ve yazma

Xml'de Wanderbricks incelemeleri yazmak ve bunları yeniden okumak için DataFrame API'sini kullanın.

Piton

# Write Wanderbricks reviews to XML
df = spark.read.table("samples.wanderbricks.reviews")
df.write \
  .format("xml") \
  .option("rootTag", "reviews") \
  .option("rowTag", "review") \
  .save("/Volumes/<catalog>/<schema>/<volume>/reviews.xml")

# Read the XML file back
df_read = spark.read \
  .format("xml") \
  .option("rowTag", "review") \
  .load("/Volumes/<catalog>/<schema>/<volume>/reviews.xml")
df_read.show()

Scala programlama dili

// Write Wanderbricks reviews to XML
val df = spark.read.table("samples.wanderbricks.reviews")
df.write
  .format("xml")
  .option("rootTag", "reviews")
  .option("rowTag", "review")
  .save("/Volumes/<catalog>/<schema>/<volume>/reviews.xml")

// Read the XML file back
val dfRead = spark.read
  .format("xml")
  .option("rowTag", "review")
  .xml("/Volumes/<catalog>/<schema>/<volume>/reviews.xml")
dfRead.show()

R

df <- loadDF("/Volumes/<catalog>/<schema>/<volume>/reviews.xml", source = "xml", rowTag = "review")
saveDF(df, "/Volumes/<catalog>/<schema>/<volume>/newreviews.xml", "xml", "overwrite")

Verileri okurken şemayı el ile belirtebilirsiniz:

Piton

from pyspark.sql.types import StructType, StructField, StringType, IntegerType

custom_schema = StructType([
    StructField("_id", StringType(), True),
    StructField("author", StringType(), True),
    StructField("rating", IntegerType(), True),
    StructField("comment", StringType(), True)
])
df = spark.read.options(rowTag='review').xml('/Volumes/<catalog>/<schema>/<volume>/reviews.xml', schema=custom_schema)
df.show()

Scala programlama dili

import org.apache.spark.sql.types.{StructType, StructField, StringType, IntegerType}

val customSchema = StructType(Array(
  StructField("_id", StringType, nullable = true),
  StructField("author", StringType, nullable = true),
  StructField("rating", IntegerType, nullable = true),
  StructField("comment", StringType, nullable = true)))
val df = spark.read.option("rowTag", "review").schema(customSchema).xml("/Volumes/<catalog>/<schema>/<volume>/reviews.xml")
df.show()

R

customSchema <- structType(
  structField("_id", "string"),
  structField("author", "string"),
  structField("rating", "integer"),
  structField("comment", "string"))

df <- loadDF("/Volumes/<catalog>/<schema>/<volume>/reviews.xml", source = "xml", schema = customSchema, rowTag = "review")
saveDF(df, "/Volumes/<catalog>/<schema>/<volume>/newreviews.xml", "xml", "overwrite")

SQL ile XML okuma ve yazma

XML dosyasından tablo oluşturmak için SQL DDL kullanın. Azure Databricks sütun türlerini otomatik olarak çıkarsar.

DROP TABLE IF EXISTS reviews;
CREATE TABLE reviews
USING XML
OPTIONS (path "/Volumes/<catalog>/<schema>/<volume>/reviews.xml", rowTag "review");
SELECT * FROM reviews;

DDL'de sütun adlarını ve türlerini de belirtebilirsiniz. Bu durumda şema otomatik olarak çıkarılmaz.

DROP TABLE IF EXISTS reviews;

CREATE TABLE reviews (_id string, author string, rating integer, comment string)
USING XML
OPTIONS (path "/Volumes/<catalog>/<schema>/<volume>/reviews.xml", rowTag "review");

COPY INTO kullanarak XML yükleme

Xml dosyalarını bulut depolama alanından Delta tablosuna yüklemek için kullanın COPY INTO .

DROP TABLE IF EXISTS reviews;
CREATE TABLE IF NOT EXISTS reviews;

COPY INTO reviews
FROM "/Volumes/<catalog>/<schema>/<volume>/reviews.xml"
FILEFORMAT = XML
FORMAT_OPTIONS ('mergeSchema' = 'true', 'rowTag' = 'review')
COPY_OPTIONS ('mergeSchema' = 'true');

Satır doğrulama ile XML okuma

rowValidationXSDPath Okurken her satırı bir XSD şemasına göre doğrulamak için seçeneğini kullanın.

Piton

df = (spark.read
    .format("xml")
    .option("rowTag", "review")
    .option("rowValidationXSDPath", xsdPath)
    .load("/Volumes/<catalog>/<schema>/<volume>/reviews.xml"))
df.printSchema()

Scala programlama dili

val df = spark.read
  .option("rowTag", "review")
  .option("rowValidationXSDPath", xsdPath)
  .xml("/Volumes/<catalog>/<schema>/<volume>/reviews.xml")
df.printSchema

SQL

SELECT * FROM read_files(
  '/Volumes/<catalog>/<schema>/<volume>/reviews.xml',
  format => 'xml',
  rowTag => 'review',
  rowValidationXSDPath => '/Volumes/<catalog>/<schema>/<volume>/reviews.xsd'
)

Otomatik Yükleyici ile XML Yükleme

Bulut depolamadaki XML dosyalarını otomatik şema çıkarımı ve şema evrimiyle bir Delta tablosuna sürekli olarak almak için Auto Loader'ı kullanın.

Piton

query = (spark.readStream
  .format("cloudFiles")
  .option("cloudFiles.format", "xml")
  .option("rowTag", "review")
  .option("cloudFiles.inferColumnTypes", True)
  .option("cloudFiles.schemaLocation", schemaPath)
  .option("cloudFiles.schemaEvolutionMode", "rescue")
  .load(inputPath)
  .writeStream
  .option("mergeSchema", "true")
  .option("checkpointLocation", checkPointPath)
  .trigger(availableNow=True)
  .toTable("reviews")
)

Scala programlama dili

val query = spark.readStream
  .format("cloudFiles")
  .option("cloudFiles.format", "xml")
  .option("rowTag", "review")
  .option("cloudFiles.inferColumnTypes", true)
  .option("cloudFiles.schemaLocation", schemaPath)
  .option("cloudFiles.schemaEvolutionMode", "rescue")
  .load(inputPath)
  .writeStream
  .option("mergeSchema", "true")
  .option("checkpointLocation", checkPointPath)
  .trigger(Trigger.AvailableNow())
  .toTable("reviews")

Ek kaynaklar

• Kitaplığı kullanarak spark-xml XML verilerini okuma ve yazma: Daha önce açık kaynak Spark XML kitaplığını kullanan kullanıcılar için eski tümleştirme kılavuzuna bakın.
• JSON dosyalarını okuma ve yazma: Verileriniz yarı yapılandırılmışsa ancak XML değilse, JSON daha basit bir biçimde benzer şema çıkarımı ve iç içe veri desteği sağlar.