oinky 0.1.0

data/lib/oinky/error.rb

@@ -0,0 +1,19 @@
+# This source is distributed under the terms of the MIT License.  Refer 
+# to the 'LICENSE' file for details.
+# 
+# Copyright (c) Jacob Lacouture, 2012
+
+module Oinky
+  class OinkyException < StandardError
+    attr_reader :code
+    def initialize(*a)
+      if a.size > 1
+        super(*a[1..-1])
+        @code = a[0]
+      else
+        super(*a)
+      end
+    end
+  end
+end
+

data/lib/oinky/modelbase.rb

@@ -0,0 +1,12 @@
+module Oinky
+  module Model
+    # Just for object type testing
+    #
+    # These are defined in the oinky gem too.  However, we declare them here
+    # also so that the gem is not required for compilation.
+    module Table
+    end
+    module Schema
+    end
+  end
+end

data/lib/oinky/nbuffer.rb

@@ -0,0 +1,152 @@
+# This source is distributed under the terms of the MIT License.  Refer 
+# to the 'LICENSE' file for details.
+# 
+# Copyright (c) Jacob Lacouture, 2012
+
+require 'ffi'
+
+class NativeMallocBuffer
+end
+
+# This is intended to be used by multiple libraries to share large string 
+# objects, without having to copy them on/off the ruby heap, via 
+# ruby String.
+#
+# Some ruby implementations (JRuby) move GC memory around, rather than just
+# refcounting it, as MRI does.  To keep the string from moving, we need to 
+# allocate it on the native heap.  However, we still want to manage it, as 
+# we want to be abel to share it between components, none of which may be
+# capable of managing it independently.
+#
+# So, we use the ruby GC to manage an object, which explicitly manages the
+# lifetime of the native object.  The native object can be passed between
+# components by reference, rather than always by value.
+module NativeBuffer
+  include Comparable
+
+  module LibC
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    
+    attach_function :malloc, [:size_t], :pointer
+    attach_function :free, [:pointer], :void
+    attach_function :memcpy, [:pointer, :pointer, :size_t], :void
+    attach_function :memcmp, [:pointer, :pointer, :size_t], :int
+  end
+
+  # supports the following methods:
+
+  # String length in bytes (not chars)
+  # length/size
+
+  # Returns an FFI pointer
+  # def ptr
+
+  # converts to a ruby string.
+  # def to_s
+
+  # Implementations of this module should supply these two definitions.
+
+#  def ptr
+#    @ptr
+#  end
+#  def length
+#    @size
+#  end
+
+  def clone
+    NativeMallocBuffer.new(self)
+  end
+
+  # Convert native string to a ruby string
+  def rb_str
+    l = self.length
+    return '' unless l > 0
+    self.ptr.read_string(l)
+  end
+
+  alias :to_s :rb_str
+
+  def inspect
+    "#<#{self.class}:0x#{self.__id__.to_s(16)} length=#{self.length} ptr=#{self.ptr.inspect}"
+  end
+
+  def each_byte
+    e = Enumerator.new { |blk|
+      (0..self.length-1).each { |i|
+        blk.yield (self.ptr + i).read_uchar
+      }
+    }
+    if block_given?
+      e.each {|v| yield v}
+      return self
+    else
+      return e
+    end
+  end
+
+  def each_char
+    if block_given?
+      each_byte { |b| yield(b.chr) }
+      return self
+    else
+      return Enumerator.new { |blk|
+        each_byte { |b| blk.yield(b.chr) }
+      }
+    end
+  end
+
+  def <=>(other)
+    if other.is_a? NativeBuffer
+      ll = self.length
+      ol = other.length
+      k = ll - ol
+      cl = k < 0 ? ll : ol
+      r = LibC.memcmp(self.ptr, other.ptr, cl)
+      return r if r != 0
+      return k
+    else
+      return self.to_s <=> other
+    end
+  end
+end
+
+# This is a specific implementation of NativeBuffer.  It uses malloc/free.
+class NativeMallocBuffer
+  include NativeBuffer
+
+  attr_reader :ptr, :length
+
+  def initialize(v = 0)
+    if (v.is_a? Fixnum)
+      @ptr = FFI::MemoryPointer.new :pointer
+      size = v
+      if size > 0 
+        @ptr = LibC.malloc(size)
+        @length = size
+      else
+        @ptr = nil
+        @length = 0
+      end
+    elsif v.is_a? String
+      size = v.length
+      @ptr = LibC.malloc(size)
+      LibC.memcpy(@ptr, v, size)
+      @length = size
+    elsif v.is_a? NativeBuffer
+      size = v.length
+      @ptr = LibC.malloc(size)
+      LibC.memcpy(@ptr, v.ptr, size)
+      @length = size
+    else
+      raise OinkyException.new("Invalid initialize parameter to NativeMallocBuffer.new") 
+    end
+
+    ObjectSpace.define_finalizer( self, self.class.finalize(@ptr) )
+  end
+
+  def self.finalize(ptr)
+    proc { LibC.free(ptr) }
+  end
+end
+

