Class: Rufus::Edo::TableQuery

Inherits:
Object
  • Object
show all
Includes:
Tokyo::QueryConstants
Defined in:
lib/rufus/edo/tabcore.rb

Overview

A query on a Tokyo Cabinet table db

Constant Summary

Constants included from Tokyo::QueryConstants

Tokyo::QueryConstants::DIRECTIONS, Tokyo::QueryConstants::OPERATORS, Tokyo::QueryConstants::TDBQCNEGATE, Tokyo::QueryConstants::TDBQCNOIDX

Instance Method Summary collapse

Constructor Details

#initialize(query_class, table) ⇒ TableQuery

Creates a query for a given Rufus::Tokyo::Table

Queries are usually created via the #query (#prepare_query #do_query) of the Table instance.

Methods of interest here are :

* #add (or #add_condition)
* #order_by
* #limit

also

* #pk_only
* #no_pk



313
314
315
316
317
318
319
 
# File 'lib/rufus/edo/tabcore.rb', line 313

def initialize (query_class, table)

  @table = table
  @query = query_class.new(table.original)

  @opts = {}
end

Instance Method Details

#add(colname, operator, val, affirmative = true, no_index = false) ⇒ Object Also known as: add_condition

Adds a condition

table.query { |q|
  q.add 'name', :equals, 'Oppenheimer'
  q.add 'age', :numgt, 35
}

Understood ‘operators’ :

:streq # string equality
:eq
:eql
:equals

:strinc # string include
:inc # string include
:includes # string include

:strbw # string begins with
:bw
:starts_with
:strew # string ends with
:ew
:ends_with

:strand # string which include all the tokens in the given exp
:and

:stror # string which include at least one of the tokens
:or

:stroreq # string which is equal to at least one token

:strorrx # string which matches the given regex
:regex
:matches

# numbers...

:numeq # equal
:numequals
:numgt # greater than
:gt
:numge # greater or equal
:ge
:gte
:numlt # greater or equal
:lt
:numle # greater or equal
:le
:lte
:numbt # a number between two tokens in the given exp
:bt
:between

:numoreq # number which is equal to at least one token



378
379
380
381
382
383
384
385
 
# File 'lib/rufus/edo/tabcore.rb', line 378

def add (colname, operator, val, affirmative=true, no_index=false)

  op = operator.is_a?(Fixnum) ? operator : OPERATORS[operator]
  op = op | TDBQCNEGATE unless affirmative
  op = op | TDBQCNOIDX if no_index

  @query.addcond(colname, op, val)
end

#count ⇒ Object

Returns the count of results this query return when last run. Returns 0 if the query was not yet run.



493
494
495
496
497
498
499
 
# File 'lib/rufus/edo/tabcore.rb', line 493

def count

  #@query.count
    # not yet implemented by Hirabayashi-san

  @last_resultset ? @last_resultset.size : 0
end

#delete ⇒ Object

Runs this query AND immediately let the matching records get deleted.



485
486
487
488
 
# File 'lib/rufus/edo/tabcore.rb', line 485

def delete

  @query.searchout || @table.raise_error
end

#free ⇒ Object Also known as: close, destroy

Frees this data structure



503
504
505
506
 
# File 'lib/rufus/edo/tabcore.rb', line 503

def free

  # nothing ... :(  I hope there's no memory leak
end

#limit(i, offset = -1)) ⇒ Object

Sets the max number of records to return for this query.

(If you’re using TC >= 1.4.10 the optional ‘offset’ (skip) parameter is accepted)



393
394
395
396
397
398
 
# File 'lib/rufus/edo/tabcore.rb', line 393

def limit (i, offset=-1)

  @query.respond_to?(:setlimit) ?
    @query.setlimit(i, offset) :
    @query.setmax(i)
end

#no_pk(on = true) ⇒ Object

When set to true, the :pk (primary key) is not inserted in the record (hashes) returned



427
428
429
430
 
# File 'lib/rufus/edo/tabcore.rb', line 427

def no_pk (on=true)

  @opts[:no_pk] = on
end

#order_by(colname, direction = :strasc) ⇒ Object

Sets the sort order for the result of the query

The ‘direction’ may be :

:strasc # string ascending
:strdesc
:asc # string ascending
:desc
:numasc # number ascending
:numdesc



411
412
413
414
 
# File 'lib/rufus/edo/tabcore.rb', line 411

def order_by (colname, direction=:strasc)

  @query.setorder(colname, DIRECTIONS[direction])
end

#pk_only(on = true) ⇒ Object

When set to true, only the primary keys of the matching records will be returned.



419
420
421
422
 
# File 'lib/rufus/edo/tabcore.rb', line 419

def pk_only (on=true)

  @opts[:pk_only] = on
end

#process(&block) ⇒ Object

Process each record using the supplied block, which will be passed two parameters, the primary key and the value hash.

The block passed to this method accepts two parameters : the [String] primary key and a Hash of the values for the record.

The return value of the passed block does matter. Three different values are expected :stop, :delete or a Hash instance.

:stop will make the iteration stop, further matching records will not be passed to the block

:delete will let Tokyo Cabinet delete the record just seen.

a Hash is passed to let TC update the values for the record just seen.

Passing an array is possible : [ :stop, { ‘name’ => ‘Toto’ } ] will update the record just seen to a unique column ‘name’ and will stop the iteration. Likewise, returning [ :stop, :delete ] will work as well.



452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
 
# File 'lib/rufus/edo/tabcore.rb', line 452

def process (&block)

  @query.proc() do |key, val|

    r = block.call(key, val)
    r = [ r ] unless r.is_a?(Array)

    if updated_value = r.find { |e| e.is_a?(Hash) }
      val.merge!(updated_value)
    end

    r.inject(0) { |i, v|
      case v
      when :stop then i = i | 1 << 24
      when :delete then i = i | 2
      when Hash then i = i | 1
      end
      i
    }
  end

  self
end

#run ⇒ Object

Runs this query (returns a TableResultSet instance)



478
479
480
481
 
# File 'lib/rufus/edo/tabcore.rb', line 478

def run

  @last_resultset = TableResultSet.new(@table, @query.search, @opts)
end