XML 파일 읽기 및 쓰기

중요합니다

이 기능은 공개 미리 보기 상태입니다.

XML(Extensible Markup Language)은 데이터를 텍스트 형식으로 서식 지정, 저장 및 공유하기 위한 태그 언어입니다. 문서에서 임의의 데이터 구조에 이르는 데이터를 직렬화하는 규칙 집합을 정의합니다.

Azure Databricks는 Apache Spark를 사용하여 XML 읽기 및 쓰기 모두를 지원하며, 자동 스키마 유추 및 진화, 행 태그 구성, XSD 유효성 검사, from_xml와 같은 SQL 식을 포함합니다. 네이티브 XML 지원은 외부 jar 파일 없이 Auto Loader, read_files, 및 COPY INTO와 함께 작동합니다.

사전 요구 사항

XML 파일 형식을 지원하려면 Databricks Runtime 14.3 이상이 필요합니다.

옵션

.option() 및 .options()의 DataFrameReader 및 DataFrameWriter 메서드를 사용하여 XML 데이터 원본을 구성합니다. 지원되는 옵션의 전체 목록은 XML 옵션 및 DataFrameReader XML 옵션을 참조 DataFrameWriter 하세요.

XML 레코드 구문 분석

XML 사양은 올바른 형식의 구조를 지정합니다. 그러나 이 사양은 테이블 형식에 즉시 매핑되지는 않습니다. rowTag DataFrame에 매핑되는 XML 요소를 나타내려면 Row 옵션을 지정해야 합니다. rowTag 요소가 최상위 struct가 됩니다. rowTag의 자식 요소는 최상위 struct의 필드가 됩니다.

이 레코드에 대한 스키마를 지정하거나 자동으로 유추할 수 있습니다. 파서는 rowTag 요소만 검사하므로 DTD와 외부 엔터티는 걸러집니다.

다음 예제에서는 다른 rowTag 옵션을 사용하여 XML 파일의 스키마 유추 및 구문 분석을 보여 줍니다.

파이썬

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)

스칼라

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)

다음과 같은 rowTag옵션을 사용하여 "reviews" XML 파일을 읽습니다.

파이썬

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

스칼라

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

출력:

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 파일을 다음과 같이 rowTag"review"읽습니다.

파이썬

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

스칼라

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

출력:

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를 사용하여 XML 레코드 유효성 검사

필요에 따라 XSD(XML 스키마 정의)를 통해 각 행 수준 XML 레코드의 유효성을 검사할 수 있습니다. XSD 파일이 옵션에 rowValidationXSDPath 지정됩니다. 그렇지 않으면 XSD가 제공되거나 유추된 스키마에 영향을 주지 않습니다. 유효성 검사에 실패한 레코드는 옵션 섹션에 설명된 손상된 레코드 처리 모드 옵션에 따라 "손상됨"으로 표시되고 처리됩니다.

XSDToSchema 사용하여 XSD 파일에서 Spark DataFrame 스키마를 추출할 수 있습니다. 단순, 복합 및 시퀀스 형식만 지원하며 기본 XSD 기능만 지원합니다.

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

다음 표에서는 XSD 데이터 형식을 Spark 데이터 형식으로 변환하는 방법을 보여 줍니다.

XSD 데이터 형식	Spark 데이터 형식
`boolean`	`BooleanType`
`decimal`	`DecimalType`
`unsignedLong`	`DecimalType(38, 0)`
`double`	`DoubleType`
`float`	`FloatType`
`byte`	`ByteType`
`short`, `unsignedByte`	`ShortType`
`integer`, `negativeInteger`, `nonNegativeInteger`, `nonPositiveInteger`, `positiveIntegerunsignedShort`	`IntegerType`
`long`, `unsignedInt`	`LongType`
`date`	`DateType`
`dateTime`	`TimestampType`
`Others`	`StringType`

중첩된 XML 구문 분석

기존 DataFrame의 문자열 값 열에 있는 XML 데이터는 schema_of_xml 및 from_xml을 사용하여 구문 분석할 수 있으며, 스키마와 구문 분석된 결과가 새로운 struct 열로 반환됩니다. XML 데이터는 인수 schema_of_xml 로 전달되며 from_xml 올바른 형식의 단일 XML 레코드여야 합니다.

XML 스키마

XML 문자열에서 Spark 스키마를 유추하는 데 사용합니다 schema_of_xml . 결과를 from_xml에 전달하여 XML 열을 구문 분석합니다.

구문: schema_of_xml(xmlStr [, options])

논쟁	필수	Description
`xmlStr`	Yes	올바른 형식의 단일 XML 레코드를 지정하는 STRING 식입니다.
`options`	No	`MAP<STRING,STRING>` 지시문을 명시하는 리터럴입니다.

XML 요소 및 속성 이름에서 파생된 열 이름을 가지는 문자열 필드 n개로 이루어진 구조체의 정의를 포함하는 STRING을 반환합니다. 필드 값은 파생 형식의 SQL 형식을 보유합니다.

from_xml

