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



619
620
621
622
623
624
625
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 619

def initialize (table)

  @table   = table
  @query   = @table.lib.qry_new(@table.pointer)
  @opts    = {}
  @has_run = false
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

:ftsph # full-text phrase search
:ftsphrase
:phrase
:ftsand # full-text AND
:ftsor # full-text OR
:ftsex # full-text with 'compound' expression



705
706
707
708
709
710
711
712
713
714
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 705

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

  colname = colname.to_s
  val = val.to_s

  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.



830
831
832
833
834
835
836
837
838
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 830

def count

  #if lib.respond_to?(:qry_count)
  run.free unless @has_run
  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.



821
822
823
824
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 821

def delete

  lib.qry_searchout(@query) || raise_error
end

#free ⇒ Object Also known as: close, destroy

Frees this data structure



842
843
844
845
846
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 842

def free

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

#lib ⇒ Object

Returns the FFI lib the table uses.



629
630
631
632
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 629

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)



722
723
724
725
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 722

def limit (i, offset=-1)

  lib.qry_setlimit(@query, i, offset)
end

#no_pk(on = true) ⇒ Object

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



754
755
756
757
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 754

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



738
739
740
741
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 738

def order_by (colname, direction=:strasc)

  lib.qry_setorder(@query, colname.to_s, DIRECTIONS[direction])
end

#pk_only(on = true) ⇒ Object

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



746
747
748
749
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 746

def pk_only (on=true)

  @opts[:pk_only] = on
end

#pointer ⇒ Object

Returns the underlying pointer.



636
637
638
639
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 636

def pointer

  @query
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)



781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 781

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)



812
813
814
815
816
817
 
# File 'lib/rufus/tokyo/cabinet/table.rb', line 812

def run

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