oklahoma_mixer 0.2.0 → 0.3.0

data/lib/oklahoma_mixer/hash_database/c.rb

@@ -1,3 +1,5 @@
+require "oklahoma_mixer/utilities"
+
 module OklahomaMixer
   class HashDatabase
     module C  # :nodoc:

data/lib/oklahoma_mixer/hash_map.rb

@@ -0,0 +1,42 @@
+require "oklahoma_mixer/hash_map/c"
+
+module OklahomaMixer
+  class HashMap  # :nodoc:
+    def initialize(pointer = C.new)
+      @pointer = pointer
+    end
+    
+    attr_reader :pointer
+    
+    def update(pairs)
+      pairs.each do |key, value|
+        C.put(@pointer, *[yield(key), yield(value)].flatten)
+      end
+    end
+    
+    def each
+      C.iterinit(@pointer)
+      loop do
+        return self unless key = C.read_from_func(:iternext, :no_free, @pointer)
+        yield [key, C.read_from_func(:get, :no_free, @pointer, key, key.size)]
+      end
+    end
+    
+    def to_hash
+      hash = { }
+      each do |key, value|
+        hash[yield(key)] = yield(value)
+      end
+      hash
+    end
+    
+    def replace(pairs, &cast)
+      C.clear(@pointer)
+      update(pairs, &cast)
+    end
+    
+    def free
+      C.del(@pointer)
+    end
+  end
+end

data/lib/oklahoma_mixer/hash_map/c.rb

@@ -0,0 +1,27 @@
+require "oklahoma_mixer/utilities"
+
+module OklahomaMixer
+  class HashMap
+    module C  # :nodoc:
+      extend OklahomaMixer::Utilities::FFIDSL
+
+      prefix :tcmap
+      
+      def_new_and_del_funcs
+      
+      func :name    => :put,
+           :args    => [:pointer, :pointer, :int, :pointer, :int]
+      func :name    => :get,
+           :args    => [:pointer, :pointer, :int, :pointer],
+           :returns => :pointer
+      func :name    => :clear,
+           :args    => :pointer
+
+      func :name    => :iterinit,
+           :args    => :pointer
+      func :name    => :iternext,
+           :args    => [:pointer, :pointer],
+           :returns => :pointer
+    end
+  end
+end

data/lib/oklahoma_mixer/query.rb

