1. 為什麼使用Kudu作為儲存介質

• 資料庫資料上的快速分析
   目前很多業務使用事務型資料庫（MySQL、Oracle）做資料分析，把資料寫入資料庫，然後使用 SQL 進行有效資訊提取，當資料規模很小的時候，這種方式確實是立竿見影的，但是當資料量級起來以後，會發現資料庫吃不消了或者成本開銷太大了，此時就需要把資料從事務型資料庫裡拷貝出來或者說剝離出來，裝入一個分析型的資料庫裡。發現對於實時性和變更性的需求，目前只有 Kudu 一種元件能夠滿足需求，所以就產生了這樣的一種場景：
  

 MySQL 資料庫增、刪、改的資料通過 Binlog 實時的被同步到 Kudu 裡，同時在 Impala（或者其他計算引擎如 Spark、Hive、Presto、MapReduce）上可以實時的看到。
這種場景也是目前業界使用最廣泛的，認可度最高。

• 使用者行為日誌的快速分析
  對於使用者行為日誌的實時性敏感的業務，比如電商流量、AB 測試、優惠券的點選反饋、廣告投放效果以及秒級匯入秒級查詢等需求，按 Kudu 出現以前的架構基本上都是這張圖的模式：
  

 不僅鏈路長而且實時性得不到有力保障，有些甚至是 T + 1 的，極大的削弱了業務的豐富度。
 引入 Kudu 以後，大家看，資料的匯入和查詢都是線上實時的：

 這種場景目前也是網易考拉和hub在使用的，其中hub甚至把 Kudu 當 HBase 來作點查使用。

2. Kudu入門

2.1 Kudu介紹

2.1.1 背景介紹

在Kudu之前，大資料主要以兩種方式儲存；

• 靜態資料：
  • 以 HDFS 引擎作為儲存引擎，適用於高吞吐量的離線大資料分析場景。
  • 這類儲存的侷限性是資料無法進行隨機的讀寫。
• 動態資料：
  • 以 HBase、Cassandra 作為儲存引擎，適用於大資料隨機讀寫場景。
  • 這類儲存的侷限性是批量讀取吞吐量遠不如 HDFS，不適用於批量資料分析的場景。

 從上面分析可知，這兩種資料在儲存方式上完全不同，進而導致使用場景完全不同，但在真實的場景中，邊界可能沒有那麼清晰，面對既需要隨機讀寫，又需要批量分析的大資料場景，該如何選擇呢？這個場景中，單種儲存引擎無法滿足業務需求，我們需要通過多種大資料工具組合來滿足這一需求。

 如上圖所示，資料實時寫入 HBase，實時的資料更新也在 HBase 完成，為了應對 OLAP 需求，我們定時（通常是 T+1 或者 T+H）將 HBase 資料寫成靜態的檔案（如：Parquet）匯入到 OLAP 引擎（如：HDFS）。這一架構能滿足既需要隨機讀寫，又可以支援 OLAP 分析的場景，但它有如下缺點：

• 架構複雜。從架構上看，資料在HBase、訊息佇列、HDFS 間流轉，涉及環節太多，運維成本很高。並且每個環節需要保證高可用，都需要維護多個副本，儲存空間也有一定的浪費。最後資料在多個系統上，對資料安全策略、監控等都提出了挑戰。
• 時效性低。資料從HBase匯出成靜態檔案是週期性的，一般這個週期是一天（或一小時），在時效性上不是很高。
• 難以應對後續的更新。真實場景中，總會有資料是延遲到達的。如果這些資料之前已經從HBase匯出到HDFS，新到的變更資料就難以處理了，一個方案是把原有資料應用上新的變更後重寫一遍，但這代價又很高。

 為了解決上述架構的這些問題，Kudu應運而生。Kudu的定位是Fast Analytics on Fast Data，是一個既支援隨機讀寫、又支援 OLAP 分析的大資料儲存引擎。

 從上圖可以看出，KUDU 是一個折中的產品，在 HDFS 和 HBase 這兩個偏科生中平衡了隨機讀寫和批量分析的效能。從 KUDU 的誕生可以說明一個觀點：底層的技術發展很多時候都是上層的業務推動的，脫離業務的技術很可能是空中樓閣。

