Kudu范围分区、Hash分区、多级分区

最新推荐文章于 2024-07-09 11:06:29 发布
最新推荐文章于 2024-07-09 11:06:29 发布
阅读量2.5k 收藏 5
点赞数
分类专栏： 大数据 文章标签： kudu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangyueranbbc/article/details/114298721
版权

范围分区：

 范围分区使用全序的范围分区键对数据行进行分配。(全序是指，集合中的任两个元素之间都可以比较的关系。比如实数中的任两个数都可以比较大小，那么“大小”就是实数集的一个全序关系。)
每个分区都是根据范围分区键分配的连续段。范围分区键必须是主键的子集。
如果表只存在范围分区，不存在散列分区，则每个分区恰好对应一个tablet。

/**
     * 预分区模式建表 范围分区
     *
     * @throws KuduException
     */
    @Test
    public void prePartitionCreateTable() throws KuduException {
        String prePartitionTableName = "prepartitiontable";
        if (!kuduClient.tableExists(prePartitionTableName)) {
            ArrayList<ColumnSchema> columnSchemas = new ArrayList<ColumnSchema>();
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("id", Type.INT32).key(true).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("name", Type.STRING).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("date", Type.INT32).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("money", Type.DOUBLE).build());
            Schema schema = new Schema(columnSchemas);

            CreateTableOptions options = new CreateTableOptions();
            //设置范围分区的分区规则
            List<String> parcols = new LinkedList<String>();
            parcols.add("id");
            //设置按照哪个字段进行range分区
            options.setRangePartitionColumns(parcols);
            // 范围分区
            /*
                RANGE (id) (
                    PARTITION 0 <= VALUES < 10,
                    PARTITION 10 <= VALUES < 20,
                    PARTITION 20 <= VALUES < 30,
                    PARTITION 30 <= VALUES < 40,
                    PARTITION 40 <= VALUES < 50,
                    PARTITION 50 <= VALUES < 60,
                    PARTITION 60 <= VALUES < 70,
                    PARTITION 70 <= VALUES < 80,
                    PARTITION 80 <= VALUES < 90
                )
             */
            int count = 0;
            for (int i = 1; i < 10; i++) {
                PartialRow lower = schema.newPartialRow();
                lower.addInt("id", count);
                PartialRow upper = schema.newPartialRow();
                count += 10;
                upper.addInt("id", count);
                options.addRangePartition(lower, upper);
            }

            // 设置副本数为3
            options.setNumReplicas(3);
            kuduClient.createTable(prePartitionTableName, schema, options);
        } else {
            kuduClient.deleteTable(prePartitionTableName);
        }
    }

 

Hash分区：

散列分区是根据hash值把行数据分配到某个buckets里面。如果只是一层hash，则一个bucket对应一个tablet。
buckets的数量是在创建表的时候指定的。
散列分区使用的分区列是主键列，同范围分区，可以使用主键列的任意子集做分区。
散列分区是一种高效的策略，当不需要要有序的访问表的时候。
散列分区对在tablet之间的随机写入非常有效，这样有助于缓解tablet的热点问题和数据分布不均匀的问题。

 /**
     * Hash分区方式建表
     *
     * @throws KuduException
     */
    @Test
    public void testCreateTable() throws KuduException {
        if (!kuduClient.tableExists(tableName)) {
            ArrayList<ColumnSchema> columnSchemas = new ArrayList<ColumnSchema>();
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("id", Type.INT32).key(true).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("name", Type.STRING).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("date", Type.INT32).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("money", Type.DOUBLE).build());
            Schema schema = new Schema(columnSchemas);

            CreateTableOptions options = new CreateTableOptions();
            List<String> hashKeys = new ArrayList<String>();
            //kudu表的分区字段是什么
            hashKeys.add("id");
            //按照id.hashcode % 分区数 = 分区号
            // 分区数
            int numBuckets = 8;
            // Hash分区
            options.addHashPartitions(hashKeys, numBuckets);
            // 设置副本数为3
            options.setNumReplicas(3);
            kuduClient.createTable(tableName, schema, options);
        } else {
            kuduClient.deleteTable(tableName);
        }
    }

 

 