@@ -0,0 +1,73 @@
+require "oklahoma_mixer/error"
+require "oklahoma_mixer/query/c"
+
+module OklahomaMixer
+  class Query  # :nodoc:
+    def initialize(table_pointer)
+      @pointer = C.new(table_pointer)
+    end
+    
+    attr_reader :pointer
+    
+    def condition(column, operator, expression, no_index = false)
+      operator =  operator.to_s
+      negate   =  operator.sub!(/\A(?:!_?|not_)/, "")
+      operator =  case operator
+                  when /\A(?:=?=|eq(?:ua)?ls?\??)\z/
+                    if expression.is_a? Numeric               then :TDBQCNUMEQ
+                    else                                           :TDBQCSTREQ
+                    end
+                  when /\Astr(?:ing)?_eq(?:ua)?ls?\??\z/      then :TDBQCSTREQ
+                  when /\Ainclude?s?\??\z/                    then :TDBQCSTRINC
+                  when /\Astarts?_with\??\z/                  then :TDBQCSTRBW
+                  when /\Aends?_with\??\z/                    then :TDBQCSTREW
+                  when /\Aincludes?_all(?:_tokens?)?\??\z/    then :TDBQCSTRAND
+                  when /\Aincludes?_any(?:_tokens?)?\??\z/    then :TDBQCSTROR
+                  when /\Aeq(?:ua)?ls?_any(?:_tokens?)?\??\z/ then :TDBQCSTROREQ
+                  when /\A(?:~|=~|match(?:es)?\??)\z/         then :TDBQCSTRRX
+                  when /\Anum(?:ber)?_eq(?:ua)?ls?\??\z/      then :TDBQCNUMEQ
+                  when ">"                                    then :TDBQCNUMGT
+                  when ">="                                   then :TDBQCNUMGE
+                  when "<"                                    then :TDBQCNUMLT
+                  when "<="                                   then :TDBQCNUMLE
+                  when /\Abetween\??\z/                       then :TDBQCNUMBT
+                  when /\Aany_num(?:ber)?\??\z/               then :TDBQCNUMOREQ
+                  when /\Aphrase_search\??\z/                 then :TDBQCFTSPH
+                  when /\Aall_tokens?_search\??\z/            then :TDBQCFTSAND
+                  when /\Aany_tokens?_search\??\z/            then :TDBQCFTSOR
+                  when /\Aexpression_search\??\z/             then :TDBQCFTSEX
+                  else
+                    fail Error::QueryError, "unknown condition operator"
+                  end
+      operator =  C::CONDITIONS[operator]
+      operator |= C::CONDITIONS[:TDBQCNEGATE] if negate
+      operator |= C::CONDITIONS[:TDBQCNOIDX]  if no_index
+      C.addcond( @pointer,
+                 yield(column),
+                 operator,
+                 yield( expression.respond_to?(:source) ?
+                          expression.source             :
+                          expression ) )
+    end
+    
+    def order(column, str_num_asc_desc = nil)
+      str_num_asc_desc = case str_num_asc_desc.to_s
+                         when /\A(?:STR_)?ASC\z/i, "" then :TDBQOSTRASC
+                         when /\A(?:STR_)?DESC\z/i    then :TDBQOSTRDESC
+                         when /\ANUM_ASC\z/i          then :TDBQONUMASC
+                         when /\ANUM_DESC\z/i         then :TDBQONUMDESC
+                         else
+                           fail Error::QueryError, "unknown order type"
+                         end
+      C.setorder(@pointer, yield(column), C::ORDERS[str_num_asc_desc])
+    end
+    
+    def limit(max, offset = nil)
+      C.setlimit(@pointer, max.to_i, offset.to_i)
+    end
+    
+    def free
+      C.del(@pointer)
+    end
+  end
+end

data/lib/oklahoma_mixer/query/c.rb

@@ -0,0 +1,51 @@
+require "oklahoma_mixer/utilities"
+
+module OklahomaMixer
+  class Query
+    module C  # :nodoc:
+      extend OklahomaMixer::Utilities::FFIDSL
+
+      prefix :tctdbqry
+      
+      CONDITIONS = enum :TDBQCSTREQ,    0,
+                        :TDBQCSTRINC,   1,
+                        :TDBQCSTRBW,    2,
+                        :TDBQCSTREW,    3,
+                        :TDBQCSTRAND,   4,
+                        :TDBQCSTROR,    5,
+                        :TDBQCSTROREQ,  6,
+                        :TDBQCSTRRX,    7,
+                        :TDBQCNUMEQ,    8,
+                        :TDBQCNUMGT,    9,
+                        :TDBQCNUMGE,   10,
+                        :TDBQCNUMLT,   11,
+                        :TDBQCNUMLE,   12,
+                        :TDBQCNUMBT,   13,
+                        :TDBQCNUMOREQ, 14,
+                        :TDBQCFTSPH,   15,
+                        :TDBQCFTSAND,  16,
+                        :TDBQCFTSOR,   17,
+                        :TDBQCFTSEX,   18,
+                        :TDBQCNEGATE,  1 << 24,
+                        :TDBQCNOIDX,   1 << 25
+      ORDERS     = enum :TDBQOSTRASC,  0,
+                        :TDBQOSTRDESC, 1,
+                        :TDBQONUMASC,  2,
+                        :TDBQONUMDESC, 3
+      
+      
+      func :name    => :new,
+           :args    => :pointer,
+           :returns => :pointer
+      func :name    => :del,
+           :args    => :pointer
+      
+      func :name    => :addcond,
+           :args    => [:pointer, :string, CONDITIONS, :string]
+      func :name    => :setorder,
+           :args    => [:pointer, :string, ORDERS]
+      func :name    => :setlimit,
+           :args    => [:pointer, :int, :int]
+    end
+  end
+end