2.1.2 新的硬體裝置

 記憶體（RAM）的技術發展非常快，它變得越來越便宜，容量也越來越大。Cloudera的客戶資料顯示，他們的客戶所部署的伺服器，2012年每個節點僅有32GB RAM，現如今增長到每個節點有128GB或256GB RAM。儲存裝置上更新也非常快，在很多普通伺服器中部署SSD也是屢見不鮮。HBase、HDFS、以及其他的Hadoop工具都在不斷自我完善，從而適應硬體上的升級換代。然而，從根本上，HDFS基於03年GFS，HBase基於05年BigTable，在當時系統瓶頸主要取決於底層磁碟速度。當磁碟速度較慢時，CPU利用率不足的根本原因是磁碟速度導致的瓶頸，當磁碟速度提高了之後，CPU利用率提高，這時候CPU往往成為系統的瓶頸。HBase、HDFS由於年代久遠，已經很難從基本架構上進行修改，而Kudu是基於全新的設計，因此可以更充分地利用RAM、I/O資源，並優化CPU利用率。
 我們可以理解為：Kudu相比與以往的系統，CPU使用降低了，I/O的使用提高了，RAM的利用更充分了。

2.1.3 Kudu是什麼

 Apache Kudu是由Cloudera開源的儲存引擎，可以同時提供低延遲的隨機讀寫和高效的資料分析能力。它是一個融合HDFS和HBase的功能的新元件，具備介於兩者之間的新儲存元件。
 Kudu支援水平擴充套件，並且與Cloudera Impala和Apache Spark等當前流行的大資料查詢和分析工具結合緊密。

2.1.4 Kudu的應用場景

 Kudu的很多特性跟HBase很像，它支援索引鍵的查詢和修改。Cloudera曾經想過基於Hbase進行修改，然而結論是對HBase的改動非常大，Kudu的資料模型和磁碟儲存都與Hbase不同。HBase本身成功的適用於大量的其它場景，因此修改HBase很可能吃力不討好。最後Cloudera決定開發一個全新的儲存系統。

• Strong performance for both scan and random access to help customers simplify complex hybrid architectures（適用於那些既有隨機訪問，也有批量資料掃描的複合場景）
• High CPU efficiency in order to maximize the return on investment that our customers are making in modern processors（高計算量的場景）
• High IO efficiency in order to leverage modern persistent storage（使用了高效能的儲存裝置，包括使用更多的記憶體）
• The ability to upDATE data in place, to avoid extraneous processing and data movement（支援資料更新，避免資料反覆遷移）
• The ability to support active-active replicated clusters that span multiple data centers in geographically distant locations（支援跨地域的實時資料備份和查詢）

2.1.5 Kudu架構

 下圖顯示了一個具有三個 master 和多個 tablet server 的 Kudu 叢集，每個伺服器都支援多個 tablet。
 它說明了如何使用 Raft 共識來允許 master 和 tablet server 的 leader 和 follow。
 此外，tablet server 可以成為某些 tablet 的 leader，也可以是其他 tablet 的 follower。leader 以金色顯示，而 follower 則顯示為藍色。

下面是一些基本概念：

角色	作用
Master	叢集中的老大，負責叢集管理、後設資料管理等功能
Tablet Server	叢集中的小弟，負責資料儲存，並提供資料讀寫服務 一個 tablet server 儲存了table表的tablet 和為 tablet 向 client 提供服務。對於給定的 tablet，一個tablet server 充當 leader，其他 tablet server 充當該 tablet 的 follower 副本。 只有 leader服務寫請求，然而 leader 或 followers 為每個服務提供讀請求 。一個 tablet server 可以服務多個 tablets ，並且一個 tablet 可以被多個 tablet servers 服務著。
Table（表）	一張table是資料儲存在Kudu的tablet server中。表具有 schema 和全域性有序的primary key（主鍵）。table 被分成稱為 tablets 的 segments。
Tablet	一個 tablet 是一張 table連續的segment，tablet是kudu表的水平分割槽，類似於google Bigtable的tablet，或者HBase的region。每個tablet儲存著一定連續range的資料（key），且tablet兩兩間的range不會重疊。一張表的所有tablet包含了這張表的所有key空間。與其它資料儲存引擎或關係型資料庫中的 partition（分割槽）相似。給定的tablet 冗餘到多個 tablet 伺服器上，並且在任何給定的時間點，其中一個副本被認為是leader tablet。任何副本都可以對讀取進行服務，並且寫入時需要在為 tablet 服務的一組 tablet server之間達成一致性。

2.2 Java程式碼操作Kudu

2.2.1 構建maven工程

2.2.2 匯入依賴

