mohair 0.0.2 → 0.0.3

data/.gitignore

@@ -19,3 +19,4 @@ Gemfile.lock
 .yardoc
 _yardoc
 doc/
+vendor

data/Gemfile

@@ -4,4 +4,7 @@ gemspec
 
 # Specify your gem's dependencies in mohair.gemspec
 gem "riak-client"
-
+gem "parslet"
+gem "rake"
+# gem "treetop"
+gem 'json', '~> 1.7.7'

data/README.md

@@ -1,7 +1,5 @@
 # Mohair
 
-TODO: Write a gem description
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -18,7 +16,40 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+now:
+
+```
+$ bundle exec bin/mohair -q "select all from sometable" -i INDEX
+$ bundle exec bin/mohair_dump < data.json
+```
+
+future:
+
+```
+$ bundle exec bin/mohair -i
+mohair> select * from sometable
+mohair> insert * into ...
+mohair>
+```
+
+```
+$ bundle exec bin/mohair -q "select * from sometable"
+...
+```
+
+## Currently works
+
+- basic SQL parsing
+- select * from table
+- select col,col,col from table [where col = "name" and col < 23] [group by col]
+
+## TODO
+
+- group by
+- limit 10
+- asc/desc
+- 2i
+- query optimization
 
 ## Contributing
 
@@ -27,3 +58,7 @@ TODO: Write usage instructions here
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+```
+$ bundle exec rake release
+```

data/Rakefile

@@ -1,3 +1,13 @@
 require "bundler/gem_tasks"
 require 'bundler'  
