Fichier Avro

Avro est un système social basé sur des lignes qui peut utiliser le cadre de sérialisation des données développé par Apache Hadoop. Le fichier Avro est un fichier de données pouvant transporter la sérialisation des données pour sérialiser les données dans un format binaire compact. Le schéma sera au format JSON lorsque nous l'essayerons avec Apache MapReduce ; Ensuite, ces fichiers peuvent réserver les marqueurs lorsque nous avons d'énormes ensembles de données qui doivent être répartis en sous-ensembles. Il dispose également d'un fichier conteneur pour réserver des données prudentes qui peuvent facilement être lues et écrites ; il n'est pas nécessaire de faire une configuration supplémentaire.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Aperçu du fichier Avro

Le fichier Avro est un système de sérialisation de données qui peut fournir une grande structure de données et un format de données binaire compact et rapide. Il peut également disposer du fichier conteneur, qui peut transporter les données continues et utiliser les procédures RPC. De plus, grâce à son intégration simple, il peut être utilisé avec différents langages, de sorte que la création d'un nouveau code n'est pas nécessaire pour lire ou écrire les fichiers de données dans lesquels la création du code ne sera pas obligatoire. Il ne peut se déployer qu'avec des langages typés de manière rigide.

Normalement, il comporte deux segments : le premier est un schéma qui peut être volontaire, et le second est des données binaires. Ainsi, par exemple, supposons que nous voulions consulter le fichier avro à l'aide de l'éditeur de texte. Dans ce cas, nous pouvons visualiser les deux segments dans lesquels le premier segment contiendra les données qui ont commencé avec l'objet, et le deuxième segment contiendra les données lisibles et le type de fichier dont nous avons besoin. confirmez quel Bhoomi saura lire et écrire.

Configuration du fichier Avro

Voyons la configuration du fichier Avro, dans laquelle nous pouvons transformer les actions des fichiers de données Avro à l'aide de différents paramètres structurés.

Lorsque nous utilisons Hadoop,

• Si nous voulions configurer les fichiers avro, nous ne voulons pas obtenir le '. L'extension d'Avro au moment de la lecture des fichiers permet alors d'ajuster le paramètre en utilisant 'avro.mapred.ignore.inputs.without.extension', qui a false comme valeur par défaut.

• Pour ce qui précède, nous devons d'abord atteindre Spark, puis le contenu Spark, puis la configuration Hadoop, puis nous devons définir ("avro.mapred.ignore.inputs.without.extension", "true").

Lorsque nous essayons de configurer la compression, nous devons alors définir les propriétés suivantes,

• Le codec de compression – spark.sql.avro.compression.codec a un codec snappy et dégonfle dans lequel snappy est le codec par défaut.
• Si nous voulions définir le codec de compression sur deflate, alors nous devons ajuster le niveau de compression comme « spark.sql.avro.deflate.level », et il a « -1 » comme niveau par défaut.
• Nous pouvons également ajuster les éléments dans le cluster de l'étincelle, tels que

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

spark.conf.set("spark.sql.avro.deflate.level", "4").

Types de fichiers Avro

Il existe deux types de fichiers Avro,

1. Types primitifs

Il comprend null, booléen, int, long, double, octets et chaîne.

Schema: {"type": "null"}

2. Types complexes

• tableau :

{
"kind": "array"
"objects": "long"
}

• carte : les clés sont des chaînes

{
"kind": "map"
"values": "long"
}

• enregistrement :

{
"kind": "record",
"name": "---",
"doc": "---",
"area": [
{"name": "--", "type": "int"},
---
]
}

• énumération :

{
"kind": "enum",
"name": "---",
"doc": "---",
"symbols": ["--", "--"]
}

• corrigé : Il contient des octets non signés de 8 bits

{
"kind": "fixed",
"name": "---",
"size": in bytes
}

• union : les données seront égales au schéma

[
"null",
"string",
--
]

Exemples de fichier Avro

Voyons les exemples de fichiers avro avec schéma et sans schéma,

Exemple n°1

Fichier Avro utilisant le schéma :

import java.util.Properties
import java.io.InputStream
import com.boomi.execution.ExecutionUtil
import org.apache.avro.Schema;
import org.apache.avro.file.DataFileStream;
import org.apache.avro.generic.GenericDatumReader;
import org.apache.avro.generic.GenericRecord;
import org.apache.avro.io.DatumReader;
logger = ExecutionUtil.getBaseLogger();
for (int j = 0; j < dataContext.getDataCount(); j++) {
InputStream istm = dataContext.getStream(j)
Properties prop = dataContext.getProperties(j)
DatumReader<GenericRecord> datumReader = new GenericDatumReader<GenericRecord>();
DataFileStream<GenericRecord> dataFileStream = new DataFileStream<GenericRecord>(istm, datumReader);
Schema sche = dataFileStream.getSchema();
logger.info("Schema utilize for: " + sche);
GenericRecord rec = null;
while (dataFileStream.hasNext()) {
rec = dataFileStream.next(rec);
System.out.println(rec);
istm = new ByteArrayInputStream(rec.toString().getBytes('UTF-8'))
dataContext.storeStream(istm, prop)
}
}

Dans l'exemple ci-dessus dans lequel le schéma a été utilisé avec les fichiers avro, nous pouvons dire que c'est le script qui peut lire le fichier avro, et dans celui-ci, nous avons généré plus d'un document JSON. Nous avons importé les packages associés, défini le schéma et l'avons appelé en créant l'objet et en écrivant les données en JSON en utilisant le code comme indiqué dans le script ci-dessus.

Exemple n°2

Fichier Avro sans schéma :

import java.util.Properties
import java.io.InputStream
import com.boomi.execution.ExecutionUtil
import org.apache.avro.Schema;
import org.apache.avro.file.DataFileStream;
import org.apache.avro.generic.GenericDatumReader;
import org.apache.avro.generic.GenericRecord;
import org.apache.avro.io.DatumReader;
logger = ExecutionUtil.getBaseLogger();
String schemaString = '{"type":"record","name":"college","namespace":"student.avro",' +
'"fields":[{"name":"title","type":"string","doc":"college title"},{"name":"exam_date","type":"string","sub":"start date"},{"name":"teacher","type":"int","sub":"main charactor is the teacher in college"}]}'
for (int k = 0; k < dataContext.getDataCount(); k++) {
InputStream istm = dataContext.getStream(k)
Properties prop = dataContext.getProperties(k)
DatumReader<GenericRecord> datumReader = new GenericDatumReader<GenericRecord>();
DataFileStream<GenericRecord> dataFileStre= new DataFileStream<GenericRecord>(istm, datumReader);
Schema sche = Schema.parse(scheString)
logger.info("Schema used: " + sche);
GenericRecord rec = null;
while (dataFileStre.hasNext()) {
rec = dataFileStre.next(rec);
System.out.println(rec);
is = new ByteArrayInputStream(rec.toString().getBytes('UTF-8'))
dataContext.storeStream(is, prop)
}
}

In the above example, we have written an example of reading files without schema in which we have to understand that if we have not included the schema under the avro file, then we have to perform some steps for informing the interpreter how to explain binary avro data, we also need to generate the schema which has been utilizing, in which this example can avro schema with a different name. We can also set it on another path.

Conclusion

In this article, we have concluded that the avro file is a data file that can work with the data serialized system utilized by Apache Hadoop. It has an open-source platform; we have also seen the configuration of the data files and examples, which helps to understand the concept.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!