<repositories>
    <repository>
        <id>cloudera</id>
        <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>org.apache.kudu</groupId>
        <artifactId>kudu-client</artifactId>
        <version>1.9.0-cdh6.2.1</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <dependency>
        <groupId>org.apache.kudu</groupId>
        <artifactId>kudu-client-tools</artifactId>
        <version>1.9.0-cdh6.2.1</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.9.0-cdh6.2.1</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-sql -->
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-sql_2.11</artifactId>
        <version>2.1.0</version>
    </dependency>
</dependencies>

2.2.3 建立包結構

包名	說明
com.erainm	程式碼所在的包目錄

2.2.4 初始化方法

import org.apache.kudu.ColumnSchema;
import org.apache.kudu.Type;
import org.apache.kudu.client.KuduClient;
import org.junit.Before;

public class TestKudu {
    //定義KuduClient客戶端物件
    private static KuduClient kuduClient;
    //定義表名
    private static String tableName = "person";

    /**
     * 初始化方法
     */
    @Before
    public void init() {
        //指定master地址
        String masterAddress = "node2";
        //建立kudu的資料庫連線
        kuduClient = new KuduClient.KuduClientBuilder(masterAddress).defaultSocketReadTimeoutMs(6000).build();
    }

    //構建表schema的欄位資訊
    //欄位名稱   資料型別     是否為主鍵
    public ColumnSchema newColumn(String name, Type type, boolean isKey) {
        ColumnSchema.ColumnSchemaBuilder column = new ColumnSchema.ColumnSchemaBuilder(name, type);
        column.key(isKey);
        return column.build();
    }
}

2.2.5 建立表

/**  使用junit進行測試
 *
 * 建立表
 * @throws KuduException
 */
@Test
public void createTable() throws KuduException {
    //設定表的schema
    List<ColumnSchema> columns = new LinkedList<ColumnSchema>();
    columns.add(newColumn("CompanyId", Type.INT32, true));
    columns.add(newColumn("WorkId", Type.INT32, false));
    columns.add(newColumn("Name", Type.STRING, false));
    columns.add(newColumn("Gender", Type.STRING, false));
    columns.add(newColumn("Photo", Type.STRING, false));
    Schema schema = new Schema(columns);
    //建立表時提供的所有選項
    CreateTableOptions tableOptions = new CreateTableOptions();
    //設定表的副本和分割槽規則
    LinkedList<String> list = new LinkedList<String>();
    list.add("CompanyId");
    //設定表副本數
    tableOptions.setNumReplicas(1);
    //設定range分割槽
    //tableOptions.setRangePartitionColumns(list);
    //設定hash分割槽和分割槽的數量
    tableOptions.addHashPartitions(list, 3);
    try {
        kuduClient.createTable("person", schema, tableOptions);
    } catch (Exception e) {
        e.printStackTrace();
    }
    kuduClient.close();
}

2.2.6 插入資料

/**
 * 向表中載入資料
 * @throws KuduException
 */
@Test
public void loadData() throws KuduException {
    //開啟表
    KuduTable kuduTable = kuduClient.openTable(tableName);
    //建立KuduSession物件 kudu必須通過KuduSession寫入資料
    KuduSession kuduSession = kuduClient.newSession();
    //採用flush方式 手動重新整理
    kuduSession.setFlushMode(SessionConfiguration.FlushMode.MANUAL_FLUSH);
    kuduSession.setMutationBufferSpace(3000);
    //準備資料
    for(int i=1; i<=10; i++){
        Insert insert = kuduTable.newInsert();
        //設定欄位的內容
        insert.getRow().addInt("CompanyId",i);
        insert.getRow().addInt("WorkId",i);
        insert.getRow().addString("Name","lisi"+i);
        insert.getRow().addString("Gender","male");
        insert.getRow().addString("Photo","person"+i);
        kuduSession.flush();
        kuduSession.apply(insert);
    }
    kuduSession.close();
    kuduClient.close();
}

2.2.7 查詢資料

/**
 * 查詢表資料
 * @throws KuduException
 */
@Test
public void queryData() throws KuduException {
    //開啟表
    KuduTable kuduTable = kuduClient.openTable(tableName);
    //獲取scanner掃描器
    KuduScanner.KuduScannerBuilder scannerBuilder = kuduClient.newScannerBuilder(kuduTable);
    KuduScanner scanner = scannerBuilder.build();
    //遍歷
    while(scanner.hasMoreRows()){
        RowResultIterator rowResults = scanner.nextRows();
        while (rowResults.hasNext()){
            RowResult result = rowResults.next();
            int companyId = result.getInt("CompanyId");
            int workId = result.getInt("WorkId");
            String name = result.getString("Name");
            String gender = result.getString("Gender");
            String photo = result.getString("Photo");
            System.out.print("companyId:"+companyId+" ");
            System.out.print("workId:"+workId+" ");
            System.out.print("name:"+name+" ");
            System.out.print("gender:"+gender+" ");
            System.out.println("photo:"+photo);
        }
    }
    //關閉
    scanner.close();
    kuduClient.close();
}

