Class: Rufus::Edo::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(query_class, 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]

    
444
445
446
447
448
449
450
        
          # File 'lib/rufus/edo/tabcore.rb', line 444

def initialize (query_class, table)

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

  @opts = {}
end

Public Visibility

Public Instance Method Summary

#add(colname, operator, val, affirmative = true, no_index = false) #add_condition	Adds a condition.
#count	Returns the count of results this query return when last run.
#delete	Runs this query AND immediately let the matching records get deleted.
#free #destroy #close	Frees this data structure.
#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.
#original	Returns the original, underlying RDBQUERY instance.
#pk_only(on = true)	When set to true, only the primary keys of the matching records will be returned.
#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]

    
523
524
525
526
527
528
529
530
531
532
533
        
          # File 'lib/rufus/edo/tabcore.rb', line 523

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

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

count

public count

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

[View source]

    
641
642
643
644
645
646
647
        
          # File 'lib/rufus/edo/tabcore.rb', line 641

def count

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

  @last_resultset ? @last_resultset.size : 0
end

delete

public delete

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

[View source]

    
633
634
635
636
        
          # File 'lib/rufus/edo/tabcore.rb', line 633

def delete

  @query.searchout || @table.raise_error
end

free

public free

Also known as: destroy close

Frees this data structure

[View source]

    
651
652
653
654
        
          # File 'lib/rufus/edo/tabcore.rb', line 651

def free

  # nothing ... :(  I hope there's no memory leak
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]

    
541
542
543
544
545
546
        
          # File 'lib/rufus/edo/tabcore.rb', line 541

def limit (i, offset=-1)

  @query.respond_to?(:setlimit) ?
    @query.setlimit(i, offset) :
    @query.setmax(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]

    
575
576
577
578
        
          # File 'lib/rufus/edo/tabcore.rb', line 575

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]

    
559
560
561
562
        
          # File 'lib/rufus/edo/tabcore.rb', line 559

def order_by (colname, direction=:strasc)

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

original

public original

Returns the original, underlying RDBQUERY instance.

[View source]

    
454
455
456
457
        
          # File 'lib/rufus/edo/tabcore.rb', line 454

def original

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

    
567
568
569
570
        
          # File 'lib/rufus/edo/tabcore.rb', line 567

def pk_only (on=true)

  @opts[:pk_only] = on
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.

[View source]

    
      
        
          

600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
        
        
          # File 'lib/rufus/edo/tabcore.rb', line 600

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

public run

Runs this query (returns a TableResultSet instance)

[View source]

    
626
627
628
629
        
          # File 'lib/rufus/edo/tabcore.rb', line 626

def run

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