Parquet文件格式定义和数据写入

最新推荐文章于 2024-10-12 15:28:30 发布
最新推荐文章于 2024-10-12 15:28:30 发布
阅读量2.7k 收藏 7
点赞数
分类专栏： 大数据 # MapReduce 文章标签： hive big data hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swg321321/article/details/125395036
版权

文章目录

前言

Parquet文件存储的时候是以列存储的，数据格式支持List，Map，Struct，Decimal、基础数据类型(PrimitiveTypeInfo)。

pom.xml文件引入

<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-mapreduce-client-core</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-mapreduce-client-jobclient</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.hive</groupId>
    <artifactId>hive-jdbc</artifactId>
    <version>3.1.2</version>
</dependency>
<dependency>
    <groupId>org.apache.hive</groupId>
    <artifactId>hive-exec</artifactId>
    <version>3.1.2</version>
</dependency>

一、定义Parquet数据格式

Parquet数据类型分为基础数据类型和Group数据类型

1. 基础数据类型如下

void、boolean、int、bigint、string、char、varchar、float、double、tinyint、smallint、date、timestamp、interval_year_month、interval_day_time、binary、decimal。

2. Group数据类型

List、Map、Struct

3. 定义Parquet数据类型代码

详细实现和数据类型见 private static Type convertType(final String name, final TypeInfo typeInfo, final Repetition repetition)方法

package com.study.spark.mr.utils;

import org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe;
import org.apache.hadoop.hive.serde.serdeConstants;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.typeinfo.*;
import org.apache.parquet.schema.*;
import org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName;
import org.apache.parquet.schema.Type.Repetition;

import java.util.ArrayList;
import java.util.List;

/**
 * 定义Parquet Schema格式
 * GroupType是Type的子类
 */
public class ParquetDataSchema {

    public static MessageType convert(final List<String> columnNames, final List<TypeInfo> columnTypes) {
        final MessageType schema = new MessageType("hive_schema", convertTypes(columnNames, columnTypes));
        return schema;
    }

    private static Type[] convertTypes(final List<String> columnNames, final List<TypeInfo> columnTypes) {
        if (columnNames.size() != columnTypes.size()) {
            throw new IllegalStateException("Mismatched Hive columns and types. Hive columns names" +
                    " found : " + columnNames + " . And Hive types found : " + columnTypes);
        }
        final Type[] types = new Type[columnNames.size()];
        for (int i = 0; i < columnNames.size(); ++i) {
            types[i] = convertType(columnNames.get(i), columnTypes.get(i));
        }
        return types;
    }

    private static Type convertType(final String name, final TypeInfo typeInfo) {
        return convertType(name, typeInfo, Repetition.OPTIONAL);
    }