2.2.8 修改資料

/**
 * 修改資料
 * @throws KuduException
 */
@Test
public void upDATEData() throws KuduException {
    //開啟表
    KuduTable kuduTable = kuduClient.openTable(tableName);
    //構建kuduSession物件
    KuduSession kuduSession = kuduClient.newSession();
    //設定重新整理資料模式，自動提交
    kuduSession.setFlushMode(SessionConfiguration.FlushMode.AUTO_FLUSH_BACKGROUND);

    //更新資料需要獲取UpDATE物件
    UpDATE upDATE = kuduTable.newUpDATE();
    //獲取row物件
    PartialRow row = upDATE.getRow();
    //設定要更新的資料資訊
    row.addInt("CompanyId",1);
    row.addString("Name","kobe");
    //操作這個upDATE物件
    kuduSession.apply(upDATE);
    kuduSession.close();
}

2.2.9 刪除資料

/**
 * 刪除表中的資料
 */
@Test
public void deleteData() throws KuduException {
    //開啟表
    KuduTable kuduTable = kuduClient.openTable(tableName);
    KuduSession kuduSession = kuduClient.newSession();
    //獲取Delete物件
    Delete delete = kuduTable.newDelete();
    //構建要刪除的行物件
    PartialRow row = delete.getRow();
    //設定刪除資料的條件
    row.addInt("CompanyId",2);
    kuduSession.flush();
    kuduSession.apply(delete);
    kuduSession.close();
    kuduClient.close();
}

2.2.10 刪除表

/**
 * 刪除表
 */
@Test
public void dropTable() throws KuduException {
    //刪除表
    DeleteTableResponse response = kuduClient.deleteTable(tableName);
    //關閉客戶端連線
    kuduClient.close();
}

2.2.11 kudu的分割槽方式（結合Impala）

 為了提供可擴充套件性，Kudu 表被劃分為稱為 tablets 的單元，並分佈在許多 tablet servers 上。行總是屬於單個tablet 。將行分配給 tablet 的方法由在表建立期間設定的表的分割槽決定。
kudu提供了3種分割槽方式。

2.2.11.1 Hash Partitioning (雜湊分割槽)

 雜湊分割槽通過雜湊值將行分配到許多 buckets ( 儲存桶 )之一； 雜湊分割槽是一種有效的策略，當不需要對錶進行有序訪問時。雜湊分割槽對於在 tablet 之間隨機散佈這些功能是有效的，這有助於減輕熱點和 tablet 大小不均勻。

/**
 * 測試分割槽：
 * hash分割槽
 */
@Test
public void testHashPartition() throws KuduException {
    //設定表的schema
    LinkedList<ColumnSchema> columnSchemas = new LinkedList<ColumnSchema>();
    columnSchemas.add(newColumn("CompanyId", Type.INT32,true));
    columnSchemas.add(newColumn("WorkId", Type.INT32,false));
    columnSchemas.add(newColumn("Name", Type.STRING,false));
    columnSchemas.add(newColumn("Gender", Type.STRING,false));
    columnSchemas.add(newColumn("Photo", Type.STRING,false));
    //建立schema
    Schema schema = new Schema(columnSchemas);
    //建立表時提供的所有選項
    CreateTableOptions tableOptions = new CreateTableOptions();
    //設定副本數
    tableOptions.setNumReplicas(1);
    //設定範圍分割槽的規則
    LinkedList<String> parcols = new LinkedList<String>();
    parcols.add("CompanyId");
    //設定按照那個欄位進行range分割槽
    tableOptions.addHashPartitions(parcols,6);
    try {
        kuduClient.createTable("dog",schema,tableOptions);
    } catch (KuduException e) {
        e.printStackTrace();
    }
    kuduClient.close();
}

2.2.11.2 Range Partitioning (範圍分割槽)

 範圍分割槽可以根據存入資料的資料量，均衡的儲存到各個機器上，防止機器出現負載不均衡現象.

/**
 * 測試分割槽：
 * RangePartition
 */