多级分区：

  kudu允许在一个表中指定多级分区。零个或多个散列分区级别可以和可选的范围分区级别组合。多级分区与单个分区的区别是增加了约束条件，多级散列分区不能散列相同的列。(存在多级散列分区时候，各个散列分区计算散列值使用的列不能一样)如果使用正确，多级分区可以保留各个分区类型的好处，同时减少每个分区类型的缺点。多级分区表中的tablet总数是每个级别中分区数的乘积。

/**
     * 多级分区建表 Hash分区+范围分区
     *
     * @throws KuduException
     */
    @Test
    public void multilevelCreateTable() throws KuduException {
        String multilevelTableName = "multileveltable";
        if (!kuduClient.tableExists(multilevelTableName)) {
            ArrayList<ColumnSchema> columnSchemas = new ArrayList<ColumnSchema>();
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("id", Type.INT32).key(true).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("name", Type.STRING).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("date", Type.INT32).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("money", Type.DOUBLE).build());
            Schema schema = new Schema(columnSchemas);

            CreateTableOptions options = new CreateTableOptions();
            //设置范围分区的分区规则
            List<String> parcols = new LinkedList<String>();
            parcols.add("id");

            //按照id.hashcode % 分区数 = 分区号
            // 分区数
            int numBuckets = 3;
            // Hash分区
            options.addHashPartitions(parcols, numBuckets);
            //设置按照哪个字段进行range分区
            options.setRangePartitionColumns(parcols);

            // 范围分区
            int count = 0;
            for (int i = 1; i < 10; i++) {
                PartialRow lower = schema.newPartialRow();
                lower.addInt("id", count);
                PartialRow upper = schema.newPartialRow();
                count += 10;
                upper.addInt("id", count);
                options.addRangePartition(lower, upper);
            }

            /*
                HASH (id) PARTITIONS 3,
                RANGE (id) (
                    PARTITION 0 <= VALUES < 10,
                    PARTITION 10 <= VALUES < 20,
                    PARTITION 20 <= VALUES < 30,
                    PARTITION 30 <= VALUES < 40,
                    PARTITION 40 <= VALUES < 50,
                    PARTITION 50 <= VALUES < 60,
                    PARTITION 60 <= VALUES < 70,
                    PARTITION 70 <= VALUES < 80,
                    PARTITION 80 <= VALUES < 90
                )
             */

            // 设置副本数为3
            options.setNumReplicas(3);
            kuduClient.createTable(multilevelTableName, schema, options);
        } else {
            kuduClient.deleteTable(multilevelTableName);
        }
    }

 

代码仓库地址：

https://github.com/huangyueranbbc/KuduDemo

 

maven依赖：

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <log4j.version>2.9.1</log4j.version>
        <scala.version>2.11.12</scala.version>
        <spark.version>2.4.0.cloudera2</spark.version>
        <!--跳过单元测试 -->
        <maven.test.skip>true</maven.test.skip>
</properties>

 
<dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.kudu/kudu-client -->
        <dependency>
            <groupId>org.apache.kudu</groupId>
            <artifactId>kudu-client</artifactId>
            <version>1.14.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
        <!-- spark -->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-core -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-sql -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-sql -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.kudu/kudu-spark2 -->
        <dependency>
            <groupId>org.apache.kudu</groupId>
            <artifactId>kudu-spark2_2.11</artifactId>
            <version>1.10.0</version>
        </dependency>
    </dependencies>

 

运行代码：

package com.hyr.cn.kudu;

import org.apache.kudu.ColumnSchema;
import org.apache.kudu.Schema;
import org.apache.kudu.Type;
import org.apache.kudu.client.*;
import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

/*******************************************************************************
 * @date 2021-02-26 4:23 下午
 * @author: <a href=mailto:@>huangyr</a>
 * @Description: Kudu
 ******************************************************************************/
public class KuduDemo {

    private static final org.slf4j.Logger logger =
            org.slf4j.LoggerFactory.getLogger(KuduDemo.class);

    /*
        同步客户端，线程安全
     */
    private KuduClient kuduClient;
    /*
        异步客户端,只需要实例化一次
     */
    private AsyncKuduClient asyncKuduClient;

    private String tableName;

    @Before
    public void init() {
        // 创建kudu客户端
        tableName = "user";
        String kuduMaster = "server1:7051,server2:7051,server3:7051";
        KuduClient.KuduClientBuilder kuduClientBuilder = new KuduClient.KuduClientBuilder(kuduMaster);
        AsyncKuduClient.AsyncKuduClientBuilder asyncKuduClientBuilder = new AsyncKuduClient.AsyncKuduClientBuilder(kuduMaster);
        kuduClientBuilder.defaultAdminOperationTimeoutMs(10000);
        asyncKuduClientBuilder.defaultAdminOperationTimeoutMs(10000);
        asyncKuduClient = asyncKuduClientBuilder.build();
        kuduClient = kuduClientBuilder.build();
    }