    private static Type convertType(final String name, final TypeInfo typeInfo, final Repetition repetition) {
        //是否是基础数据类型
        if (typeInfo.getCategory().equals(ObjectInspector.Category.PRIMITIVE)) {
            if (typeInfo.equals(TypeInfoFactory.stringTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.BINARY, repetition).as(OriginalType.UTF8)
                        .named(name);
            } else if (typeInfo.equals(TypeInfoFactory.intTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.INT32, repetition).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.shortTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.INT32, repetition)
                        .as(OriginalType.INT_16).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.byteTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.INT32, repetition)
                        .as(OriginalType.INT_8).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.longTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.INT64, repetition).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.doubleTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.DOUBLE, repetition).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.floatTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.FLOAT, repetition).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.booleanTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.BOOLEAN, repetition).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.binaryTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.BINARY, repetition).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.timestampTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.INT96, repetition).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.voidTypeInfo)) {
                throw new UnsupportedOperationException("Void type not implemented");
            } else if (typeInfo.getTypeName().toLowerCase().startsWith(
                    serdeConstants.CHAR_TYPE_NAME)) {
                return Types.optional(PrimitiveTypeName.BINARY).as(OriginalType.UTF8)
                        .named(name);
            } else if (typeInfo.getTypeName().toLowerCase().startsWith(
                    serdeConstants.VARCHAR_TYPE_NAME)) {
                return Types.optional(PrimitiveTypeName.BINARY).as(OriginalType.UTF8)
                        .named(name);
            } else if (typeInfo instanceof DecimalTypeInfo) {
                DecimalTypeInfo decimalTypeInfo = (DecimalTypeInfo) typeInfo;
                int prec = decimalTypeInfo.precision();
                int scale = decimalTypeInfo.scale();
                int bytes = ParquetHiveSerDe.PRECISION_TO_BYTE_COUNT[prec - 1];
                return Types.optional(PrimitiveTypeName.FIXED_LEN_BYTE_ARRAY).length(bytes).as(OriginalType.DECIMAL).
                        scale(scale).precision(prec).named(name);
            } else if (typeInfo.equals(TypeInfoFactory.dateTypeInfo)) {
                return Types.primitive(PrimitiveTypeName.INT32, repetition).as(OriginalType.DATE).named
                        (name);
            } else if (typeInfo.equals(TypeInfoFactory.unknownTypeInfo)) {
                throw new UnsupportedOperationException("Unknown type not implemented");
            } else {
                throw new IllegalArgumentException("Unknown type: " + typeInfo);
            }
        } else if (typeInfo.getCategory().equals(ObjectInspector.Category.LIST)) {
            return convertArrayType(name, (ListTypeInfo) typeInfo);
        } else if (typeInfo.getCategory().equals(ObjectInspector.Category.STRUCT)) {
            return convertStructType(name, (StructTypeInfo) typeInfo);
        } else if (typeInfo.getCategory().equals(ObjectInspector.Category.MAP)) {
            return convertMapType(name, (MapTypeInfo) typeInfo);
        } else if (typeInfo.getCategory().equals(ObjectInspector.Category.UNION)) {
            throw new UnsupportedOperationException("Union type not implemented");
        } else {
            throw new IllegalArgumentException("Unknown type: " + typeInfo);
        }
    }

    // An optional group containing a repeated anonymous group "bag", containing
    // 1 anonymous element "array_element"
    @SuppressWarnings("deprecation")
    private static GroupType convertArrayType(final String name, final ListTypeInfo typeInfo) {
        final TypeInfo subType = typeInfo.getListElementTypeInfo();
        return new GroupType(Repetition.OPTIONAL, name, OriginalType.LIST, new GroupType(Repetition.REPEATED,
                ParquetHiveSerDe.ARRAY.toString(), convertType("array_element", subType)));
    }

    // An optional group containing multiple elements
    private static GroupType convertStructType(final String name, final StructTypeInfo typeInfo) {
        final List<String> columnNames = typeInfo.getAllStructFieldNames();
        final List<TypeInfo> columnTypes = typeInfo.getAllStructFieldTypeInfos();
        return new GroupType(Repetition.OPTIONAL, name, convertTypes(columnNames, columnTypes));

    }

    // An optional group containing a repeated anonymous group "map", containing
    // 2 elements: "key", "value"
    private static GroupType convertMapType(final String name, final MapTypeInfo typeInfo) {
        final Type keyType = convertType(ParquetHiveSerDe.MAP_KEY.toString(),
                typeInfo.getMapKeyTypeInfo(), Repetition.REQUIRED);
        final Type valueType = convertType(ParquetHiveSerDe.MAP_VALUE.toString(),
                typeInfo.getMapValueTypeInfo());
        return ConversionPatterns.mapType(Repetition.OPTIONAL, name, keyType, valueType);
    }
}

4. 测试示例

示例代码

package com.study.spark.mr.utils;

import org.apache.hadoop.hive.serde2.typeinfo.*;
import org.apache.hadoop.security.UserGroupInformation;
import org.apache.parquet.example.data.simple.SimpleGroupFactory;
import org.apache.parquet.schema.GroupType;
import org.apache.parquet.schema.MessageType;
import org.apache.parquet.schema.PrimitiveType;
import org.apache.parquet.schema.Type;
import org.apache.spark.sql.hive.orc.OrcOutputWriter;

import java.util.ArrayList;
import java.util.List;

public class ParquetSchemaTest {

    public static void main(String[] args){
        ParquetSchemaTest test = new ParquetSchemaTest();

        test.messageType();
    }
    
    public void messageType(){
        MessageType messageType = parquetSchema();
        System.out.println("schema string = "+messageType.toString());
        println(messageType.getFields());

    }

