Fichier AvroAvro file

Apache Avro est un système de sérialisation de données.Apache Avro is a data serialization system. Avro fournit les éléments suivants :Avro provides:

  • Structures de données enrichies.Rich data structures.
  • Format de données binaire, rapide et compact.A compact, fast, binary data format.
  • Un fichier conteneur pour stocker les données persistantes.A container file, to store persistent data.
  • Appel de procédure distante (RPC).Remote procedure call (RPC).
  • Intégration simple avec les langages dynamiques.Simple integration with dynamic languages. La génération de code n’est pas nécessaire pour lire ou écrire des fichiers de données, ni pour utiliser ou implémenter des protocoles RPC.Code generation is not required to read or write data files nor to use or implement RPC protocols. Génération de code comme une optimisation facultative, qui mérite d’être implémentée uniquement pour les langages typés statiquement.Code generation as an optional optimization, only worth implementing for statically typed languages.

La source de données Avro prend en charge :The Avro data source supports:

  • Conversion de schéma : conversion automatique entre Apache Spark enregistrements SQL et Avro.Schema conversion: Automatic conversion between Apache Spark SQL and Avro records.
  • Partitionnement : lecture et écriture aisées de données partitionnées sans configuration supplémentaire.Partitioning: Easily reading and writing partitioned data without any extra configuration.
  • Compression : compression à utiliser lors de l’écriture de Avro sur le disque.Compression: Compression to use when writing Avro out to disk. Les types pris en charge sont uncompressed , snappy et deflate .The supported types are uncompressed, snappy, and deflate. Vous pouvez également spécifier le niveau de déflateur.You can also specify the deflate level.
  • Noms d’enregistrement : nom et espace de noms d’enregistrement en passant une carte de paramètres avec recordName et recordNamespace .Record names: Record name and namespace by passing a map of parameters with recordName and recordNamespace.

Consultez également lire et écrire des données de Avro de diffusion en continu.Also see Read and write streaming Avro data.

ConfigurationConfiguration

Vous pouvez modifier le comportement d’une source de données Avro à l’aide de différents paramètres de configuration.You can change the behavior of an Avro data source using various configuration parameters.

Pour ignorer les fichiers sans l' .avro extension lors de la lecture, vous pouvez définir le paramètre avro.mapred.ignore.inputs.without.extension dans la configuration Hadoop.To ignore files without the .avro extension when reading, you can set the parameter avro.mapred.ignore.inputs.without.extension in the Hadoop configuration. La valeur par défaut est false.The default is false.

spark.
  .sparkContext
  .hadoopConfiguration
  .set("avro.mapred.ignore.inputs.without.extension", "true")

Pour configurer la compression lors de l’écriture, définissez les propriétés Spark suivantes :To configure compression when writing, set the following Spark properties:

  • Codec de compression : spark.sql.avro.compression.codec .Compression codec: spark.sql.avro.compression.codec. Les codecs pris en charge sont snappy et deflate .Supported codecs are snappy and deflate. Le codec par défaut est snappy .The default codec is snappy.
  • Si le codec de compression est deflate , vous pouvez définir le niveau de compression avec : spark.sql.avro.deflate.level .If the compression codec is deflate, you can set the compression level with: spark.sql.avro.deflate.level. Le niveau par défaut est -1 .The default level is -1.

Vous pouvez définir ces propriétés dans la configuration du cluster Spark ou au moment de l’exécution à l’aide de spark.conf.set() .You can set these properties in the cluster Spark configuration or at runtime using spark.conf.set(). Par exemple :For example:

spark.conf.set("spark.sql.avro.compression.codec", "deflate")
spark.conf.set("spark.sql.avro.deflate.level", "5")

Types pris en charge pour la conversion de Avro-> Spark SQLSupported types for Avro -> Spark SQL conversion

Cette bibliothèque prend en charge la lecture de tous les types Avro.This library supports reading all Avro types. Il utilise le mappage suivant entre les types Avro et les types SQL Spark :It uses the following mapping from Avro types to Spark SQL types:

Type AvroAvro type Type SQL SparkSpark SQL type
booleanboolean BooleanTypeBooleanType
intint IntegerTypeIntegerType
longlong LongTypeLongType
floatfloat FloatTypeFloatType
doubledouble DoubleTypeDoubleType
octetsbytes BinaryTypeBinaryType
stringstring StringTypeStringType
enregistrementrecord StructTypeStructType
enumenum StringTypeStringType
tableauarray ArrayTypeArrayType
mapmap MapTypeMapType
fixefixed BinaryTypeBinaryType
unionunion Consultez les types d’Union.See Union types.

Types unionUnion types

La source de données Avro prend en charge les types de lecture union .The Avro data source supports reading union types. Avro considère les trois types suivants comme des union types :Avro considers the following three types to be union types:

  • union(int, long) correspond à LongType.union(int, long) maps to LongType.
  • union(float, double) correspond à DoubleType.union(float, double) maps to DoubleType.
  • union(something, null), où something est tout type Avro pris en charge.union(something, null), where something is any supported Avro type. Correspond au même type Spark SQL que celui de something , avec la nullable valeur true .This maps to the same Spark SQL type as that of something, with nullable set to true.

Tous les autres union types sont des types complexes.All other union types are complex types. Ils sont mappés à StructType où les noms de champs sont member0 , member1 , et ainsi de suite, conformément aux membres de union .They map to StructType where field names are member0, member1, and so on, in accordance with members of the union. Cela est cohérent avec le comportement lors de la conversion entre Avro et parquet.This is consistent with the behavior when converting between Avro and Parquet.

