Class: HBase::Table

Inherits:
Object
  • Object
show all
Includes:
Enumerable, Admin, Scoped::Aggregation::Admin, Util
Defined in:
lib/hbase-jruby/table.rb,
lib/hbase-jruby/table/admin.rb,
lib/hbase-jruby/table/mutation.rb,
lib/hbase-jruby/table/inspection.rb,
lib/hbase-jruby/table/batch_action.rb,
lib/hbase-jruby/table/checked_operation.rb

Overview

@return [org.apache.hadoop.conf.Configuration]

Defined Under Namespace

Classes: BatchAction, CheckedOperation, Mutation

Constant Summary

Constants included from Util

Util::JAVA_BYTE_ARRAY_CLASS, Util::JAVA_BYTE_ARRAY_EMPTY

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Util

append_0, from_bytes, java_bytes?, parse_column_name, to_bytes, to_typed_bytes

Methods included from Scoped::Aggregation::Admin

#disable_aggregation, #disable_aggregation!, #enable_aggregation, #enable_aggregation!

Instance Attribute Details

#config ⇒ Object (readonly)

Returns the value of attribute config.



11
12
13
 
# File 'lib/hbase-jruby/table.rb', line 11

def config
  @config
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



10
11
12
 
# File 'lib/hbase-jruby/table.rb', line 10

def name
  @name
end

Instance Method Details

#add_coprocessor(class_name, props = {}) ⇒ Object

Adds the table coprocessor to the table (asynchronous)



173
174
175
 
# File 'lib/hbase-jruby/table/admin.rb', line 173

def add_coprocessor class_name, props = {}
  _add_coprocessor class_name, props, false
end

#add_coprocessor!(class_name, props = {}) {|progress, total| ... } ⇒ Object

Adds the table coprocessor to the table

Parameters:

  • class_name (String) —

    Full class name of the coprocessor

  • props (Hash) (defaults to: {}) —

    Coprocessor properties