data/lib/oinky/normalize.rb

@@ -0,0 +1,132 @@
+require 'date'
+
+module Oinky
+module Model
+
+  DefaultsByType = {
+      :string=>'',
+      :bit=>false,
+      :int8=>0,
+      :int16=>0,
+      :int32=>0,
+      :int64=>0,
+      :uint8=>0,
+      :uint16=>0,
+      :uint32=>0,
+      :uint64=>0,
+      :float32=>0.0,
+      :float64=>0.0,
+      :variant=>0,
+      :datetime=>DateTime.parse("0001-01-01T00:00:00 UTC")
+    }
+
+  def self.validate_keys(h, keys)
+    h.keys.each{|k,v|
+        unless keys.find_index(k)
+          raise ArgumentError.new("Unrecognized key in Oinky schema " +
+                                  "definition: #{k}")
+        end
+      }
+  end
+  def self.validate_type(t)
+    unless DefaultsByType.has_key?(t)
+      raise ArgumentError.new("Unrecognized type in Oinky schema definition: #{k}")
+    end
+  end
+
+  def self.normalize_column_def(nm, v)
+    if v.is_a? Symbol
+      validate_type(v)
+      return {:type=>v, :default=>DefaultsByType[v], :accessor=>nm}
+    end
+    # Otherwise v is a hash
+    validate_keys(v,[:type,:default,:accessor])
+    t = v[:type]
+    raise ArgumentError.new("No column type specified for column [#{nm}]") unless t
+    v[:default] = DefaultsByType[t] unless v.has_key?(:default)
+    # the accessor is only used for some target languages
+    v[:accessor] = nm unless v.has_key?(:accessor)
+    return v
+  end
+
+  def self.normalize_index_column_def(cd)
+    if cd.is_a?(Symbol)
+      cd = cd.to_s
+    end
+    if cd.is_a?(String)
+      # ascending is the default
+      return {:name=>cd, :ascending=>true}
+    end
+    cd[:ascending] = true unless cd.has_key?(:ascending)
+    validate_keys(cd,[:name,:ascending])
+    return cd
+  end
+
+  def self.normalize_index_def(k,v)
+    validate_keys(v,[:unique,:columns,:accessor, :name])
+    if v.has_key?(:name) and (k.to_s != v[:name].to_s)
+      raise ArgumentError.new("Inconsistent names for index: [#{k}] and [#{v[:name]}].")
+    end
+    d = {}
+    d[:unique] = (v[:unique] or false)
+    d[:accessor] = (v[:accessor] or k.to_s)
+    d[:columns] = v[:columns].map{|cd| 
+        normalize_index_column_def(cd)
+      }
+    return d
+  end
+
+  def self.normalize_table_schema(nm, h)
+    cols = {}
+    # columns is a hash of column_name=>defn
+    h[:columns].each{|k,v|
+        cn = k.to_s
+        cols[cn] = normalize_column_def(cn, v)
+      }
+
+    ixs = {}
+    h[:indices].each{|k,v|
+        ixs[k.to_s] = normalize_index_def(k,v)
+      }
+    
+    if h.has_key?(:name) and (nm.to_s != h[:name].to_s)
+      raise ArgumentError.new("Inconsistent names for table: [#{nm}] and [#{h[:name]}].")
+    end
+
+    return {
+        :name=>nm.to_s,
+        :accessor=>(h[:accessor] or nm).to_s,
+        :columns=>cols,
+        :indices=>ixs
+      }
+  end
+  
+  def self.normalize_schema(s)
+    validate_keys(s,[:name, :tables, :version, :classname])
+    raise ArgumentError.new("Invalid schema definition") unless
+      s[:name] and s[:name].size and s[:tables] and s[:version]
+    
+    tbls = {}
+    if s[:tables].is_a? Hash
+      s[:tables].each{|k,v|
+          tbls[k.to_s] = normalize_table_schema(k.to_s, v)
+        }
+    else
+      s[:tables].each{|v|
+          nm = v[:name].to_s
+          tbls[nm] = normalize_table_schema(nm, v)
+        }
+    end
+
+    extras = {}
+    extras[:classname] = s[:classname] if s.has_key?(:classname) 
+
+    return {
+        :name=>s[:name].to_s,
+        :tables=>tbls,
+        :version=>s[:version]
+      }.merge(extras)
+  end
+
+end #module Model
+end #module Oinky