Types logiquesLogical types

La source de données Avro prend en charge la lecture des types logiques Avrosuivants :The Avro data source supports reading the following Avro logical types:

Type logique AvroAvro logical type Type AvroAvro type Type SQL SparkSpark SQL type
Datedate intint DateTypeDateType
l’horodateur-fraisagetimestamp-millis longlong TimestampTypeTimestampType
horodateur-microstimestamp-micros longlong TimestampTypeTimestampType
Décimaldecimal fixefixed DecimalTypeDecimalType
Décimaldecimal octetsbytes DecimalTypeDecimalType

Notes

La source de données Avro ignore les documents, les alias et les autres propriétés présents dans le fichier Avro.The Avro data source ignores docs, aliases, and other properties present in the Avro file.

Types pris en charge pour la conversion Avro de Spark SQL->Supported types for Spark SQL -> Avro conversion

Cette bibliothèque prend en charge l’écriture de tous les types SQL Spark dans Avro.This library supports writing of all Spark SQL types into Avro. Pour la plupart des types, le mappage entre les types Spark et les types Avro est simple (par exemple, est IntegerType converti en int ); Voici une liste des rares cas spéciaux :For most types, the mapping from Spark types to Avro types is straightforward (for example IntegerType gets converted to int); the following is a list of the few special cases:

Type SQL SparkSpark SQL type Type AvroAvro type Type logique AvroAvro logical type
ByteTypeByteType intint
ShortTypeShortType intint
BinaryTypeBinaryType octetsbytes
DecimalTypeDecimalType fixefixed Décimaldecimal
TimestampTypeTimestampType longlong horodateur-microstimestamp-micros
DateTypeDateType intint Datedate

Vous pouvez également spécifier le schéma Avro de sortie entier avec l’option avroSchema , afin que les types SQL Spark puissent être convertis en d’autres types Avro.You can also specify the whole output Avro schema with the option avroSchema, so that Spark SQL types can be converted into other Avro types. Les conversions suivantes ne sont pas appliquées par défaut et nécessitent le schéma Avro spécifié par l’utilisateur :The following conversions are not applied by default and require user specified Avro schema:

Type SQL SparkSpark SQL type Type AvroAvro type Type logique AvroAvro logical type
ByteTypeByteType fixefixed
StringTypeStringType enumenum
DecimalTypeDecimalType octetsbytes Décimaldecimal
TimestampTypeTimestampType longlong l’horodateur-fraisagetimestamp-millis

ExemplesExamples

Ces exemples utilisent le fichier épisodes. Avro .These examples use the episodes.avro file.

ScalaScala

// The Avro records are converted to Spark types, filtered, and
// then written back out as Avro records

val df = spark.read.format("avro").load("/tmp/episodes.avro")
df.filter("doctor > 5").write.format("avro").save("/tmp/output")

Cet exemple illustre un schéma Avro personnalisé :This example demonstrates a custom Avro schema:

import org.apache.avro.Schema

val schema = new Schema.Parser().parse(new File("episode.avsc"))

spark
  .read
  .format("avro")
  .option("avroSchema", schema.toString)
  .load("/tmp/episodes.avro")
  .show()

Cet exemple illustre les options de compression Avro :This example demonstrates Avro compression options:

// configuration to use deflate compression
spark.conf.set("spark.sql.avro.compression.codec", "deflate")
spark.conf.set("spark.sql.avro.deflate.level", "5")

val df = spark.read.format("avro").load("/tmp/episodes.avro")

// writes out compressed Avro records
df.write.format("avro").save("/tmp/output")

Cet exemple illustre les enregistrements Avro partitionnés :This example demonstrates partitioned Avro records:

import org.apache.spark.sql.SparkSession

val spark = SparkSession.builder().master("local").getOrCreate()

val df = spark.createDataFrame(
  Seq(
    (2012, 8, "Batman", 9.8),
    (2012, 8, "Hero", 8.7),
    (2012, 7, "Robot", 5.5),
    (2011, 7, "Git", 2.0))
  ).toDF("year", "month", "title", "rating")

df.toDF.write.format("avro").partitionBy("year", "month").save("/tmp/output")

Cet exemple illustre le nom et l’espace de noms de l’enregistrement :This example demonstrates the record name and namespace:

val df = spark.read.format("avro").load("/tmp/episodes.avro")

val name = "AvroTest"
val namespace = "org.foo"
val parameters = Map("recordName" -> name, "recordNamespace" -> namespace)

df.write.options(parameters).format("avro").save("/tmp/output")

PythonPython

# Create a DataFrame from a specified directory
df = spark.read.format("avro").load("/tmp/episodes.avro")

#  Saves the subset of the Avro records read in
subset = df.where("doctor > 5")
subset.write.format("avro").save("/tmp/output")

SQLSQL

Pour interroger des données Avro dans SQL, enregistrez le fichier de données sous la forme d’une table ou d’une vue temporaire :To query Avro data in SQL, register the data file as a table or temporary view:

CREATE TEMPORARY VIEW episodes
USING avro
OPTIONS (path "/tmp/episodes.avro")

SELECT * from episodes

NotebookNotebook

Le bloc-notes suivant montre comment lire et écrire des fichiers Avro.The following notebook demonstrates how to read and write Avro files.

Lire et écrire le bloc-notes des fichiers AvroRead and write Avro files notebook

Obtenir le notebookGet notebook