XML 레코드가 포함된 STRING 열을 구조체로 파싱하려면 from_xml을(를) 사용하세요. 스키마를 직접 제공하거나 schema_of_xml의 출력을 사용합니다.

구문: from_xml(xmlStr, schema [, options])

논쟁	필수	Description
`xmlStr`	Yes	올바른 형식의 단일 XML 레코드를 지정하는 STRING 식입니다.
`schema`	Yes	문자열 식 또는 `schema_of_xml` 함수 호출입니다.
`options`	No	지시문을 지정하는 `MAP<STRING,STRING>` 리터럴입니다.

스키마 정의와 일치하는 필드 이름 및 형식이 있는 구조체를 반환합니다. 스키마는 쉼표로 구분된 열 이름 및 데이터 형식 쌍(예: CREATE TABLE)으로 정의되어야 합니다. 옵션 섹션에 표시된 대부분의 옵션은 다음과 같은 예외에 적용됩니다.

rowTag: XML 레코드 rowTag 가 하나뿐이므로 이 옵션을 적용할 수 없습니다.
mode (기본값: PERMISSIVE): 구문 분석 중에 손상된 레코드를 처리하는 모드를 허용합니다.
- PERMISSIVE: 손상된 레코드를 만나면 잘못된 형식의 문자열을 columnNameOfCorruptRecord로 구성된 필드에 넣고, 잘못된 형식의 필드는 null로 설정합니다. 손상된 레코드를 유지하려면 사용자 정의 스키마에서 columnNameOfCorruptRecord 문자열 형식 필드를 설정할 수 있습니다. 스키마에 필드가 없으면 구문 분석 중에 손상된 레코드가 삭제됩니다. 스키마를 유추할 때 출력 스키마에 columnNameOfCorruptRecord 필드를 암시적으로 추가합니다.
- FAILFAST: 손상된 레코드를 발견하면 예외를 발생시킵니다.

예제

XML 문자열 열을 구문 분석하려면 schema_of_xml를 사용하여 스키마를 유추한 다음, 그 스키마를 from_xml에 전달합니다.

파이썬

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

스칼라

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에서 인라인 XML을 구문 분석하려면 다음을 수행합니다.

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과 DataFrame 구조 간 변환

DataFrame과 XML의 구조 차이로 인해 XML 데이터를 DataFrame로 변환하는 규칙과 DataFrame를 XML 데이터로 변환하는 규칙이 있습니다. 옵션 excludeAttribute으로 처리 특성을 사용하지 않도록 설정할 수 있습니다.

XML에서 DataFrame으로 변환

XML을 읽을 때 Azure Databricks 다음 규칙에 따라 XML 요소와 특성을 DataFrame 필드에 매핑합니다.

특성은 제목 접두사를 가진 필드로 변환됩니다 attributePrefix.

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

이렇게 하면 다음 스키마가 생성됩니다.

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

속성 또는 자식 요소를 포함하는 요소의 문자 데이터는 valueTag 필드로 구문 분석됩니다. 문자 데이터가 여러 번 발생하면 필드가 valueTag 형식으로 array 변환됩니다.

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

이렇게 하면 다음 스키마가 생성됩니다.

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에서 XML로 변환

DATAFrame을 XML에 쓸 때 특정 중첩된 구조는 DataFrame과 XML 데이터 모델 간의 차이로 인해 특별한 처리가 필요합니다.

DataFrame에 요소 형식도 ArrayType인 ArrayType 필드가 포함되어 있으면, 이를 XML로 쓸 때 XML 파일을 왕복 변환할 때는 존재하지 않는 추가 중첩 수준이 생성됩니다. 이는 XML 외부에서 원본이 된 DataFrame에만 영향을 줍니다. XML 파일을 읽고 쓰면 원래 구조가 유지됩니다.

예를 들어 다음 스키마가 있는 DataFrame이 있습니다.

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

및 다음 데이터:

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

는 다음 XML 출력을 생성합니다.

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

이름 없는 배열 DataFrame 의 요소 이름은 옵션 arrayElementName (기본값: item)으로 지정됩니다.

복구된 데이터 열 활성화

구조된 데이터 열은 ETL 중에 데이터가 손실되지 않도록 합니다. 레코드의 하나 이상의 필드에 다음 문제 중 하나가 있으므로 구문 분석되지 않은 모든 데이터를 캡처합니다.

제공된 스키마에 누락되었습니다.
제공된 스키마의 데이터 형식과 일치하지 않습니다.
제공된 스키마의 필드 이름과 대소문자가 일치하지 않는 부분이 있습니다.

구조된 데이터 열은 구조된 열과 레코드의 원본 파일 경로를 포함하는 JSON 문서로 반환됩니다.

복구 데이터 열을 사용 설정하려면 읽을 때 rescuedDataColumn 옵션을 열 이름으로 설정하세요:

파이썬

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

스칼라

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

복구된 데이터 열에서 원본 파일 경로를 제거하려면 다음을 설정합니다.

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

