Avro-Datei

Avro ist ein zeilenbasiertes soziales System, das das von Apache Hadoop entwickelte Datenserialisierungs-Framework verwenden kann. Die Avro-Datei ist eine Datendatei, die die Datenserialisierung zum Serialisieren der Daten in einem kompakten Binärformat übertragen kann. Das Schema wird im JSON-Format vorliegen, wenn wir es mit Apache MapReduce ausprobieren; Dann können diese Dateien die Markierungen reservieren, wenn wir große Datensätze haben, die in Teilmengen verteilt werden müssen. Es verfügt außerdem über eine Containerdatei zum Reservieren vertraulicher Daten, die leicht gelesen und geschrieben werden können. Es ist keine zusätzliche Konfiguration erforderlich.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Übersichten über Avro File

Die Avro-Datei ist ein Datenserialisierungssystem, das eine große Datenstruktur und ein kompaktes, schnelles Binärdatenformat bereitstellen kann. Es kann auch über eine Containerdatei verfügen, die die kontinuierlichen Daten übertragen und die RPC-Prozeduren verwenden kann. Darüber hinaus kann es aufgrund der einfachen Integration mit verschiedenen Sprachen verwendet werden, sodass zum Lesen oder Schreiben der Datendateien, in denen die Erstellung des Codes nicht obligatorisch ist, keine neue Codeerstellung erforderlich ist. Es kann nur mit starr typisierten Sprachen bereitgestellt werden.

Normalerweise besteht es aus zwei Segmenten: Das erste ist ein Schema, das freiwillig sein kann, und das zweite sind Binärdaten. Angenommen, wir wollten die Avro-Datei mit dem Texteditor betrachten. In diesem Fall können wir das Zwei-Segment anzeigen, wobei das erste Segment die Daten enthält, die mit dem Objekt begonnen haben, und das zweite Segment Daten enthält, die gelesen werden können, und den Dateityp, den wir benötigen Bestätigen Sie, welcher Bhoomi lesen und schreiben kann.

Avro-Dateikonfiguration

Sehen wir uns die Konfiguration der Avro-Datei an, in der wir die Aktionen von Avro-Datendateien mithilfe verschiedener strukturierter Parameter umwandeln können.

Wenn wir Hadoop verwenden,

• Wenn wir die Avro-Dateien konfigurieren wollten, wollten wir das nicht erreichen. Die Erweiterung von Avro zum Zeitpunkt des Lesens der Dateien ermöglicht dann die Anpassung des Parameters mithilfe von „avro.mapred.ignore.inputs.without.extension“, dessen Standardwert „false“ ist.

• Für das oben Genannte müssen wir zuerst Spark erreichen, dann Spark Content, dann die Hadoop-Konfiguration und dann müssen wir festlegen („avro.mapred.ignore.inputs.without.extension“, „true“).

Wenn wir versuchen, die Komprimierung zu konfigurieren, müssen wir die folgenden Eigenschaften festlegen:

• Der Komprimierungscodec – spark.sql.avro.compression.codec – hat einen Snappy- und Deflates-Codec, wobei Snappy der Standardcodec ist.
• Wenn wir den Komprimierungscodec auf „deflate“ festlegen wollten, müssen wir die Komprimierungsstufe als „spark.sql.avro.deflate.level“ anpassen und sie hat „-1“ als Standardstufe.
• Wir können auch die Dinge im Cluster des Funkens anpassen, wie zum Beispiel

ein spark.conf.set („spark.sql.avro.compression.codec“, „deflate“)

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

Arten von Avro-Dateien

Es gibt zwei Arten von Avro-Dateien

1. Primitive Typen

Es umfasst null, Boolean, int, long, double, Bytes und String.

Schema: {"type": "null"}

2. Komplexe Typen

• Array:

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

• Karte: Schlüssel sind Zeichenfolgen

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

• Aufzeichnung:

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

• enum:

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

• behoben: Es hat 8-Bit-Bytes ohne Vorzeichen

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

• Union:Daten entsprechen dem Schema

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

Beispiele für Avro-Dateien

Sehen wir uns die Beispiele von Avro-Dateien mit Schema und ohne Schema an

Beispiel #1

Avro-Datei mit Schema:

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

Im obigen Beispiel, in dem das Schema mit den Avro-Dateien verwendet wurde, können wir sagen, dass dies das Skript ist, das die Avro-Datei lesen kann, und in diesem Fall haben wir mehr als ein JSON-Dokument generiert. Wir haben die zugehörigen Pakete importiert, das Schema festgelegt und es aufgerufen, indem wir das Objekt erstellt und die Daten mit dem im obigen Skript angegebenen Code in JSON geschrieben haben.

Beispiel #2

Avro-Datei ohne Schema:

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.

Das obige ist der detaillierte Inhalt vonAvro-Datei. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!