精华内容
下载资源
问答
  • Hbase 删除某一列

    2018-02-07 10:47:03
    删除Hbase中某个表的一列值 命令 java -jar deleteOneColumn.jar(这个文件的路径) '表名' '列簇名' '列名'
  • HBase简介HBase个分布式的、面向的开源数据库存储系统,是对Google论文BigTable的实现,具有高可靠性、高性能和可伸缩性,它可以处理分布在数千台通用服务器上的PB级的海量数据。BigTable的底层是通过GFS...

    02cd0f750644b519214255d539fd0afa.png

    102de5481c54361ddee6e9af2a64efbb.png

    HBase简介

    HBase是一个分布式的、面向列的开源数据库存储系统,是对Google论文BigTable的实现,具有高可靠性高性能可伸缩性,它可以处理分布在数千台通用服务器上的PB级的海量数据。BigTable的底层是通过GFS(Google文件系统)来存储数据,而HBase对应的则是通过HDFS(Hadoop分布式文件系统)来存储数据的。

    HBase不同于一般的关系型数据库,它是一个适合于非结构化数据存储的数据库。HBase不限制存储的数据的种类,允许动态的、灵活的数据模型。HBase可以在一个服务器集群上运行,并且能够根据业务进行横向扩展。

    HBase特点

    f39193ba9a749f084ae5961f532a8c3d.png
    • 海量存储:HBase适合存储PB级别的海量数据,在PB级别的数据以及采用廉价PC存储的情况下,能在几十到百毫秒内返回数据。这与HBase的记忆扩展性息息相关。正是因为HBase的良好扩展性,才为海量数据的存储提供了便利。
    • 列式存储:列式存储,HBase是根据列族来存储数据的。列族下面可以有非常多的列,列族在创建表的时候就必须指定,而不用指定列。
    • 极易扩展:HBase的扩展性主要体现在两个方面,一个是基于上层处理能力(RegionServer)的扩展,一个是基于存储能力(HDFS)的扩展。
    • 高并发:目前大部分使用HBase的架构,都是采用廉价PC,因此单个IO的延迟其实并不小,一般在几十到上百ms之间。这里说的高并发,主要是在并发的情况下,HBase的单个IO延迟下降并不多。
    • 稀疏:稀疏主要是针对HBase列的灵活性,在列族中,可以指定任意多的列,在列数据为空的情况下,是不会占用存储空间。

    HBase与关系型数据库对比

    bb9efe1d1876d5f19a7de06e1c5c0112.png

    HBase数据模型

    • Namespace(表命名空间):表命名空间不是强制的,如果想把多个表分到一个组去统一管理的时候才会用到表命名空间。
    • Table(表):一个表由一个或者多个列族组成。
    • Row(行):一个行包含了多个列,这些列通过列族来分类。行中的数据所属列族只能从该表所定义的列族中选取,不能定义这个表中不存在的列族。
    • Column Family(列族):列族是多个列的集合。
    • Column Qualifier(列):多个列组成一个行。列族和列用:Column Family:Column Qualifier表示。列是可以随意定义的,一个行中的列不限名字,不限数量,只限定列族。
    • Cell(单元格):一个列中可以存储多个版本的数据,每个版本就称为一个Cell。也就是说在HBase中一个列可以保存多个版本的数据。
    • Timestamp(时间戳/版本号):用来标定同一个列中多个Cell的版本号。当在插入数据的时候,如果不指定版本号,系统会自动采用系统的当前时间戳来作为版本号,也可以手动指定一个数字作为版本号。
    • Rowkey(行键):用来标识表中唯一的一行数据,以字节数组形式存储,类似关系型数据库中表的主键。rowkey在HBase中时严格按照字典序排序的。

    a4113f6ab83a94413870c6566559dd83.png

    物理视图

    在物理存储上,数据是以Key-Vaule对形式存储,每个Key-Value只存储一个Cell里面的数据,不同的列族存储在不同的文件中,每个逻辑单元格(Cell)会对应一行数据,有Timestamp标记版本,每次插入、删除都会生成一行数据(append-only,写效率高)。

    8796030262a0290061161e3ab0798bad.png

    1a6530784f00001c639d9dc4c5359b9d.png

    HBase体系架构

    HBase的服务器体系结构遵循简单的主从服务器架构,一般一个HBase集群由一个Master服务(高可用的话,至少两个)和1个或多个RegionServer服务组成。Master服务负责维护表结构信息,实际的数据是保存在RegionServer上,最终RegionServer保存的表数据会直接存储在HDFS上。HBase的体系架构图如下图所示:

    bcea5125f4e15579b2987305db7b2b23.png

    Master HBase的管理节点,在一个集群中Master一般是主备的,主备的选择是由Zookeeper实现的。

    HBase Master主要职责:

    • 为RegionServer分配Region;
    • 负责RegionServer的负载均衡;
    • 发现失效的RegionServer并重新分配其上的Region;
    • 处理Schema更新请求(表的创建、删除、修改、列族的增加等)。

    RegionServer

    RegionServer主要负责服务和管理Region。在分布式集群中,建议RegionServer和DataNode按照1:1比例部署,这样RegionServer中的数据文件可以存储一个副本于本机的DataNode节点中,从而在读取数据时可以利用HDFS的"短路径读取(Short Circuit)"来绕过网络请求,降低读延时。

    RegionServer内部管理一个或多个Region。Region许多Store组成。每个Store对用Table中的一个列族存储,即一个Store管理一个Region上的一个列族。每个Store包含一个MemStore和0到多个StoreFile。

    RegionServer的主要职责:

    • RegionServe维护Master分配给它的Region,处理Client对这些Region的IO请求;
    • RegionServer还负责Region的Split、Compaction。

    Zookeeper

    HBase通过Zookeeper来做Master的高可用、RegionServer的监控、元数据的入口以及集群配置的维护等工作。具体工作如下:

    • 为HBase提供Failover机制,选举master,避免master单点故障问题;
    • 存储所有Region的寻址入口,保存hbase:meta表信息;
    • 实时监控RegionServer的状态,将RegionServer的上线和下线信息实时通知给master;
    • 存储HBase的Schema,包括有哪些Table,每个Table有哪些Column Family。

    HDFS

    HDFS为HBase提供最终的底层数据存储服务,同时为HBase提供高可用(HLog)的支持。HBase底层存储并非必须是HDFS文件系统,但是HDFS是最佳选择,也是目前应用最广泛的选择。HDFS具体功能如下:

    • 提供元数据和表数据的底层分布式存储服务;
    • 数据多副本,保证了高可靠和高可用性

    Client

    Client使用HBase的RPC机制与HMaster、RegionServer进行通信,Client与Master进行管理类通信,与RegionServer进行数据操作类通信。Client包含了访问HBase的接口,另外Client还维护了对应的cache来加速HBase的访问,比如.META.元数据信息。

    RegionServer内部结构

    1a831a06d8fec6c79e2dfb4bf77a24a0.png
    • WAL:预写日志(Write Ahead Log)。当操作到达Region的时候,HBase先把数据写到WAL中,再把数据写到MemStore中,等数据达到阈值时才会被刷写(flush)到最终存储的HFile中。WAL是一个保险机制,这样在Region的机器宕机时,由于WAL的数据是存储在HDFS中的,可以从WAL中恢复数据,所以数据并不会丢失。
    • BlockCache:读缓存,用于在内存中缓存经常被读的数据。Least Recently Used (LRU) 数据在存满时会被失效。
    • Region:Region相当于一个数据的分片。每一个Region都有起始rowkey和结束rowkey,这表示了Region的存储的row的范围。一个RegionServer包含多个Region,一个表的一段键值在一个RegionServer上会产生一个Region。在一个RegionServer中有一个或多个Region。
    • Store:一个Region包含多个Store,一个列族分为一个Store,如果一个表只有一个列族,那么这个表在这台机器上的每一个Region里面都只有一个Store。Store是HBase的存储核心,一个Store里面有一个MemStore和一个或多个HFile。
    • MemStore:有序的内存缓冲区,用于缓存还未被持久化到磁盘的数据,在持久化之前会先将数据排序,每个Region的每个列族(Store)都有一个 MemStore。
    • HFile:真正存在硬盘上的,对数据按照Rowkey排好序的键值对文件。每次MemStore的flush会产生新的HFile文件。

    用户写入的数据先写入WAL,然后写入MemStore,当MemStore满了以后会Flush成一个StoreFile(存储为HFile),当StoreFile数量到达一定阈值,会触发Compact合并,将多个StoreFile合并成一个StoreFile。StoreFiles合并后会逐渐形成越来越大的StoreFile,当Region内的所有的StoreFiles的总的大小超过阈值(hbase.hregion.max.filesize)会触发Split操作。会把当前Region Split成两个Region,父Region下线,新Split的两个子Region被Master分配到合适的RegionServer上,使得原先一个Region的压力分流到两个Region上。

    Region寻址方式

    在进行数据操作的时候,首先要定位需要对哪个Region进行操作,或者从哪个Region上读取数据,因此HBase数据读取的第一步是Region寻址。

    de034ae7c0fc80f2a716fe1aa2c27a87.png

    Region寻址步骤:

    1. 首先Client请求Zookeeper,获取hbase:meta表所在的RegionServer的地址(/hbase/meta-region-server)。
    2. Client连接hbase:meta表所在的RegionServer,获取需要访问的数据所在的RegionServer地址。Client会将hbase:meta表的相关信息缓存起来,以便下一次能够快速访问。hbase:meta表存储了所有Region的行键范围信息,通过这个表可以查询出你要操作的Rowkey属于哪个Region的范围里面,以及这个Region是属于哪个RegionServer。
    3. Client请求数据所在的RegionServer,获取所需要的数据

    HBase读写流程

    HBase写流程

    e070d6972a8aca708d92e115625fc0e2.png
    1. Client通过Region寻址定位到需要访问的RegionServer;
    2. 将更新写入WAL HLog,然后将更新写入MemStore,两者写入完成即返回ACK到Client;
    3. 判断MemStore的大小是否达到阈值,是否需要flush为StoreFile。

    细节:

    HBase使用MemStore和StoreFile存储对象表的更新,数据在更新的时候首先写入HLog和MemStore。MemStore中的数据时排序的,当MemStore累积到一定阈值时,就会创建一个新的MemStore并将老的MemStore添加到flush队列,由单独的线程flush到磁盘上,成为一个StoreFile。同时,系统会在Zookeeper中记录一个checkpoint,表示这个时刻之前的更新已经持久化了,当系统出现意外时,可能导致MemStore中的数据丢失,此时使用HLog来恢复chckpoint之后的数据。

    HBase读流程

    053df99165505e501d1f65b298bbb8ac.png
    1. Client通过Region寻址定位到需要访问的RegionServer
    2. 先从BlockCache中查找数据,找不到再去MemStoreStoreFile中查询数据

    在对HBase进行写操作的时候,进行Put和Update操作的时候,其实是新增了一条数据,即使是在进行Delete操作的时候,也是新增一条数据,只是这条数据没有value,类型为DELETE,这条数据叫做墓碑标记(Tobstone)。数据的真正删除是在compact操作时进行的。

    WAL机制

    WAL(Write-Ahead Log,预写日志)主要用来来解决宕机之后的操作恢复问题的。数据到达Region的时候会先写入WAL,然后再被写入MemStore。就算Region的机器宕掉了,由于WAL的数据时存储在HDFS中的,所以数据并不会丢失,还可以从WAL中恢复。

    HLog的生命周期

    产生

    所有涉及到数据的变更都会先写到HLog中,除非是关闭了HLog。

    滚动

    HLog的大小可以通过参数hbase.regionserver.logroll.period来控制,默认是1小时,时间达到该参数设置的时间,HBase会创建一个新的HLog文件。这就实现了HLog滚动的目的。HBase通过hbase.regionserver.maxlogs参数控制HLog的个数。滚动的目的是为了避免单个HLog文件过大的情况,方便后续的过期和删除。

    过期

    HLog的过期依赖于sequenceid的判断。HBase会将HLog的sequenceid和HFile最大的sequenceid(刷新到的最新位置)进行比较,如果该HLog文件中的sequenceid比刷新的最新位置的sequenceid都要小,那么这个HLog就过期了,对应HLog会被移动到/hbase/oldWALs目录。

    因为HBase有主从同步的功能,这个是依赖于HLog来同步HBase的变更,所以HLog虽然过期,也不会立即删除,而是移动到别的目录中。再增加对应的检查和保留时间机制。

    删除

    如果HBase开启了replication,当replication执行完一个HLog的时候,会删除Zookeeper上的对应HLog节点,在HLog被移动到/hbase/oldWALs目录后,HBase每隔hbase.master.cleaner.interval(默认60秒)时间会去检查/hbase/oldWALs目录下的所有HLog,确认对应的Zookeeper的HLog节点是否被删除,如果Zookeeper上不存在对应的HLog节点,那么久直接删除对应的HLog。

    hbase.master.logcleaner.ttl(默认10分钟)这个参数用来控制HLog在/hbase/oldWALs目录保留的最长时间。

    MemStore刷盘

    为了提高HBase的写入性能,当写请求写入MemStore后,不会立即刷盘,而是会等到一定的时候再进行刷盘操作。

    发生MemStore刷盘场景:

    1. 全局内存控制

    当整个RegionServer中所有MemStore占用的内存达到阈值的时候,会触发刷盘的操作。

    2. MemStore达到上限

    当MemStore占用内存的大小达到hbase.hregion.memstore.flush.size的值的时候会触发刷盘,默认128M。

    3. RegionServer的HLog数量达到上限

    如果HLog太多的话,会导致故障恢复的时间过长,因此HBase会对HLog的最大个数做限制。当达到HLog的最大个数的时候,会强制刷盘(hbase.regionserver.max.logs,默认32个)。

    4. MemStore达到刷写时间间隔

    当MemStore达到时间间隔的阈值,会触发刷写操作,hbase.regionserver.optionalcacheflushinterval,默认3600000,即1小时,如果设置为0,则意味着关闭定时自动刷写。

    5. 手工触发

    可以通过hbase shell或者java api手工触发flush的操作

    6. 关闭RegionServer触发

    当正常关闭RegionServer会触发刷盘的操作,全部数据刷盘后就不需要再使用HLog恢复数据

    7. Region使用HLog恢复完数据后触发

    当RegionServer出现故障的时候,其上面的Region会迁移到其他正常的RegionServer上,在恢复完Region的数据后,会触发刷盘,当刷盘完成后才会提供给业务访问。

    Region拆分

    随着业务的发展,在表中的数据会越来越多,Region会越来越大,这样会严重影响数据读取效率。所以当一个Region变的过大后,会触发Split操作,将一个Region分裂成两个子Region。Region的拆分分为自动拆分手动拆分两种。

    89aa8e0c402ab69632a649f07defb2e9.png

    Region拆分流程

    1. RegionServer自身决定region拆分,并准备发起拆分。作为第一步,它将在zookeeper的分区/hbase/region-in-transition/region-name下中创建一个znode。
    2. 因为Master是父region-in-transition的znode节点的观察者,所以它知晓这个znode的建立。
    3. RegionServer在HDFS的父region目录下创建一个名为“.splits”的子目录。
    4. RegionServer关闭父region,强制cache刷盘并在本地数据结构中将这个region标记为offline。此时,父region的client请求将抛出NotServingRegionException,client将重试。
    5. RegionServer为子region A和B分别在.splits目录下的region目录,并创建必要的数据结构。然后拆分存储文件,即先在父region中创建每个存储文件两个reference文件。这两个reference文件将指向父region文件。
    6. RegionServer在HDFS中创建实际的region目录,并为每个子region更新相应的reference文件。
    7. RegionServer发起Put请求到.META.表,并在.META.表中将父region设置为offline,表并添加有关子region的信息。此时,.META.表中不会有每个子region的单独的条目。client可以通过scan .META.表来知晓父region正在拆分,但是除非子region信息记录到.META.表,否则client是看不到子region的。如果前面的Put操作成功写入到.META.表,则标志父region拆分完成。如果RegionServer在put操作前返回失败,则Master和打开这个region的RegionServer将会清除region拆分的错误状态,如果.META.表成功更新,则region拆分状态会被Master向前翻。
    8. RegionServer打开子region并行地接受写入请求。
    9. RegionServer将子region A和B,以及它们的承载者信息分别添加到.META.表。之后,client就可以发现新的region,并访问之。client本地缓存.META.表信息,但是当它们访问RegionServer或者.META.表时,本地缓存失效,client从.META.表获取新的region信息。
    10. RegionServer更新zookeeper的/hbase/region-in-transition/region-name节点中的region状态到SPLIT,以便master感知其状态变化。如果需要的话,负载器可以将子region自由地指定到其它region。
    11. region拆分完成后,其元数据和HDFS仍将包含对父region的引用。这些引用将在子region压缩重写数据文件时被删除。Master的GC任务会定期检查子region是否仍然引用父文件,如果没有,父region将被删除。

    为了减少对业务的影响,Region Split过程并不会真正将父Region中的HFile数据搬到子Region目录中。Split过程仅仅是在子Region中创建了到父Region的HFile的引用文件,子Region1中的引用文件指向原HFile的上部,而子Region2的引用文件指向原HFile2的下部。数据的真正搬迁工作是在Compaction过程中完成的。

    Region合并

    Region的合并分为小合并(Minor Compaction)大合并(Major Compaction)

    fdf39e29c76733f53adfe164b270ae24.png

    小合并(Minor Compaction)

    当MemStore达到hbase.hregion.memstore.flush.size大小的时候会将数据刷写到磁盘,生成StoreFile。随着业务的发展,数据量会越来越大,会产生很多的小文件,对于HBase的数据读取,如果要扫描大量的小文件,会导致性能很差,因此需要将这些小文件合并成一个大一点的文件。

    所谓的小合并,就是把多个小的StoreFile组合在一起,形成一个较大的StoreFile,通常是累积到3个SotreFile后执行。通过hbase.hstore.compationThreadhold参数配置,小合并的步骤如下:

    1. 分别读取出待合并的StoreFile文件的KeyValues,并顺序地写入到位于/hbase/.tmp目录下的临时文件中;
    2. 将临时文件移动到对应的Region目录中;
    3. 将合并的输入文件路径和输出路径封装成KeyValues写入WAL日志,并打上compaction标记,最后强制执行sync;
    4. 将对应region数据目录下的合并的输入文件全部删除,合并完成。

    这种小合并一般速度比较快,对业务的影响也比较小。本质上,小合并就是使用短时间的IO消耗以及带宽消耗换取后续查询的低延迟。在Minor Compaction过程中,达到TTL(记录保留时间)的数据会被移除,但是由墓碑标记的记录不会被移除,因为墓碑标记可能存储在不同HFile中,合并可能会跨过部分墓碑标记。

    大合并(Major Compation)

    大合并就是将一个Region下的所有StoreFile合并成一个大的StoreFile文件。在大合并的过程中,之前删除的行和过期的版本都会被删除。大合并一般一周做一次,由hbase.hregion.majorcompaction参数控制。大合并的影响一般比较大,尽量避免同一时间多个Region进行合并,因此HBase通过hbase.hregion.majorcompaction.jitter参数来进行控制,用于防止多个Region同时进行大合并。

    具体算法:

    hbase.hregion.majorcompaction参数的值乘以一个随机分数,这个随机分数不能超过hbase.hregion.majorcompation.jitter的值(默认为0.5)。

    通过hbase.hregion.majorcompaction参数的值加上或减去hbase.hregion.majorcompaction参数的值乘以一个随机分数的值就确定下一次大合并的时间区间。

    可以通过hbase.hregion.majorcompaction设置为0来禁用major compaction。

    RegionServer故障恢复

    在Zookeeper中保存着RegionServer的相关信息,在RegionServer启动的时候,会在Zookeeper中创建对应的临时节点。RegionServer通过Socket和Zookeeper建立session会话,RegionServer会周期性的向Zookeeper发送ping消息包,以此说明自己还处于存活状态。而Zookeeper收到ping包后,则会更新对应Session的超时时间。

    当Zookeeper超过session超时时间还未收到RegionServer的ping包,则Zookeeper会认为该RegionServer出现故障,Zookeeper会将该RegionServer对应的临时节点删除出,并通知Master,Master收到RegionServer挂掉的信息后就会启动数据恢复流程。

    PS:当然学习以上这么多,只能说是刚刚入门,要想继续深入学习。别担心,在这里为大家准备了学习资料(暂时不透露,嘿嘿),长按识别以下二维码,关注" DigNew"公众号,并在后台回复" HBase"即可以获取资料哈~(建议复制,避免错字)

    99512b99b4c5bbdf4432f97f55d1c43d.png

    好文推荐:

    • Spark任务调度
    • Spark Streaming读取Kafka数据两种方式
    • 初识Spark执行过程 | Spark快速入门
    • Spark快速入门-RDD操作手册
    • Spark快速入门-RDD
    • Hive性能优化小结
    展开全文
  • hbase删除某个数据

    千次阅读 2018-11-04 16:48:00
    碰到这样个事:我们往hbase里面导数据, 补了快一年的数据了,结果发现某个数据有几个月是有问题的,不能用,所以需要将这个的有问题的几个月数据全部干掉, 查了hbase的命令,发现没有这种根据rowkey范围直接...

      碰到这样一个事:我们往hbase里面导数据, 补了快一年的数据了,结果发现某个列的数据有几个月是有问题的,不能用,所以需要将这个列的有问题的几个月数据全部干掉, 查了hbase的命令,发现没有这种根据rowkey范围直接删除某个列的命令. 所以只能自己写了: 可以采用客户端编程的方式,也可以采用hbase on mr的方式,我这里采用的是hbase on mr的方式。原因是如果采用客户端编程的方式,需要scan所有的主键,然后判断rowkey是否符合删除的要求,如果符合则删除,因为数据量很大,这种方式可能太慢,其次是怕把客户端直接给弄死了。采用mr分布式的做法就不用担心这方面的问题。 

        注:

        1. hbase的版本是: HBase 0.98.9

        2. rowkey的形式是  userid+yyyyMMdd的形式, 比如: 0000120181103, 这里需要把20180406之前的数据的某个列( f:cl )干掉,代码如下:

      

    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.hbase.HBaseConfiguration;
    import org.apache.hadoop.hbase.client.Delete;
    import org.apache.hadoop.hbase.client.Result;
    import org.apache.hadoop.hbase.client.Scan;
    import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
    import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
    import org.apache.hadoop.hbase.mapreduce.TableMapper;
    import org.apache.hadoop.hbase.mapreduce.TableReducer;
    import org.apache.hadoop.hbase.util.Bytes;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Job;
    import org.apache.hadoop.util.GenericOptionsParser;
    
    import java.io.IOException;
    
    public class HbaseDelColMr {
    
        static class DelColMapper extends TableMapper<Text, NullWritable> {
    
            private Text dekKey = new Text();
    
            // key: rowkey
            // result: 一行的数据
            @Override
            public void map(ImmutableBytesWritable key, Result result, Context context) throws IOException, InterruptedException {
    
                //拿到 rowkey
                String rowkey = Bytes.toString(key.get());
    
                // 判断 rowkey 是否需要删除 rowkey的类型类似这种字符串 12556565620180405
                String dateStr = rowkey.substring(rowkey.length() - 8, rowkey.length());
    
                //如果在20180406之前的数据全部需要删掉
                if (Integer.parseInt(dateStr) < 20180406) {
                    dekKey.set(rowkey);
                    context.write(dekKey, NullWritable.get());
                }
            }
        }
    
        static class DelColReducer extends TableReducer<Text, NullWritable, ImmutableBytesWritable> {
            @Override
            public void reduce(Text delKey, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
                // delKey 这就是要删除的rowkey
                Delete delete = new Delete(Bytes.toBytes(delKey.toString()));
    
                //设置要删除的列
                delete.deleteColumn(Bytes.toBytes("f"), Bytes.toBytes("cl"));
                context.write(new ImmutableBytesWritable(Bytes.toBytes(delKey.toString())), delete);
            }
        }
    
        public static void main(String[] args) throws Exception {
            Configuration configuration = HBaseConfiguration.create();
            configuration.set("hbase.zookeeper.quorum", "zk_1,zk_2,zk_3,zk_4,zk_5");
            configuration.set("hbase.zookeeper.property.clientPort", "2181");
            //configuration.set("hbase.local.dir", "/tmp/hbase-local-dir_test");
    
            String[] otherArgs = new GenericOptionsParser(configuration, args).getRemainingArgs();
    
            for (String ar:otherArgs) {
                System.out.println(ar+" ======================================");
            }
    
            Job job = Job.getInstance(configuration);
            job.setJobName("HbaseDelColMr");
            job.setJarByClass(HbaseDelColMr.class);
    
            Scan scan = new Scan();
            scan.addColumn(Bytes.toBytes("f"), Bytes.toBytes("cl"));
            scan.setCaching(500);
            scan.setCacheBlocks(false);
    
            TableMapReduceUtil.initTableMapperJob(
                    otherArgs[0], //输入表 "dt_list_detail_test"
                    scan, // scan 对象
                    DelColMapper.class,
                    Text.class, //mapper输出的key类型
                    NullWritable.class, //mapper输出的value类型
                    job
            );
    
            TableMapReduceUtil.initTableReducerJob(
                    otherArgs[0],// 输出表 "dt_list_detail_test"
                    DelColReducer.class,
                    job);
    
            job.setNumReduceTasks(10);
    
            boolean b = job.waitForCompletion(true);
    
            if (!b) {
                throw new IOException("任务出错.....");
            }
        }
    }
    

      还有一种效率更高更加简便的方式, 就是去掉reduce阶段, 如下:

    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.hbase.HBaseConfiguration;
    import org.apache.hadoop.hbase.client.Delete;
    import org.apache.hadoop.hbase.client.Result;
    import org.apache.hadoop.hbase.client.Scan;
    import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
    import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
    import org.apache.hadoop.hbase.mapreduce.TableMapper;
    import org.apache.hadoop.hbase.util.Bytes;
    import org.apache.hadoop.mapreduce.Job;
    import org.apache.hadoop.util.GenericOptionsParser;
    
    import java.io.IOException;
    
    public class HbaseDelColMr2 {
    
        static class DelColMapper extends TableMapper<ImmutableBytesWritable, Delete> {
            @Override
            public void map(ImmutableBytesWritable key, Result result, Context context) throws IOException, InterruptedException {
    
                String rowkey = Bytes.toString(key.get()); //拿到 rowkey
    
                // 判断 rowkey 是否需要删除 rowkey的类型类似这种字符串 12556565620180405
                String dateStr = rowkey.substring(rowkey.length() - 8, rowkey.length());
    
                //如果在20180406之前的数据全部需要删掉
                if (Integer.parseInt(dateStr) < 20180406) {
                    //设置要删除的列
                    Delete delete = new Delete(Bytes.toBytes(rowkey));
                    delete.deleteColumn(Bytes.toBytes("f"), Bytes.toBytes("cl"));
                    context.write(key, delete);  //需要测试如果没有reduce阶段,这里是否会直接写入到hbase, 补充:结论是可以的
                }
            }
        }
    
        public static void main(String[] args) throws Exception {
            Configuration configuration = HBaseConfiguration.create();
            configuration.set("hbase.zookeeper.quorum", "zk_1,zk_2,zk_3,zk_4,zk_5");
            configuration.set("hbase.zookeeper.property.clientPort", "2181");
            //configuration.set("hbase.local.dir", "/tmp/hbase-local-dir_test");
    
            String[] otherArgs = new GenericOptionsParser(configuration, args).getRemainingArgs();
    
            for (String ar:otherArgs) {
                System.out.println(ar+" ======================================");
            }
    
            Job job = Job.getInstance(configuration);
            job.setJobName("HbaseDelColMr2");
            job.setJarByClass(HbaseDelColMr2.class);
    
            Scan scan = new Scan();
            scan.addColumn(Bytes.toBytes("f"), Bytes.toBytes("cl"));
            scan.setCaching(500);
            scan.setCacheBlocks(false);
    
            TableMapReduceUtil.initTableMapperJob(
                    otherArgs[0], //输入表 "dt_list_detail_test"
                    scan, // scan 对象
                    DelColMapper.class,
                    null, //没有输出,直接写入hbase
                    null, //没有输出,直接写入hbase
                    job
            );
    
            TableMapReduceUtil.initTableReducerJob(
                    otherArgs[0],// 输出表 "dt_list_detail_test"
                    null,
                    job);
    
            job.setNumReduceTasks(0);
    
            boolean b = job.waitForCompletion(true);
    
            if (!b) {
                throw new IOException("任务出错.....");
            }
        }
    }
    

      打包调用: 

     export HADOOP_CLASSPATH=`hbase classpath`

    yarn jar ./hbaseDeltest.jar xxx.HbaseDelColMr -D mapreduce.job.queuename=xxx dt_list_detail_test

     
    这样子就可以啦,上面两种方式随便选一种就ok了。。。。。。

    转载于:https://www.cnblogs.com/wuxilc/p/9904572.html

    展开全文
  • I've a requirement with deleting the data from Hbase. I want to delete the latest version of each cell based on the row key in Hbase.I thought of an approach to get the column names and latest timesta...

    I've a requirement with deleting the data from Hbase. I want to delete the latest version of each cell based on the row key in Hbase.

    I thought of an approach to get the column names and latest timestamp of each column with the given rowkey.....then perform the delete operation iteratively with each column and its time stamp.

    But I'm not able to get the column names, so I'm not able do it.

    Please share if you have any thoughts or working code ?

    解决方案Deletes work by creating tombstone markers. For example, let's suppose

    we want to delete a row. For this you can specify a version, or else

    by default the currentTimeMillis is used. What this means is “delete

    all cells where the version is less than or equal to this version”.

    HBase never modifies data in place, so for example a delete will not

    immediately delete (or mark as deleted) the entries in the storage

    file that correspond to the delete condition. Rather, a so-called

    tombstone is written, which will mask the deleted values[17]. If the

    version you specified when deleting a row is larger than the version

    of any value in the row, then you can consider the complete row to be

    deleted.

    So I don't see the problem with following the standard Delete procedure.

    However, if you want to delete only the latest versions of your cells you could use the setTimestamp method of Scan class. So, what you could do is:

    List deletes = new ArrayList<>();

    Scan scan = new Scan();

    scan.setTimestamp(latestVersionTimeStamp); //latestVersionTimeStamp is a long variable

    //set your filters here

    ResultScanner rscanner = table.getScanner(scan);

    for(Result rs : rscanner){

    deletes.add(new Delete(rs.getRow()));

    }

    try{

    table.delete(deletes);

    }

    catch(Exception e){

    e.printStackTrace();

    }

    However, if your Time Stamp isn't the same across cells, this will not work for all of them. This probably will.

    List deletes = new ArrayList<>();

    ArrayList timestamps = new ArrayList<>();//your list of timestamps

    Delete d;

    Scan scan = new Scan();

    //set your filters here

    ResultScanner rscanner = table.getScanner(scan);

    for(Pair item : zip(rscanner, timestamps)){

    d=new Delete(item.getLeft().getRow())

    d.setTimestamp(item.getRight());

    deletes.add(d);

    }

    try{

    table.delete(deletes);

    }

    catch(Exception e){

    e.printStackTrace();

    }

    I don't guarantee this will work, however. The official guides are vague enough and I might have misinterpreted anything. If I did indeed misinterpret, alert me and I will delete this answer.

    展开全文
  • 删除Hbase指定列数据

    千次阅读 2019-01-08 20:56:53
    Hbase没有删除某列数据的直接命令,通过指定表名,列簇,列名 package com.cslc.asiancup.dfstohbase; import com.cslc.asiancup.utils.HbaseUtil; import com.cslc.asiancup.utils.HbaseUtilJava; import org....

    Hbase没有删除某列数据的直接命令,通过指定表名,列簇,列名

    package com.cslc.asiancup.dfstohbase;
    
    import com.cslc.asiancup.utils.HbaseUtil;
    import com.cslc.asiancup.utils.HbaseUtilJava;
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.hbase.TableName;
    import org.apache.hadoop.hbase.client.*;
    import scala.Option;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Iterator;
    
    /**
     * @Author :LPJ
     * @Date 2019/1/4 12:31
     */
    public class DROP_Cloumn {
    
        public static void main(String[] args) throws IOException {
    
    
            final Configuration conf = HbaseUtilJava.conf;
            Connection connection = ConnectionFactory.createConnection(conf);
            Table table = connection.getTable(TableName.valueOf("UNNORMAL_STATUS"));
            final Scan scan = new Scan();
            scan.addColumn("CF1".getBytes(),"LOTTERY_AMOUNT".getBytes());
            final Iterator<Result> iterator = table.getScanner(scan).iterator();
            for( int i =0; i < 50 ; i ++){
                final ArrayList<Delete> deletes = new ArrayList<Delete>();
                while (iterator.hasNext() && deletes.size() <= 100000) {
                    final Result v = iterator.next();
                    final Delete delete = new Delete(v.getRow());
                    if (v.containsColumn("CF1".getBytes(), "LOTTERY_AMOUNT".getBytes())) {
                        delete.deleteColumns("CF1".getBytes(), "LOTTERY_AMOUNT".getBytes());
                        deletes.add(delete);
                    }
                }
                table.delete(deletes);
            }
            table.close();
            connection.close();
    
    
        }
    
    }
    

     

    展开全文
  • HBase删除数据

    2018-08-06 14:09:00
    hbase官方文档中描述了,hbase删除数据可以总结为下面三种(Java API有很多接口,可以总结下面的几种): 删除一的指定版本 删除一的所用版本 删除指定族的所有 hbase删除数据,并不是马上删掉...
  • Hbase 删除列

    千次阅读 2016-11-03 14:23:25
    删除列族 使用alter,也可以删除列族。下面给出的是使用alter删除列族...下面给出的是个例子,从“emp”表中删除列族。 假设在HBase中有个employee表。它包含以下数据hbase(main):006:0> scan '...
  • Hbase删除指定

    2020-07-18 20:41:35
    注意:先禁用要删除列族所在的表 disable '表名' alter '表名', {NAME => '族名', METHOD => 'delete'}
  • hbase删除数据

    2019-05-30 19:56:14
    hbase删除数据 package com.test.demo01; import java.io.IOException; import java.util.ArrayList; import java.util.List; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase....
  • hbase删除数据每次都要传入一的rowkey,然后按行删除数据,所以我们删除一列只需要获取到这一列数据的行号就行了。 from happybase import Connection CLIENT=Connection(host='xxxxxxxx',port=xxxxx) table=...
  • HBase删除

    千次阅读 2017-02-13 10:38:40
    HBase的Delete操作可以指定删除某个簇或某个,或者指定某个时间戳,删除比这个时间早的数据HBase的Delete操作并不是真正的从磁盘删除数据。而是通过创建墓碑标志进行处理。这些墓碑标记的值和小于该时间...
  • HBase删除数据的原理

    千次阅读 2019-07-21 10:44:59
    当执行删除操作时,HBase 新插入条相同的 KeyValue 数据,但是使 keytype=Delete,这便意味着数据删除了,直到发生 Major compaction 操作时,数据才会被真正的从磁盘上删除删除标记也会从StoreFile删除。...
  • HBase 删除指定column的所有数据

    千次阅读 2018-06-29 16:10:35
    最近由于项目改版更新,原来存储在Hbase表中的某一列数据需要全部更新,但是更新时需要每天去定时计算,而且第二天的数据需要用到前面好几天的历史数据,故需要将原来的这一列全部清空 As we know, during ...
  • HBase 删除数据过程分析

    千次阅读 2017-12-27 17:27:05
    单行删除不会立即删除,而是先在指定存储单元上标记删除,等到下次region合并或者分裂的时候才会移除数据删除行的时候,可以指定簇、或者中具体数据进行删除。没有任何指定的情况下会删除整行数据。如果使用...
  • HBase删除表中数据

    万次阅读 2017-08-15 14:22:17
    1、使用hbase shell中delete命令删除表中特定的单元格数据,命令格式如下:delete 'tablename','row','column name','time stramp'删除emp表中第二行personal data:name、时间节点为1502182102866的记录:delete '...
  • 1.通过某一列作为查询条件,根据这个字段时间戳查询到要删除数据的rowkey和这一列值,然后把数据写入到文件中。 scan ''tableName,{ COLUMNS => 't1',TIMERANGE => [1516177518989,1516177790871] } 2.将找...
  • 十九、HBase删除数据

    千次阅读 2018-07-25 09:04:04
    使用 delete 命令,可以在个表中删除特定单元格。 delete 命令的语法如下: delete ‘&lt;table name&gt;’, ‘&lt;row&gt;’, ‘&lt;column name &gt;’, ‘&lt;time stamp&gt...
  • 用Phoenix操作HBASE: 表名称: AB, 表中的列名:ID(唯一,...现在要删除某些族中的某些数据删除条件:族名在列表 [A.a1, A.a2, B.b1] 中,且 ID的数据。 怎样能用句Phoenix语句完成删除操作?
  • Hbase删除数据

    2015-09-08 09:15:47
    使用 delete 命令,可以在个表中删除特定单元格。 delete 命令的语法如下: delete ‘table name>’, ‘row>’, ‘column name >’, ‘time stamp>’ 下面是删除特定单元格和例子。在这里,我们删除salary...
  • hbase 删除数据 释放空间

    千次阅读 2017-02-07 21:17:40
    # hbase check hbase size hdfs dfs -du -h /hbase/data/default/[root@ZHJT machtalk]# hdfs dfs -du -h /hbase/data/default 197.4 M 197.4 M /hbase/data/default/API_ACCESS_RECORD 1.0 M 1.0 M /hbase/
  • HBase强制删除一个表/元数据

    千次阅读 2013-09-30 13:41:08
    1) HBase强制删除一个表 情景: 由于内网测试环境hbase并没有安装“SNAPPY”压缩,而建表时执行了 alter 'TrojanInfo', {NAME => 'i', COMPRESSION => 'SNAPPY'} 强制删除表: 1、强制删除该表在hdfs上的所有文件...
  • 最近遇到的问题,需要删除指定族下的指定,考虑到原理就是扫描hbase表,获取rowkey,进行删除,value值的返回没有意义。但是怎么能快速扫描呢?高性能肯定是第考虑点,废话不说,上代码: public static ...
  • Hbase--API删除数据详解

    千次阅读 2019-10-22 23:55:52
    文章目录Hbase--API删除数据详解:代码实现如下:二:分析和实践1)删除指定的rowkey下的所有数据2)删除指定删除指定的族3)删除指定的1.addColumn()2.addColumns()3.测试 :代码实现如下: public ...
  • 有时我们需要批量删除一些hbase中符合某些条件的数据,本文提供种简单的shell命令的方式批量删除hbase里的数据。思路就是,建立hive与hbase的关联表,通过hive sql查询出符合条件的数据rowkey导出到本地文件,然后...
  • 今天主要来说一下Hbase怎么批量删除数据,我们都知道Hbase个Nosql的分布式存储数据引擎,它可以支持千万级别的QPS写入,但是有时候我们需要批量的删除他的数据,今天就来介绍两种方法: 1.首先我们想到的就是TTL,TTL...
  • Hbase实例之创建

    千次阅读 2013-08-21 23:32:24
    关于HBase的前后因果先不讨论,现在写Hbase实例,怎么样去创建Hbase簇. public class HbaseTable { //定义hbase连接 Configuration conf = null; //构造方法初始化,连接到hbase数据库 HbaseIf...
  • HBase删除和修改操作

    2021-06-08 09:57:47
    HBase的底层依赖于HDFS,...HBase是面向的存储数据的,最终的存储单元都是KeyValue的结构,HBase本身也定义了个KeyValue的类型,这是HBase数据存储的基本类型。 从名字来看应该只有两个数据个是Key,个是Value
  • hbase根据时间戳删除数据

    千次阅读 2018-09-13 11:42:23
    hbase shell 或者脚本删除数据一般都根据rowkey进行操作,因此,此处还是要先根据时间戳范围找出rowkey,然后进行deleteall 操作,以下简单分四步进行操作 #第步:通过时间戳找到要删除数据 #第二步:构建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,763
精华内容 11,105
关键字:

hbase删除某一列数据