@Test
public void testRangePartition() throws KuduException {
    //設定表的schema
    LinkedList<ColumnSchema> columnSchemas = new LinkedList<ColumnSchema>();
    columnSchemas.add(newColumn("CompanyId", Type.INT32,true));
    columnSchemas.add(newColumn("WorkId", Type.INT32,false));
    columnSchemas.add(newColumn("Name", Type.STRING,false));
    columnSchemas.add(newColumn("Gender", Type.STRING,false));
    columnSchemas.add(newColumn("Photo", Type.STRING,false));
    //建立schema
    Schema schema = new Schema(columnSchemas);
    //建立表時提供的所有選項
    CreateTableOptions tableOptions = new CreateTableOptions();
    //設定副本數
    tableOptions.setNumReplicas(1);
    //設定範圍分割槽的規則
    LinkedList<String> parcols = new LinkedList<String>();
    parcols.add("CompanyId");
    //設定按照那個欄位進行range分割槽
    tableOptions.setRangePartitionColumns(parcols);
    /**
     * range
     *  0 < value < 10
     * 10 <= value < 20
     * 20 <= value < 30
     * ........
     * 80 <= value < 90
     * */
    int count=0;
    for(int i =0;i<10;i++){
        //範圍開始
        PartialRow lower = schema.newPartialRow();
        lower.addInt("CompanyId",count);
        //範圍結束
        PartialRow upper = schema.newPartialRow();
        count +=10;
        upper.addInt("CompanyId",count);
        //設定每一個分割槽的範圍
        tableOptions.addRangePartition(lower,upper);
    }
    try {
        kuduClient.createTable("student",schema,tableOptions);
    } catch (KuduException e) {
        e.printStackTrace();
    }
    kuduClient.close();
}

2.2.11.3 Multilevel Partitioning (多級分割槽)

Kudu 允許一個表在單個表上組合多級分割槽。
 當正確使用時，多級分割槽可以保留各個分割槽型別的優點，同時減少每個分割槽的缺點 需求.

/**
 * 測試分割槽：
 * 多級分割槽
 * Multilevel Partition
 * 混合使用hash分割槽和range分割槽
 *
 * 雜湊分割槽有利於提高寫入資料的吞吐量，而範圍分割槽可以避免tablet無限增長問題，
 * hash分割槽和range分割槽結合，可以極大的提升kudu的效能
 */
@Test
public void testMultilevelPartition() throws KuduException {
    //設定表的schema
    LinkedList<ColumnSchema> columnSchemas = new LinkedList<ColumnSchema>();
    columnSchemas.add(newColumn("CompanyId", Type.INT32,true));
    columnSchemas.add(newColumn("WorkId", Type.INT32,false));
    columnSchemas.add(newColumn("Name", Type.STRING,false));
    columnSchemas.add(newColumn("Gender", Type.STRING,false));
    columnSchemas.add(newColumn("Photo", Type.STRING,false));
    //建立schema
    Schema schema = new Schema(columnSchemas);
    //建立表時提供的所有選項
    CreateTableOptions tableOptions = new CreateTableOptions();
    //設定副本數
    tableOptions.setNumReplicas(1);
    //設定範圍分割槽的規則
    LinkedList<String> parcols = new LinkedList<String>();
    parcols.add("CompanyId");
    //hash分割槽
    tableOptions.addHashPartitions(parcols,5);
    //range分割槽
    int count=0;
    for(int i=0;i<10;i++){
        PartialRow lower = schema.newPartialRow();
        lower.addInt("CompanyId",count);
        count+=10;
        PartialRow upper = schema.newPartialRow();
        upper.addInt("CompanyId",count);
        tableOptions.addRangePartition(lower,upper);
    }
    try {
        kuduClient.createTable("cat",schema,tableOptions);
    } catch (KuduException e) {
        e.printStackTrace();
    }
    kuduClient.close();
}

2.2.12 修改表

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

import java.util.List;

/**
 * 修改表操作
 */
public class AlterTable {
    //定義kudu的客戶端物件
    private static KuduClient kuduClient;
    //定義一張表名稱
    private static String tableName = "person";

    /**
     * 初始化操作
     */
    @Before
    public void init() {
        //指定kudu的master地址
        String masterAddress = "node2";
        //建立kudu的資料庫連線
        kuduClient = new KuduClient.KuduClientBuilder(masterAddress).defaultSocketReadTimeoutMs(6000).build();
    }

    /**
     * 新增列
     */
    @Test
    public void alterTableAddColumn() {
        AlterTableOptions alterTableOptions = new AlterTableOptions();
        alterTableOptions.addColumn(new ColumnSchema.ColumnSchemaBuilder("Address", Type.STRING).nullable(true).build());
        try {
            kuduClient.alterTable(tableName, alterTableOptions);
        } catch (KuduException e) {
            e.printStackTrace();
       }
    }

