Class: Rufus::Tokyo::TableQuery

Inherits:
Object
  • Object
show all
Includes:
QueryConstants
Defined in:
lib/rufus/tokyo/cabinet/table.rb

Overview

A query on a Tokyo Cabinet table db

Constant Summary

Constants included from QueryConstants

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

Instance Method Summary collapse

Constructor Details

#initialize(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



488
489
490
491
492
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 488

def initialize (table)
  @table = table
  @query = @table.lib.qry_new(@table.pointer)
  @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



555
556
557
558
559
560
561
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 555

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
  lib.qry_addcond(@query, colname, op, val)
end

#count ⇒ Object

Gets the count of records returned by this query.

Note : the ‘real’ impl is only available since TokyoCabinet 1.4.12.



676
677
678
679
680
681
682
683
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 676

def count

  if lib.respond_to?(:qry_count)
    lib.qry_count(@query)
  else
    @last_resultset ? @last_resultset.size : 0
  end
end

#delete ⇒ Object

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



667
668
669
670
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 667

def delete

  lib.qry_searchout(@query) || raise_error
end

#free ⇒ Object Also known as: close, destroy

Frees this data structure



687
688
689
690
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 687

def free
  lib.qry_del(@query)
  @query = nil
end

#lib ⇒ Object 



494
495
496
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 494

def lib
  @table.lib
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)



569
570
571
572
573
574
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 569

def limit (i, offset=-1)

  lib.respond_to?(:qry_setlimit) ?
    lib.qry_setlimit(@query, i, offset) :
    lib.qry_setmax(@query, i)
end

#no_pk(on = true) ⇒ Object

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



601
602
603
604
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 601

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



587
588
589
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 587

def order_by (colname, direction=:strasc)
  lib.qry_setorder(@query, colname, DIRECTIONS[direction])
end

#pk_only(on = true) ⇒ Object

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



594
595
596
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 594

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.

(by Matthew King)



628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 628

def process (&block)

  callback = lambda do |pk, pklen, map, opt_param|

    key = pk.read_string(pklen)
    val = Rufus::Tokyo::Map.new(map).to_h

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

    if updated_value = r.find { |e| e.is_a?(Hash) }
      Rufus::Tokyo::Map.new(map).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

  lib.qry_proc(@query, callback, nil)

  self
end

#run ⇒ Object

Runs this query (returns a TableResultSet instance)



659
660
661
662
663
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 659

def run

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