    public void println(List<Type> types){
        for (Type type : types){
            System.out.println("type name = "+ type.getName());
            System.out.println("repetition type = "+ type.getRepetition().name());
            if(type.getOriginalType() != null){
                System.out.println("original type = " + type.getOriginalType().name());
            }
            //是否基础类型
           boolean primitive =  type.isPrimitive();
           if(primitive){
               System.out.println("primitive type name = "+type.asPrimitiveType().getName());
           }else {
              GroupType groupType = type.asGroupType();

              println(groupType.getFields());
           }
        }
    }

    public MessageType parquetSchema(){
        List<String> columnNames = new ArrayList<>();
        List<TypeInfo> columnTypes = new ArrayList<>();
        columnNames.add("name");
        columnTypes.add(TypeInfoFactory.stringTypeInfo);

        columnNames.add("age");
        columnTypes.add(TypeInfoFactory.intTypeInfo);

        columnNames.add("toatal");
        columnTypes.add(new DecimalTypeInfo(22,2));

        StructTypeInfo structTypeInfo = new StructTypeInfo();
        structTypeInfo.setAllStructFieldNames(new ArrayList<>(columnNames));
        structTypeInfo.setAllStructFieldTypeInfos(new ArrayList<>(columnTypes));
        columnNames.add("struct_test");
        columnTypes.add(structTypeInfo);

        MapTypeInfo mapTypeInfo = new MapTypeInfo();
        mapTypeInfo.setMapKeyTypeInfo(TypeInfoFactory.stringTypeInfo);
        mapTypeInfo.setMapValueTypeInfo(TypeInfoFactory.floatTypeInfo);
        columnNames.add("map_test");
        columnTypes.add(mapTypeInfo);

        ListTypeInfo listTypeInfo = new ListTypeInfo();
        listTypeInfo.setListElementTypeInfo(TypeInfoFactory.stringTypeInfo);
        columnNames.add("list_test");
        columnTypes.add(listTypeInfo);

        MessageType messageType = ParquetDataSchema.convert(columnNames,columnTypes);
        return messageType;
    }
}

测试结果

schema string = message hive_schema {
  optional binary name (UTF8);
  optional int32 age;
  optional fixed_len_byte_array(10) toatal (DECIMAL(22,2));
  optional group struct_test {
    optional binary name (UTF8);
    optional int32 age;
    optional fixed_len_byte_array(10) toatal (DECIMAL(22,2));
  }
  optional group map_test (MAP) {
    repeated group map (MAP_KEY_VALUE) {
      required binary key (UTF8);
      optional float value;
    }
  }
  optional group list_test (LIST) {
    repeated group bag {
      optional binary array_element (UTF8);
    }
  }
}

type name = name
repetition type = OPTIONAL
original type = UTF8
primitive type name = name
type name = age
repetition type = OPTIONAL
primitive type name = age
type name = toatal
repetition type = OPTIONAL
original type = DECIMAL
primitive type name = toatal
type name = struct_test
repetition type = OPTIONAL
type name = name
repetition type = OPTIONAL
original type = UTF8
primitive type name = name
type name = age
repetition type = OPTIONAL
primitive type name = age
type name = toatal
repetition type = OPTIONAL
original type = DECIMAL
primitive type name = toatal
type name = map_test
repetition type = OPTIONAL
original type = MAP
type name = map
repetition type = REPEATED
original type = MAP_KEY_VALUE
type name = key
repetition type = REQUIRED
original type = UTF8
primitive type name = key
type name = value
repetition type = OPTIONAL
primitive type name = value
type name = list_test
repetition type = OPTIONAL
original type = LIST
type name = bag
repetition type = REPEATED
type name = array_element
repetition type = OPTIONAL
original type = UTF8
primitive type name = array_element

二、将数据转为Parquet输出格式

1.转输出数据

package com.study.spark.mr.utils;

import org.apache.hadoop.hive.common.type.HiveDecimal;
import org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe;
import org.apache.hadoop.hive.ql.io.parquet.timestamp.NanoTimeUtils;
import org.apache.hadoop.hive.serde2.io.DateWritable;
import org.apache.parquet.example.data.Group;
import org.apache.parquet.io.api.Binary;
import org.apache.parquet.schema.MessageType;