    /**
     * 刪除列
     */
    @Test
    public void alterTableDeleteColumn(){
        AlterTableOptions alterTableOptions = new AlterTableOptions().dropColumn("Address");
        try {
            kuduClient.alterTable(tableName, alterTableOptions);
        } catch (KuduException e) {
            e.printStackTrace();
       }
    }

    /**
     * 新增分割槽列
     */
    @Test
    public void alterTableAddRangePartition(){
        int lowerValue = 110;
        int upperValue = 120;
        try {
            KuduTable kuduTable = kuduClient.openTable(tableName);
            List<Partition> rangePartitions = kuduTable.getRangePartitions(6000);
            boolean flag = true;
            for (Partition rangePartition : rangePartitions) {
                int startKey = rangePartition.getDecodedRangeKeyStart(kuduTable).getInt("Id");
                if(startKey == lowerValue){
                    flag = false;
                }
            }
            if(flag) {
                PartialRow lower = kuduTable.getSchema().newPartialRow();
                lower.addInt("Id", lowerValue);
                PartialRow upper = kuduTable.getSchema().newPartialRow();
                upper.addInt("Id", upperValue);
                kuduClient.alterTable(tableName,new AlterTableOptions().addRangePartition(lower, upper));
            }else{
                System.out.println("分割槽已經存在，不能重複建立！");
            }
        } catch (KuduException e) {
            e.printStackTrace();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

    /**
     * 刪除表
     * @throws KuduException
     */
    @Test
    public void dropTable() throws KuduException {
        kuduClient.deleteTable(tableName);
    }
}

2.3 Spark操作Kudu

• Spark與KUDU整合支援：
  • DDL操作（建立/刪除）
  • 本地Kudu RDD
  • Native Kudu資料來源，用於DataFrame整合
  • 從kudu讀取資料
  • 從Kudu執行插入/更新/ upsert /刪除
  • 謂詞下推
  • Kudu和Spark SQL之間的模式對映
  • 到目前為止，我們已經聽說過幾個上下文，例如SparkContext，SQLContext，HiveContext， SparkSession，現在，我們將使用Kudu引入一個KuduContext。這是可以在Spark應用程式中廣播的主要可序列化物件。此類代表在Spark執行程式中與Kudu Java客戶端進行互動。
  • KuduContext提供執行DDL操作所需的方法，與本機Kudu RDD的介面，對資料執行更新/插入/刪除，將資料型別從Kudu轉換為Spark等。

2.3.1 建立表

• 定義kudu的表需要分成5個步驟：
  • 提供表名
  • 提供schema
  • 提供主鍵
  • 定義重要選項；例如：定義分割槽的schema
  • 呼叫create Table api
• 程式碼開發

import java.util
import com.erainm.SparkKuduDemo.TABLE_NAME
import org.apache.kudu.client.CreateTableOptions
import org.apache.kudu.spark.kudu.KuduContext
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}

object SparkKuduTest {
  def main(args: Array[String]): Unit = {
    //構建sparkConf物件
    val sparkConf: SparkConf = new SparkConf().setAppName("SparkKuduTest").setMaster("local[2]")

    //構建SparkSession物件
    val sparkSession: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()

    //獲取sparkContext物件
    val sc: SparkContext = sparkSession.sparkContext
    sc.setLogLevel("warn")

    //構建KuduContext物件
    val kuduContext = new KuduContext("node2:7051", sc)

    //1.建立表操作
    createTable(kuduContext)

    /**
     * 建立表
     *
     * @param kuduContext
     * @return
     */
    def createTable(kuduContext: KuduContext) = {
      //如果表不存在就去建立
      if (!kuduContext.tableExists(TABLE_NAME)) {

        //構建建立表的表結構資訊,就是定義表的欄位和型別
        val schema: StructType = StructType(
          StructField("userId", StringType, false) ::
            StructField("name", StringType, false) ::
            StructField("age", IntegerType, false) ::
            StructField("sex", StringType, false) :: Nil)

        //指定表的主鍵欄位
        val keys = List("userId")

        //指定建立表所需要的相關屬性
        val options: CreateTableOptions = new CreateTableOptions
        //定義分割槽的欄位
        val partitionList = new util.ArrayList[String]
        partitionList.add("userId")
        //新增分割槽方式為hash分割槽
        options.addHashPartitions(partitionList, 6)

        //建立表
        kuduContext.createTable(TABLE_NAME, schema, keys, options)
      }
    }
  }
}