data/lib/oklahoma_mixer/table_database.rb

@@ -0,0 +1,402 @@
+require "oklahoma_mixer/error"
+require "oklahoma_mixer/array_list"
+require "oklahoma_mixer/hash_map"
+require "oklahoma_mixer/query"
+require "oklahoma_mixer/hash_database"
+require "oklahoma_mixer/table_database/c"
+
+module OklahomaMixer
+  class TableDatabase < HashDatabase
+    module Paginated
+      attr_accessor :current_page, :per_page, :total_entries
+      
+      def total_pages
+        (total_entries / per_page.to_f).ceil
+      end
+      
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      def offset
+        (current_page - 1) * per_page
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+    end
+
+    ################################
+    ### Getting and Setting Keys ###
+    ################################
+    
+    def store(key, value, mode = nil, &dup_handler)
+      if mode == :add and dup_handler.nil?
+        super
+      elsif dup_handler
+        warn "block supersedes mode argument" unless mode.nil?
+        k        = cast_key_in(key)
+        callback = lambda { |old_value_pointer, old_size, returned_size, _|
+          old_value         = cast_from_null_terminated_colums(
+                                *old_value_pointer.get_bytes(0, old_size)
+                              )
+          replacement, size = cast_to_null_terminated_colums( yield( key,
+                                                                     old_value,
+                                                                     value ) )
+          returned_size.put_int(0, size)
+          pointer = Utilities.malloc(size)
+          pointer.put_bytes(0, replacement) unless pointer.address.zero?
+          pointer
+        }
+        try(:putproc, k, cast_to_null_terminated_colums(value), callback, nil)
+        value
+      else
+        Utilities.temp_map do |map|
+          map.update(value) { |string|
+            cast_to_bytes_and_length(string)
+          }
+          result = super(key, map, mode, &dup_handler)
+          result == map ? value : result
+        end
+      end
+    end
+    alias_method :[]=, :store
+
+    def fetch(key, *default)
+      if value = try( :get, cast_key_in(key),
+                      :failure  => lambda { |value| value.address.zero? },
+                      :no_error => {22 => nil} )
+        cast_value_out(value)
+      else
+        if block_given?
+          warn "block supersedes default value argument" unless default.empty?
+          yield key
+        elsif not default.empty?
+          default.first
+        else
+          fail IndexError, "key not found"
+        end
+      end
+    end
+    
+    def generate_unique_id
+      try(:genuid, :failure => -1)
+    end
+    alias_method :uid, :generate_unique_id
+    
+    #################
+    ### Iteration ###
+    #################
+    
+    def each
+      try(:iterinit)
+      loop do
+        pointer = try( :iternext3,
+                       :failure  => lambda { |value| value.address.zero? },
+                       :no_error => {22 => nil} )
+        return self unless pointer
+        value = cast_value_out(pointer)
+        key   = value.delete("")
+        yield [key, value]
+      end
+    end
+    alias_method :each_pair, :each
+    
+    ###############
+    ### Queries ###
+    ###############
+    
+    def all(options = { }, &iterator)
+      query(options) do |q|
+        mode = results_mode(options)
+        if block_given?
+          results  = self
+          callback = lambda { |key_pointer, key_size, doc_map, _|
+            if mode != :docs
+              key = cast_key_out(key_pointer.get_bytes(0, key_size))
+            end
+            if mode != :keys
+              map = HashMap.new(doc_map)
+              doc = map.to_hash { |string| cast_to_encoded_string(string) }
+            end
+            flags = case mode
+                    when :keys then yield(key)
+                    when :docs then yield(doc)
+                    else            yield(key, doc)
+                    end
+            Array(flags).inject(0) { |returned_flags, flag|
+              returned_flags | case flag.to_s
+                               when "update"
+                                 if mode != :keys
+                                   map.replace(doc) { |key_or_value|
+                                     cast_to_bytes_and_length(key_or_value)
+                                   }
+                                 end
+                                 lib::FLAGS[:TDBQPPUT]
+                               when "delete" then lib::FLAGS[:TDBQPOUT]
+                               when "break"  then lib::FLAGS[:TDBQPSTOP]
+                               else               0
+                               end
+            }
+          }
+        else
+          results  = mode != :hoh ? [ ] : { }
+          callback = lambda { |key_pointer, key_size, doc_map, _|
+            if mode == :docs
+              results << cast_value_out(doc_map, :no_free)
+            else
+              key = cast_key_out(key_pointer.get_bytes(0, key_size))
+              case mode
+              when :keys
+                results << key
+              when :hoh
+                results[key] = cast_value_out(doc_map, :no_free)
+              when :aoh
+                results << cast_value_out(doc_map, :no_free).
+                           merge(:primary_key => key)
+              else
+                results << [key, cast_value_out(doc_map, :no_free)]
+              end
+            end
+            0
+          }
+        end
+        lib.qryproc(q.pointer, callback, nil)
+        results
+      end
+    end
+    
+    def first(options = { })
+      all(options.merge(:limit => 1)).first
+    end
+    
+    def count(options = { })
+      count = 0
+      all(options) { count += 1 }
+      count
+    end
+    
+    def paginate(options)
+      mode    = results_mode(options)
+      results = (mode != :hoh ? [ ] : { }).extend(Paginated)
+      fail Error::QueryError, ":page argument required" \
+        unless options.include? :page
+      results.current_page = (options[:page] || 1).to_i
+      fail Error::QueryError, ":page must be >= 1" if results.current_page < 1
+      results.per_page = (options[:per_page] || 30).to_i
+      fail Error::QueryError, ":per_page must be >= 1" if results.per_page < 1
+      results.total_entries = 0
+      all( options.merge( :select => :keys_and_docs,
+                          :limit  => nil ) ) { |key, value|
+        if results.total_entries >= results.offset and
+           results.size          <  results.per_page
+          case mode
+          when :keys
+            results << key
+          when :docs
+            results << value
+          when :hoh
+            results[key] = value
+          when :aoh
+            results << value.merge(:primary_key => key)
+          else
+            results << [key, value]
+          end
+        end
+        results.total_entries += 1
+      }
+      results
+    end
+    
+    def union(q, *queries)
+      search([q] + queries, lib::SEARCHES[:TDBMSUNION])
+    end
+    
+    def intersection(q, *queries)
+      search([q] + queries, lib::SEARCHES[:TDBMSISECT])
+    end
+    alias_method :isect, :intersection
+    
+    def difference(q, *queries)
+      search([q] + queries, lib::SEARCHES[:TDBMSDIFF])
+    end
+    alias_method :diff, :difference
+    
+    ###############
+    ### Indexes ###
+    ###############
+    
+    def add_index(column, type, keep = false)
+      type =  case type.to_s
+              when "lexical", "string"  then lib::INDEXES[:TDBITLEXICAL]
+              when "decimal", "numeric" then lib::INDEXES[:TDBITDECIMAL]
+              when "token"              then lib::INDEXES[:TDBITTOKEN]
+              when "qgram"              then lib::INDEXES[:TDBITQGRAM]
+              else
+                fail Error::IndexError, "unknown index type"
+              end
+      type |= lib::INDEXES[:TDBITKEEP] if keep
+      try( :setindex,
+           cast_to_bytes_and_length(column_name(column)).first,
+           type,
+           :no_error => {21 => false} )
+    end
+    
+    def remove_index(column)
+      try( :setindex,
+           cast_to_bytes_and_length(column_name(column)).first,
+           lib::INDEXES[:TDBITVOID],
+           :no_error => {2 => false} )
+    end
+    
+    def optimize_index(column)
+      try( :setindex,
+           cast_to_bytes_and_length(column_name(column)).first,
+           lib::INDEXES[:TDBITOPT],
+           :no_error => {2 => false} )
+    end
+    alias_method :defrag_index, :optimize_index
+    
+    #######
+    private
+    #######
+    
+    def tune(options)
+      super
+      if options.values_at(:bnum, :apow, :fpow, :opts).any?
+        optimize(options.merge(:tune => true))
+      end
+      if options.values_at(:rcnum, :lcnum, :ncnum).any?
+        setcache(options)
+      end
+    end
+    
+    def setcache(options)
+      try( :setcache,
+           options.fetch(:rcnum, 0).to_i,
+           options.fetch(:lcnum, 0).to_i,
+           options.fetch(:ncnum, 0).to_i )
+    end
+    
+    def cast_value_in(value)
+      value.pointer
+    end
+    
+    def cast_value_out(pointer, no_free = false)
+      map = HashMap.new(pointer)
+      map.to_hash { |string| cast_to_encoded_string(string) }
+    ensure
+      map.free if map and not no_free
+    end
+    
+    def cast_from_null_terminated_colums(string)
+      Hash[*string.split("\0").map { |s| cast_to_encoded_string(s) }]
+    end
+    
+    def cast_to_null_terminated_colums(hash)
+      cast_to_bytes_and_length(hash.to_a.flatten.join("\0"))
+    end
+    
+    def column_name(column)
+      case column
+      when :primary_key, :pk then ""
+      else                        column
+      end
+    end
+    
+    def query(options = { })
+      query      = Query.new(@db)
+      conditions = Array(options[:conditions])
+      conditions = [conditions] unless conditions.empty? or
+                                       conditions.first.is_a? Array
+      conditions.each do |condition|
+        fail Error::QueryError,
+             "condition must be column, operator, and expression" \
+          unless condition.size.between? 3, 4
+        query.condition( column_name(condition.first),
+                         *condition[1..-1] ) { |string|
+          cast_to_bytes_and_length(string).first
+        }
+      end
+      unless options[:order].nil?
+        order = options[:order] == "" ? [""] : Array(options[:order])
+        fail Error::QueryError, "order must have a field and can have a type" \
+          unless order.size.between? 1, 2
+        order[0] = column_name(order[0])
+        query.order(*order) { |string|
+          cast_to_bytes_and_length(string).first
+        }
+      end
+      unless options[:limit].nil?
+        query.limit(options[:limit], options[:offset])
+      end
+      if block_given?
+        yield query
+      else
+        query
+      end
+    ensure
+      query.free if query and block_given?
+    end
+    
+    def results_mode(options)
+      case options[:select].to_s
+      when /\A(?:primary_)?keys?\z/i then :keys
+      when /\Adoc(?:ument)?s?\z/i    then :docs
+      else
+        case options[:return].to_s
+        when /\Ah(?:ash_)?o(?:f_)?h(?:ash)?e?s?\z/i  then :hoh
+        when /\Aa(?:rray_)?o(?:f_)?a(?:rray)?s?\z/i  then :aoa
+        when /\Aa(?:rray_)?o(?:f_)?h(?:ash)?e?s?\z/i then :aoh
+        else
+          if RUBY_VERSION < "1.9" and not options[:order].nil? then :aoa
+          else                                                      :hoh
+          end
+        end
+      end
+    end
+    
+    def search(queries, operation)
+      mode = results_mode(queries.first)
+      qs   = queries.map { |q| query(q) }
+      keys = ArrayList.new( Utilities.temp_pointer(qs.size) do |pointer|
+        pointer.write_array_of_pointer(qs.map { |q| q.pointer })
+        lib.metasearch(pointer, qs.size, operation)
+      end )
+      case mode
+      when :keys
+        keys.map { |key| cast_key_out(key) }
+      when :docs
+        keys.map { |key| self[cast_key_out(key)] }
+      when :hoh
+        results = { }
+        while key = keys.shift { |k| cast_key_out(k) }
+          results[key] = self[key]
+        end
+        results
+      when :aoh
+        keys.map { |key|
+          key = cast_key_out(key)
+          self[key].merge(:primary_key => key)
+        }
+      else
+        keys.map { |key|
+          key = cast_key_out(key)
+          [key, self[key]]
+        }
+      end
+    ensure
+      if qs
+        qs.each do |q|
+          q.free
+        end
+      end
+      keys.free if keys
+    end
+  end
+end