    /**
     * Hash分区方式建表
     *
     * @throws KuduException
     */
    @Test
    public void testCreateTable() throws KuduException {
        if (!kuduClient.tableExists(tableName)) {
            ArrayList<ColumnSchema> columnSchemas = new ArrayList<ColumnSchema>();
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("id", Type.INT32).key(true).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("name", Type.STRING).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("date", Type.INT32).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("money", Type.DOUBLE).build());
            Schema schema = new Schema(columnSchemas);

            CreateTableOptions options = new CreateTableOptions();
            List<String> hashKeys = new ArrayList<String>();
            //kudu表的分区字段是什么
            hashKeys.add("id");
            //按照id.hashcode % 分区数 = 分区号
            // 分区数
            int numBuckets = 8;
            // Hash分区
            options.addHashPartitions(hashKeys, numBuckets);
            // 设置副本数为3
            options.setNumReplicas(3);
            kuduClient.createTable(tableName, schema, options);
        } else {
            kuduClient.deleteTable(tableName);
        }
    }

    /**
     * 预分区模式建表 范围分区
     *
     * @throws KuduException
     */
    @Test
    public void prePartitionCreateTable() throws KuduException {
        String prePartitionTableName = "prepartitiontable";
        if (!kuduClient.tableExists(prePartitionTableName)) {
            ArrayList<ColumnSchema> columnSchemas = new ArrayList<ColumnSchema>();
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("id", Type.INT32).key(true).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("name", Type.STRING).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("date", Type.INT32).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("money", Type.DOUBLE).build());
            Schema schema = new Schema(columnSchemas);

            CreateTableOptions options = new CreateTableOptions();
            //设置范围分区的分区规则
            List<String> parcols = new LinkedList<String>();
            parcols.add("id");
            //设置按照哪个字段进行range分区
            options.setRangePartitionColumns(parcols);
            // 范围分区
            /*
                RANGE (id) (
                    PARTITION 0 <= VALUES < 10,
                    PARTITION 10 <= VALUES < 20,
                    PARTITION 20 <= VALUES < 30,
                    PARTITION 30 <= VALUES < 40,
                    PARTITION 40 <= VALUES < 50,
                    PARTITION 50 <= VALUES < 60,
                    PARTITION 60 <= VALUES < 70,
                    PARTITION 70 <= VALUES < 80,
                    PARTITION 80 <= VALUES < 90
                )
             */
            int count = 0;
            for (int i = 1; i < 10; i++) {
                PartialRow lower = schema.newPartialRow();
                lower.addInt("id", count);
                PartialRow upper = schema.newPartialRow();
                count += 10;
                upper.addInt("id", count);
                options.addRangePartition(lower, upper);
            }

            // 设置副本数为3
            options.setNumReplicas(3);
            kuduClient.createTable(prePartitionTableName, schema, options);
        } else {
            kuduClient.deleteTable(prePartitionTableName);
        }
    }

    /**
     * 多级分区建表 Hash分区+范围分区
     *
     * @throws KuduException
     */
    @Test
    public void multilevelCreateTable() throws KuduException {
        String multilevelTableName = "multileveltable";
        if (!kuduClient.tableExists(multilevelTableName)) {
            ArrayList<ColumnSchema> columnSchemas = new ArrayList<ColumnSchema>();
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("id", Type.INT32).key(true).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("name", Type.STRING).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("date", Type.INT32).build());
            columnSchemas.add(new ColumnSchema.ColumnSchemaBuilder("money", Type.DOUBLE).build());
            Schema schema = new Schema(columnSchemas);

            CreateTableOptions options = new CreateTableOptions();
            //设置范围分区的分区规则
            List<String> parcols = new LinkedList<String>();
            parcols.add("id");

            //按照id.hashcode % 分区数 = 分区号
            // 分区数
            int numBuckets = 3;
            // Hash分区
            options.addHashPartitions(parcols, numBuckets);
            //设置按照哪个字段进行range分区
            options.setRangePartitionColumns(parcols);

            // 范围分区
            int count = 0;
            for (int i = 1; i < 10; i++) {
                PartialRow lower = schema.newPartialRow();
                lower.addInt("id", count);
                PartialRow upper = schema.newPartialRow();
                count += 10;
                upper.addInt("id", count);
                options.addRangePartition(lower, upper);
            }

            /*
                HASH (id) PARTITIONS 3,
                RANGE (id) (
                    PARTITION 0 <= VALUES < 10,
                    PARTITION 10 <= VALUES < 20,
                    PARTITION 20 <= VALUES < 30,
                    PARTITION 30 <= VALUES < 40,
                    PARTITION 40 <= VALUES < 50,
                    PARTITION 50 <= VALUES < 60,
                    PARTITION 60 <= VALUES < 70,
                    PARTITION 70 <= VALUES < 80,
                    PARTITION 80 <= VALUES < 90
                )
             */

            // 设置副本数为3
            options.setNumReplicas(3);
            kuduClient.createTable(multilevelTableName, schema, options);
        } else {
            kuduClient.deleteTable(multilevelTableName);
        }
    }


    /**
     * 插入数据
     *
     * @throws KuduException
     */
    @Test
    public void insert() throws KuduException {
        final KuduSession kuduSession = kuduClient.newSession();
        kuduSession.setFlushMode(SessionConfiguration.FlushMode.AUTO_FLUSH_SYNC);

        for (int i = 0; i <= 10000000; i++) {
            // 打开表
            KuduTable userTable = kuduClient.openTable(tableName);
            Insert insert = userTable.newInsert();
            PartialRow row = insert.getRow();
            row.addInt("id", i);
            row.addString("name", "wang" + i);
            row.addDouble("money", 100.342 + i);
            row.addInt("date", 20210225);
            kuduSession.apply(insert);
        }

        if (kuduSession.countPendingErrors() != 0) {
            // 是否错误溢出
            if (kuduSession.getPendingErrors().isOverflowed()) {
                logger.error("error collector had an overflow and had to discard row errors.");
            }
            RowError[] rowErrors = kuduSession.getPendingErrors().getRowErrors();
            for (RowError rowError : rowErrors) {
                logger.error("insert has error:{}", rowError);
            }
        }

        kuduSession.close();
    }

    /**
     * 查询
     *
     * @throws KuduException
     */
    @Test
    public void query() throws KuduException {
        KuduTable kuduTable = kuduClient.openTable(tableName);
        KuduScanner.KuduScannerBuilder kuduScannerBuilder = kuduClient
                .newScannerBuilder(kuduTable);
        Schema schema = kuduTable.getSchema();
        List<String> columns = Arrays.asList("id", "name", "money", "date");
        kuduScannerBuilder.setProjectedColumnNames(columns);
        // money >= 90000
        KuduPredicate moneyPredicate = KuduPredicate.newComparisonPredicate(schema.getColumn("money"), KuduPredicate.ComparisonOp.GREATER_EQUAL, 90000.0);
        KuduPredicate namePredicate = KuduPredicate.newComparisonPredicate(schema.getColumn("name"), KuduPredicate.ComparisonOp.EQUAL, "wang96556");

        KuduScanner kuduScanner = kuduScannerBuilder
                .addPredicate(namePredicate)
                .addPredicate(moneyPredicate)
                .build();
        while (kuduScanner.hasMoreRows()) {
            RowResultIterator rowResults = kuduScanner.nextRows();
            while (rowResults.hasNext()) {
                RowResult row = rowResults.next();
                logger.info("id={},name={},money={},date={}",
                        row.getInt("id"),
                        row.getString("name"),
                        row.getDouble("money"),
                        row.getInt("date"));
            }
        }
        kuduScanner.close();
    }


    /**
     * 更新数据
     *
     * @throws KuduException
     */
    @Test
    public void update() throws KuduException {
        KuduSession kuduSession = kuduClient.newSession();
        kuduSession.setFlushMode(SessionConfiguration.FlushMode.AUTO_FLUSH_SYNC);
        KuduTable kuduTable = kuduClient.openTable(tableName);

        //Update update = kuduTable.newUpdate();

        //id存在就修改，不存在就新增
        Upsert upsert = kuduTable.newUpsert();
        PartialRow row = upsert.getRow();
        row.addInt("id", 100000);
        row.addString("name", "huangyr");
        row.addDouble("money", 100.222);
        row.addInt("date", 20210226);
        RowError rowError = kuduSession.apply(upsert).getRowError();
        logger.info("get rowError:{}", rowError);
    }

    /**
     * 删除
     *
     * @throws KuduException
     */
    @Test
    public void delete() throws KuduException {
        KuduSession kuduSession = kuduClient.newSession();
        //设置手动刷新
        kuduSession.setFlushMode(SessionConfiguration.FlushMode.MANUAL_FLUSH);
        KuduTable table = kuduClient.openTable(tableName);
        Delete delete = table.newDelete();
        delete.getRow().addInt("id", 96555);
        kuduSession.apply(delete);
        kuduSession.flush();
        kuduSession.close();
    }

}
huangyueranbbc
关注
专栏目录
Kudu分区 --- 高级部分
杨鑫newlife的专栏
09-06 5771
您可以组合 HASH 和 RANGE 分区来创建更复杂的分区模式。您可以指定零个或多个 HASH 定义，后跟零个或一个 RANGE 定义。 每个定义可以包含一个或多个列。虽然枚举每个可能的分发模式都超出了本文档的范围，但是几个例子说明了一些可能性。 PARTITION BY HASH and RANGE   考虑上面的 简单哈希 示例，如果您经常查询一系列 sku 值，可以通过将哈希分区...
客快物流大数据项目(四十三)：kudu的分区方式
Lansonli（蓝深李）的博客
02-20 1181
目录 kudu的分区方式 一、Hash Partitioning (哈希分区) 二、Range Partitioning (范围分区) 三、​​​​​​​Multilevel Partitioning (多级分区) kudu的分区方式 为了提供可扩展性，Kudu 表被划分为称为 tablets 的单元，并分布在许多 tablet servers 上。行总是属于单个tablet 。将行分配给 tablet 的方法由在表创建期间设置的表的分区决定。 kudu提供了3种分区方式。 一、​​.
kudu表分区
u011250186的博客
03-13 4169
kudu表的数据结构是列式存储，但也支持像mysql那样进行检索，而且与spark、impala等现有的应用完美契合，可以说是是大数据平台上支持快速sql查询的上佳选择了。它的好处这里不多说啦，公司的大数据查询有一部分是用到这个技术，这里就列几个其他博客里不常见的涉及kudu表分区的语句（其实官网里都有，只是中文博客里还没见到）。 分区有两种方式，hash 和range分区， hash分...
Kudu分区策略
最新发布
weixin_41026747的博客
07-09 233
Kudu表的分区策略主要有三种：范围分区（Partition By Range）、哈希分区（Partition By Hash）和高级分区（Partition By Hash And Range）。这些策略都要求分区字段必须包含在主键中。
深入解析partition-hash分区
crbzijz188696507的博客
03-12 661
依据惯例，先看官网对hash partition的解释 Hash partitioning enables easy partitioning of data that does not lend itself...
kudu建分区表
感谢你的关注~~~~ღ( ´･ᴗ･` )
08-17 1381
CREATE TABLE impala_kudu.ods_app_real_time ( `id` INT, `app_date` STRING, `app_hour` STRING, `user_id` INT PRIMARY KEY(`app_date`,`id`) ) PARTITION BY range(`apply_date`)( PARTITION app_date='2015-06' PARTITION app_date='2015-07' ) STORED AS KUDU TBLPROP.
kudu表新增range分区
qq_30908729的博客
01-10 832
kudu impala表添加range分区
kudu-列式存储管理器-第三篇
CD
02-26 1220
1、kudu-分区方式 为了提供可扩展性，Kudu 表被划分为称为 tablets 的单元，并分布在许多 tablet servers 上。行总是属于单个 tablet 。将行分配给 tablet 的方法由在表创建期间设置的表的分区决定。 kudu提供了3种分区方式: 1.1、Range Partitioning ( 范围分区 ) 1.1.1、Range Partitioning ( 范围...
presto连接kudu建表与查询方法
liuya19921123的博客
11-15 4042
使用presto连接kudu查询引擎，在kudu中进行增删改查 查询数据 Apache Kudu 不支持模式，即表的命名空间。连接器可以选择通过表命名约定来模拟模 默认行为（无模式模拟） 默认情况下禁用模式模​​拟。在这种情况下，所有 Kudu 表都是default架构的一部分。 例如， 如果目录和模式分别设置为和，则orders可以在 Presto 中查询名为 的 Kudu 表。SELECT * FROM kudu.default.orders、SELECT * FROM orders。 表名
大数据物流项目：Kudu 操作命令（六）
Maynor的博客
07-11 532
存储引擎`Kudu`，类似HBase数据库，由Cloudera公司开发，目的取代HDFS和HBase框架，
【硬刚大数据】2021年从零到大数据专家之Kudu篇
微信搜：import_bigdata，大数据领域硬核原创作者
08-14 649
欢迎关注博客主页：https://blog.csdn.net/u013411339 欢迎点赞、收藏、留言 ，欢迎留言交流！本文由【王知无】原创，首发于 CSDN博客！本文首发CSDN论坛，未经过官方和本人允许，严禁转载！ 本文是对《【硬刚大数据之学习路线篇】2021年从零到大数据专家的学习指南(全面升级版)》的面试部分补充。 硬刚大数据系列文章链接： 2021年从零到大数据专家的学习指南(全面升级版) 2021年从零到大数据专家之Hadoop/HDFS/Yarn篇 2021.
kudu的分区方式
01-02 336
为了提供可扩展性，Kudu 表被划分为称为 tablets 的单元，并分布在许多 tablet servers 上。行总是属于单个 tablet 。将行分配给 tablet 的方法由在表创建期间设置的表的分区决定。 kudu提供了3种分区方式: Range Partitioning ( 范围分区 ) 范围分区可以根据存入数据的数据量，均衡的存储到各个机器上，防止机器出现...
NoSQL生态系统——hash分片和范围分片两种分片
djph26741的博客
01-06 252
13.4 横向扩展带来性能提升 很多NoSQL系统都是基于键值模型的，因此其查询条件也基本上是基于键值的查询，基本不会有对整个数据进行查询的时候。由于基本上所有的查询操作都是基本键值形式的，因此分片通常也基于数据的键来做：键的一些属性会决定这个键值对存储在哪台机器上。下面我们将会对hash分片和范围分片两种分片方式进行描述。 3.4.2 通过协调器进行数据分片 由于CouchDB专...
kudu查询表的range分区情况
qq_30908729的博客
01-10 706
kudu查询表的range分区情况
Kudu Partition Tablet Bucket
bigdataprimary的博客
01-07 1270
kudu中关于分区的概念有三个：partition，tablet，bucket。 概念： 「partition」类似hbase中的「region」也就是将整张表来分片存储管理，是一个逻辑上的概念。 「tablet」是分区中存储数据的最小单位，是物理概念，也就是数据在寻找存储位置的时候最终会落到一个确定的「tablet」中。 「bucket」这个概念是比较容易混淆的，「bucket」是在ha...
Partition by Hash on Keys
bzhangusc的专栏
01-24 456
When an RDD object is created, it will partitioned to multiple pieces for parallel processing. If we have to join the RDD with other RDDs many times on some Key, we’d better partition the RDDs by the
kudu-impala分区表（hash和range分区）
热门推荐
01-08 1万+
1、分区表支持hash分区和range分区，根据主键列上的分区模式将table划分为 tablets 。每个 tablet 由至少一台 tablet server提供。理想情况下，一张table分成多个tablets分布在不同的tablet servers ，以最大化并行操作。 2、Kudu目前没有在创建表之后拆分或合并 tablets 的机制。 3、创建表时，必须为表提供分区模式。 4、在
PostgreSQL分表（partition）文档学习笔记
Yvelyne的博客
02-01 6045
文章目录0. 背景1. What & Why1.1 Why1.1 What2. PostgreSQL分表方式3. 官方文档中的示例4. 注意事项4.1 在哪些列上建立分区4.2 分区数量 0. 背景 博主有一批500G的轨迹数据文本文件，想用PG进行管理。新手上路第一天，手动建立了十几个表，用copy_from的方式导入数据，但导着导着速度越来越慢……发现对一个含1126万条数据的表（没有索引）执行count(*)耗时5min32s，绝了。搜到partiton这种方法，先死马当活马医吧。（貌似可以进
KUDU数据库详解与小米实战
例如，创建一个名为sales_by_year的表，根据年份和销售ID进行分区，每个销售ID使用4个哈希分区，年份则按照范围进行分区，确保数据分布均匀并支持高效的查询操作。 在小米的实践中，KUDU可能被用作实时数据分析的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值