data/lib/oinky/oc_builder.rb

@@ -0,0 +1,44 @@
+# This source is distributed under the terms of the MIT License.  Refer 
+# to the 'LICENSE' file for details.
+# 
+# Copyright (c) Jacob Lacouture, 2012
+
+
+module Oinky
+  module Detail
+    class Builder
+      include Enumerable
+
+      def initialize(lwidth = 4, lcount = 0)
+        @lwidth = lwidth
+        @lcount = lcount
+        @str = []
+      end
+      def next(s1, s2)
+        self << s1
+        @lcount += 1
+        yield
+        @lcount -= 1
+        self << s2
+        self
+      end
+      def <<(s)
+        write(s, 0)
+      end
+      def write(s, ldelta) 
+        l = @lcount + ldelta
+        @str << ((' ' * l * @lwidth) + s)
+        self
+      end
+
+      def format
+        return (@str * "\n") + "\n"
+      end
+
+      def each
+        return @str.each
+      end
+    end
+  end
+end
+

data/lib/oinky/query.rb

@@ -0,0 +1,193 @@
+# This source is distributed under the terms of the MIT License.  Refer 
+# to the 'LICENSE' file for details.
+# 
+# Copyright (c) Jacob Lacouture, 2012
+
+require 'oinky/error'
+
+# This is the crude skeleton of basic query operations.  Currently
+# This works by returning enhanced enumerator objects.
+
+module Oinky
+  # This adds simple operations (max/min/average) to enumerable value sets.
+  class ValuesEnumerator < Enumerator
+    def self.from_opt(opt)
+      # These are column references.
+      if opt.is_a? Symbol
+        opt = opt.to_s
+      end
+      if opt.is_a? String
+        # Turn this into a proc that extracts the selected value.
+        cn = opt
+        opt = lambda {|row| row[cn]}
+      end
+
+      raise OinkyException.new("ArgumentError - Invalid proc") unless opt.is_a? Proc
+      return opt
+    end
+    private
+    def values_loop(opt)
+      # This is a function object which will map the row to a value that
+      # we will compute the average of
+      opt = self.class.from_opt(opt)
+      begin
+        while true
+          v = self.next
+          val = opt.call(v)
+          raise OinkyException.new("nil result from functor") unless val
+          yield val
+        end
+      rescue StopIteration => e
+      end
+    end
+
+    public
+    def average(opt)
+      avg = nil
+      count = 0
+      values_loop(opt) { |val|
+        if avg
+          avg += val
+        else
+          avg = val
+        end
+        count += 1
+      }
+      # We do not test for zero elements.  We just invoke the value's divide
+      # method.  The caller can use any type, and define divide however
+      # they choose.
+      return avg / count
+    end
+    def max(opt)
+      mx = nil
+      values_loop(opt) { |val|
+        if not mx
+          mx = val
+        elsif mx < val
+          mx = val
+        end
+      }
+      return mx
+    end
+    def min(opt)
+      mn = nil
+      values_loop(opt) { |val|
+        if not mn
+          mn = val
+        elsif mn > val
+          mn = val
+        end
+      }
+      return mn
+    end
+  end
+
+  # Add dataset filtering to the rowset (applies to both tables and indices)
+  # The indexes are not used autmatically.  An index is only used if the 
+  # filter is applied to an index using positional specification.
+
+  module RowSet
+    def __each_filtered(c,terminate,filter)
+      Enumerator.new {|blk|
+        if c.is_valid?
+          v = c.select_all
+          while true
+            blk.yield v if filter.call(v)
+            c.seek_next
+            break unless c.is_valid?
+            v = c.select_all
+            break if terminate and terminate.call(v)
+          end
+        end
+      }
+    end
+    def __make_filter_proc(f)
+      if [String,Integer,Fixnum,Float,DateTime].find_index(f.class)
+        return lambda{|v| v == f}
+      end
+      if f.is_a? Proc
+        return f
+      end
+      raise ArgumentError.new("Hash value must be proc or value.")
+    end
+    def __rs_filter(f,c,t)
+      if f.is_a? Hash
+        p = {}
+        cols = @table.columns
+        f.each{|k,kf|
+          unless cols[k]
+            raise ArgumentError.new("Unknown column name in hash filter.")
+          end
+          p[k] = __make_filter_proc(kf)
+        }
+        f = lambda {|v|
+          r = true
+          p.each{|k,kf|
+            r &&= kf.call(v[k])
+          }
+        }
+      end
+      unless f.is_a? Proc
+        raise ArgumentError.new("Invalid argument to filter.  Need Proc or Hash.")
+      end
+
+      seq = __each_filtered(c,t,f)
+      if block_given?
+        seq.each {|v|
+          yield v
+        }
+        return self
+      else
+        return seq
+      end
+    end
+    def filter(f)
+      __rs_filter(f,new_cursor(),nil)
+    end
+  end #module RowSet
+
+  class Index
+    # Specialize the rowset filter to add specification by array(position)
+    def filter(f)
+      if f.is_a? Array
+        c = new_cursor().seek(f)
+        rg = f
+        cols = self.columns
+        if f.size > cols.size
+          raise ArgumentError.new("Position specification exceeds index width.")
+        end
+        # truncate our test width to what we were given
+        cols = cols[0..f.size-1]
+        # Use an array for indirection in the first parameter, so
+        # the two lambdas can share state.
+        result = [true]
+        f = lambda {|v| 
+          r = true
+          cols.each_with_index{|cn,i|
+            if rg[i].is_a? Proc
+              r &&= rg[i].call(v[cn])
+            else
+              r &&= (v[cn] == rg[i])
+            end
+          }
+          result[0] = r
+          r
+        }
+        result[0] = c.is_valid? && f.call(c.select_all)
+        # We stop on the first rejection
+        done = lambda { |c| !result[0]}
+      else
+        c = new_cursor().seek_first()
+        done = nil
+      end
+      e = __rs_filter(f,c,done)
+      if block_given?
+        e.each {|v| yield v}
+        return self
+      else
+        return e
+      end
+    end
+  end
+end #module Oinky
+