 定義表時要注意的是Kudu表選項值。你會注意到在指定組成範圍分割槽列的列名列表時我們呼叫“asJava”方 法。這是因為在這裡，我們呼叫了Kudu Java客戶端本身，它需要Java物件（即java.util.List）而不是Scala的List對 象；（要使“asJava”方法可用，請記住匯入JavaConverters庫。） 建立表後，通過將瀏覽器指向http//master主機名:8051/tables

• 來檢視Kudu主UI可以找到建立的表，通過單擊表ID，能夠看到表模式和分割槽資訊。
  
  點選Table id 可以觀察到表的schema等資訊：
  

2.3.2 DML操作

 Kudu支援許多DML型別的操作，其中一些操作包含在Spark on Kudu整合. 包括：

• INSERT - 將DataFrame的行插入Kudu表。請注意，雖然API完全支援INSERT，但不鼓勵在Spark中使用它。 使用INSERT是有風險的，因為Spark任務可能需要重新執行，這意味著可能要求再次插入已插入的行。這樣做會導致失敗，因為如果行已經存在，INSERT將不允許插入行（導致失敗）。相反，我們鼓勵使用下面描述 的INSERT_IGNORE。
• INSERT-IGNORE - 將DataFrame的行插入Kudu表。如果表存在，則忽略插入動作。
• DELETE - 從Kudu表中刪除DataFrame中的行
• UPSERT - 如果存在，則在Kudu表中更新DataFrame中的行，否則執行插入操作。
• UPDATE - 更新dataframe中的行

2.3.2.1 插入資料insert操作

先建立一張表，然後把資料插入到表中

import java.util

import com.erainm.SparkKuduDemo.{TABLE_NAME, erainm}
import org.apache.kudu.client.CreateTableOptions
import org.apache.kudu.spark.kudu.KuduContext
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.sql.{DataFrame, SparkSession}
import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}


object SparkKuduTest {
  //定義樣例類
  case class erainm(id:Int, name:String, age:Int, sex:Int)
  
  def main(args: Array[String]): Unit = {
    //構建sparkConf物件
    val sparkConf: SparkConf = new SparkConf().setAppName("SparkKuduTest").setMaster("local[2]")

    //構建SparkSession物件
    val sparkSession: SparkSession = SparkSession.builder().config(sparkConf).getOrCreate()

    //獲取sparkContext物件
    val sc: SparkContext = sparkSession.sparkContext
    sc.setLogLevel("warn")

    //構建KuduContext物件
    val kuduContext = new KuduContext("node2:7051", sc)

    //1.建立表操作
    createTable(kuduContext)

    /**
     * 建立表
     *
     * @param kuduContext
     * @return
     */
    def createTable(kuduContext: KuduContext) = {
      //如果表不存在就去建立
      if (!kuduContext.tableExists(TABLE_NAME)) {

        //構建建立表的表結構資訊,就是定義表的欄位和型別
        val schema: StructType = StructType(
          StructField("userId", StringType, false) ::
            StructField("name", StringType, false) ::
            StructField("age", IntegerType, false) ::
            StructField("sex", StringType, false) :: Nil)

        //指定表的主鍵欄位
        val keys = List("userId")

        //指定建立表所需要的相關屬性
        val options: CreateTableOptions = new CreateTableOptions
        //定義分割槽的欄位
        val partitionList = new util.ArrayList[String]
        partitionList.add("userId")
        //新增分割槽方式為hash分割槽
        options.addHashPartitions(partitionList, 6)

        //建立表
        kuduContext.createTable(TABLE_NAME, schema, keys, options)
      }
    }

    /**
     * 2）載入資料
     * @param session
     * @param sc
     * @param kuduContext
     */
    def inserData(session: SparkSession, sc: SparkContext, kuduContext: KuduContext): Unit = {
      //定義資料
      val data = List(erainm(1, "tom", 30, 1), erainm(2, "mark", 26, 0))
      val erainmRDD = sc.makeRDD(data)
      import session.implicits._
      val dataFrame: DataFrame = erainmRDD.toDF

      kuduContext.insertRows(dataFrame, TABLE_NAME)
    }
  }
}

2.3.2.2 刪除資料delete操作

/**
 * 4）刪除資料
 * @param session
 * @param kuduContext
 */
def deleteData(session: SparkSession, kuduContext: KuduContext): Unit = {
  //定義資料
  val data = List(erainm(1, "tom", 50, 1), erainm(2, "mark", 30, 0))

  import session.implicits._
  val dataFrame: DataFrame = data.toDF().select("id")

  kuduContext.deleteRows(dataFrame, TABLE_NAME)
}