import java.awt.*;
import java.sql.Date;
import java.sql.Timestamp;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class ParquetDataWrite {

    public static Boolean booleanDataWriter(Boolean val) {
        return val;
    }

    public static Integer byteDataWriter(byte val) {
        return new Integer(val);

    }

    public static Integer shortDataWriter(Short val) {
        return new Integer(val);
    }

    public static Integer intWriter(Integer val) {
        return val;
    }

    public static Long longWriter(Long val) {
        return val;
    }

    public static Float floatWriter(Float val) {
        return val;
    }

    public static Double doubleDataWriter(Double val) {
        return val;
    }

    public static Binary stringWriter(String val) {
        return Binary.fromString(val);
    }

    public static Binary varcharWriter(String val) {
        return Binary.fromString(val);
    }

    /**
     * 将byte[]数据转为Binary，用于写入
     */
    public static Binary binaryWrite(byte[] bytes) {
        return Binary.fromByteArray(bytes);
    }

    /**
     * 将时间戳Timestamp转为Binary，用于写入
     */
    public static Binary timestampWrite(Timestamp ts) {
        return NanoTimeUtils.getNanoTime(ts, false).toBinary();
    }

    /**
     * 将字符串Decimal数据转为Binary，用于写入使用
     *
     * @param val   数据值
     * @param prec  定义Decimal中的数据长度
     * @param scale 定义Decimal中小数点后面位数
     */
    public static Binary decimalWrite(String val, int prec, int scale) {
        HiveDecimal hiveDecimal = HiveDecimal.create(val);
        byte[] decimalBytes = hiveDecimal.bigIntegerBytesScaled(scale);

        // Estimated number of bytes needed.
        int precToBytes = ParquetHiveSerDe.PRECISION_TO_BYTE_COUNT[prec - 1];
        if (precToBytes == decimalBytes.length) {
            // No padding needed.
            return Binary.fromByteArray(decimalBytes);
        }

        byte[] tgt = new byte[precToBytes];
        if (hiveDecimal.signum() == -1) {
            // For negative number, initializing bits to 1
            for (int i = 0; i < precToBytes; i++) {
                tgt[i] |= 0xFF;
            }
        }

        System.arraycopy(decimalBytes, 0, tgt, precToBytes - decimalBytes.length, decimalBytes.length); // Padding leading zeroes/ones.
        return Binary.fromByteArray(tgt);
    }

    /**
     * 将Date数据类型转为Int
     */
    public static Integer dateWrite(Date date) {
        return Integer.valueOf(DateWritable.dateToDays(date));
    }

    /**
     * list 数据类型转为Group
     * @param group  主结构体
     * @param index 为当前数据在结构体中的位置，也可以传入字段名称
     * @param values  数组中的值，这里String只是示例，具体根据List立民安数据类型写入
     * @return
     */
    public static Group listWrite(Group group, int index,List<String> values){
        Group listGroup = group.addGroup(index);
        for(String v : values){
            Group bagGroup = listGroup.addGroup(0);
            bagGroup.add(0,v);
        }
        return group;
    }
    /**
     * map 数据类型转为Group
     * @param group  主结构体
     * @param index 为当前数据在结构体中的位置，也可以传入字段名称
     * @param values  map中Key和value只是示例，具体根据定义Map结构传入
     */
    public static Group mapWrite(Group group, int index, Map<String,String> values){
        Group mapGroup = group.addGroup(index);
        Iterator<String> iterable =  values.keySet().iterator();
        while (iterable.hasNext()){
            String key = iterable.next();
            String value = values.get(key);
           Group dataGroup =  mapGroup.addGroup(0);
           dataGroup.add("key",key);
           dataGroup.add("value",value);
        }
        return group;
    }

    /**
     * Struct 结构转为Group
     * @param group 主结构体
     * @param index 为当前数据在结构体中的位置，也可以传入字段名称
     * @param values 这里为示例，具体根据定义结构传入
     * @return
     */
    public static Group structWrite(Group group, int index,String[] values){
        Group structGroup =group.addGroup(index);
        for(int i = 0; i < values.length; i++){
            structGroup.add(i,values[i]);
        }
        return group;

    }

}

总结

  1. 在写入数据的时候Group数据类型中，传入参数只是一个示例。在这里面数据类型需要和定义的数据类型匹配。
