Class: Rufus::Tokyo::TableQuery

Included Modules

Rufus::Tokyo::QueryConstants

A query on a Tokyo Cabinet table db

Constants Included from Rufus::Tokyo::QueryConstants

DIRECTIONS, OPERATORS, TDBQCNEGATE, TDBQCNOIDX

Constructor Summary

public initialize(table)

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

[View source]

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

def initialize (table)
  @table = table
  @query = @table.lib.qry_new(@table.pointer)
  @opts = {}
end

Public Visibility

Public Instance Method Summary

#add(colname, operator, val, affirmative = true, no_index = false) #add_condition	Adds a condition.
#count	Gets the count of records returned by this query.
#delete	Runs this query AND let all the matching records get deleted.
#free #destroy #close	Frees this data structure.
#lib	Returns the FFI lib the table uses.
#limit(i, offset = -1)	Sets the max number of records to return for this query.
#no_pk(on = true)	When set to true, the :pk (primary key) is not inserted in the record (hashes) returned.
#order_by(colname, direction = :strasc)	Sets the sort order for the result of the query.
#pk_only(on = true)	When set to true, only the primary keys of the matching records will be returned.
#pointer	Returns the underlying pointer.
#process(&block)	Process each record using the supplied block, which will be passed two parameters, the primary key and the value hash.
#run	Runs this query (returns a TableResultSet instance).

Public Instance Method Details

add

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

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

[View source]

    
714
715
716
717
718
719
720
721
722
723
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 714

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

public count

Gets the count of records returned by this query.

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

[View source]

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

def count

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

delete

public delete

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

[View source]

    
831
832
833
834
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 831

def delete

  lib.qry_searchout(@query) || raise_error
end

free

public free

Also known as: destroy close

Frees this data structure

[View source]

    
851
852
853
854
855
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 851

def free

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

lib

public lib

Returns the FFI lib the table uses.

[View source]

    
638
639
640
641
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 638

def lib

  @table.lib
end

limit

public limit(i, offset = -1)

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)

[View source]

    
731
732
733
734
735
736
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 731

def limit (i, offset=-1)

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

no_pk

public no_pk(on = true)

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

[View source]

    
765
766
767
768
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 765

def no_pk (on=true)

  @opts[:no_pk] = on
end

order_by

public order_by(colname, direction = :strasc)

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

[View source]

    
749
750
751
752
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 749

def order_by (colname, direction=:strasc)

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

pk_only

public pk_only(on = true)

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

[View source]

    
757
758
759
760
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 757

def pk_only (on=true)

  @opts[:pk_only] = on
end

pointer

public pointer

Returns the underlying pointer.

[View source]

    
645
646
647
648
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 645

def pointer

  @query
end

process

public process(&block)

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)

[View source]

    
      
        
          

792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
        
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 792

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

public run

Runs this query (returns a TableResultSet instance)

[View source]

    
823
824
825
826
827
        
          # File 'lib/rufus/tokyo/cabinet/table.rb', line 823

def run

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