Options Hash (props):

  • path (String) —

    The path of the JAR file

  • priority (Fixnum) —

    Coprocessor priority

  • params (Hash<#to_s, #to_s>) —

    Arbitrary key-value parameter pairs passed into the coprocessor

Yields:

  • (progress, total)

Yield Parameters:

  • progress (Fixnum) —

    Number of regions updated

  • total (Fixnum) —

    Total number of regions



168
169
170
 
# File 'lib/hbase-jruby/table/admin.rb', line 168

def add_coprocessor! class_name, props = {}, &block
  _add_coprocessor class_name, props, true, &block
end

#add_family(name, opts) ⇒ Object

Adds the column family (asynchronous)

See Also:



122
123
124
 
# File 'lib/hbase-jruby/table/admin.rb', line 122

def add_family name, opts
  _add_family name, opts, false
end

#add_family!(name, opts) {|progress, total| ... } ⇒ nil

Adds the column family (synchronous)

Parameters:

  • name (#to_s) —

    The name of the column family

  • opts (Hash) —

    Column family properties

Yields:

  • (progress, total)

Yield Parameters:

  • progress (Fixnum) —

    Number of regions updated

  • total (Fixnum) —

    Total number of regions

Returns:

  • (nil) 


116
117
118
 
# File 'lib/hbase-jruby/table/admin.rb', line 116

def add_family! name, opts, &block
  _add_family name, opts, true, &block
end

#alter(props) ⇒ Object

Alters the table (asynchronous)

See Also:



105
106
107
 
# File 'lib/hbase-jruby/table/admin.rb', line 105

def alter props
  _alter props, false
end

#alter!(props) {|progress, total| ... } ⇒ nil

Alters the table (synchronous)

Examples:

table.alter!(
  :max_filesize       => 512 * 1024 ** 2,
  :memstore_flushsize =>  64 * 1024 ** 2,
  :readonly           => false,
  :deferred_log_flush => true
)

Parameters:

  • props (Hash) —

    Table properties

Yields:

  • (progress, total)

Yield Parameters:

  • progress (Fixnum) —

    Number of regions updated

  • total (Fixnum) —

    Total number of regions

Returns:

  • (nil) 


99
100
101
 
# File 'lib/hbase-jruby/table/admin.rb', line 99

def alter! props, &block
  _alter props, true, &block
end

#alter_family(name, opts) ⇒ Object

Alters the column family (asynchronous)

See Also:



139
140
141
 
# File 'lib/hbase-jruby/table/admin.rb', line 139

def alter_family name, opts
  _alter_family name, opts, false
end

#alter_family!(name, opts) {|progress, total| ... } ⇒ nil

Alters the column family

Parameters:

  • name (#to_s) —

    The name of the column family

  • opts (Hash) —

    Column family properties

Yields:

  • (progress, total)

Yield Parameters:

  • progress (Fixnum) —

    Number of regions updated

  • total (Fixnum) —

    Total number of regions

Returns:

  • (nil) 


133
134
135
 
# File 'lib/hbase-jruby/table/admin.rb', line 133

def alter_family! name, opts, &block
  _alter_family name, opts, true, &block
end

#append(rowkey, spec) ⇒ Hash

Appends values to one or more columns within a single row.

Examples:

table.put :rowkey, col1: 'hello', col2: 'foo'
table.append :rowkey, col1: ' world', col2: 'bar'
  # { col1: 'hello world', col2: 'foobar' }

Parameters:

  • rowkey (Object) —

    Rowkey

  • spec (Hash) —

    Hash (column to value)

Returns:

  • (Hash) —

    Updated values



196
197
198
199
 
# File 'lib/hbase-jruby/table.rb', line 196

def append rowkey, spec
  result = htable.append @mutation.append(rowkey, spec)
  Row.send(:new, self, result).to_h if result # (maybe null)
end

#batch(arg = nil) {|HBase::Table::BatchAction| ... } ⇒ Array<Hash>

Method that does a batch call on Deletes, Gets, Puts, Increments, Appends and RowMutations. The ordering of execution of the actions is not defined. An Array of Hashes are returned as the results of each operation. For Delete, Put, and RowMutation, :result entry of the returned Hash is Boolean. For Increment and Append, it will be plain Hashes, and for Get, HBase::Rows will be returned. When an error has occurred, you can still access the partial results using ‘results` method of the thrown BatchException instance.

Yields:

Returns:

  • (Array<Hash>)

Raises:



258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
 
# File 'lib/hbase-jruby/table.rb', line 258

def batch arg = nil
  if arg
    # Backward compatibility
    return scoped.batch(arg)
  else
    raise ArgumentError, "Block not given" unless block_given?
  end
  b = BatchAction.send(:new, self, @mutation)
  yield b
  results = Array.new(b.actions.length).to_java
  process = lambda do
    results.each_with_index do |r, idx|
      action = b.actions[idx]
      type = action[:type]
      case type
      when :get
        action[:result] = (r.nil? || r.empty?) ? nil : Row.send(:new, self, r)
      when :append
        action[:result] = r && Row.send(:new, self, r).to_h
      when :increment
        action[:result] = r &&
          Row.send(:new, self, r).to_h.tap { |h|
            h.each do |k, v|
              h[k] = Util.from_bytes :fixnum, v unless v.is_a?(Fixnum)
            end
          }
      else
        case r
        when java.lang.Exception
          action[:result] = false
          action[:exception] = r
        when nil
          action[:result] = false
        else
          action[:result] = true
        end
      end
    end
    b.actions
  end

  begin
    htable.batch b.actions.map { |a| a[:action] }, results
    process.call
  rescue Exception => e
    raise HBase::BatchException.new(e, process.call)
  end
end

#check(rowkey, cond) ⇒ HBase::Table::CheckedOperation

Returns CheckedOperation instance for check-and-put and check-and-delete

Parameters:

  • rowkey (Object)
  • cond (Hash)

Returns:

Raises:

  • (ArgumentError) 


235
236
237
238
239
240
241
242
243
244
245
 
# File 'lib/hbase-jruby/table.rb', line 235

def check rowkey, cond
  raise ArgumentError, 'invalid check condition' unless cond.length == 1
  col, val = cond.first

  cf, cq, type = lookup_and_parse(col, true)

  # If the passed value is null, the check is for the lack of column
  CheckedOperation.new self, @mutation, Util.to_bytes(rowkey),
    cf, cq,
    (val.nil? ? nil : Util.to_typed_bytes(type, val))
end

#close ⇒ nil

Deprecated.

Returns:

  • (nil) 


34
35
36
 
# File 'lib/hbase-jruby/table.rb', line 34

def close
  nil
end

#closed? ⇒ Boolean

Returns whether if the connection is closed

Returns:

  • (Boolean) 


40
41
42
 
# File 'lib/hbase-jruby/table.rb', line 40

def closed?
  @hbase.closed?
end

#create!(column_family_name, props = {}) ⇒ nil #create!(column_family_hash, props = {}) ⇒ nil #create!(table_descriptor) ⇒ nil

Creates the table

Overloads:

  • #create!(column_family_name, props = {}) ⇒ nil

    Create the table with one column family of the given name

    Parameters:

    • The (#to_s) —

      name of the column family

    • props (Hash) (defaults to: {}) —

      Table properties

    Returns:

    • (nil)
  • #create!(column_family_hash, props = {}) ⇒ nil

    Create the table with the specified column families

    Examples:

    table.create!(
  # Column family with default options
  :cf1 => {},
  # Another column family with custom properties
  :cf2 => {
    :blockcache         => true,
    :blocksize          => 128 * 1024,
    :bloomfilter        => :row,
    :compression        => :snappy,
    :in_memory          => true,
    :keep_deleted_cells => true,
    :min_versions       => 2,
    :replication_scope  => 0,
    :ttl                => 100,
    :versions           => 5
  }
)

    Parameters:

    • Column (Hash) —

      family properties

    • props (Hash) (defaults to: {}) —

      Table properties

    Returns:

    • (nil)
  • #create!(table_descriptor) ⇒ nil

    Create the table with the given HTableDescriptor

    Parameters:

    • Table (org.apache.hadoop.hbase.HTableDescriptor) —

      descriptor

    Returns:

    • (nil) 


54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/hbase-jruby/table/admin.rb', line 54

def create! desc, props = {}
  splits =
    if props[:splits]
      raise ArgumentError, ":splits property must be an Array" if !props[:splits].is_a?(Array)
      props[:splits].map { |e| Util.to_bytes(e).to_a }.to_java(Java::byte[])
    end

  todo = nil
  with_admin do |admin|
    raise RuntimeError, 'Table already exists' if admin.tableExists(@name)

    case desc
    when HTableDescriptor
      patch_table_descriptor! desc, props
      admin.createTable(*[desc, splits].compact)
    when Symbol, String
      todo = lambda { create!({desc => {}}, props) }
    when Hash
      htd = HTableDescriptor.new(@name.to_java_bytes)
      patch_table_descriptor! htd, props
      desc.each do |name, opts|
        htd.addFamily hcd(name, opts)
      end

      admin.createTable(*[htd, splits].compact)
    else
      raise ArgumentError, 'Invalid table description'
    end
  end
  todo.call if todo # Avoids mutex relocking
end

#delete(rowkey) ⇒ nil #delete(rowkey, *extra) ⇒ nil #delete(*delete_specs) ⇒ nil

Deletes data

Overloads:

  • #delete(rowkey) ⇒ nil

    Deletes a row with the given rowkey

    Examples:

    table.delete('a000')

    Parameters:

    • rowkey (Object)

    Returns:

    • (nil)
  • #delete(rowkey, *extra) ⇒ nil

    Deletes columns in the row.

    Examples:

    # A column (with schema)
table.delete('a000', :title)
# Two columns (with schema)
table.delete('a000', :title, :author)
# A column (without schema)
table.delete('a000', 'cf1:col1')
# Columns in cf1 family
table.delete('a000', 'cf1')
# A version
table.delete('a000', :author, 1352978648642)
# Two versions
table.delete('a000', :author, 1352978648642, 1352978647642)
# Combination of columns and versions
table.delete('a000', :author, 1352978648642, 1352978647642,
                     :title,
                     :image, 1352978648642)

    Parameters:

    • rowkey (Object)
    • extra (*Object) —
      Family|Qualifier [Timestamp …]

      …

    Returns:

    • (nil)
  • #delete(*delete_specs) ⇒ nil

    Batch deletion

    Examples:

    table.delete(
  ['a000', 'cf1:col1', 1352978648642],
  ['a001', 'cf1:col1'],
  ['a002', 'cf1'],
  ['a003'])

    Parameters:

    • delete_specs (*Array)

    Returns:

    • (nil) 


125
126
127
128
129
130
131
132
133
134
 
# File 'lib/hbase-jruby/table.rb', line 125

def delete *args
  specs = args.first.is_a?(Array) ? args : [args]

  list = specs.map { |spec| spec.empty? ? nil : @mutation.delete(*spec) }.compact
  if list.length == 1
    htable.delete list.first
  else
    htable.delete list
  end
end

#delete_family(name) ⇒ Object

Removes the column family (asynchronous)

See Also:



155
156
157
 
# File 'lib/hbase-jruby/table/admin.rb', line 155

def delete_family name
  _delete_family name, false
end

#delete_family!(name) {|progress, total| ... } ⇒ nil

Removes the column family

Parameters:

  • name (#to_s) —

    The name of the column family

Yields:

  • (progress, total)

Yield Parameters:

  • progress (Fixnum) —

    Number of regions updated

  • total (Fixnum) —

    Total number of regions

Returns:

  • (nil) 


149
150
151
 
# File 'lib/hbase-jruby/table/admin.rb', line 149

def delete_family! name, &block
  _delete_family name, true, &block
end

#delete_row(*rowkeys) ⇒ nil

Delete rows.

Parameters:

  • rowkeys (*Object) —

    List of rowkeys of rows to delete

Returns:

  • (nil) 


139
140
141
142
143
144
145
146
 
# File 'lib/hbase-jruby/table.rb', line 139

def delete_row *rowkeys
  list = rowkeys.map { |rk| Delete.new(Util.to_bytes rk) }
  if list.length == 1
    htable.delete list.first
  else
    htable.delete list
  end
end

#descriptor ⇒ org.apache.hadoop.hbase.client.UnmodifyableHTableDescriptor

Returns a read-only org.apache.hadoop.hbase.HTableDescriptor object

Returns:

  • (org.apache.hadoop.hbase.client.UnmodifyableHTableDescriptor) 


5
6
7
 
# File 'lib/hbase-jruby/table/inspection.rb', line 5

def descriptor
  htable.get_table_descriptor
end

#disable! ⇒ nil

Disables the table

Returns:

  • (nil) 


217
218
219
220
221
 
# File 'lib/hbase-jruby/table/admin.rb', line 217

def disable!
  with_admin do |admin|
    admin.disableTable @name if admin.isTableEnabled(@name)
  end
end

#disabled? ⇒ true, false

Checks if the table is disabled

Returns:

  • (true, false) —

    Whether table is disabled



17
18
19
 
# File 'lib/hbase-jruby/table/admin.rb', line 17

def disabled?
  !enabled?
end

#drop! ⇒ nil

Drops the table

Returns:

  • (nil) 


233
234
235
236
237
238
239
240
241
 
# File 'lib/hbase-jruby/table/admin.rb', line 233

def drop!
  with_admin do |admin|
    raise RuntimeError, 'Table does not exist' unless admin.tableExists @name

    admin.disableTable @name if admin.isTableEnabled(@name)
    admin.deleteTable  @name
    close
  end
end

#each {|row| ... } ⇒ Enumerator

Scan through the table

Yields:

  • (row) —

    Yields each row in the scope

Yield Parameters:

Returns:

  • (Enumerator) 


221
222
223
 
# File 'lib/hbase-jruby/table.rb', line 221

def each &block
  scoped.each(&block)
end

#enable! ⇒ nil

Enables the table

Returns:

  • (nil) 


209
210
211
212
213
 
# File 'lib/hbase-jruby/table/admin.rb', line 209

def enable!
  with_admin do |admin|
    admin.enableTable @name unless admin.isTableEnabled(@name)
  end
end

#enabled? ⇒ true, false

Checks if the table is enabled

Returns:

  • (true, false) —

    Whether table is enabled



11
12
13
 
# File 'lib/hbase-jruby/table/admin.rb', line 11

def enabled?
  with_admin { |admin| admin.isTableEnabled(@name) }
end

#exists? ⇒ true, false

Checks if the table of the name exists

Returns:

  • (true, false) —

    Whether table exists



5
6
7
 
# File 'lib/hbase-jruby/table/admin.rb', line 5

def exists?
  with_admin { |admin| admin.tableExists @name }
end

#families ⇒ Hash

Returns properties of column families indexed by family name

Returns:

  • (Hash) 


31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/hbase-jruby/table/inspection.rb', line 31

def families
  {}.tap { |ret|
    descriptor.families.each do |family|
      name = family.name_as_string
      ret[name] =
        {}.tap { |props|
          COLUMN_PROPERTIES.each do |prop, gs|
            get = gs[:get]
            if get && family.respond_to?(get)
              props[prop] = parse_property family.send get
            end
          end
        }
    end
  }
end

#has_coprocessor?(class_name) ⇒ true, false

Return if the table has the coprocessor of the given class name

Parameters:

  • class_name (String) —

    Full class name of the coprocessor

Returns:

  • (true, false) 


196
197
198
 
# File 'lib/hbase-jruby/table/admin.rb', line 196

def has_coprocessor? class_name
  descriptor.hasCoprocessor(class_name)
end

#htable ⇒ org.apache.hadoop.hbase.client.PooledHTable

(INTERNAL) Returns the underlying org.apache.hadoop.hbase.client.HTable object (local to current thread)

Returns:

  • (org.apache.hadoop.hbase.client.PooledHTable) 


20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/hbase-jruby/table.rb', line 20

def htable
  check_closed

  # [:hbase_jruby][HBase connection][Table name]
  local_vars = Thread.current[:hbase_jruby] ||= {}
  unless local_htables = local_vars[@hbase]
    @hbase.send :register_thread, Thread.current
    local_htables = local_vars[@hbase] = {}
  end
  local_htables[@name] ||= @hbase.send :get_htable, @name
end

#increment(rowkey, column, by) ⇒ Hash #increment(rowkey, column_by_hash) ⇒ Hash #increment(inc_spec) ⇒ Hash

Atomically increase numeric values

Overloads:

  • #increment(rowkey, column, by) ⇒ Hash

    Atomically increase column value by the specified amount

    Examples:

    table.increment('a000', 'cf1:col1', 1)

    Parameters:

    • rowkey (Object) —

      Rowkey

    • column (String, Array) —

      Column expression in String “FAMILY:QUALIFIER”, or in Array [FAMILY, QUALIFIER]

    • by (Fixnum) —

      Increment amount

    Returns:

    • (Hash)
  • #increment(rowkey, column_by_hash) ⇒ Hash

    Atomically increase values of multiple columns

    Examples:

    table.increment('a000', 'cf1:col1' => 1, 'cf1:col2' => 2)

    Parameters:

    • rowkey (Object) —

      Rowkey

    • column_by_hash (Hash) —

      Column expression to increment amount pairs

    Returns:

    • (Hash)
  • #increment(inc_spec) ⇒ Hash

    Increase values of multiple columns from multiple rows.

    Examples:

    table.increment 'a000' => { 'cf1:col1' => 1, 'cf1:col2' => 2 },
                'a001' => { 'cf1:col1' => 3, 'cf1:col2' => 4 }

    Parameters:

    • inc_spec (Hash) —

      { rowkey => { col => by } }

    Returns:

    • (Hash) 


171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/hbase-jruby/table.rb', line 171

def increment rowkey, *args
  if args.empty? && rowkey.is_a?(Hash)
    INSENSITIVE_ROW_HASH.clone.tap { |result|
      rowkey.each do |key, spec|
        result[Util.java_bytes?(key) ? ByteArray[key] : key] = increment(key, spec)
      end
    }
  else
    incr = @mutation.increment(rowkey, *args)
    Row.send(:new, self, htable.increment(incr)).to_h.tap { |h|
      h.each do |k, v|
        h[k] = Util.from_bytes :fixnum, v unless v.is_a?(Fixnum)
      end
    }
  end
end

#inspect ⇒ String

Returns a printable version of the table description

Returns:

  • (String) —

    Table description



69
70
71
72
73
74
75
76
 
# File 'lib/hbase-jruby/table/inspection.rb', line 69

def inspect
  if exists?
    descriptor.toStringCustomizedValues
  else
    # FIXME
    "{NAME => '#{@name}'}"
  end
end

#lookup_and_parse(col, expect_cq) ⇒ Object 



313
314
315
 
# File 'lib/hbase-jruby/table.rb', line 313

def lookup_and_parse col, expect_cq
  @hbase.schema.lookup_and_parse @name_sym, col, expect_cq
end

#lookup_schema(col) ⇒ Object 



308
309
310
 
# File 'lib/hbase-jruby/table.rb', line 308

def lookup_schema col
  @hbase.schema.lookup @name_sym, col
end

#mutate(rowkey) {|HBase::Table::Mutation::Mutator| ... } ⇒ nil

Performs multiple mutations atomically on a single row. Currently Put and Delete are supported. The mutations are performed in the order in which they were specified.

Examples:

table.mutate do |m|
  m.put a: 100, b: 'hello'
  m.delete :c, :d
  m.put e: 3.14
end

Parameters:

  • rowkey (Object) —

    Rowkey

Yields:

Returns:

  • (nil) 


213
214
215
 
# File 'lib/hbase-jruby/table.rb', line 213

def mutate(rowkey, &block)
  htable.mutateRow @mutation.mutate(rowkey, &block)
end

#properties ⇒ Hash

Returns table properties

Returns:

  • (Hash) 


11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/hbase-jruby/table/inspection.rb', line 11

def properties
  desc = descriptor
  {}.tap { |props|
    TABLE_PROPERTIES.each do |prop, gs|
      get = gs[:get]
      if get && desc.respond_to?(get)
        props[prop] = parse_property desc.send get
      end
    end
  }
end

#put(rowkey, data) ⇒ Fixnum #put(data) ⇒ Fixnum

Performs PUT operations

Overloads:

  • #put(rowkey, data) ⇒ Fixnum

    Put operation on a rowkey

    Parameters:

    • rowkey (Object) —

      Rowkey

    • data (Hash) —

      Data to put

    Returns:

    • (Fixnum) —

      Number of puts succeeded

  • #put(data) ⇒ Fixnum

    Put operation on multiple rowkeys

    Parameters:

    • data (Hash<Hash>) —

      Data to put indexed by rowkeys

    Returns:

    • (Fixnum) —

      Number of puts succeeded



72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/hbase-jruby/table.rb', line 72

def put *args
  case args.length
  when 1
    puts = args.first.map { |rowkey, props| @mutation.put rowkey, props }
    htable.put puts
    puts.length
  when 2
    htable.put @mutation.put(*args)
    1
  else
    raise ArgumentError, 'invalid number of arguments'
  end
end

#raw_families ⇒ Hash

Returns raw String-to-String map of column family properties indexed by name

Returns:

  • (Hash) 


50
51
52
53
54
55
56
57
 
# File 'lib/hbase-jruby/table/inspection.rb', line 50

def raw_families
  {}.tap { |ret|
    descriptor.families.each do |family|
      name = family.name_as_string
      ret[name] = parse_raw_map family.values
    end
  }
end

#raw_properties ⇒ Hash

Returns raw String-to-String map of table properties

Returns:

  • (Hash) 


25
26
27
 
# File 'lib/hbase-jruby/table/inspection.rb', line 25

def raw_properties
  parse_raw_map descriptor.values
end

#regions ⇒ Hash

Returns region information

Returns:

  • (Hash) 


61
62
63
64
65
 
# File 'lib/hbase-jruby/table/inspection.rb', line 61

def regions
  with_admin do |admin|
    _regions admin
  end
end

#remove_coprocessor(class_name) ⇒ Object

Removes the coprocessor from the table (asynchronous)

See Also:



189
190
191
 
# File 'lib/hbase-jruby/table/admin.rb', line 189

def remove_coprocessor class_name
  _remove_coprocessor class_name, false
end

#remove_coprocessor!(class_name) {|progress, total| ... } ⇒ nil

Removes the coprocessor from the table.

Parameters:

  • class_name (String) —

    Full class name of the coprocessor

Yields:

  • (progress, total)

Yield Parameters:

  • progress (Fixnum) —

    Number of regions updated

  • total (Fixnum) —

    Total number of regions

Returns:

  • (nil) 


183
184
185
 
# File 'lib/hbase-jruby/table/admin.rb', line 183

def remove_coprocessor! class_name, &block
  _remove_coprocessor class_name, true, &block
end

#scoped ⇒ HBase::Scoped

Returns HBase::Scoped object for this table

Returns:



227
228
229
 
# File 'lib/hbase-jruby/table.rb', line 227

def scoped
  Scoped.send(:new, self, @hbase.config.get('hbase.client.scanner.caching').to_i)
end

#snapshot!(snapshot_name) ⇒ nil

Creates a snapshot of the table

Parameters:

  • snapshot_name (String) —

    Snapshot name

Returns:

  • (nil) 


246
247
248
249
250
 
# File 'lib/hbase-jruby/table/admin.rb', line 246

def snapshot! snapshot_name
  with_admin do |admin|
    admin.snapshot snapshot_name, @name
  end
end

#snapshots ⇒ Array<Hash>

Returns an Array of snapshot information for this table

Returns:

  • (Array<Hash>) 


254
255
256
 
# File 'lib/hbase-jruby/table/admin.rb', line 254

def snapshots
  @hbase.snapshots.select { |h| h[:table] == @name }
end

#split!(*split_keys) ⇒ nil

Splits the table region on the given split point (asynchronous)

Parameters:

  • split_keys (*Object)

Returns:

  • (nil) 


203
204
205
 
# File 'lib/hbase-jruby/table/admin.rb', line 203

def split! *split_keys
  _split split_keys, false
end

#truncate! ⇒ nil

Truncates the table by dropping it and recreating it.

Returns:

  • (nil) 


225
226
227
228
229
 
# File 'lib/hbase-jruby/table/admin.rb', line 225

def truncate!
  htd = htable.get_table_descriptor
  drop!
  create! htd
end

#with_java_get(&block) ⇒ Object 



58
59
60
 
# File 'lib/hbase-jruby/table.rb', line 58

def with_java_get &block
  self.scoped.with_java_get(&block)
end

#with_java_scan(&block) ⇒ Object 



54
55
56
 
# File 'lib/hbase-jruby/table.rb', line 54

def with_java_scan &block
  self.scoped.with_java_scan(&block)
end