-Bundler::GemHelper.install_tasks  
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/plugin/*.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/bin/mohair_dump

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'mohair'
+
+Mohair::do_dump()

data/lib/mohair/inserter.rb

@@ -0,0 +1,39 @@
+require 'mohair'
+require 'riak'
+
+module Mohair
+  class Inserter
+    def initialize bucket_name
+      @bucket_name = bucket_name
+    end
+    def insert_all objs
+      @client = Riak::Client.new(:protocol => "http")
+      bucket = @client.bucket(@bucket_name)
+      if bucket.props["allow_mult"] then
+        $stderr.puts "allow_mult should be false (how to handle siblilngs?)"
+        return
+      end
+
+      objs.each do |obj|
+        r_o = Riak::RObject.new(bucket, obj["key"])
+
+        data = r_o.data = obj["data"]
+        obj["data"].each do |k,v|
+          begin
+            if integer? v then r_o.indexes[k + "_int"] << v end
+          rescue
+            r_o.indexes[k + "_bin"] << v
+          end
+        end
+        r_o.content_type = 'application/json'
+        r_o.store
+        print obj["key"] , "\t => ", data, "\n"
+      end
+    end
+    
+    def exec!
+    end
+    def pr
+    end
+  end
+end

data/lib/mohair/selector.rb

@@ -1,43 +1,148 @@
 require 'mohair'
+require 'riak'
+require 'erb'
 
 module Mohair
-  class Selector
-    def initialize argv
-      @cols = []
-      @from = []
-      @where = []
-      argv.shift
-      parse_first argv
-    end
-    def parse_first tokens
-      token = tokens.shift.downcase
-      case token.downcase
-      when 'from'
-        parse_from tokens
-      when 'where'
-        parse_where tokens
-      else
-        @cols << token
-        parse_first tokens
+
+  MapperTemplate = <<EOMAP
+function(v){
+  var f = function(key, obj){
+    var ret = {};
+    <% select.each do |c| %>
+    <%=  c %>
+    <% end %>
+    ret.__key = key;
+    <%= where %>
+  };
+  var raw_obj = JSON.parse(v.values[0].data);
+  if(raw_obj instanceof Array){
+    var ret0 = [];
+    for(var i in raw_obj){
+      ret0 = ret0.concat(f(v.key, raw_obj[i]));
+    }
+    return ret0;
+  }else{
+    return f(v.key, raw_obj);
+  }
+}
+EOMAP
+
+  ReducerTemplate = <<EOREDUCE
+function(values){
+  var ret = {};
+  // init lines
+  <%= agg_init %>
+  for(var i in values){
+    var v=values[i];
+    <%= agg_fun %>
+  }
+  return [ret];
+}
+EOREDUCE
+  # if(!!(v.sum_age)){ ret.sum_age += v.sum_age; }
+
+  GetAllMapper = <<GETALLMAPPER
+function(v){
+  var f = function(key, obj){
+    var ret = obj;
+    ret.__key = key;
+    <%= where %>
+  };
+  var raw_obj = JSON.parse(v.values[0].data);
+  if(raw_obj instanceof Array){
+    var ret0 = [];
+    for(var i in raw_obj){
+      ret0 = ret0.concat(f(v.key, raw_obj[i]));
+    }
+    return ret0;
+  }else{
+    return f(v.key, raw_obj);
+  }
+}
+GETALLMAPPER
+
+  GroupByMapperTemplate = <<EOGROUPER
+function(v){
+  ejsLog('/tmp/map_reduce.log', "startmapper>")
+  var f = function(key, obj){
+    var ret = {};
+    <% select.each do |c| %>
+    <%=  c %>
+    <% end %>
+    ret.__key = key;
+    <%= where %>
+  };
+  var arr = [];
+  var raw_obj = JSON.parse(v.values[0].data);
+  if(raw_obj instanceof Array){
+    var ret0 = [];
+    for(var i in raw_obj){
+      ret0 = ret0.concat(f(v.key, raw_obj[i]));
+    }
+    arr = ret0;
+  }else{
+    arr = f(v.key, raw_obj);
+  }
+  var ret = {};
+  for(var i in arr){
+    //ejsLog('/tmp/map_reduce.log', JSON.stringify(arr[i].<%= col %>))
+    var col = arr[i].<%= col %>;
+    //ejsLog('/tmp/map_reduce.log', JSON.stringify(col))
+    if(ret[col]){
+      ret[col] = ret[col].push(arr[i]);
+      //ejsLog('/tmp/map_reduce.log', JSON.stringify(ret[col]))
+    }else{
+      ret[col] = [arr[i]];
+      //ejsLog('/tmp/map_reduce.log', JSON.stringify(ret[col]))
+    }
+  }
+  ejsLog('/tmp/map_reduce.log', "<eomapper")
+  return [ret];
+}
+EOGROUPER
+
+
+## merge them all
+## [{ k, v }, ....] -> {k, v}
+  GroupByReducerTemplate = <<EOREDUCEGROUPER
+function(values){
+  ejsLog('/tmp/map_reduce.log', "start>");
+  var ret = {};
+  for(var i in values){
+  ejsLog('/tmp/map_reduce.log', JSON.stringify(i))
+    for(var a in values[i]){
+      if(ret[a]){
+        ret[a] = ret[a].concat(values[i][a]);
+      }else{
+        ret[a] = values[i][a];
+      }
+    }
+  }
+  ejsLog('/tmp/map_reduce.log', "<end");
+//  ejsLog('/tmp/map_reduce.log', JSON.stringify(ret))
+  return [ret];
+}
+EOREDUCEGROUPER
+
+  
+  def Mohair.format_result results
+    columns = Set.new
+    results.each do |r|
+      r.each do |k,v|
+        columns.add(k)
       end
     end
-    def parse_from tokens
-      token = tokens.shift.downcase
-      p token
-      case token.downcase
-      when 'where'
-        parse_where tokens
-      else
-        @from << token
+    columns.delete('__key')
+    cols = columns.to_a.join("\t| ")
+    print "|               | #{cols}|\n"
+    print "+---------------+------------------------------+\n"
+    results.each do |r|
+      print "| #{r['__key']}\t| "
+      columns.to_a.each do |c|
+        print "#{r[c]} \t| "
       end
-    end
-    def parse_where tokens
-    end
-    def exec!
-      pr
-    end
-    def pr
-      print "<select> #{@cols} <from> #{@from};\n"
+      print "\n"
     end
   end
+
 end

data/lib/mohair/sql/parser.rb

@@ -0,0 +1,88 @@
+
+require "rubygems"
+require "parslet"
+
+module Mohair
+  module Sql
+    class Parser < Parslet::Parser
+      rule(:integer)    { match('[0-9]').repeat(1) }
+      #rule(:float)      { integer.repeat >> str('.') >> integer.maybe }
+
+      rule(:space)      { match('\s').repeat(1) }
+      rule(:space?)     { space.maybe }
+      rule(:comma)      { str(',') >> space? }
+      rule(:lparen)     { str('(') >> space? }
+      rule(:rparen)     { str(')') >> space? }
+
+      # logical operators
+      rule(:eq)         { str('=') }
+      rule(:neq)        { str('!=') | str('<>') }
+      rule(:gt)         { str('>') }
+      rule(:lt)         { str('<') }
+      rule(:geq)        { str('>=') }
+      rule(:leq)        { str('<=') }
+      rule(:btw)        { str('between') }
+      #rule(:like)       { str('like') >> space? }
+      rule(:binop)      { eq | neq | gt | lt | geq | leq | btw}
+
+      rule(:string)     { str('"') >> match('[a-zA-Z0-9]').repeat >> str('"') }
+
+      rule(:const)      {
+        integer | string
+      }
+      rule(:term)       { const | item }
+
+      rule(:bool_and)   { str('and') }
+      rule(:bool_or)    { str('or') }
+
+
+      rule(:identifier) { match('[a-z]').repeat(1) }
+
+      rule(:function)   {
+        identifier.as(:function) >> space? >>
+        lparen >> arglist.as(:arguments) >> rparen
+      }
+
+      rule(:item)       { function | identifier }
+
+      rule(:arglist)    {
+        item.as(:item) >> (comma >> item.as(:item)).repeat
+      }
+      rule(:namelist)   {
+        identifier.as(:name) >> (comma >> identifier.as(:name)).repeat
+      }
+
+      rule(:single_cond){
+        term.as(:lhs) >> space? >> binop.as(:op) >> space? >> term.as(:rhs)
+      }
+
+      rule(:condition)  {
+        single_cond.as(:lhs) >> space? >>
+        ((bool_and.as(:op) | bool_or.as(:op)) >>
+         space? >>
+         condition.as(:rhs)).maybe
+      }
+
+      rule(:select_s)   {
+        str('select').as(:op) >> space? >> (arglist | str('*')).as(:select)
+      }
+      rule(:from_s)     {
+        str('from') >> space? >> namelist.as(:from)
+      }
+      rule(:where_s)    {
+        str('where') >> space? >> condition.as(:where)
+      }
+      rule(:group_s)    {
+        str('group') >> space? >> str('by') >> space? >> item.as(:group_by)
+      }
+      rule(:select)     {
+        select_s >> space? >> from_s >> space? >>
+        (where_s >> space? >> group_s.maybe | group_s).maybe
+      }
+      ## limit 10 desc by 'col'
+
+      rule(:expression) { select } #| insert | create }
+      root :expression
+    end
+  end
+end

data/lib/mohair/sql/select.rb

@@ -0,0 +1,93 @@
+require 'mohair/selector'
+
+module Mohair
+    class Select
+    def initialize tree
+      @select = build_columns tree[:select]
+      @from   = From.new tree[:from]
+      @where  = Where.new tree[:where]
+      @group_by = Group.new tree[:group_by]
+      @agg = false
+    end
+
+    def build_columns items
+      reqs = []
+      if items.class == Array then
+        items.each do |i|
+          reqs << maybe_column(i[:item])
+        end
+      elsif items.class == Hash then
+        reqs << maybe_column(items[:item])
+      elsif items.to_s == "*" then
+        reqs = :all
+      end
+      reqs
+    end
+
+    def maybe_column item
+      if item.class == Hash then
+        if item[:function] then
+          Function.new item
+        else
+          raise item
+        end
+      else
+        Column.new item
+      end
+    end
+
+    def bucket
+      @from.bucket
+    end
+
+    def mapper
+      where = @where.to_js
+
+      ## don't do 'select * from table group by col'
+      if @select == :all then
+        ERB.new(GetAllMapper).result(binding)
+
+      elsif @group_by and @group_by.col then
+        select = []
+        col = @group_by.col
+        @select.each do |c| select << c.to_map_js end
+        ERB.new(GroupByMapperTemplate).result(binding)
+
+      else
+        select = []
+        @select.each do |c| select << c.to_map_js end
+        ERB.new(MapperTemplate).result(binding)
+
+      end
+    end
+
+    def reducer
+      if @select == :all then
+        return nil
+      end
+      if @group_by and @group_by.col then
+        col = @group_by.col
+        return ERB.new(GroupByReducerTemplate).result(binding)
+      end
+
+      @select.each do |c|
+        if c.is_agg? then
+          agg_init, agg_fun = c.to_reduce_js
+          return ERB.new(ReducerTemplate).result(binding)
+        end
+      end
+      return nil
+    end
+    
+  end
+
+  def any(arr, fun)
+    arr.each do |e|
+      if fun(e) then
+        return true
+      end
+    end
+    return false
+  end
+
+end

data/lib/mohair/sql/tree.rb

@@ -0,0 +1,197 @@
+## syntax tree
+require 'mohair/sql/select'
+
+module Mohair
+
+  def Mohair.build tree
+    case tree[:op]
+    when 'select'
+      Select.new tree
+    when 'insert'
+      Insert.new tree
+    when 'update'
+      Update.new tree
+    when 'delete'
+      Delete.new tree
+    else
+      LOG.error "bad :op", tree
+    end
+  end
+
+
+  class Column
+    def initialize item
+      @name = item.to_s
+    end
+
+    def to_map_js
+      "ret.#{@name} = obj.#{@name};"
+    end
+
+    def is_agg?
+      false
+    end
+  end
+
+  class Function
+    def initialize item
+      @name = item[:function].to_s
+      @argv = []
+      if item[:arguments] == Array then
+        item[:arguments].each do |i|
+          @argv << i[:item].to_s
+        end
+      else
+        @argv << item[:arguments][:item]
+      end
+    end
+
+    def to_map_js
+      s = @argv[0]
+      case @name
+      when 'sum' then
+        "ret.sum_#{s} = obj.#{s};"
+      when 'avg' then
+        "ret.sum_#{s} = obj.#{s};\n ret.count_#{s} = 1;"
+      when 'count' then
+        if s == 'key' then
+          "if(!!(v.#{s})){ ret.count_#{s} = 1; }"
+        else
+          "if(!!(obj.#{s})){ ret.count_#{s} = 1; }"
+        end
+      end
+    end
+
+    def to_reduce_js
+
+      s = @argv[0]
+      case @name
+      when 'sum' then
+        ["ret.sum_#{s} = 0;", "if(!!(v.sum_#{s})){ ret.sum_#{s} += v.sum_#{s}; }"]
+      when 'avg' then
+        ["ret.sum_#{s} = 0; ret.count_#{s} = 0;",
+         "if(!!(v.sum_#{s})){ ret.sum_#{s} += v.sum_#{s};\n ret.count_#{s} += v.count_#{s}; }"]
+      when 'count' then
+        ["ret.count_#{s} = 0;",
+         "if(!!(v.count_#{s})){ ret.count_#{s} += v.count_#{s}; }"]
+      end
+
+    end
+
+    def is_agg?
+      true
+    end
+  end
+
+  class Insert
+  end
+
+  class Update
+  end
+
+  class Delete
+  end
+
+  class From
+    def initialize tree
+      @name = tree[:name]
+    end
+    def bucket
+      @name.to_s
+    end
+  end
+
+  class Condition
+    def initialize tree
+      if tree[:rhs].nil? && tree[:lhs].class == Hash then
+        tree = tree[:lhs]
+      end
+      lhs = tree[:lhs]
+      rhs = tree[:rhs]
+      @op  = tree[:op].to_s
+
+      if lhs.class == Hash then
+        @lhs = Condition.new lhs
+      elsif (lhs.to_s =~ /^[0-9]+$/).nil? then
+        @lhs = lhs.to_s
+      else
+        @lhs = lhs.to_i
+      end
+
+      if rhs.class == Hash then
+        @rhs = Condition.new rhs
+      elsif (rhs.to_s =~ /^[0-9]+$/).nil? then
+        @rhs = rhs.to_s
+      else
+        @rhs = rhs.to_i
+      end
+    end
+
+    def to_js
+      lhs = rhs = nil
+      if @rhs.class == Fixnum then
+        rhs = @rhs
+      elsif @rhs.class == Condition then
+        rhs = "( #{@rhs.to_js} )"
+      elsif (@rhs[0] == "\"" and @rhs[-1] == "\"") then
+        rhs = @rhs
+      else
+        rhs = "obj.#{@rhs}"
+      end
+      if @lhs.class == Fixnum then
+        lhs = @lhs
+      elsif @lhs.class == Condition then
+        lhs = "( #{@lhs.to_js} )"
+      elsif (@lhs[0] == "\"" and @lhs[-1] == "\"") then
+        lhs = @lhs
+      else
+        lhs = "obj.#{@lhs}"
+      end
+      " (#{lhs}) #{operator2str(@op)} (#{rhs}) "
+    end
+
+    def operator2str op
+      ## SQL to JS operator
+      case op
+      when '=' then '=='
+      when '<>' then '!='
+      when "and" then '&&'
+      when 'or' then '||'
+      else op
+      end
+    end
+
+  end
+
+  class Where
+    def initialize tree
+      if tree then
+        @cond = Condition.new tree
+      else
+        @cond = nil
+      end
+    end
+    def to_js
+      if @cond.nil? then
+        "return [ret];"
+      else
+        s = @cond.to_js
+        "if(#{s}){ return [ret]; }else{ return[]; }"
+      end
+    end
+  end
+
+  class Order
+  end
+
+  class Group
+    def initialize col
+      @col = col.to_s
+    end
+
+    def col
+      @col
+    end
+  end
+
+end

data/lib/mohair/version.rb

@@ -1,3 +1,3 @@
 module Mohair
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/mohair.rb

@@ -1,17 +1,87 @@
+require "mohair/sql/parser"
+require "mohair/sql/tree"
+
 require "mohair/version"
 require "mohair/selector"
+require "mohair/inserter"
+
+require "json"
+require "optparse"
+require "logger"
+
+LOG = Logger.new(STDERR)
+LOG.level = Logger::DEBUG # WARN, INFO, DEBUG, ...
 
 module Mohair
-  # Your code goes here...
+  
+  def self.usage
+    print <<EOS
+usage:
+ $ mohair -q "select foo, bar from bucket_name" [-i INDEX]
+ $ mohair_dump <bucket_name> < sample_data.json
+
+insert, delete sentence is future work
+mohair version #{Mohair::VERSION}
+EOS
+    exit -1
+  end
+
   def self.main
-    case ARGV[0].downcase
+
+    q = nil #query!!
+    index = nil
+
+    opt = OptionParser.new
+    opt.on('-q Q'){|v| q = v}
+    opt.on('-i INDEX'){|v| index = v}
+    opt.on('-h', '--help'){ usage }
+
+    opt.parse!(ARGV)
+
+    parser = Sql::Parser.new
+    sql_syntax_tree =  parser.parse (q.strip)
+    LOG.debug sql_syntax_tree
+
+    case sql_syntax_tree[:op]
     when 'select'
-      Selector.new(ARGV).exec!
-    when 'insert'
-    when 'show'
-    when 'create'
+
+      s = (Mohair.build sql_syntax_tree)
+
+      LOG.debug "mapper->\n"
+      LOG.debug s.mapper
+      LOG.debug "reducer->\n"
+      LOG.debug s.reducer
+      
+      client = Riak::Client.new(:protocol => "http")
+      bucket = Riak::MapReduce.new(client)
+        .add(client.bucket(s.bucket))## keyfilsters and so on here
+      
+      reducer = s.reducer
+      result = nil
+      if reducer.nil? then
+        result = bucket.map(s.mapper, :keep => true)
+          .run
+      else
+        result = bucket.map(s.mapper, :keep => false)
+          .reduce(reducer, :keep => true)
+          .run
+      end
+
+      #LOG.debug "raw query result> #{result}"
+      LOG.info "query result:"
+      format_result result
+
+    # when :insert
+    # when :show
+    when :create
+      LOG.error "CREATE sentence is unavailable at mohair"
     else
-      print "bad query: ", ARGV, "\n"
+      LOG.error "bad query: ", result, "\n"
     end
   end
+
+  def self.do_dump
+    objs = JSON.load(STDIN)
+    Inserter.new(ARGV[0]).insert_all(objs)
+  end
 end

data/sample_data.json

@@ -0,0 +1,40 @@
+[{
+    "key" : "ham",
+    "data" : {
+        "name" : "john smith",
+        "age"  : 42,
+        "gender" : "male"
+    }
+},
+ {
+     "key" : "hamspam",
+     "data" : {
+        "name" : "john smith",
+        "age"  : 42,
+        "gender" : "male"
+     }
+ },
+ {
+     "key" : "eggspam",
+     "data" : {
+        "name" : "joanna smith",
+        "age"  : 42,
+        "gender" : "female"
+     }
+ },
+ {
+     "key" : "adam_smith2",
+     "data" : {
+         "name" : "john smith",
+         "age"  : 42,
+         "gender" : "male"
+     }
+ },
+ {
+     "key" : "adam_smith",
+     "data" : {
+        "name" : "Adam smith",
+        "age"  : 456,
+        "gender" : "male"
+     }
+ }]

data/test/plugin/selector.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+
+class SelectorTest < MiniTest::Unit::TestCase
+  def setup
+  end
+  def teardown
+  end
+  def test_one
+  end
+end

data/test/plugin/sql.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+# require 'parslet'
+
+class ParserTest < MiniTest::Unit::TestCase
+  #include Mohair
+
+  def setup
+    @parser = Mohair::Sql::Parser.new
+  end
+  def teardown
+  end
+  def test_simples # check syntax parser with parslet
+    [
+     'select a from b',
+     'select a, b from comme',
+     'select b from far',
+     'select c from d',
+     'select a, c, d,e,f,f from b ',
+     'select count(a) from d',
+    ].each do |sql|
+      s = @parser.parse sql
+      assert_equal(expected = "select", actual = s[:op])
+      assert(! s[:select].nil?)
+      assert(! s[:from].nil?)
+      assert(! (Mohair.build s).nil?)
+    end
+  end
+
+  def test_bad_sql
+    [
+     'select',
+     ' select a from b',
+     ].each do |bad_sql|
+      assert_raises Parslet::ParseFailed do
+        @parser.parse bad_sql
+      end
+    end
+  end
+
+  def test_where
+    [
+     'select a from b where a > 20',
+     'select a,b from c where a = 20',
+     'select a,b from c where 20 < a and b < 234',
+     'select a,b from c where 20 < a or b = 234',
+     'select a, b from c where a = "oo"',
+     'select a, b from c where a = "oo" and c > 235',
+    ].each do |where_sql|
+      s = @parser.parse where_sql
+      assert_equal(expected = "select", actual = s[:op])
+      assert(! s[:select].nil?)
+      assert(! s[:from].nil?)
+      assert(! s[:where].nil?)
+      assert(! (Mohair.build s).nil?)
+    end
+  end
+
+  def test_group_by
+    [
+     'select a from b group by c',
+     'select a from b where a > 345 group by c',
+     'select a from b where a > 345 and foo = "hoge" group by c',
+    ].each do |where_sql|
+      s = @parser.parse where_sql
+      assert_equal(expected = "select", actual = s[:op])
+      assert(! s[:select].nil?)
+      assert(! s[:from].nil?)
+      assert(! s[:group_by].nil?)
+      assert(! (Mohair.build s).nil?)
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'test/unit'
+require 'mohair'

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mohair
 version: !ruby/object:Gem::Version 
+  hash: 25
   prerelease: 
-  version: 0.0.2
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - UENISHI Kota
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-03-18 00:00:00 Z
+date: 2013-05-25 00:00:00 Z
 dependencies: []
 
 description: a new type of Riak client
@@ -18,6 +23,7 @@ email:
 - kuenishi@gmail.com
 executables: 
 - mohair
+- mohair_dump
 extensions: []
 
 extra_rdoc_files: []
@@ -29,10 +35,19 @@ files:
 - README.md
 - Rakefile
 - bin/mohair
+- bin/mohair_dump
 - lib/mohair.rb
+- lib/mohair/inserter.rb
 - lib/mohair/selector.rb
+- lib/mohair/sql/parser.rb
+- lib/mohair/sql/select.rb
+- lib/mohair/sql/tree.rb
 - lib/mohair/version.rb
 - mohair.gemspec
+- sample_data.json
+- test/plugin/selector.rb
+- test/plugin/sql.rb
+- test/test_helper.rb
 homepage: ""
 licenses: []
 
@@ -46,19 +61,27 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: a new type of a riak client
-test_files: []
-
+test_files: 
+- test/plugin/selector.rb
+- test/plugin/sql.rb
+- test/test_helper.rb