swg321321
关注
专栏目录
用于大数据分析的数据存储格式：Parquet、Avro 和 ORC 的性能和成本影响
09-12 568
本文探讨了不同存储格式（特别是 Parquet、Avro 和 ORC）对 Google Cloud Platform （GCP） 上大数据环境中查询性能和成本的影响。本文提供了基准测试，讨论了成本影响，并提供了根据特定使用案例选择合适的格式的建议。在大数据生态系统中，Parquet 和 ORC 等列式格式以及 Avro 等基于行的格式因其针对特定类型的查询和处理任务的优化性能而被广泛使用。本研究的主要目的是评估不同的存储格式（Parquet、Avro、ORC）如何影响大数据环境中的查询性能和成本。
Parquet文件格式
fengfengzai0101的博客
12-06 2768
Parquet文件格式 Parquet文件格式包含一个header，多个blocks（row groups），一个footer。header仅仅包含4字节数字，表示这个文件是parquet格式。所有的文件元数据存储在footer中，文件元数据包含格式版本，schema，额外的key-value值，每个row group的元数据。footer还包含4字节文件元数据的编码长度，以及4字节的数字。 读...
Spark SQL数据源 - Parquet文件
lxq1145371298的博客
06-15 591
对于这种情况，Spark SQL读取Parquet数据源时可以自动检测并合并所有Parquet文件的Schema。导入SaveMode类后，执行命令：usersdf.select("name", "favorite_color").write.mode(SaveMode.Overwrite)parquet("hdfs://master:9000/result")加载和写入Parquet文件时，除了可以使用load()方法和save()方法外，还可以直接使用Spark SQL内置的parquet()方法。
对数据分析真的超实用！分享几款Python做数据分析必须掌握的三方库！
z_ipython的博客
09-07 1221
作为一个热爱编程和数据的程序员，数据分析这块内容也经常围绕在我的工作周围。今天就为大家分享3款，Python技术下数据分析经常会使用到的三个库。（非Pandas|Numpy）
Parquet数据格式
weixin_41227335的博客
11-07 1348
转自： https://www.cnblogs.com/ITtangtang/p/7681019.html
Parquet存储的数据模型以及文件格式
qq_31412425的博客
08-06 1029
本文主要参考文献：Tom White. Hadoop权威指南. 第4版. 清华大学出版社, 2017.pages 363.Aapche Parquet是一种能有效存储嵌套数据的列式存储格式，在Spark中应用较多。列式存储格式在文件大小和查询性能上表现优秀，在列式存储格式下，同一列的数据连续保存。一般来说，这种做法可以允许更高效的编码方式，从而使列式存储格式的文件常常比行式存储格式的同等文件占用更少的空间。
Parquet文件格式详解（含行、列式存储区别）
喻师傅的学习笔记
05-26 2266
行、列式文件存储详解，parquet文件详解
深入理解 Parquet 文件格式
最新发布
雨化于画
10-12 1329
例如，部门列中"市场部"和"技术部"重复多次，字典编码只需存储这些值一次，然后在实际数据中使用索引引用，大大提高了压缩效率。例如，如果年龄列中的值都在0到63之间，可以使用6位而不是标准的32位来表示每个值，从而显著降低数据存储的大小。在数据块（Row Group）中，数据按照列存储，每一列被称为列块（Column Chunk），进一步细分为多个页面（Page），便于数据的读取和缓存。因此，Parquet 格式采用列式存储方式，旨在解决行式存储的局限性，提升大数据处理的效率。
Parquet格式：Apache Parquet
02-03
Parquet-format项目包含所有Thrift定义，这些定义对于创建Parquet文件的读取器和写入器是必需的。 动机 我们创建Parquet是为了使Hadoop生态系统中的任何项目都可以使用压缩的，高效的列式数据表示形式。 Parquet是...
列存储格式数据模型及Parquet文件结构
a396683431的博客
01-09 611
列存储格式数据模型 1. 列式存储格式 1 Schema 每个schema的结构是这样的：根叫做message，message包含多个fields。每个field包含三个属性：repetition, type, name。repetition可以是以下三种：required（出现1次），optional（出现0次或者1次），repeated（出现0次或者多次）。type可以是一个group或者一个...
21、MapReduce读写SequenceFile、MapFile、ORCFile和ParquetFile文件
05-29
在Hadoop生态系统中，为了高效地存储和处理数据，有多种文件格式被设计出来，如SequenceFile、MapFile、ORCFile和ParquetFile。这些文件格式各有特点，适合不同的场景需求。 1. **SequenceFile** SequenceFile是...
old-data-import:将基于 parquet 的文件写入 HDFS 文件系统（在 Cloudera 上）并使用 Impala 进行访问
06-28
如果您添加其他数据文件，请不要忘记使用刷新 refresh ; 查看 使用显示压缩的镶木地板文件。 问题及解决方案 异常：引起：org.apache.hadoop.ipc.RemoteException：权限被拒绝 要访问集群的 HDFS 文件系统，当前...
Parquet 支持数据嵌套的列式数据存储格式
weixin_34116110的博客
06-17 191
2019独角兽企业重金招聘Python工程师标准>>> ...
大数据_Hadoop_Parquet数据格式详解
迎难而上
07-31 1872
之前有面试官问到了parquet的数据格式，下面对这种格式做一个详细的解读。
4.3Spark SQL数据源-Parquet文件
qq_65274143的博客
06-15 1448
Apache Parquet是Hadoop生态系统中任何项目都可以使用的列式存储格式，不受数据处理框架、数据模型和编程语言的影响。Spark SQL支持对Parquet文件的读写，并且可以自动保存源数据的Schema。当写入Parquet文件时，为了提高兼容性，所有列都会自动转换为“可为空”状态。
什么是parquet文件？
乔治大哥的博客
11-15 6405
Apache Parquet是Hadoop生态系统中任何项目均可使用的列式存储格式，而与选择数据处理框架，数据模型或编程语言无关。 parquet的起源： 我们创建Parquet是为了使Hadoop生态系统中的任何项目都可以使用压缩的，高效的列式数据表示形式。 Parquet是从头开始构建的，考虑了复杂的嵌套数据结构，并使用了Dremel论文中描述的记录粉碎和组装算法。我们相信这种方法...
Parquet文件格式问答
鸭梨的博客
04-15 2686
在Parquet文件格式中，行组（Row Group）是一个逻辑单位，用于组织一组行（Record）和多个列（Column）的数据。行组包含了多个列的数据页（Data Page）以及对应的定义页（Definition Page），它们具有相同的行数和行顺序，并且使用相同的压缩算法和编码方式进行压缩。行组的主要作用是将一个大的数据集划分为多个较小的块，以便于处理和存储。通过将数据分组为多个行组，可以提高数据读取和查询的效率，同时也可以降低内存和磁盘的使用量，从而更好地支持大规模数据处理和分析。
Parquet文件详解
weixin_42704604的博客
11-28 9690
Apache Parquet是Apache Hadoop生态系统的一种免费的开源面向列的数据存储格式。它类似于Hadoop中可用的其他列存储文件格式，如RCFile格式和ORC格式。本文将简单介绍一下Parquet文件的结构。数据首先写入文件，元数据最后写入单遍（single pass）写入。首先让我们看一下Parquet文件的格式，然后再看一下元数据。Parquet 的存储模型主要由行组（Row Group）、列块（Column Chuck）、页（Page）组成。
Parquet 文件结构与优势
天道酬勤
04-29 1989
一个 Parquet 文件的内容有 Header、Data Block 和 Footer 三个部分组成。 Header 每个 Parquet 的首尾各有一个大小为 4 bytes ，内容为 PAR1 的 Magic Number，用来标识这个文件是 Parquet 文件。 Data Block 中间的 Data Block 是具体存放数据的区域，由多个行组（Row Group）组成。行组 （Row Group），是按照行将数据在物理上分成多个单元，每一个行组包含一定的行数。比如一个文件有10000条.
如何使用avro创建parquet文件
04-24
您可以按照以下步骤使用avro创建parquet文件: 1. 定义一个avro schema，描述您要写入parquet文件的数据结构。 2. 使用avro库读入数据源（例如json或CSV文件），按照您定义的schema进行解析。您可以使用avro的代码生成器自动生成Java或其他语言的数据模型类。 3. 创建一个parquet writer对象，将数据写入parquet文件。您可以使用parquet-avro库将avro数据直接写入parquet，也可以使用parquet-mr库（Java）或其他类似库在不同语言中进行转换。 4. 在写入数据时，您可以指定压缩算法、列式存储等选项。 请注意，使用avro创建parquet文件需要一些编程经验和相关库的使用知识。如果您不熟悉这些工具，请参考官方文档或其他资源进行学习。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值