XML 파서는 레코드를 구문 분석할 때 세 가지 PERMISSIVEDROPMALFORMEDFAILFAST모드를 지원합니다. rescuedDataColumn과 함께 사용하면 데이터 형식 불일치로 인해 DROPMALFORMED 모드에서 레코드가 삭제되거나 FAILFAST 모드에서 오류가 throw되지 않습니다. 손상된 레코드(불완전하거나 형식이 잘못된 XML)만 제거되거나 오류를 발생시킵니다.

자동 로더를 사용하여 스키마 유추 및 발전

이 항목 및 적용 가능한 옵션에 대한 자세한 내용은 자동 로더스키마 유추 및 진화 구성을 참조하세요. 로드된 XML 데이터의 스키마를 자동으로 검색하도록 자동 로더를 구성하여 데이터 스키마를 명시적으로 선언하지 않고 테이블을 초기화하고 새 열이 도입될 때 테이블 스키마를 발전시킬 수 있습니다. 이렇게 하면 시간이 지남에 따라 스키마 변경 내용을 수동으로 추적하고 적용할 필요가 없습니다.

기본적으로 자동 로더 스키마 유추는 형식 불일치로 인한 스키마 진화 문제를 방지하려고 합니다. 데이터 형식(JSON, CSV 및 XML)을 인코딩하지 않는 형식의 경우 자동 로더는 XML 파일의 중첩 필드를 포함하여 모든 열을 문자열로 유추합니다. Apache Spark DataFrameReader 스키마 유추에 다른 동작을 사용하여 샘플 데이터를 기반으로 XML 원본의 열에 대한 데이터 형식을 선택합니다. 자동 로더에서 이 동작을 사용하도록 설정하려면 옵션 cloudFiles.inferColumnTypestrue설정합니다.

자동 로더는 데이터를 처리할 때 새 열의 추가를 검색합니다. 자동 로더가 새 열을 감지하면 스트림이 UnknownFieldException오류 코드와 함께 중지됩니다. 스트림이 이 오류를 throw하기 전에 자동 로더는 데이터의 최신 마이크로 배치에 대한 스키마 유추를 수행하고 스키마의 끝에 새 열을 병합하여 스키마 위치를 최신 스키마로 업데이트합니다. 기존 열의 데이터 형식은 변경되지 않은 상태로 유지됩니다. 자동 로더는 스키마 진화을 위해 옵션에서 설정한 다양한 모드를 지원합니다.

스키마 힌트를 사용하여 유추된 스키마에서 알고 예상하는 스키마 정보를 적용할 수 있습니다. 열이 특정 데이터 형식임을 알고 있거나 보다 일반적인 데이터 형식(예: 정수 대신 double)을 선택하려는 경우 SQL 스키마 사양 구문을 사용하여 열 데이터 형식에 대한 임의의 힌트 수를 문자열로 제공할 수 있습니다. 구조된 데이터 열을 사용하도록 설정하면 스키마가 아닌 경우 명명된 필드가 _rescued_data 열에 로드됩니다. 옵션을 readerCaseSensitive 설정하여 이 동작을 false변경할 수 있습니다. 이 경우 자동 로더는 대/소문자를 구분하지 않는 방식으로 데이터를 읽습니다.

Usage

다음 예제에서는 Wanderbricks 데이터 세트를 사용하여 Spark DataFrame API 및 SQL을 사용하여 XML 파일을 읽고 쓰는 방법을 보여 줍니다.

XML 읽기 및 쓰기

DataFrame API를 사용하여 Wanderbricks 검토를 XML에 쓰고 다시 읽습니다.

파이썬

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

스칼라

// 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")

데이터를 읽을 때 스키마를 수동으로 지정할 수 있습니다.

파이썬

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

스칼라

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을 사용하여 XML 읽기 및 쓰기

SQL DDL을 사용하여 XML 파일에서 테이블을 만듭니다. Azure Databricks 열 형식을 자동으로 유추합니다.

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

DDL에서 열 이름 및 형식을 지정할 수도 있습니다. 이 경우 스키마는 자동으로 유추되지 않습니다.

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 사용하여 XML 로드

클라우드 스토리지에서 델타 테이블로 XML 파일을 로드하는 데 사용합니다 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');

행 유효성 검사를 사용하여 XML 읽기

이 rowValidationXSDPath 옵션을 사용하여 읽는 동안 XSD 스키마에 대해 각 행의 유효성을 검사합니다.

파이썬

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

스칼라

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

자동 로더를 사용하여 XML 로드

자동 로더를 사용하여 자동 스키마 유추 및 진화를 통해 클라우드 스토리지에서 델타 테이블로 XML 파일을 지속적으로 수집합니다.

파이썬

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

스칼라

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

추가 리소스

라이브러리를 사용하여 spark-xml XML 데이터 읽기 및 쓰기: 이전에 오픈 소스 Spark XML 라이브러리를 사용한 사용자의 경우 레거시 통합 가이드를 참조하세요.
JSON 파일 읽기 및 쓰기: 데이터가 반구조적이지만 XML이 아닌 경우 JSON은 더 간단한 형식으로 유사한 스키마 유추 및 중첩된 데이터 지원을 제공합니다.

피드백

이 페이지가 도움이 되었나요?

Last updated on 2026-06-24