精华内容
下载资源
问答
  • HBase数据类型

    千次阅读 2020-09-08 23:44:13
    HBase数据类型 1 简介 在HBASE中,数据存储在具有行和列的表中。这是看起来关系数据库(RDBMS)一样,但将HBASE表看成是多个维度的Map结构更容易理解。 ROWKEY C1列蔟 C2列蔟 rowkey 列1 列2 列3 列4 列...

    HBase的数据类型

    1 简介

    在HBASE中,数据存储在具有行和列的表中。这是看起来关系数据库(RDBMS)一样,但将HBASE表看成是多个维度的Map结构更容易理解。

    ROWKEYC1列蔟C2列蔟
    rowkey列1列2列3列4列4列6
    rowkey0001
    C1(Map)列1 => 值1 列2 => 值2 列3 => 值3
    C2(Map)列4 => 值4 列5 => 值5 列6 => 值6
    {
      "zzzzz" : "woot",
      "xyz" : "hello",
      "aaaab" : "world",
      "1" : "x",
      "aaaaa" : "y"
    }
    
    

    2 术语

    2.1 表(Table)

    • HBase中数据都是以表形式来组织的

    • HBase中的表由多个行组成

    在HBase WebUI(http://node1.itcast.cn:16010中可以查看到目前HBase中的表)

    在这里插入图片描述

    2.2 行(row)

    • HBASE中的行由一个rowkey(行键)和一个或多个列组成,列的值与rowkey、列相关联

    • 行在存储时按行键按字典顺序排序

    • 行键的设计非常重要,尽量让相关的行存储在一起

    • 例如:存储网站域。如行键是域,则应该将域名反转后存储(org.apache.www、org.apache.mail、org.apache.jira)。这样,所有Apache域都在表中存储在一起,而不是根据子域的第一个字母展开

    2.3 列(Column)

    • HBASE中的列由列族(Column Family)和列限定符(Column Qualifier)组成

    • 表示如下——列族名:列限定符名。例如:C1:USER_ID、C1:SEX

    1.2.4 列族(Column Family)

    在这里插入图片描述

    • 出于性能原因,列族将一组列及其值组织在一起

    • 每个列族都有一组存储属性,例如:

      • 是否应该缓存在内存中
      • 数据如何被压缩或行键如何编码等
    • 表中的每一行都有相同的列族,但在列族中不存储任何内容

    • 所有的列族的数据全部都存储在一块(文件系统HDFS)

    • HBase官方建议所有的列蔟保持一样的列,并且将同一类的列放在一个列蔟中

    2.5 列标识符(Column Qualifier)

    • 列族中包含一个个的列限定符,这样可以为存储的数据提供索引

    • 列族在创建表的时候是固定的,但列限定符是不作限制的

    • 不同的行可能会存在不同的列标识符

    2.6 单元格(Cell)

    • 单元格是行、列系列和列限定符的组合

    • 包含一个值和一个时间戳(表示该值的版本)

    • 单元格中的内容是以二进制存储的

    ROWCOLUMN+CELL
    1250995column=C1:ADDRESS, timestamp=1588591604729, value=\xC9\xBD\xCE\xF7\xCA
    1250995column=C1:LATEST_DATE, timestamp=1588591604729, value=2019-03-28
    1250995column=C1:NAME, timestamp=1588591604729, value=\xB7\xBD\xBA\xC6\xD0\xF9
    1250995column=C1:NUM_CURRENT, timestamp=1588591604729, value=398.5
    1250995column=C1:NUM_PREVIOUS, timestamp=1588591604729, value=379.5
    1250995column=C1:NUM_USEAGE, timestamp=1588591604729, value=19
    1250995column=C1:PAY_DATE, timestamp=1588591604729, value=2019-02-26
    1250995column=C1:RECORD_DATE, timestamp=1588591604729, value=2019-02-11
    1250995column=C1:SEX, timestamp=1588591604729, value=\xC5\xAE
    1250995column=C1:TOTAL_MONEY, timestamp=1588591604729, value=114

    3 概念模型

    Row KeyTime StampColumnFamily contentsColumnFamily anchorColumnFamily people
    “com.cnn.www”t9anchor:cnnsi.com = “CNN”
    “com.cnn.www”t8anchor:my.look.ca = “CNN.com”
    “com.cnn.www”t6contents:html = “…”
    “com.cnn.www”t5contents:html = “…”
    “com.cnn.www”t3contents:html = “…”
    “com.example.www”t5contents:html = “…”people:author = “John Doe”
    • 上述表格有两行、三个列族(contens、ancho、people)

    • “com.cnn.www”这一行anchor列族两个列(anchor:cssnsi.com、anchor:my.look.ca)、contents列族有个1个列(html)

    • “com.cnn.www”在HBase中有 t3、t5、t6、t8、t9 5个版本的数据

    • HBase中如果某一行的列被更新的,那么最新的数据会排在最前面,换句话说同一个rowkey的数据是按照倒序排序的

    展开全文
  • HBase海量数据存储

    2020-04-20 11:33:48
    1.海量数据存储HBase表中的数据能够容纳上百亿行*上百万列。 2.面向列的存储数据在表中是按照列进行存储的,能够动态的增加列并对列进行各种操作。 3.准实时查询,HBase在海量的数据量下能够接近准实时的查询...

    1.简介

     

     1337502-20190102144147564-43981520.pnguploading.4e448015.gif转存失败重新上传取消

     

    HBase是一个基于HDFS的、分布式的、面向列的非关系型数据库。

     

    HBase的特点

    1.海量数据存储,HBase表中的数据能够容纳上百亿行*上百万列。

    2.面向列的存储,数据在表中是按照列进行存储的,能够动态的增加列并对列进行各种操作。

    3.准实时查询,HBase在海量的数据量下能够接近准实时的查询(百毫秒以内)

    4.多版本,HBase中每一列的数据都可以有多个版本。

    5.可靠性,HBase中的数据存储于HDFS中且依赖于Zookeeper进行Master和RegionServer的协调管理。 

     

    HBase与关系型数据库的区别

    1.HBase中的数据类型只有String,而关系型数据库中有char、varchar、int等。

    2.HBase中只有普通的增删改查操作,没有表与表之间的连接、子查询等,若想要在HBase中进行复杂的操作则应该使用Phoenix。

    3.HBase是基于列进行存储的,因此在查询指定列的数据时效率会很高,而关系型数据库是基于行存储,每次查询都要查询整行。

    4.HBase适合海量数据存储,而关系型数据库一般一张表不超过500M,否则就要考虑分表操作。

    5.HBase中为空的列不占用存储空间,表的设计可以非常稀疏,而关系型数据库中表的设计较谨密。

    6.HBase不支持事务,而非关系型数据库支持事务。 

    7.HBase区分大小写,而SQL不区分大小写。

     

    2.HBase的表结构

     

     

     

    *HBase中的表由RowKey、ColumnFamily、Column、Timestamp组成。

     

    RowKey

    记录的唯一标识,相当于关系型数据库中的主键。

    *RowKey最大长度为64KB且按字典顺序进行排序存储。

    *HBase会自动为RowKey加上索引,当按RowKey查询时速度很快。

     

    ColumnFamily

    列簇相当于特定的一个类别,每个列簇下可以有任意数量个列,并且列是动态进行添加的,只在插入数据后存在,HBase在创建表时只需要指定表名和列簇即可。

    *一个列簇下的成员有着相同的前缀,使用冒号来对列簇和列名进行分隔。

    *一张表中的列簇最好不超过5个。

     

    Column

    列只有在插入数据后才存在,且列在列簇中是有序的。

    *每个列簇下的列数没有限制。

     

    Timestamp

    HBase中的每个键值对都有一个时间戳,在进行插入时由HBase进行自动赋值。

     

     

    3.HBase的物理模型

     

     

     

     

    1337502-20190102162914913-718849828.pnguploading.4e448015.gif转存失败重新上传取消

     

     

    Master

    1.处理对表的添加、删除、查询等操作。

    2.进行RegionServer的负载均衡(Region与RegionServer的分配)

    3.在RegionServer宕机后负责RegionServer上的Region转移(通过WAL日志)

    *Master失效仅会导致meta数据和表无法被修改,表中的数据仍然可以进行读取和写入。

     

    RegionServer

    1.处理对表中数据的添加、删除、修改、查询等操作。

    2.维护Region并将Region中StoreFile写入到HDFS中。

    3.当Region中的数据达到一定大小时进行Region的切分。

     

    Region

    1.表中的数据存储在Region中,每个Region都由RegionServer进行管理。

    2.每个Region都包含MemoryStore和StoreFile,MemoryStore中的数据位于内存,每当MemoryStore中的数据达到128M时将会生成一个StoreFile并写入到HDFS中。

    3.Region中每个列簇对应一个MemoryStore,可以有多个StoreFile,当StoreFile的数量超过一定时,会进行StoreFile的合并,将多个StoreFile文件合并成一个StoreFile,当StoreFile文件的大小超过一定阀值时,会进行Region的切分,由Master将新Region分配到相应的RegionServer中,实现负载均衡。

      

    Zookeeper在HBase中的作用

    1.保证Master的高可用性,当状态为Active的Master无法提供服务时,会立刻将状态为StandBy的Master切换为Active状态。

    2.实时监控RegionServer集群,当某个RegionServer节点无法提供服务时将会通知Master,由Master进行RegionServer上的Region转移以及重新进行负载均衡。

    3.当HBase集群启动后,Master和RegionServer会分别向Zookeeper进行注册,会在Zookeeper中存放HBase的meta表数据,Region与RegionServer的关系、以及RegionServer的访问地址等信息。

    *meta表中维护着TableName、RowKey和Region的关联关系。

     

    HBase处理读取和写入请求的流程

    HBase处理读取请求的过程

    1.客户端连接Zookeeper,根据TableName和RowKey从Meta表中计算出该Row对应的Region。

    2.获取该Region所关联的RegionServer,并获取RegionServer的访问地址。

    3.访问RegionServer,找到对应的Region。

    4.如果Region的MemoryStore中有该Row则直接进行获取,否则从StoreFile中进行查询。

     

    HBase处理写入请求的过程

    1.客户端连接Zookeeper,根据TableName找到其Region列表。

    2.通过一定算法计算出要写入的Region。

    3.获取该Region所关联的RegionServer并进行连接。

    4.把数据分别写到HLog和MemoryStore中。

    5.每当MemoryStore中的大小达到128M时,会生成一个StoreFile。

    6.当StoreFile的数量超过一定时,会进行StoreFile的合并,将多个StoreFile文件合并成一个StoreFile,当StoreFile的文件大小超过一定阈值时,会进行Region的切分,由Master将新Region分配到相应的RegionServer中,实现负载均衡。

     

    *在第一次读取或写入时才需要连接Zookeeper,会将Zookeeper中的相关数据缓存到本地,往后直接从本地进行读取,当Zookeeper中的信息发生变化时,再通过通知机制通知客户端进行更新。

     

     

    HBase在HDFS中的目录

    1.tmp目录:当对HBase的表进行创建和删除时,会将表移动到该目录中进行操作。

    2.MasterProcWALs目录:预写日志目录,主要用于存储Master的操作日志。

    3.WALs目录:预写日志目录,主要用于存储RegionServer的操作日志。

    4.data目录:存储Region中的StoreFile。

    5.hbase.id文件:HBase集群的唯一标识。

    6.hbase.version文件:HBase集群的版本号。

    7.oldWALs目录:当WALs目录下的日志文件超过一定时间后,会将其移动到oldWALs目录中,Master会定期进行清理。

     

     

    4.HBase集群的搭建

     

    1.安装JDK和Hadoop

    由于HBase是通过JAVA语言编写的,且HBase是基于HDFS的,因此需要安装JDK和Hadoop,并配置好JAVA_HOME环境变量。

     

    由于HDFS一般都以集群的方式运行,因此需要搭建HDFS集群。

    1337502-20190103163751108-1772284052.pnguploading.4e448015.gif转存失败重新上传取消

    *在搭建HDFS集群时,需要相互配置SSH使之互相信任并且开放防火墙相应的端口,或者直接关闭防火墙。

     

    2.安装Zookeeper并进行集群的搭建

    由于HDFS HA依赖于Zookeeper,且HBase也依赖于Zookeeper,因此需要安装Zookeeper并进行集群的搭建。

    1337502-20190103164112228-2041162906.pnguploading.4e448015.gif转存失败重新上传取消

     

    3.安装HBase

    1.从CDH中下载HBase并进行解压:http://archive.cloudera.com/cdh5/cdh/5/ 

     

    2.修改hbase-env.sh配置文件

    #设置JDK的安装目录
    export JAVA_HOME=/usr/jdk8/jdk1.8.0_161
    
    #true则使用hbase自带的zk服务,false则使用外部的zk服务.
    export HBASE_MANAGES_ZK=flase

     

    3.修改hbase-site.xml配置文件

    复制代码

      <!-- 指定HBase日志的存放目录 -->  
      <property> 
        <name>hbase.tmp.dir</name>  
        <value>/usr/hbase/hbase-1.2.8/logs</value> 
      </property>  
      <!-- 指定HBase中的数据存储在HDFS中的目录 -->  
      <property> 
        <name>hbase.rootdir</name>  
        <value>hdfs://nameservice:8020/hbase</value> 
      </property>  
      <!-- 设置是否是分布式 -->  
      <property> 
        <name>hbase.cluster.distributed</name>  
        <value>true</value> 
      </property>  
      <!-- 指定HBase使用的ZK地址 -->  
      <property> 
        <name>hbase.zookeeper.quorum</name>  
        <value>192.168.1.80:2181,192.168.1.81:2181,192.168.1.82:2181</value> 
      </property> 

    复制代码

     

    4.修改regionservers文件,配置充当RegionServer的节点

    *值可以是主机名或者IP地址

    *如果Hadoop配置了HDFS HA高可用集群,那么就会有两个NameNode和一个NameService,此时就需要将HDFS的core-site.xml和hdfs-site.xml配置文件复制到HBase的conf目录下,且hbase-site.xml配置文件中的hbase.rootdir配置项的HDFS地址指向NameService的名称。

     

    5.NTP时间同步

    NTP是一个时间服务器,作用是使集群中的各个节点的时间都保持一致。

    由于在HBase集群中,Zookeeper与HBase对时间的要求较高,如果两个节点之间的时间相差过大时,那么整个集群就会崩溃,因此需要使各个节点的时间都保持一致。

    复制代码

    #查看是否安装了NTP服务
    rpm -qa|grep ntp
    
    #安装NTP服务
    yum install ntp -y
    
    #从NTP服务器中获取时间并同步本地
    ntpdate 192.168.1.80

    复制代码

    *在实际的应用场景中,可以自己搭建NTP服务器,也可以使用第三方开源的NTP服务器,如阿里等。

    使用 “ntpdate NTP服务器地址” 命令从NTP服务器中获取时间并同步本地,一般配合Linux的crontab使用,每隔5分钟进行一次时间的同步。

     

    4.启动集群

    使用bin目录下的start-hbase.sh命令启动集群,那么会在当前节点中启动一个Master和RegionSever进程,并通过SSH访问其它节点,启动RegionServer进程。

     

    由于HBase的Master HA集群是通过Zookeeper进行协调的,需要手动在其他节点中启动Master,Zookeeper能保证当前HBase集群中有且只有一个Master处于Active状态,当状态为Active的Master无法正常提供服务时,会将处于StandBy的Master的状态修改为Active。 

     

    *当HBase集群启动后,可以访问http:/localhost:16030,进入HBase的Web监控页面。

     

     

    5.使用Shell操作HBase

     

    使用bin/hbase shell命令进行HBase的Shell操作

    复制代码

    #创建表
    create 'tableName' , 'columnFamily' , 'columnFamily...'
    
    #添加记录
    put 'tableName' , 'rowkey' , 'columnFamily:column' , 'value'
    
    #查询记录
    get 'tableName' , 'rowkey'
    
    #统计表的记录数
    count 'tableName'
    
    #删除记录
    deleteall 'tableName' , 'rowkey'
    
    #删除记录的某一列
    delete 'tableName' , 'rowkey' ,'columnFamily:column'
    
    #禁用表
    disable 'tableName'
    
    #启动表
    enable 'tableName'
    
    #查看表是否被禁用
    is_disabled 'tableName'
    
    #删除表
    drop 'tableName'
    
    #查看表中的所有记录
    scan 'tableName'
    
    #查看表中指定列的所有记录
    scan 'tableName' , {COLUMNS=>'columnFamily:column'}
    
    #检查表是否存在
    exists 'tableName'
    
    #查看当前HBase中的表
    list

    复制代码

     

    *在删除表时需要禁用表,否则无法删除。

    *使用put相同rowkey的一条数据来进行记录的更新,仅会更新列相同的值。

     

     

    6.使用JAVA操作HBase

     

    1.导入相关依赖

    <dependency>
      <groupId>org.apache.hbase</groupId>
      <artifactId>hbase-client</artifactId>
      <version>1.2.8</version>
    </dependency>

     

    2.初始化配置

    使用HBaseConfiguration的create()静态方法创建一个Configuration实例,用于封装环境配置信息。

    Configuration config = HBaseConfiguration.create();
    config.set("hbase.zookeeper.quorum","192.168.1.80,192.168.1.81,192.168.1.82");
    config.set("hbase.zookeeper.property.clientPort","2181");

    *此方法会默认加载classpath下的hbase-site.xml配置文件,如果没有此配置文件则需要手动进行环境的配置。

     

    3.创建HBase连接对象

    Connection conn = ConnectionFactory.createConnection(config);

     

    4.进行表的管理

    *使用Admin类进行HBase表的管理,通过Connection实例的getAdmin()静态方法返回一个Admin实例。

    复制代码

    //判断表是否存在
    boolean tableExists(TableName);
    
    //遍历HBase中的表定义
    HTableDescriptor [] listTables();
    
    //遍历HBase中的表名称
    TableName [] listTableNames();
    
    //根据表名获取表定义
    HTableDescriptor getTableDescriptor(TableName);
    
    //创建表
    void createTable(HTableDescriptor);
    
    //删除表
    void deleteTable(TableName);
    
    //启用表
    void enableTable(TableName);
    
    //禁用表
    void disableTable(TableName);
    
    //判断表是否是启用状态
    boolean isTableEnabled(TableName);
    
    //判断表是否是禁用状态
    boolean isTableDisabled(TableName);
    
    //为表添加列簇
    void addColumn(TableName,HColumnDescriptor);
    
    //删除表中的列簇
    void deleteColumn(TableName,byte);
    
    //修改表中的列簇
    void modifyColumn(TableName,HColumnDescriptor);

    复制代码

     

    TableName实例用于封装表名称。

    HTableDescriptor实例用于封装表定义,包括表的名称、表的列簇等。

    HColumnDescriptor实例用于封装表的列簇。

     

    5.对表中的数据进行增删改查

    使用Table类进行表数据的增删改查,通过Connection的getTable(TableName)静态方法返回一个Table实例。

    复制代码

    //判断指定RowKey的数据是否存在
    boolean exists(Get get);
    
    //根据RowKey获取数据
    Result get(Get get);
    
    //根据多个RowKey获取数据
    Result [] get(List<Get>);
    
    //获取表的扫描器
    ResultScanner getScanner(Scan);
    
    //添加数据
    void put(Put);
    
    //批量添加数据
    void put(List<Put>);
    
    //删除数据
    void delete(Delete);
    
    //批量删除数据
    void delete(List<Delete>)

    复制代码

     

    使用Get实例封装查询参数,使用其构建方法设置RowKey。

    使用Put实例封装新增和更新参数,使用其构建方法设置RowKey,使用其addColumn(byte[] family , byte[] qualifier , byte[] value)方法分别指定列簇、列名、列值。

    使用Delete实例封装删除参数,使用其构建方法设置RowKey。

    使用Scan实例封装扫描器的查询条件,使用其addFamily(byte[] family)方法设置扫描的列簇,使用其addColumn(byte[] family , byte[] qualifier)方法分别指定要扫描的列簇和列名。

     

    *在进行表的增删改查时,方法参数大多都是字节数组类型,可以使用HBase Java提供的Bytes工具类进行字符串和字节数组之间的转换。

    *在进行查询操作时,会返回Result实例,Result实例包含了一个RowKey的所有键值对(cell,不区分列簇),可以通过Result实例的listCells()方法获取其包含的所有cell,借助CellUtil工具类获取Cell实例中对应的RowKey、Family、Qualifier、Value等属性信息。

    *在使用getScanner扫描时,返回的ResultScanner接口继承Iterable接口,其泛型是Result,因此可以理解成ResultScanner是Result的一个集合。

     

    6.完整的HBaseUtil

    复制代码

    /**
     * @Auther: ZHUANGHAOTANG
     * @Date: 2018/11/26 11:40
     * @Description:
     */
    public class HBaseUtils {
    
        private static final Logger logger = LoggerFactory.getLogger(HBaseUtils.class);
    
        /**
         * ZK集群地址
         */
        private static final String ZK_CLUSTER_HOSTS = "192.168.1.80,192.168.1.81,192.168.1.82";
    
        /**
         * ZK端口
         */
        private static final String ZK_CLUSTER_PORT = "2181";
    
        /**
         * HBase全局连接
         */
        private static Connection connection;
    
        static {
            //默认加载classpath下hbase-site.xml文件
            Configuration configuration = HBaseConfiguration.create();
            configuration.set("hbase.zookeeper.quorum", ZK_CLUSTER_HOSTS);
            configuration.set("hbase.zookeeper.property.clientPort", ZK_CLUSTER_PORT);
            try {
                connection = ConnectionFactory.createConnection(configuration);
            } catch (Exception e) {
                logger.info("初始化HBase连接失败:", e);
            }
        }
    
        /**
         * 返回连接
         */
        public static Connection getConnection() {
            return connection;
        }
    
        /**
         * 创建表
         */
        public static void createTable(String tableName, String... families) throws Exception {
            Admin admin = connection.getAdmin();
            if (admin.tableExists(TableName.valueOf(tableName))) {
                throw new UnsupportedOperationException("tableName " + tableName + " is already exists");
            }
            HTableDescriptor descriptor = new HTableDescriptor(TableName.valueOf(tableName));
            for (String family : families)
                descriptor.addFamily(new HColumnDescriptor(family));
            admin.createTable(descriptor);
        }
    
        /**
         * 删除表
         */
        public static void deleteTable(String tableName) throws Exception {
            Admin admin = connection.getAdmin();
            if (admin.tableExists(TableName.valueOf(tableName))) {
                admin.disableTable(TableName.valueOf(tableName));
                admin.deleteTable(TableName.valueOf(tableName));
            }
        }
    
        /**
         * 获取所有表名称
         */
        public static TableName[] getTableNameList() throws Exception {
            Admin admin = connection.getAdmin();
            return admin.listTableNames();
        }
    
        /**
         * 获取所有表定义
         */
        public static HTableDescriptor[] getTableDescriptorList() throws Exception {
            Admin admin = connection.getAdmin();
            return admin.listTables();
        }
    
        /**
         * 为表添加列簇
         */
        public static void addFamily(String tableName, String family) throws Exception {
            Admin admin = connection.getAdmin();
            if (!admin.tableExists(TableName.valueOf(tableName))) {
                throw new UnsupportedOperationException("tableName " + tableName + " is not exists");
            }
            admin.addColumn(TableName.valueOf(tableName), new HColumnDescriptor(family));
        }
    
        /**
         * 删除表中指定的列簇
         */
        public static void deleteFamily(String tableName, String family) throws Exception {
            Admin admin = connection.getAdmin();
            admin.deleteColumn(TableName.valueOf(tableName), Bytes.toBytes(family));
        }
    
        /**
         * 为表添加一条数据
         */
        public static void put(String tableName, String rowKey, String family, Map<String, String> values) throws Exception {
            Table table = connection.getTable(TableName.valueOf(tableName));
            Put put = new Put(Bytes.toBytes(rowKey));
            for (Map.Entry<String, String> entry : values.entrySet())
                put.addColumn(Bytes.toBytes(family), Bytes.toBytes(entry.getKey()), Bytes.toBytes(entry.getValue()));
            table.put(put);
        }
    
        /**
         * 批量为表添加数据
         */
        public static void batchPut(String tableName, String family, Map<String, Map<String, String>> values) throws Exception {
            Table table = connection.getTable(TableName.valueOf(tableName));
            List<Put> puts = new ArrayList<>();
            for (Map.Entry<String, Map<String, String>> entry : values.entrySet()) {
                Put put = new Put(Bytes.toBytes(entry.getKey()));
                for (Map.Entry<String, String> subEntry : entry.getValue().entrySet())
                    put.addColumn(Bytes.toBytes(family), Bytes.toBytes(subEntry.getKey()), Bytes.toBytes(subEntry.getValue()));
                puts.add(put);
            }
            table.put(puts);
        }
    
        /**
         * 删除RowKey中的某列
         */
        public static void deleteColumn(String tableName, String rowKey, String family, String qualifier) throws Exception {
            Table table = connection.getTable(TableName.valueOf(tableName));
            Delete delete = new Delete(Bytes.toBytes(rowKey));
            delete.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
            table.delete(delete);
        }
    
        /**
         * 删除RowKey
         */
        public static void delete(String tableName, String rowKey) throws Exception {
            Table table = connection.getTable(TableName.valueOf(tableName));
            table.delete(new Delete(Bytes.toBytes(rowKey)));
        }
    
        /**
         * 批量删除RowKey
         */
        public static void batchDelete(String tableName, String... rowKeys) throws Exception {
            Table table = connection.getTable(TableName.valueOf(tableName));
            List<Delete> deletes = new ArrayList<>();
            for (String rowKey : rowKeys)
                deletes.add(new Delete(Bytes.toBytes(rowKey)));
            table.delete(deletes);
        }
    
        /**
         * 根据RowKey获取数据
         */
        public static Map<String, String> get(String tableName, String rowKey) throws Exception {
            Table table = connection.getTable(TableName.valueOf(tableName));
            Result result = table.get(new Get(Bytes.toBytes(rowKey)));
            List<Cell> cells = result.listCells();
            Map<String, String> cellsMap = new HashMap<>();
            for (Cell cell : cells) {
                cellsMap.put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
            }
            return cellsMap;
        }
    
        /**
         * 获取全表数据
         */
        public static Map<String, Map<String, String>> scan(String tableName) throws Exception {
            Table table = connection.getTable(TableName.valueOf(tableName));
            ResultScanner resultScanner = table.getScanner(new Scan());
            return getResult(resultScanner);
        }
    
        /**
         * 获取某列数据
         */
        public static Map<String, Map<String, String>> scan(String tableName, String family, String qualifier) throws Exception {
            Table table = connection.getTable(TableName.valueOf(tableName));
            Scan scan = new Scan();
            scan.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
            ResultScanner resultScanner = table.getScanner(scan);
            return getResult(resultScanner);
        }
    
        private static Map<String, Map<String, String>> getResult(ResultScanner resultScanner) {
            Map<String, Map<String, String>> resultMap = new HashMap<>();
            for (Result result : resultScanner) {
                List<Cell> cells = result.listCells();
                Map<String, String> cellsMap = new HashMap<>();
                for (Cell cell : cells)
                    cellsMap.put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
                resultMap.put(Bytes.toString(result.getRow()), cellsMap);
            }
            return resultMap;
        }
    
    }

    复制代码

     

    展开全文
  • hive与hbase数据类型对应关系

    千次阅读 2014-12-26 02:20:28
    hive与hbase数据类型对应关系 当hbase中double,int 类型以byte方式存储时,用字符串取出来必然是乱码。 在hivd与hbase整合时也遇到这个问题:做法是:#b 1.加#b CREATE EXTERNAL TABLE hivebig (key string,...

    hive与hbase数据类型对应关系

    当hbase中double,int 类型以byte方式存储时,用字符串取出来必然是乱码。

    在hivd与hbase整合时也遇到这个问题:做法是:#b

    1.加#b

    CREATE EXTERNAL TABLE hivebig (key string,CUST_NAME string,PHONE_NUM int,BRD_WORK_FLUX double) 

    STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler' 
    WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,bd:CUST_NAME, bd:PHONE_NUM#b, bd:BRD_WORK_FLUX#b") 
    TBLPROPERTIES ("hbase.table.name" = "bigtable2");


    2.不加#b时,hive shell读取出来是乱码

    CREATE EXTERNAL TABLE hivebig (key string,CUST_NAME string,PHONE_NUM int,BRD_WORK_FLUX double) 

    STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler' 
    WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,bd:CUST_NAME, bd:PHONE_NUM, bd:BRD_WORK_FLUX") 
    TBLPROPERTIES ("hbase.table.name" = "bigtable2");
    select * FROM hivebig;


    select * FROM hivebig where PHONE_NUM > 1;

    select * FROM hivebig where BRD_WORK_FLUX > 1555;


    cf:val#s 中的#s就表示类型为string,cf:foo没有配置类型,则采用hbase.table.default.storage.type的配置,#b为binary

    展开全文
  • 1.Hbase shell 中插入带int类型数据 ...Hbase会将int类型数据自动转换为字符类型存储。方便我们在shell中观察和操作。 2.在Java API中编写插入带int类型数据 在Java API插入int型数据会保存为ASCII形式。...

    1.Hbase shell 中插入带int类型的数据

    在Hbase的shell命令中输入插入一行value为int类型的数据

    put 'hbase1','row','hb1:age',30

    Hbase会将int类型数据自动转换为字符类型来存储。方便我们在shell中观察和操作。

    2.在Java API中编写插入带int类型的数据

    在Java API插入int型数据会保存为ASCII形式。这样我们就只能看出是ASCII码。

    3.Hbase shell默认转换的缺陷

    在业务需求中出现比较大小的时候,这时候就没法比了,然而使用Java API操作的是ASCII码。

    取出来的是Int类型的数据。可以进行比较。

    展开全文
  • Hbase如何存储数据

    千次阅读 2016-11-18 17:32:46
    1、HBase是一个针对结构化的可伸缩、高可靠的、面向列的开源数据库,HBase不同于传统的关系型数据库,采用了BigT的able数据模型,是一个适合于非结构化数据存储的数据库。HBase是Apache的Hadoop项目的子项目。HBase...
  • HBase删除数据

    2021-02-27 17:05:36
    由于HBase底层依赖HDFS,对于HBase删除操作来说,HBase无法在查询到之前的数据并进行修改,只能顺序读写,追加记录。为了更新或删除数据HBase会插入一条一模一样的新的数据,但是key type会标记成Delete状态,以...
  • Hbase–海量数据导入HbaseHbase数据导入Hdfs 文章目录Hbase--海量数据导入HbaseHbase数据导入Hdfs一:海量数据导入Hbase1.代码实现2.遇到的错误以及注意要点二:数据Hbase导入到Hdfs1.代码实现2.遇到的错误...
  • Hbase存储及元数据meta

    2021-01-19 22:20:29
    Hbase的列族式存储 列族就是多个数据列的组合,列族式可以说是表的schema的一部分,而列不是。Hbase可以说是列簇数据库,在创建表的时候要指定列族,而不需要指定...Hbase数据存储原型 HBase 是一个稀疏的、分布式、
  • HBASE就是基于Hadoop的一个开源项目,也是对Google的BigTable的一种实现。  BigTable是什么?Google的Paper对其作了充分的说明。字面上看就是一张大表,其实和我们想象的传统数据库的表还是有些差别的。松散数据...
  • HBase加载数据原理:利用HBase的数据信息按照特定格式存储在hdfs内这一原理,直接...HBase的数据在底层文件中时以KeyValue键值对的形式存储的,HBase没有数据类型,HFile中存储的是字节,这些字节按字典序排列。 自...
  • HBase 0.1.0 数据存储基本结构详解

    千次阅读 2012-12-02 18:26:26
    HBase采用了LSM-Tree来解决数据存储问题。其中有几个核心数据结构: HRegion:一个独立的数据存储单元。存储从startkey-endkey的所有数据。HRegion中会根据每个columnfamily生成一个HStore对象 HStore:存储了...
  • HBase(2.3)-HBase存储格式、数据模型

    千次阅读 2017-08-23 14:34:02
    1.HBase数据模型 1.1 逻辑视图 hbase模式里的逻辑实体包括: (1)表(table):HBase用表来组织数据。...行键没有数据类型,总是视为字节数组byte []。 (3)列族(column family):行里的数据按照列
  • HBase数据检索流程与数据存储

    千次阅读 2017-08-17 09:20:21
    一、HBase数据检索流程  上图中,我们可以看出不管客户端读或写一个表的数据,首先链接Zookeeper,因为需要到Zookeeper中找读的数据,表是通过Region来管理,每个Region由RegionServer管理...
  • 以上对long类型数据的累加,double类型数据累加是将double类型*10000,这样将double转成一个long类型的数字进行累加,使用这种方法时要注意控制double类型数据的精度 转载于:...
  • HBase数据分布

    2018-09-19 17:20:33
    浅谈HBase数据分布 摘要: HBase的rowkey设计一直都是难点和痛点,不合适的rowkey设计会导致读写性能、吞吐不佳等诸多问题。本文从数据分布问题展开,介绍HBase基于Range的分布策略与region的调度问题,详细讨论...
  • HBase读写数据流程1. 架构分析1.1 HMaster1.2 HRegionServer1.3HRegion1.4 Store2. 复合键设计3. 数据结构3.1 RowKey3.2 Column ...负责管理HBase数据,即表的结构、表存储的Region等元信息。 负责表的创建,删
  • HBASE就是基于Hadoop的一个开源项目,也是对Google的BigTable的一种实现。  BigTable是什么?Google的Paper对其作了充分的说明。字面上看就是一张大表,其实和我们想象的传统数据库的表还是有些差别的。松散...
  • 本节和大家一起学习一下Hadoop:HBASE松散数据存储设计方面的内容,希望通过本节介绍大家能够掌握Hadoop:HBASE松散数据存储设计的方法。 Hadoop:HBASE松散数据存储设计初识 最近关注Hadoop,因此也顺便关注了...
  • 2 HBase数据模型

    2021-07-22 15:17:36
    HBase数据模型 HBase数据模型HBase数据模型数据模型解析专业术语...数据类型:int,char… HBase不存在数据类型,字节存储 数据模型:行,列 HBase不仅有行列,HBase还有:RK,CF,TS,Q,cell 专业术语 NameSpace:
  • HBase数据模型

    2019-06-11 01:38:45
    文章目录1、HBse表结构2、HBase 与 HDFS 的关系3、HBase 使用选择4、HBase 数据存储模型4.1 CAP 定理4.2 ACID4.3 数据模型4.4 HBase 与 RDBMS 的区别 1、HBse表结构 HBase 是面向列的数据库。有别于RDBMS(行式...
  • 摘 要:随着互联网Web2.0的兴起,数据量在以指数级飞速增长的同时数据类型也越来越多样化,因此如何实现海量多样化数据的存储和检索成为急需解决的问题。相比传统关系型数据库,非关系型数据库为我们提供了高可用、...
  • Hbase 数据模型

    2017-09-22 17:26:30
    Hbase 数据模型 行键(rowkey) 时间戳 列族a 列族b 列族c douguo st1 1     st2 2 4 7 st3 3 ...* Hbase中,数据全都以字节数组类型存储 Row Key
  • Hbase数据模型与存储结构

    万次阅读 多人点赞 2018-09-02 00:32:10
    依托Hadoop-HDFS作为其文件存储系统,利用MapReduce来处理海量数据,用Zookeeper作为其分布式协同服务,主要用来存储非结构化和半结构化的松散数据(列存 NoSQL 数据库)。 二、 Hbase数据模型 1、存储模型分布 ...
  • Kafka里存的是Json数据,StreamSets通过解析JSON数据后把每个字段值写入HBase,因为JSON里字段是没有具体数据类型的,StreamSets可能会把字段转成字符串后解析成二进制写入HBase,这里就造成存储HBase的Decimal类型...
  • Hbase存储详解

    千次阅读 2018-12-22 16:47:53
    Hbase存储详解 一、概述  Hbase是建立的hdfs之上,提供高可靠性、高性能、列存储、可伸缩、实时读写的数据库系统。  它介于nosql和RDBMS之间,仅能通过主键(row key)和主键的range来检索数据,仅支持单行事务...
  • HBase学习(三) HBase数据结构

    千次阅读 2021-03-23 14:35:33
    目录RowKeyColumn FamilyCellTime Stamp命名空间 RowKey HBase 数据库中也有一个表示唯一的键,这个唯一的键是 RowKey。...存储时,数据按照RowKey的字典序(byte order)排序存储。设计RowKey时,要充分排序存储这个特

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,362
精华内容 20,544
关键字:

hbase存储数据类型