精华内容
下载资源
问答
  • 在hive中删除hbase表数据
    2020-10-15 20:56:54

     

    1.创建hive的hbase的映射表(我使用的是阿里云大数据平台,hbase的相关jar以及配置文件已经拷贝到hive相应的目录下面,该步骤省略)

    CREATE EXTERNAL TABLE `xxxxxxxxx`(
    	  `keyid` string COMMENT 'from deserializer', 
    	  `action` string COMMENT 'from deserializer')
    	ROW FORMAT SERDE 
    	  'org.apache.hadoop.hive.hbase.HBaseSerDe' 
    	STORED BY 
    	  'org.apache.hadoop.hive.hbase.HBaseStorageHandler' 
    	WITH SERDEPROPERTIES ( 
    	  'hbase.columns.mapping'=':key,info:action', 
    	  'serialization.format'='1')
    	TBLPROPERTIES (
    	  'hbase.table.name'='xxxxxxxxx', 
    	  'transient_lastDdlTime'='1602294488')

    2.表写shell脚本实现hbase的批量删除操作

    #!/bin/bash
    # 该shell脚本实现删除前四天的所有数据
    date=$(date -d "4 day ago" +%Y-%m-%d)
    echo ${date}
    #用hivesql,查出需要删除的数据,并且拼接hbase shell删除命令,逐条删除,重定向覆盖到del_temp.txt
    hive -e "select concat('deleteall \'xxxxxxxxx\',\'',keyid,'\'') from test.xxxxxxxxxwhere  keyid like '${date}%'" > del_temp.txt 
    # 重定向追加一个exit,这样在下一条语句执行完毕,就可以退出hbase shell了
    echo 'exit' >> del_temp.txt
    # 到hbase shell里面执行删除语句
    hbase shell ./del_temp.txt
    exit
    

    操作如此丝滑,就像用了飘柔。。。。。。。

    文章最后Congratulations to the Lakers, goodbye to Kobe, goodbye to my youth。。。。。

     

    更多相关内容
  • 主要介绍了详解hbasehive数据同步的相关资料,需要的朋友可以参考下
  • hive数据导入hbase

    2021-01-26 15:41:03
    hive数据导入hbase一、hive外部映射hbase表1. hbase里面创建2. 建立hive外部并映射hbase表3.测试spark bulkload方式准备事项pom文件代码 一、hive外部映射hbase表 1. hbase里面创建 create 'B_TEST_STU'...

    一、hive外部表映射hbase表

    1. hbase里面创建表

    create 'B_TEST_STU', { NAME => 'info', COMPRESSION => 'SNAPPY' }
    

    2. 建立hive外部表并映射hbase表

    create database yh_test;
    use yh_test;
    create external table yh_test.stu(
    id String, 
    name String
    )
    ROW FORMAT SERDE 'org.apache.hadoop.hive.hbase.HBaseSerDe'
    STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler' 
    WITH SERDEPROPERTIES ("hbase.columns.mapping" = 
    ":key,
    info:name,
    info:gender
    ") TBLPROPERTIES("hbase.table.name" ="B_TEST_STU");
    

    3.测试

    在hive表插入数据

    insert into table stu  values ('001','zhangsan','1');
    

    去hbase表查看数据是否生成

    scan 'hb_stu'
    

    二、spark bulkload方式

    参考官网
    分为两个步骤:

    1. 生成hfile文件格式数据
    2. 将生成的hfile文件移动到hbase对应位置

    1.准备事项

    1. hdfs、hive、hbase、zookeeper、spark集群均可正常使用
    2. 将hive的hive-site.xml文件复制到$SPARK_HOME/conf目录、项目的resource目录下(保证spark能够访问到外部hive)
    3. 将对应保存元数据数据库的驱动添加到项目resource目录下

    在这里插入图片描述

    2.pom文件

    <properties>
            <hadoop-version>2.6.0</hadoop-version>
            <hive-version>1.1.0</hive-version>
            <hbase-version>1.2.0</hbase-version>
            <spark.version>2.3.3</spark.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.scala-lang</groupId>
                <artifactId>scala-library</artifactId>
                <version>2.11.12</version>
            </dependency>
    
            <!-- Spark Dependencies -->
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-core_2.11</artifactId>
                <version>${spark.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-sql_2.11</artifactId>
                <version>${spark.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-hive_2.11</artifactId>
                <version>${spark.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-common</artifactId>
                <version>${hbase-version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-server</artifactId>
                <version>${hbase-version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-client</artifactId>
                <version>${hbase-version}</version>
            </dependency>
    
            <!-- 指定hadoop-client API的版本 -->
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-client</artifactId>
                <version>${hadoop-version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hive</groupId>
                <artifactId>hive-hbase-handler</artifactId>
                <version>${hive-version}</version>
            </dependency>
        </dependencies>
    
        <build>
            <pluginManagement>
                <plugins>
                    <!-- 编译scala的插件 -->
                    <plugin>
                        <groupId>net.alchim31.maven</groupId>
                        <artifactId>scala-maven-plugin</artifactId>
                        <version>3.2.2</version>
                    </plugin>
                    <!-- 编译java的插件 -->
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.5.1</version>
                    </plugin>
                </plugins>
            </pluginManagement>
            <plugins>
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>scala-maven-plugin</artifactId>
                    <executions>
                        <execution>
                            <id>scala-compile-first</id>
                            <phase>process-resources</phase>
                            <goals>
                                <goal>add-source</goal>
                                <goal>compile</goal>
                            </goals>
                        </execution>
                        <execution>
                            <id>scala-test-compile</id>
                            <phase>process-test-resources</phase>
                            <goals>
                                <goal>testCompile</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
    
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <executions>
                        <execution>
                            <phase>compile</phase>
                            <goals>
                                <goal>compile</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
    
    
                <!-- 打jar插件 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.4.3</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <filters>
                                    <filter>
                                        <artifact>*:*</artifact>
                                        <excludes>
                                            <exclude>META-INF/*.SF</exclude>
                                            <exclude>META-INF/*.DSA</exclude>
                                            <exclude>META-INF/*.RSA</exclude>
                                        </excludes>
                                    </filter>
                                </filters>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    

    3.代码

    package com.yh
    
    import org.apache.hadoop.conf.Configuration
    import org.apache.hadoop.fs.{FileSystem, Path}
    import org.apache.hadoop.hbase.client.ConnectionFactory
    import org.apache.hadoop.hbase.io.ImmutableBytesWritable
    import org.apache.hadoop.hbase.mapreduce.{HFileOutputFormat2, LoadIncrementalHFiles}
    import org.apache.hadoop.hbase.util.Bytes
    import org.apache.hadoop.hbase.{HBaseConfiguration, KeyValue, TableName}
    import org.apache.hadoop.mapreduce.Job
    import org.apache.spark.sql.SparkSession
    
    import java.net.URI
    
    /**
     *
    spark-on-yarn提交方式
    
     bin/spark-submit \
    --class com.yh.BulkloadTest \
    --master yarn \
    --executor-memory 1G \
    --total-executor-cores 2 \
    --num-executors 2 \
    hdfs://node01:8020/spark_bulkload_hbase-1.0-SNAPSHOT.jar \
    
     */
    object BulkloadTest {
      def main(args: Array[String]): Unit = {
        val spark = SparkSession.builder().appName("BulkloadTest")
          .master("local[*]")
          .enableHiveSupport()
          .getOrCreate()
        //从hive中读取数据,数据是在hdfs上,hive是个外部表,你也可以用内部表,都一样
        spark.sql("use yh_test")
        spark.sql("select *,id rowkey from stu").show()
        val Data = spark.sql("select *,id rowkey from stu")
    
        val dataRdd = Data.rdd.flatMap(row => { //cf是列族名,ID、DATA_TYPE、DEVICE_ID为字段名
          val rowkey = row.getAs[String]("rowkey".toLowerCase)
          Array(
            (rowkey, ("info", "id", row.getAs[String]("id"))),
            (rowkey, ("info", "name", row.getAs[String]("name")))
          )
        })
        //要保证行键,列族,列名的整体有序,必须先排序后处理,防止数据异常过滤rowkey
        val rdds = dataRdd.filter(x => x._1 != null).sortBy(x => (x._1, x._2._1, x._2._2)).map(x => {
          //将rdd转换成HFile需要的格式,Hfile的key是ImmutableBytesWritable,那么我们定义的RDD也是要以ImmutableBytesWritable的实例为key
          //KeyValue的实例为value
          val rowKey = Bytes.toBytes(x._1)
          val family = Bytes.toBytes(x._2._1)
          val colum = Bytes.toBytes(x._2._2)
          val value = Bytes.toBytes(x._2._3)
          (new ImmutableBytesWritable(rowKey), new KeyValue(rowKey, family, colum, value))
        })
    
        //临时文件保存位置,在hdfs上
        print(" 临时文件保存位置 hdfs://node01:8020/tmp/test2")
        val tmpdir = "hdfs://node01:8020/tmp/test2"
    
        val hconf = new Configuration()
        hconf.set("fs.defaultFS", "hdfs://node01:8020")
    
        val fs = FileSystem.get(new URI("hdfs://node01:8020"), hconf, "hadoop") //hadoop为你的服务器用户名
        if (fs.exists(new Path(tmpdir))) { //由于生成Hfile文件的目录必须是不存在的,所以我们存在的话就把它删除掉
          println("删除临时文件夹")
          fs.delete(new Path(tmpdir), true)
        }
    
        //创建HBase的配置
        val conf = HBaseConfiguration.create()
        conf.set("hbase.zookeeper.quorum", "node01,node02,node03")
        conf.set("hbase.zookeeper.property.clientPort", "2181")
    
        //为了预防hfile文件数过多无法进行导入,设置该参数值
        conf.setInt("hbase.mapreduce.bulkload.max.hfiles.perRegion.perFamily", 5000)
        //此处运行完成之后,在tmpdir生成的Hfile文件
        rdds.saveAsNewAPIHadoopFile(tmpdir,
          classOf[ImmutableBytesWritable],
          classOf[KeyValue],
          classOf[HFileOutputFormat2],
          conf)
        //开始HFile导入到Hbase
        val load = new LoadIncrementalHFiles(conf)
        //hbase的表名
        val tableName = "B_TEST_STU"
    
        //创建hbase的链接,利用默认的配置文件,实际上读取的hbase的master地址
        val conn = ConnectionFactory.createConnection(conf)
        //根据表名获取表
        val table = conn.getTable(TableName.valueOf(tableName))
    
        try {
    
          //获取hbase表的region分布
          val regionLocator = conn.getRegionLocator(TableName.valueOf(tableName))
          println("获取hbase表的region分布:   "+regionLocator)
          //创建一个hadoop的mapreduce的job
          val job = Job.getInstance(conf)
    
          //设置job名称,随便起一个就行
          job.setJobName("bulkload_stu_test")
    
          //此处最重要,需要设置文件输出的key,因为我们要生成HFil,所以outkey要用ImmutableBytesWritable
          job.setMapOutputKeyClass(classOf[ImmutableBytesWritable])
    
          //输出文件的内容KeyValue
          job.setMapOutputValueClass(classOf[KeyValue])
          print("配置HFileOutputFormat2的信息-----开始导入----------")
          //配置HFileOutputFormat2的信息
          HFileOutputFormat2.configureIncrementalLoad(job, table, regionLocator)
          print("开始导入----------")
          //开始导入
          load.doBulkLoad(new Path(tmpdir), conn.getAdmin, table, regionLocator)
          print("结束导入----------")
        } finally {
          table.close()
          conn.close()
        }
      }
    }
    
    

    上面是基于hive1.x
    后面我又基于hive2.x实现了bulkload方式导入。

    <properties>
            <hadoop-version>2.6.5</hadoop-version>
            <hive-version>2.3.2</hive-version>
            <hbase-version>1.2.4</hbase-version>
            <spark-version>2.0.0</spark-version>
            <scala-version>2.11.8</scala-version>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.scala-lang</groupId>
                <artifactId>scala-library</artifactId>
                <version>${scala-version}</version>
            </dependency>
    
            <!-- Spark Dependencies -->
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-core_2.11</artifactId>
                <version>${spark-version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-sql_2.11</artifactId>
                <version>${spark-version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-hive_2.11</artifactId>
                <version>${spark-version}</version>
            </dependency>
    
            <!--连接连接hive元数据的服务-->
            <dependency>
                <groupId>org.apache.spark</groupId>
                <artifactId>spark-hive-thriftserver_2.11</artifactId>
                <version>${spark-version}</version>
                <scope>provided</scope>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-common</artifactId>
                <version>${hbase-version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-server</artifactId>
                <version>${hbase-version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-client</artifactId>
                <version>${hbase-version}</version>
            </dependency>
    
            <!-- 指定hadoop-client API的版本 -->
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-client</artifactId>
                <version>${hadoop-version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-common</artifactId>
                <version>${hadoop-version}</version>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-hdfs -->
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-hdfs</artifactId>
                <version>${hadoop-version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hive</groupId>
                <artifactId>hive-hbase-handler</artifactId>
                <version>${hive-version}</version>
            </dependency>
        </dependencies>
    
        <build>
            <pluginManagement>
                <plugins>
                    <!-- 编译scala的插件 -->
                    <plugin>
                        <groupId>net.alchim31.maven</groupId>
                        <artifactId>scala-maven-plugin</artifactId>
                        <version>3.2.2</version>
                    </plugin>
                    <!-- 编译java的插件 -->
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.5.1</version>
                    </plugin>
                </plugins>
            </pluginManagement>
            <plugins>
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>scala-maven-plugin</artifactId>
                    <executions>
                        <execution>
                            <id>scala-compile-first</id>
                            <phase>process-resources</phase>
                            <goals>
                                <goal>add-source</goal>
                                <goal>compile</goal>
                            </goals>
                        </execution>
                        <execution>
                            <id>scala-test-compile</id>
                            <phase>process-test-resources</phase>
                            <goals>
                                <goal>testCompile</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
    
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <executions>
                        <execution>
                            <phase>compile</phase>
                            <goals>
                                <goal>compile</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
    
                <!-- 打jar插件 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.4.3</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <filters>
                                    <filter>
                                        <artifact>*:*</artifact>
                                        <excludes>
                                            <exclude>META-INF/*.SF</exclude>
                                            <exclude>META-INF/*.DSA</exclude>
                                            <exclude>META-INF/*.RSA</exclude>
                                        </excludes>
                                    </filter>
                                </filters>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    

    整体上差不多。有一个小错误:
    在这里插入图片描述
    解决方式,指定spark.sql.warehouse.dir:

    val spark = SparkSession
          .builder()
          .master("local[*]")
          .appName("SavingDetail")
          .config("spark.sql.warehouse.dir","/spark-warehouse/")
          .enableHiveSupport()
          .getOrCreate()
    

    执行main方法即可将hive数据通过bulkload方式导入数据。

    展开全文
  • @[toc]一、前言HBase 只提供了简单的基于 Key 值的快速查询...HiveHBase 整合的实现是利用两者本身对外的 API 接口互相通信来完成的,其具体工作交由 Hive 的 lib 目录hive-hbase-handler-xxx.jar 工具类...

    @[toc]

    一、前言

    HBase 只提供了简单的基于 Key 值的快速查询能力,没法进行大量的条件查询,对于数据分析来说,不太友好。

    hive 整合 hbase 为用户提供一种 sqlOnHbase 的方法。Hive 与 HBase 整合的实现是利用两者本身对外的 API 接口互相通信来完成的,其具体工作交由 Hive 的 lib 目录中的 hive-hbase-handler-xxx.jar 工具类来实现对 HBase 数据的读取。

    Hive 和 HBase 通过接口互通,用户可以方便地通过 SQL 接口进行建表、映射表、查询、删除等操作。 使用 Hive 操作 HBase 中的表,只是提供了便捷性,由于对于 hiveOnHbase 表的查询走 MR 框架,因此查询效率较为缓慢需酌情使用。

    Hive 集成 HBase 可以有效利用 HBase 数据库的存储特性,如行更新和列索引等。在集成的过程中注意维持 HBase jar 包的一致性。Hive 集成 HBase 需要在 Hive 表和 HBase 表之间建立映射关系,也就是 Hive 表的列 (columns) 和列类型(column types)与 HBase 表的列族(column families)及列限定词(column qualifiers)建立关联。

    每一个在 Hive 表中的域都存在于 HBase 中,而在 Hive 表中不需要包含所有HBase 中的列。HBase 中的 RowKey 对应到 Hive 中为选择一个域使用 :key 来对应,列族(cf:)映射到 Hive 中的其它所有域,列为(cf:cq)。

    image

    二、适用场景

    实现将批量数据导入到 HBase 表中。

    image

    通过 Hive 与 HBase 整合,可以将 HBase 的数据通过 Hive 来分析,让 HBase 支持 JOIN、GROUP 等 SQL 查询语法。

    image

    构建低延时的数据仓库

    image

    三、依赖条件

    已有 HDFS、MapReduce、Hive、Zookeeper、HBase 环境。

    确保 Hive 的 lib 目录下有 hive-hbase-handler-xxx.jar、Zookeeper jar、HBase Server jar、HBase Client jar 包。

    四、具体使用

    4.1、Hive 表映射到 Hbase 中

    create table hive_people

    (

    id int,

    name string,

    age string,

    sex string,

    edu string,

    country string,

    telPhone string,

    email string

    )

    stored by 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'

    with serdeproperties ("hbase.columns.mapping" = "

    :key,

    basic_info:name,

    basic_info:age,

    basic_info:sex,

    basic_info:edu,

    other_info:country,

    other_info:telPhone,

    other_info:email

    ")

    tblproperties("hbase.table.name" = "default:hbase_people","hbase.mapred.output.outputtable" = "default:hbase_people");

    参数解释:

    hbase.columns.mapping:

    定义 hive 表中的字段与 hbase 的列族映射

    hbase.table.name:

    可选参数,仅当用户想在 Hive 和 HBase 中使用不同表名时才需要填写。

    hbase.mapred.output.outputtable:

    可选参数,仅当想往这个表中插入数据时使用(在hbase.mapreduce.TableOutputFormat 中使用到)

    stored by 'org.apache.hadoop.hive.hbase.HBaseStorageHandler':

    指定处理的存储器,就是 hive-hbase-handler-*.jar 包,要做 hive 和 hbase 的集成必须要加上这一句

    在 hive 中执行该语句后,hbase 会相应创建表,可以用 list 命令查看下。

    往 hive 中插入数据:

    insert overwrite table hive_people select * from people where age = 17;

    hive 会触发 map 任务,运行结束后在 hive 和 hbase 中都可以查询到数据。就不具体展示了。

    4.2、HBase 表映射到 Hive 表中

    在 hive 中建立 HBase 的外部映射表,只在 hive 端执行建表操作,要求 HBase 端的表事先存在。hive 端执行表删除操作时,只会删除 hive 端的外部映射表,对 HBase 中被映射的表无影响。

    所以先在 HBase 中建一张 t_employee_info 表,添加两个列族 st1,st2 :

    create 't_employee_info','st1','st2'

    对于在 HBase 已经存在的表,在 hive 中使用 CREATE EXTERNAL TABLE 来建立联系。

    create external table t_employee_info(id int,age int,sex string)

    stored by 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'

    with serdeproperties("hbase.columns.mapping"=":key,st1:age,st2:sex")

    tblproperties("hbase.table.name"="t_employee_info");

    然后往 HBase 的 t_employee_info 中添加数据:

    put 't_employee_info','1001','st2:sex','man'

    put 't_employee_info','1001','st1:age','32'

    put 't_employee_info','1002','st1:age','25'

    put 't_employee_info','1002','st2:sex','woman'

    在 hive 中查询该表:

    hive> select * from t_employee_info;

    OK

    1001 32 man

    1002 25 woman

    注意!注意!注意: 在上述示例中,使用的 insert 命令向 Hive 表中插入数据。对于批量数据的插入,还是建议使用 load 命令,但对于 Hive 外部表来说,不支持 load 命令。可以先创建一个 Hive 内部表,将数据 load 到该表中,最后将查询内部表的所有数据都插入到与 Hbase 关联的 Hive 外部表中,就可以了,相当于中转一下。

    4.3、Hive Map 类型在 HBase 中的映射

    通过 Hive 的 Map 数据类型映射 HBase 表,这样每行都可以有不同的列组合,列名与 map中的 key 对应,列值与 map 中的 value 对应 :

    CREATE TABLE hbase_table_1(value map, row_key int)

    STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'

    WITH SERDEPROPERTIES (

    "hbase.columns.mapping" = "cf:,:key"

    );

    INSERT OVERWRITE TABLE hbase_table_1 SELECT map(bar, foo), foo FROM pokes

    WHERE foo=98 OR foo=100;

    当 hbase.columns.mapping 中的列族后面为空时(形如cf:),说明在 Hive 中其对应的数据类型为 map。

    4.4、 使用 Hive 集成 HBase 表的需注意

    对 HBase 表进行预分区,增大其 MapReduce 作业的并行度

    合理的设计 rowkey 使其尽可能的分布在预先分区好的 Region 上

    通过 set hbase.client.scanner.caching 设置合理的扫描缓存(内存未提供数据的情况下扫描仪下次调用时所提取的行数。较高缓存值需启用较快速度的扫描仪,但这需要更多的内存且当缓存为空时某些下一次调用会运行较长时间 )

    五、来源

    展开全文
  • 概述:HBase:查询效率比较高,常为实时业务提供服务,但是其查询方式比较单一,只能通过row方式get单条数据,或者通过scan加过滤器的方式扫描...有时候我们数据存在HBase中,但是需要通过sql语句来操作hbase表数据...

    概述:

    HBase:

    查询效率比较高,常为实时业务提供服务,但是其查询方式比较单一,只能通过row方式get单条数据,或者通过scan加过滤器的方式扫描数据表获取数据。

    Hive:

    hive用来存储结构化数据,常用来搭建数据仓库作为离线分析的数据存储,支持HQL操作,但是对于复杂HQL都会转化成mapreduce任务,执行比较慢。

    有时候我们数据存在HBase中,但是需要通过sql语句来操作hbase表数据,我们一般使用Hive外部表操作HBase数据。

    大体步骤如下:

    1.拷贝依赖包

    将Hive操作HBase依赖的几个包拷贝到Hive安装目录下的lib下(每个hive节点都要执行拷贝):

    /usr/lib/hive/lib/zookeeper.jar;

    /usr/lib/hive/lib/hbase.jar;

    /usr/lib/hive/lib/hive-hbase-handler-X.X.X.jar

    /usr/lib/hive/lib/guava-11.0.2.jar;

    2.HBase操作

    登录hbase shell控制台,新建hbase表ljs:student(ljs是命名空间,student是表名)

    执行命令:

    create_namespace 'ljs'

    create 'ljs:student','info'

    查看表结构:

    !desc  'ljs:student'

    向HBase表插入数据:

    put 'ljs:student','1001','info:name','ljs1001'

    put 'ljs:student','1001','info:age','21'

    put 'ljs:student','1001','info:score','89'

    put 'ljs:student','2001','info:name','ljs1002'

    put 'ljs:student','2001','info:age','24'

    put 'ljs:student','2001','info:score','78'

    查看表数据:

    3.Hive操作

    执行/usr/hdp/2.6.3.0-235/hive/bin/hive登录到hive控制台

    新建hive数据表:

    create external table hive_student(user_no string,user_name string,user_age string,user_score string) stored by 'org.apache.hadoop.hive.hbase.HBaseStorageHandler' with serdeproperties  ("hbase.columns.mapping" = ":key,info:name,info:age,info:score") tblproperties("hbase.table.name" = "ljs:student");

    查询hive表,可查看hbase映射表中对应的数据:

    至此Hive操作HBase表数据完成。

    注意:

    1.hive中建hbase映射表时,建表语句中关键字“hbase.columns.mapping”后面的对应映射字段要与HBase表字段大小写一致。否则可能映射失败。

    展开全文
  • HIVE建表时可以指定映射关系直接读取HBASE数据,相当于有了一个HBASEHIVE的通道。那HIVEHBASE有通道吗?本文主要讲述了Hive数据如何入到HBASE中
  • 现在要在hive中创建一个来装下hbase中‘events_db:user_friend3’的数据。 将hbase里的数据导入hive --优化 --这是必要的准备工作 set hive.exec.dynamic.partition=true; set hive.exec.dynamic.partition.
  • Hbase数据映射到Hive

    2021-06-07 15:57:23
    Hbase数据映射到Hive //新建库 并使用库 create database events; use events; //设置变量名为db 指向库名 events set hivevar:db=events; //设置允许所有的分区列都是动态分区列00000000000000000000 ...
  • Hive整合映射HBase

    2020-12-29 19:28:32
    HiveHBase通过接口互通,用户可以方便地通过SQL接口进行建表、映射、查询、删除等操作。由于对于hiveOnHbase的查询走MR框架,因此查询效率较为缓慢需酌情使用。非CM管理的CDH集群进行整合时需以下几步:1....
  • hivehbase之间数据的同步

    千次阅读 2020-11-13 15:14:57
    一、前言 ...(一)hive关联hbase表的方式 1.适用场景 数据量不大4T以下(因为需要走hbase的api导入数据); 2.连接方式 从hbase页面获取zk连接地址(http://hadoop102:16010),并用下述方式启动h.
  • Hive数据导入Hbase

    2020-12-22 17:13:29
    方案一:Hive关联HBase表方式适用场景:数据量不大4T以下(走hbase的api导入数据)一、hbase表不存在的情况创建hive表hive_hbase_table映射hbase表hbase_table,会自动创建hbase表hbase_table,且会随着hive表删除而...
  • 命名空间:namespace-> database list_namespace #查看所有命名空间列表 create_namespace 'NS_NAME' #创建命名空间 ...list #查看当前hbase中的所有 create 'NS_NAME:TBL_NAME','C
  • hive关联hbase表

    2021-11-01 16:54:05
    hive中orc格式数据导入 Java通过jdbc连接hive 通过HiveServer2访问Hive SpringBoot连接Hive实现自助取数 hive关联hbase表 Hive udf 使用方法 Hive基于UDF进行文本分词 Hive窗口函数row number的用法 数据仓库之...
  • 背景依旧是用户画像的项目,现在标签化的数据存放在hive中,而查询是要在hbase上进行查询,所以需要将hive数据导入hbase中。方案:1、hivehbase建立映射关系,读取...
  • 1、通过 HiveHBase 整合,可以将 HBase数据通过 Hive 来分析,让 HBase 支持 JOIN、GROUP 等 SQL 查询语法。 2、HiveHbase是两种基于Hadoop的不同技术,Hive是一种类SQL的引擎,并且运行MapReduce任务,...
  • 通过hive表整合查询hbase数据

    千次阅读 2018-08-14 11:47:28
    通过Hive整合HBase,可以通过hive表查询hbase数据,下面是测试过程 --创建hbase create "user","account","address","info","userid" --创建映射hbase列族...
  • 最详细的Hive&HBase

    2022-04-03 18:07:43
    Hive 由 Facebook 实现并开源,是基于 Hadoop 的一个数据仓库工具,可以将结构化的数据映射为一张数据库,并提供 HQL(Hive SQL)查询功能,底层数据是存储 HDFS 上。 Hive 本质: 将 SQL 语句转换为 MapReduce ...
  • hbase数据同步到hive

    2021-08-27 15:17:59
    在hive中写sql 注意:EXTERNAL表示HBase中已经存在了data_detail_history; 映射字段最多只能有175个字段 ,超过175个字段,查询该会报错 CREATE EXTERNAL TABLE hbase_jssl_tgy_history( key string, code...
  • HiveHBase比较

    千次阅读 2022-02-19 11:16:29
    Hive:本质上是一个用于进行数据仓库管理的工具,实际过程经常用于对数据进行分析和清洗,提供了相对标准的SQL结构,底层会将SQL转化为MapReduce来执行,因此Hive的效率相对较低,更适合于离线开发的场景。Hive...
  • hivehbase数据迁移

    2022-06-30 17:43:49
    hivehbase数据迁移
  • 目前似乎没有提供批量删除的方法,只有一个单行删除的命令:deleteall 'tablename', rowkey二、删除方法:方法一:通过写 shell 脚本,从 hbase shell 查出需要删除的 rowkey ,拼成删除命令(deleteall 'tablename',...
  • HBASEHIVE转换

    2021-11-01 21:42:33
    在hive中建 create table if not exists employee ( uid int, uname string, age int, sex string, province string ) stored by 'org.apache.hadoop.hive.hbase.HBaseStorageHandler' with serdeproperties( ...
  • hive访问不同一集群的hbase表数据

    千次阅读 2019-09-25 16:10:52
    最近有个需求,有一些数据会实时写入到 hbase,但是又需要 hive 计算这些数据,最后把结果同步到 mysql。如果对于 hbasehive 同一个集群,是很简单的操作,直接 hive 创建一个 hbase 的外部映射就好...
  • hive-hbase映射内部:新表格,原hbase中不含该在hive中删除映射亦会同步删除hbase中被映射的;外部hbase中含有该表格,在hbase建立映射hive中的映射删除不影响hbase中
  • HBase数据导入Hive

    2021-06-07 16:52:08
    文章目录HBase数据的准备Hive建表和导入 HBase数据的准备 :event_db:users 结构 数据 Hive建表和导入 创建库:create database events 设置临时变量代表 events:set hivevar:db=events; 设置动态分区非...
  • 删除一个库的时候 ,若库里面有则提示不能删除 hive> drop database TABLENAME; FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. InvalidOperationException(message:...
  • Hive映射Hbase表

    千次阅读 2017-08-01 17:15:23
    Hive是基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射为一张数据库,并提供完整的sql查询功能,可以将sql语句转换为MapReduce任务进行运行。其优点是学习成本低,可以通过类SQL语句快速实现简单的...
  • Hive映射 Hbase

    2021-06-08 06:38:57
    hive 映射hbase
  • Hive操作Hbase(详细配置及操作)

    千次阅读 2021-01-14 17:42:20
    Hive操作Hbase(详细配置及...使用Hive删除批量Hbase数据 前言 HBase 虽然可以存储数亿或数十亿行数据,但是对于数据分析来说,不太友好,只提供了简单的基于 Key 值的快速查询能力,没法进行大量的条件查询。 不过,Hi
  • 本文讲解的使用启动我们可以使用下面命令启动Hive,使之拥有读取Hbase的功能,如果你的Hbase只有一台机器(single-node HBase server),可以使用下面命令启动hive client: $HIVE_HOME/bin/hive --auxpath $HIVE_HOME...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,343
精华内容 7,337
关键字:

在hive中删除hbase表数据