2.3.2.3 更新資料upsert操作

/**
 * 3）修改資料
 * @param session
 * @param kuduContext
 */
def upDATEData(session: SparkSession, kuduContext: KuduContext): Unit = {
  //定義資料
  val data = List(erainm(1, "tom", 50, 1), erainm(2, "mark", 30, 0))

  import session.implicits._
  val dataFrame: DataFrame = data.toDF()

  kuduContext.upDATERows(dataFrame, TABLE_NAME)
}

2.3.3 dataFrame操作kudu

2.3.3.1 DataFrameApi讀取kudu表中的資料

 雖然我們可以通過上面顯示的KuduContext執行大量操作，但我們還可以直接從預設資料來源本身呼叫讀/寫API。要設定讀取，我們需要為Kudu表指定選項，命名我們要讀取的表以及為表提供服務的Kudu叢集的Kudu主伺服器列表。

• 程式碼示例

/**
 * 使用DataFrameApi讀取kudu表中的資料
 * @param sparkSession
 * @param kuduMaster
 * @param tableName
 */
def getTableData(sparkSession: SparkSession, kuduMaster: String, tableName: String): Unit = {
  //定義map集合，封裝kudu的master地址和要讀取的表名
  val options = Map(
    "kudu.master" -> kuduMaster,
    "kudu.table" -> tableName
  )
  sparkSession.read.options(options).kudu.show()
}

2.3.3.2 DataFrameApi寫資料到kudu表中

在通過DataFrame API編寫時，目前只支援一種模式“append”。尚未實現的“覆蓋”模式。

• 程式碼示例

/**
 * 6）DataFrameApi寫資料到kudu表中
 */
def dataFrame2Kudu(session: SparkSession, kuduContext: KuduContext): Unit ={
  val data = List(erainm(3, "canglaoshi", 14, 0), erainm(4, "xiaowang", 18, 1))
  import  session.implicits._
  val dataFrame = data.toDF

  //目前，在kudu中，資料的寫入只支援append追加
  dataFrame.write.mode("append").options(kuduOptions).kudu

  //檢視結果
  //導包
  import org.apache.kudu.spark.kudu._
  //載入表的資料，導包呼叫kudu方法，轉換為dataFrame，最後在使用show方法顯示結果
  sparkSession.read.options(kuduOptions).kudu.show()
}

2.3.3.3 使用sparksql操作kudu表

 可以選擇使用Spark SQL直接使用INSERT語句寫入Kudu表；與’append’類似，INSERT語句實際上將預設使用 UPSERT語義處理；

• 程式碼示例

/**
 * 使用sparksql操作kudu表
 * @param sparkSession
 * @param sc
 * @param kuduMaster
 * @param tableName
 */
def SparkSql2Kudu(sparkSession: SparkSession, sc: SparkContext, kuduMaster: String, tableName: String): Unit = {
  //定義map集合，封裝kudu的master地址和表名
  val options = Map(
    "kudu.master" -> kuduMaster,
    "kudu.table" -> tableName
  )
  val data = List(erainm(10, "小張", 30, 0), erainm(11, "小王", 40, 0))
  import sparkSession.implicits._
  val dataFrame: DataFrame = sc.parallelize(data).toDF
  //把dataFrame註冊成一張表
  dataFrame.createTempView("temp1")

  //獲取kudu表中的資料，然後註冊成一張表
  sparkSession.read.options(options).kudu.createTempView("temp2")
  //使用sparkSQL的insert操作插入資料
  sparkSession.sql("insert into table temp2 select * from temp1")
  sparkSession.sql("select * from temp2 where age >30").show()
}

2.3.4 Kudu Native RDD

Spark與Kudu的整合同時提供了kudu RDD.

• 程式碼示例

val columnsList = List("id", "name", "age", "sex")
val rowRDD: RDD[Row] = kuduContext.kuduRDD(sc, TABLE_NAME, columnsList)
rowRDD.foreach(println(_))
sc.stop()
//session.read.options(kuduOptions).kudu.show()

2.3.5 修改表

/**
 * 新增列
 * @param kuduContext
 */
def addColumn(kuduContext: KuduContext): Unit ={
  val alterTableOptions: AlterTableOptions = new AlterTableOptions
  alterTableOptions.addColumn(new ColumnSchema.ColumnSchemaBuilder("Address", Type.STRING).nullable(true).build)
  try {
    kuduContext.syncClient.alterTable(tableName, alterTableOptions)
  } catch {
    case ex:Exception => ex.printStackTrace()
  }
}