rocksdb-ruby2 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c8fd69dc617a175a1b1e1212aee796400cc779376be3f3aef98e3d2a7fb78b6
+  data.tar.gz: 27927cac99fdbfe7172901f5279aca55898143f65218d1bc934ecef4eb44aba5
+SHA512:
+  metadata.gz: aa7b5494b8d065d0c1fcd6234e2dc977982dedf647d8067959631604536fe99d3dec703afbf2b398e670bd0428df29653ca7d234705ab90a76515ccc4e57cff6
+  data.tar.gz: 6e6bd49dd1fbc9636b615061aae0e912b7e10155248ef52c48cdd70170b97ce7adf0aa6dff1cf0c06e15d3831424c7e372b88cf8fe233bd72e710ca0c76484e1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rocksdb-ruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013-2016 Isamu Arimoto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# RocksDB
+
+The rocksdb is a persistent in-process key-value store.
+
+Read more about it here: http://rocksdb.org/
+
+This gem contains Ruby bindings so that you can use it from your Ruby process.
+
+## Installation
+
+First install rocksdb.
+
+Add this line to your application's Gemfile:
+
+    gem 'rocksdb-ruby'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rocksdb-ruby
+
+## Usage
+
+    require "rocksdb"
+
+    # Reads And Writes
+    key = "test"
+    value = "1"
+    rocksdb = RocksDB::DB.new "/tmp/file"
+    rocksdb.put(key, value)
+    new_value = rocksdb.get(key)
+    rocksdb.delete(key)
+
+    #Atomic Updates
+    batch = RocksDB::Batch.new
+    batch.delete("test:batch1")
+    batch.put("test:batch2", "b")
+    rocksdb.write(batch)
+
+    #Iteration
+    iterator = rocksdb.new_iterator
+
+    iterator.seek_to_first
+    while(iterator.valid)
+      iterator.value
+      iterator.key
+      iterator.next
+    end
+    iterator.close
+
+    #Block
+    rocksdb.each do |data|
+      puts data
+    end
+
+    #Hash access
+    rocksdb['key'] = data
+    puts rocksdb['key']
+
+    
+    rocksdb.close
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+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

data/Rakefile

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new('spec')
+task :build do
+  Dir.chdir('ext/rocksdb/') do
+    output = `ruby extconf.rb`
+    raise output unless $? == 0
+    output = `make`
+    raise output unless $? == 0
+  end
+end
+
+task :spec => :build

data/ext/rocksdb/extconf.rb

@@ -0,0 +1,11 @@
+require "mkmf"
+
+dir_config('rocksdb')
+RbConfig::CONFIG["CPP"] = "g++ -E -std=gnu++11"
+
+if have_header('rocksdb/db.h') and have_library('rocksdb') 
+  $CPPFLAGS << " -std=gnu++11"
+  create_makefile("RocksDB/RocksDB")
+else
+  abort "can't find header or library of rocksdb"
+end

data/ext/rocksdb/rocksdb_batch_rb.cc

@@ -0,0 +1,38 @@
+#include "rocksdb_batch_rb.h"
+
+extern "C" {
+#include <ruby.h>
+
+  VALUE batch_alloc(VALUE klass){
+    rocksdb::WriteBatch *batch = ALLOC(rocksdb::WriteBatch);
+    batch = new rocksdb::WriteBatch;
+    return Data_Wrap_Struct(klass, 0, -1, batch);
+  }
+
+  VALUE rocksdb_write_batch_init(){
+    return Qtrue;
+  }
+  VALUE rocksdb_write_batch_put(VALUE self, VALUE v_key, VALUE v_value){
+    Check_Type(v_key, T_STRING);
+    Check_Type(v_value, T_STRING);
+
+    rocksdb::WriteBatch *batch;
+    std::string key = std::string((char*)RSTRING_PTR(v_key), RSTRING_LEN(v_key));
+    std::string value = std::string((char*)RSTRING_PTR(v_value), RSTRING_LEN(v_value));
+    
+    Data_Get_Struct(self, rocksdb::WriteBatch, batch);
+    batch->Put(key, value);
+    return Qnil;
+  }
+  VALUE rocksdb_write_batch_delete(VALUE self, VALUE v_key){
+    Check_Type(v_key, T_STRING);
+
+    rocksdb::WriteBatch *batch;
+    std::string key = std::string((char*)RSTRING_PTR(v_key), RSTRING_LEN(v_key));
+    
+    Data_Get_Struct(self, rocksdb::WriteBatch, batch);
+    batch->Delete(key);
+
+    return Qnil;
+  }
+}

data/ext/rocksdb/rocksdb_batch_rb.h

@@ -0,0 +1,14 @@
+#include "rocksdb/db.h"
+#include "rocksdb/write_batch.h"
+
+extern "C" {
+
+#include <ruby.h>
+  
+  typedef VALUE (*METHOD)(...);
+
+  VALUE rocksdb_write_batch_init();
+  VALUE batch_alloc(VALUE klass);
+  VALUE rocksdb_write_batch_put(VALUE self, VALUE v_key, VALUE v_value);
+  VALUE rocksdb_write_batch_delete(VALUE self, VALUE v_key);
+}

data/ext/rocksdb/rocksdb_db_rb.cc

@@ -0,0 +1,270 @@
+#include "rocksdb_rb.h"
+#include "rocksdb_db_rb.h"
+#include "ruby/encoding.h"
+#include <iostream>
+
+extern "C" {
+#include <ruby.h>
+
+  VALUE rocksdb_db_init(int argc, VALUE* argv, VALUE self) {
+    VALUE v_db_file_name;
+    VALUE v_options;
+    rocksdb_pointer* db_pointer;
+    rocksdb::DB* db;
+    rocksdb::Options options;
+    rocksdb::Status status;
+    std::string db_file_name;
+    bool readonly;
+    
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+    rb_scan_args(argc, argv, "11", &v_db_file_name, &v_options);
+
+    Check_Type(v_db_file_name, T_STRING);
+    db_file_name = std::string((char*)RSTRING_PTR(v_db_file_name));
+
+    readonly = false;
+    if (TYPE(v_options) == T_HASH) {
+      VALUE v = rb_hash_aref(v_options, ID2SYM(rb_intern("readonly")));
+      if(v == Qtrue){
+	readonly = true;
+      }
+      set_opt(&options, &v_options);
+    }
+    //std::cout << options.max_bytes_for_level_base << "\n";
+    //std::cout << options.max_grandparent_overlap_factor << "\n";
+    //std::cout << options.delete_obsolete_files_period_micros << "\n";
+
+    options.create_if_missing = true;
+    if(readonly){
+      status = rocksdb::DB::OpenForReadOnly(options, db_file_name, &db);
+    }else{
+      status = rocksdb::DB::Open(options, db_file_name, &db);
+    }
+
+    db_pointer->db = db;
+
+    return status.ok() ? Qtrue : Qfalse;
+  }
+
+  void set_opt_unit_val(uint64_t* opt, char* name, VALUE *v_options){
+
+    VALUE v2 = rb_hash_aref(*v_options, ID2SYM(rb_intern(name)));
+    if(RB_TYPE_P(v2, T_FIXNUM)){
+      *opt = NUM2INT(v2);
+    }
+  }
+  void set_opt_int_val(int* opt, char* name, VALUE *v_options){
+    VALUE v2 = rb_hash_aref(*v_options, ID2SYM(rb_intern(name)));
+    if(RB_TYPE_P(v2, T_FIXNUM)){
+      *opt = NUM2INT(v2);
+    }
+  }
+
+  void set_opt(rocksdb::Options* options, VALUE *v_options){
+    set_opt_unit_val(&options->max_bytes_for_level_base, (char *) "max_bytes_for_level_base", v_options);
+    set_opt_unit_val(&options->delete_obsolete_files_period_micros, (char *) "delete_obsolete_files_period_micros", v_options);
+  }
+
+  VALUE db_alloc(VALUE klass){
+    rocksdb_pointer* db_pointer = ALLOC(rocksdb_pointer);
+    return Data_Wrap_Struct(klass, 0, db_free, db_pointer);
+  }
+
+  VALUE rocksdb_db_put(VALUE self, VALUE v_key, VALUE v_value) {
+    Check_Type(v_key, T_STRING);
+    Check_Type(v_value, T_STRING);
+
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+    
+    std::string key = std::string((char*)RSTRING_PTR(v_key), RSTRING_LEN(v_key));
+    std::string value = std::string((char*)RSTRING_PTR(v_value), RSTRING_LEN(v_value));
+
+    // std::cout << key << "\n";
+    rocksdb::Status status = db_pointer->db->Put(rocksdb::WriteOptions(), key, value);
+    
+    return status.ok() ? Qtrue : Qfalse;
+  }
+
+  VALUE rocksdb_db_write(VALUE self, VALUE v_write){
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+
+    rocksdb::WriteBatch *batch;
+    Data_Get_Struct(v_write, rocksdb::WriteBatch, batch);
+
+    rocksdb::Status status = db_pointer->db->Write(rocksdb::WriteOptions(), batch);
+    return status.ok() ? Qtrue : Qfalse;
+  }
+
+  VALUE rocksdb_db_get(VALUE self, VALUE v_key){
+    Check_Type(v_key, T_STRING);
+
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+    
+    std::string key = std::string((char*)RSTRING_PTR(v_key), RSTRING_LEN(v_key));
+    std::string value;
+    rocksdb::Status status = db_pointer->db->Get(rocksdb::ReadOptions(), key, &value);    
+
+    return (status.IsNotFound()) ? Qnil : rb_enc_str_new(value.data(), value.size(), rb_utf8_encoding());
+
+  }
+
+
+  VALUE rocksdb_db_multi_get(VALUE self, VALUE v_array){
+    Check_Type(v_array, T_ARRAY);
+
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+
+    long i;
+    long length = RARRAY_LEN(v_array);
+    std::vector<std::string> values(length);
+    std::vector<rocksdb::Slice> keys(length);
+    std::vector<rocksdb::Status> status;
+
+    for(i=0; i < length; i++){
+      VALUE op = rb_ary_entry(v_array, i);
+      keys[i] = rocksdb::Slice((char*)RSTRING_PTR(op), RSTRING_LEN(op));
+    }
+
+    status = db_pointer->db->MultiGet(rocksdb::ReadOptions(),keys,&values);
+    for(i=0; i < length; i++){
+      rb_ary_store(v_array, i, rb_enc_str_new(values[i].data(), values[i].size(), rb_utf8_encoding()));
+    }
+    return v_array;
+  }
+  
+  VALUE rocksdb_db_delete(VALUE self, VALUE v_key){
+    Check_Type(v_key, T_STRING);
+    
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+
+    std::string key = std::string((char*)RSTRING_PTR(v_key), RSTRING_LEN(v_key));
+    rocksdb::Status status = db_pointer->db->Delete(rocksdb::WriteOptions(), key);
+    
+    return status.ok() ? Qtrue : Qfalse;
+  }
+
+  VALUE rocksdb_db_exists(VALUE self, VALUE v_key){
+    Check_Type(v_key, T_STRING);
+
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+
+    std::string key = std::string((char*)RSTRING_PTR(v_key), RSTRING_LEN(v_key));
+    std::string value = std::string();
+    
+    return db_pointer->db->KeyMayExist(rocksdb::ReadOptions(), key, &value) ? Qtrue : Qfalse;
+  }  
+
+  VALUE rocksdb_db_close(VALUE self){
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+
+    if(db_pointer->db != NULL){
+      delete db_pointer->db;
+      db_pointer->db = NULL;
+    }
+    return Qnil;
+  }
+
+  void db_free(rocksdb_pointer* db_pointer){
+    if(db_pointer->db != NULL){
+      delete db_pointer->db;
+      db_pointer->db = NULL;
+    }
+    delete db_pointer;
+  }
+
+  VALUE rocksdb_db_new_iterator(VALUE self){
+    rocksdb_pointer* db_pointer;
+    rocksdb_iterator_pointer* rocksdb_it;
+
+    VALUE klass;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+
+    rocksdb::Iterator* it = db_pointer->db->NewIterator(rocksdb::ReadOptions());
+
+    klass = rb_class_new_instance(0, NULL, cRocksdb_iterator);
+
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    rocksdb_it->it = it;
+    return klass;
+  }
+
+
+  VALUE rocksdb_db_each(VALUE self){
+    if(!rb_block_given_p()){
+      return rocksdb_db_new_iterator(self);
+    }
+    
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+    rocksdb::Iterator* it = db_pointer->db->NewIterator(rocksdb::ReadOptions());
+
+    for (it->SeekToFirst(); it->Valid(); it->Next()) {
+      rb_yield(rb_enc_str_new(it->value().data(), it->value().size(), rb_utf8_encoding()));
+    }
+    
+    delete it;
+    return self;
+  }
+
+  VALUE rocksdb_db_each_index(VALUE self){
+    if(!rb_block_given_p()){
+      return rocksdb_db_new_iterator(self);
+    }
+    
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+    rocksdb::Iterator* it = db_pointer->db->NewIterator(rocksdb::ReadOptions());
+
+    for (it->SeekToFirst(); it->Valid(); it->Next()) {
+      rb_yield(rb_enc_str_new(it->key().data(), it->key().size(), rb_utf8_encoding()));
+    }
+    
+    delete it;
+    return self;
+  }
+
+  VALUE rocksdb_db_each_with_index(VALUE self){
+    if(!rb_block_given_p()){
+      return rocksdb_db_new_iterator(self);
+    }
+    
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+    rocksdb::Iterator* it = db_pointer->db->NewIterator(rocksdb::ReadOptions());
+
+    for (it->SeekToFirst(); it->Valid(); it->Next()) {
+      VALUE a = rb_enc_str_new(it->key().data(), it->key().size(), rb_utf8_encoding());
+      VALUE b = rb_enc_str_new(it->value().data(), it->value().size(), rb_utf8_encoding());
+      rb_yield_values(2, a, b);
+    }
+    
+    delete it;
+    return self;
+  }
+
+  
+
+  VALUE rocksdb_db_reverse_each(VALUE self){
+    rocksdb_pointer* db_pointer;
+    Data_Get_Struct(self, rocksdb_pointer, db_pointer);
+    rocksdb::Iterator* it = db_pointer->db->NewIterator(rocksdb::ReadOptions());
+
+    for (it->SeekToLast(); it->Valid(); it->Prev()) {
+      rb_yield(rb_enc_str_new(it->value().data(), it->value().size(), rb_utf8_encoding()));
+    }
+    
+    delete it;
+    return self;
+  }
+
+  VALUE rocksdb_db_debug(VALUE self){
+    return Qnil;
+  }
+}

data/ext/rocksdb/rocksdb_db_rb.h

@@ -0,0 +1,25 @@
+#include "rocksdb/db.h"
+#include "rocksdb/write_batch.h"
+
+extern "C" {
+#include <ruby.h>
+  VALUE rocksdb_db_init(int argc, VALUE* argv, VALUE self);
+  VALUE db_alloc(VALUE klass);
+  VALUE rocksdb_db_put(VALUE self, VALUE v_key, VALUE v_value);
+  VALUE rocksdb_db_write(VALUE self, VALUE v_write);
+  VALUE rocksdb_db_get(VALUE self, VALUE v_key);
+  VALUE rocksdb_db_multi_get(VALUE self, VALUE v_array);
+  VALUE rocksdb_db_delete(VALUE self, VALUE v_key);
+  VALUE rocksdb_db_exists(VALUE self, VALUE v_key);
+  VALUE rocksdb_db_close(VALUE self);
+  VALUE rocksdb_db_debug(VALUE self);
+  VALUE rocksdb_db_new_iterator(VALUE self);
+  VALUE rocksdb_db_each(VALUE self);
+  VALUE rocksdb_db_each_index(VALUE self);
+  VALUE rocksdb_db_each_with_index(VALUE self);
+  VALUE rocksdb_db_reverse_each(VALUE self);
+  void db_free(rocksdb_pointer* db_pointer);
+  void set_opt(rocksdb::Options* opt, VALUE *v_options);
+  void set_opt_unit_val(uint64_t* opt, char* name, VALUE *v_options);
+  void set_opt_int_val(int* opt, char* name, VALUE *v_options);
+}

data/ext/rocksdb/rocksdb_iterator_rb.cc

@@ -0,0 +1,83 @@
+#include "rocksdb_rb.h"
+#include "rocksdb_batch_rb.h"
+#include "ruby/encoding.h"
+#include <iostream>
+
+extern "C" {
+#include <ruby.h>
+
+  VALUE rocksdb_iterator_seek_to_first(VALUE klass){
+    rocksdb_iterator_pointer* rocksdb_it;
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    rocksdb_it->it->SeekToFirst();
+
+    return Qnil;
+  }
+
+  VALUE rocksdb_iterator_seek_to_last(VALUE klass){
+    rocksdb_iterator_pointer* rocksdb_it;
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    rocksdb_it->it->SeekToLast();
+
+    return Qnil;
+  }
+
+  VALUE rocksdb_iterator_seek(VALUE klass, VALUE v_target){
+    Check_Type(v_target, T_STRING);
+    rocksdb::Slice target = rocksdb::Slice((char*)RSTRING_PTR(v_target), RSTRING_LEN(v_target));
+
+    rocksdb_iterator_pointer* rocksdb_it;
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    rocksdb_it->it->Seek(target);
+
+    return Qnil;
+  }
+
+  VALUE rocksdb_iterator_alloc(VALUE klass){
+    rocksdb_iterator_pointer* it = ALLOC(rocksdb_iterator_pointer);
+    return Data_Wrap_Struct(klass, 0, -1, it);
+  }
+
+  VALUE rocksdb_iterator_valid(VALUE klass){
+    rocksdb_iterator_pointer* rocksdb_it;
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    return rocksdb_it->it->Valid() ? Qtrue : Qfalse;
+  }
+
+  VALUE rocksdb_iterator_key(VALUE klass){
+    rocksdb_iterator_pointer* rocksdb_it;
+    std::string value;
+
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    value = rocksdb_it->it->key().ToString();
+
+    return rb_enc_str_new(value.data(), value.size(), rb_utf8_encoding());
+  }
+  
+  VALUE rocksdb_iterator_value(VALUE klass){
+    rocksdb_iterator_pointer* rocksdb_it;
+    std::string value;
+
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    value = rocksdb_it->it->value().ToString();
+
+    return rb_enc_str_new(value.data(), value.size(), rb_utf8_encoding());
+
+  }
+  
+  VALUE rocksdb_iterator_next(VALUE klass){
+    rocksdb_iterator_pointer* rocksdb_it;
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    rocksdb_it->it->Next();
+
+    return Qnil;
+  }
+
+  VALUE rocksdb_iterator_close(VALUE klass){
+    rocksdb_iterator_pointer* rocksdb_it;
+    Data_Get_Struct(klass, rocksdb_iterator_pointer , rocksdb_it);
+    delete rocksdb_it->it;
+
+    return Qnil;
+  }
+}

data/ext/rocksdb/rocksdb_iterator_rb.h

@@ -0,0 +1,21 @@
+#include "rocksdb/db.h"
+#include "rocksdb/write_batch.h"
+
+extern "C" {
+
+#include <ruby.h>
+  
+  typedef VALUE (*METHOD)(...);
+
+  VALUE rocksdb_iterator_seek_to_first(VALUE klass);
+  VALUE rocksdb_iterator_seek_to_last(VALUE klass);
+  VALUE rocksdb_iterator_seek(VALUE klass, VALUE v_target);
+  VALUE rocksdb_iterator_alloc(VALUE klass);
+  VALUE rocksdb_iterator_valid(VALUE klass);
+  VALUE rocksdb_iterator_key(VALUE klass);
+  VALUE rocksdb_iterator_value(VALUE klass);
+  VALUE rocksdb_iterator_next(VALUE klass);
+  VALUE rocksdb_iterator_close(VALUE klass);
+
+} 
+ 

data/ext/rocksdb/rocksdb_rb.cc

@@ -0,0 +1,61 @@
+#include "rocksdb_rb.h"
+#include "rocksdb_db_rb.h"
+#include "rocksdb_batch_rb.h"
+#include "rocksdb_status_rb.h"
+#include "rocksdb_iterator_rb.h"
+
+extern "C" {
+  VALUE cRocksdb_iterator;
+
+  void Init_RocksDB(){
+   
+    VALUE cRocksdb;
+    VALUE cRocksdb_db;
+    VALUE cRocksdb_write_batch;
+    VALUE cRocksdb_read_options;
+    VALUE cRocksdb_write_options;
+    VALUE cRocksdb_status;
+    
+    cRocksdb = rb_define_module("RocksDB");
+    cRocksdb_db = rb_define_class_under(cRocksdb, "DB", rb_cObject);
+    rb_define_alloc_func(cRocksdb_db, db_alloc);
+
+    rb_define_private_method(cRocksdb_db, "initialize", (METHOD)rocksdb_db_init, -1);
+    rb_define_method(cRocksdb_db, "put", (METHOD)rocksdb_db_put, 2);
+    rb_define_method(cRocksdb_db, "write", (METHOD)rocksdb_db_write, 1);
+    rb_define_method(cRocksdb_db, "get", (METHOD)rocksdb_db_get, 1);
+    rb_define_method(cRocksdb_db, "multi_get", (METHOD)rocksdb_db_multi_get, 1);
+    rb_define_method(cRocksdb_db, "delete", (METHOD)rocksdb_db_delete, 1);
+    rb_define_method(cRocksdb_db, "exists?", (METHOD)rocksdb_db_exists, 1);
+    rb_define_method(cRocksdb_db, "close", (METHOD)rocksdb_db_close, 0);
+    rb_define_method(cRocksdb_db, "debug", (METHOD)rocksdb_db_debug, 0);
+    rb_define_method(cRocksdb_db, "new_iterator", (METHOD)rocksdb_db_new_iterator, 0);
+
+    rb_define_method(cRocksdb_db, "iterator", (METHOD)rocksdb_db_each, 0);
+    rb_define_method(cRocksdb_db, "each_index", (METHOD)rocksdb_db_each_index, 0);
+    rb_define_method(cRocksdb_db, "each_with_index", (METHOD)rocksdb_db_each_with_index, 0);
+    rb_define_method(cRocksdb_db, "reverse_each", (METHOD)rocksdb_db_reverse_each, 0);
+
+    cRocksdb_write_batch = rb_define_class_under(cRocksdb, "Batch", rb_cObject);
+    rb_define_alloc_func(cRocksdb_write_batch, batch_alloc);
+    rb_define_private_method(cRocksdb_write_batch, "initialize", (METHOD)rocksdb_write_batch_init, 0);
+    rb_define_method(cRocksdb_write_batch, "put", (METHOD)rocksdb_write_batch_put, 2);
+    rb_define_method(cRocksdb_write_batch, "delete", (METHOD)rocksdb_write_batch_delete, 1);
+
+    cRocksdb_iterator = rb_define_class_under(cRocksdb, "Iterator", rb_cObject);
+    rb_define_alloc_func(cRocksdb_iterator, rocksdb_iterator_alloc);
+    rb_define_method(cRocksdb_iterator, "seek_to_first", (METHOD)rocksdb_iterator_seek_to_first, 0);
+    rb_define_method(cRocksdb_iterator, "seek_to_last", (METHOD)rocksdb_iterator_seek_to_last, 0);
+    rb_define_method(cRocksdb_iterator, "seek", (METHOD)rocksdb_iterator_seek, 1);
+    rb_define_method(cRocksdb_iterator, "valid", (METHOD)rocksdb_iterator_valid, 0);
+    rb_define_method(cRocksdb_iterator, "key", (METHOD)rocksdb_iterator_key, 0);
+    rb_define_method(cRocksdb_iterator, "value", (METHOD)rocksdb_iterator_value, 0);
+    rb_define_method(cRocksdb_iterator, "next", (METHOD)rocksdb_iterator_next, 0);
+    rb_define_method(cRocksdb_iterator, "close", (METHOD)rocksdb_iterator_close, 0);
+
+    cRocksdb_status = rb_define_class_under(cRocksdb, "Status", rb_cObject);
+    cRocksdb_read_options = rb_define_class_under(cRocksdb, "ReadOptions", rb_cObject);
+    cRocksdb_write_options = rb_define_class_under(cRocksdb, "WriteOptions", rb_cObject);
+
+  }
+}

data/ext/rocksdb/rocksdb_rb.h

@@ -0,0 +1,24 @@
+#include "rocksdb/db.h"
+#include "rocksdb/write_batch.h"
+
+#ifndef RUBY_ROCKSDB_H
+#define RUBY_ROCKSDB_H 1
+
+
+extern "C" {
+
+#include <ruby.h>
+  extern VALUE cRocksdb_iterator;
+  
+  typedef VALUE (*METHOD)(...);
+  
+  struct rocksdb_pointer{ 
+    rocksdb::DB* db;
+  };
+
+  struct rocksdb_iterator_pointer{ 
+    rocksdb::Iterator* it;
+  };
+  
+}
+#endif

data/ext/rocksdb/rocksdb_status_rb.cc

@@ -0,0 +1,3 @@
+extern "C" {
+#include <ruby.h>
+}

data/ext/rocksdb/rocksdb_status_rb.h

@@ -0,0 +1,3 @@
+extern "C" {
+#include <ruby.h>
+}

data/lib/rocksdb.rb

@@ -0,0 +1,28 @@
+require "rocksdb/RocksDB" # the c extension
+require "rocksdb/ruby/version"
+
+module RocksDB
+  class DB
+    include Enumerable
+    
+    class << self
+    end
+    
+    alias :includes? :exists?
+    alias :contains? :exists?
+    alias :member? :exists?
+    alias :[] :get
+    alias :[]= :put
+    alias :close! :close
+
+    def each(&block)
+      if block_given?
+        self.each_with_index do |key, value|
+          block.call(value)
+        end
+      else
+        self.iterator
+      end
+    end
+  end
+end

data/lib/rocksdb/ruby/version.rb

@@ -0,0 +1,5 @@
+module Rocksdb
+  module Ruby
+    VERSION = "0.1.4"
+  end
+end

data/rocksdb-ruby.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rocksdb/ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.extensions = ["ext/rocksdb/extconf.rb"]
+
+  spec.name          = "rocksdb-ruby2"
+  spec.version       = Rocksdb::Ruby::VERSION
+  spec.authors       = ["Isamu Arimoto"]
+  spec.email         = ["isamu.a@gmail.com"]
+  spec.summary       = %q{A simple RocksDB library for Ruby}
+  spec.homepage      = "https://github.com/isamu/rocksdb-ruby"
+  spec.license       = "mit"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["ext", "lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/db_null_spec.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require "rocksdb"
+
+describe RocksDB do
+  before do
+    @rocksdb = RocksDB::DB.new "/tmp/file"
+  end
+
+  it 'should get null contained data' do
+    @aaa = "aa\0aa"
+
+    @rocksdb.put("test:null", @aaa)
+    expect(@rocksdb.get("test:null")).to eq "aa\0aa"
+  end
+
+  it 'should get from null contained key' do
+    @key = "test:aa\0aa"
+    @rocksdb.put(@key, "aaa")
+    expect(@rocksdb.get(@key)).to eq "aaa"
+    
+    @key = "test:aa"
+    expect(@rocksdb.get(@key)).to eq nil
+
+  end
+
+  it 'should get multi data' do
+    @rocksdb.put("test:nullmulti1\0a", "a\01")
+    @rocksdb.put("test:nullmulti2\0a", "b\02")
+    @rocksdb.put("test:nullmulti3\0a", "c\03")
+
+    expect(@rocksdb.multi_get(["test:nullmulti1\0a", "test:nullmulti2\0a", "test:nullmulti3\0a"])).to eq ["a\01", "b\02", "c\03"]
+    expect(@rocksdb.multi_get(["test:nullmulti1", "test:nullmulti2", "test:nullmulti3"])).to eq ["", "", ""]
+  end
+  
+  after do
+    @rocksdb.close
+  end
+  
+end

data/spec/db_options_spec.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require "rocksdb"
+
+describe RocksDB do
+  before do
+    @rocksdb = RocksDB::DB.new "/tmp/file3", {:max_bytes_for_level_base => 10485760, :max_grandparent_overlap_factor => 20}
+  end
+
+  it 'should get data' do
+    @rocksdb.put("test:multi_db", "10")
+    expect(@rocksdb.get("test:multi_db")).to eq "10"
+  end
+
+  after do
+    @rocksdb.close
+  end
+end

data/spec/db_readonly_spec.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require "rocksdb"
+
+describe RocksDB do
+  before do
+    @rocksdb = RocksDB::DB.new "/tmp/file2"
+    @rocksdb.put("test:multi_db", "1")
+    @rocksdb.close
+
+    @rocksdb2 = RocksDB::DB.new "/tmp/file2", {:readonly => true}
+  end
+
+  it 'should get data' do
+    @rocksdb2.put("test:multi_db", "10")
+    expect(@rocksdb2.get("test:multi_db")).to eq "1"
+  end
+
+  after do
+    @rocksdb2.close
+  end
+end

data/spec/db_spec.rb

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require "rocksdb"
+
+describe RocksDB do
+  before do
+    @rocksdb = RocksDB::DB.new "/tmp/file"
+  end
+
+  it 'should get data' do
+    @rocksdb.put("test:read", "1")
+    expect(@rocksdb.get("test:read")).to eq "1"
+  end
+
+  it 'should put data' do 
+    expect(@rocksdb.put("test:put", "2")).to be true
+    expect(@rocksdb.get("test:put")).to eq "2"
+  end
+
+  it 'should delete data' do 
+    @rocksdb.put("test:delete", "3")
+    expect(@rocksdb.get("test:delete")).to eq "3"
+
+    expect(@rocksdb.delete("test:delete")).to be true
+    expect(@rocksdb.get("test:delete")).to be_nil
+  end
+
+  it 'should get multi data' do
+    @rocksdb.put("test:multi1", "a")
+    @rocksdb.put("test:multi2", "b")
+    @rocksdb.put("test:multi3", "c")
+
+    expect(@rocksdb.multi_get(["test:multi1", "test:multi2", "test:multi3"])).to eq ["a", "b", "c"]
+  end
+
+  it 'should put data atomic update' do
+    @rocksdb.put("test:batch1", "a")
+    @rocksdb.delete("test:batch2")
+
+    expect(@rocksdb.get("test:batch1")).to eq "a"
+    expect(@rocksdb.get("test:batch")).to be_nil
+
+    batch = RocksDB::Batch.new
+    batch.delete("test:batch1")
+    batch.put("test:batch2", "b")
+    @rocksdb.write(batch)
+
+    expect(@rocksdb.get("test:batch1")).to be_nil
+    expect(@rocksdb.get("test:batch2")).to eq "b"
+  end
+
+  it 'should use multiple db' do
+    @rocksdb2 = RocksDB::DB.new "/tmp/file2"
+    
+    @rocksdb.put("test:multi_db", "1")
+    @rocksdb2.put("test:multi_db", "2")
+    
+    expect(@rocksdb.get("test:multi_db")).to eq "1"
+    expect(@rocksdb2.get("test:multi_db")).to eq "2"
+    @rocksdb2.close
+  end
+
+  it 'should use japanese charactor' do
+    @rocksdb.put("test:japanese", "あいうえお")
+
+    expect(@rocksdb.get("test:japanese")).to eq "あいうえお"
+    expect(@rocksdb.multi_get(["test:japanese"])).to eq ["あいうえお"]
+  end
+
+  it 'should use each' do
+    iter = @rocksdb.each 
+
+    array = []
+    @rocksdb.each do |value|
+      expect(value).not_to be_empty
+      array << value
+    end
+
+    rev_array = []
+    @rocksdb.reverse_each do |value|
+      expect(value).not_to be_empty
+      rev_array << value
+    end
+ 
+
+    expect(array).to eq rev_array.reverse
+
+    @rocksdb.each_index do |key|
+      expect(key).not_to be_empty
+    end
+
+    @rocksdb.each_with_index do |key, value|
+      expect(key).not_to be_empty
+      expect(value).not_to be_empty
+    end
+
+    iter.close
+  end
+
+  it 'should exists?' do
+    @rocksdb.put("test:exists?", "a")
+    @rocksdb.delete("test:noexists?")
+    expect(@rocksdb.exists?("test:exists?")).to be true
+    expect(@rocksdb.exists?("test:noexists?")).to be false
+
+    expect(@rocksdb.includes?("test:exists?")).to be true
+    expect(@rocksdb.includes?("test:noexists?")).to be false
+
+  end
+
+  it 'hash' do
+    @rocksdb.delete("test:hash")
+    expect(@rocksdb["test:hash"]).to be_nil
+    @rocksdb["test:hash"] = "a"
+    expect(@rocksdb["test:hash"]).to eq "a"
+
+  end
+  
+  after do
+    @rocksdb.close
+  end
+end
+

data/spec/iterator_spec.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require "RocksDB"
+
+describe RocksDB do
+  before do
+    @rocksdb = RocksDB::DB.new "/tmp/file"
+  end
+
+  it 'should use iterator' do
+    iterator = @rocksdb.new_iterator
+
+    iterator.seek_to_first
+    
+    expect(iterator.valid).to be true
+    while(iterator.valid)
+      expect(iterator.value).not_to be_empty
+      expect(iterator.key).not_to be_empty
+      iterator.next
+    end
+    iterator.close
+  end
+
+  it 'should seek iterator' do
+    iterator = @rocksdb.new_iterator
+
+    iterator.seek("test:put")
+    
+    iterator.valid
+    expect(iterator.value).to eq "2"
+    expect(iterator.key).to eq "test:put"
+
+    iterator.close
+  end
+
+  after do
+    @rocksdb.close
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+
+$: << File.dirname(__FILE__) + '/../ext/rocksdb'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: rocksdb-ruby2
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+platform: ruby
+authors:
+- Isamu Arimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- isamu.a@gmail.com
+executables: []
+extensions:
+- ext/rocksdb/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/rocksdb/extconf.rb
+- ext/rocksdb/rocksdb_batch_rb.cc
+- ext/rocksdb/rocksdb_batch_rb.h
+- ext/rocksdb/rocksdb_db_rb.cc
+- ext/rocksdb/rocksdb_db_rb.h
+- ext/rocksdb/rocksdb_iterator_rb.cc
+- ext/rocksdb/rocksdb_iterator_rb.h
+- ext/rocksdb/rocksdb_rb.cc
+- ext/rocksdb/rocksdb_rb.h
+- ext/rocksdb/rocksdb_status_rb.cc
+- ext/rocksdb/rocksdb_status_rb.h
+- lib/rocksdb.rb
+- lib/rocksdb/ruby.rb
+- lib/rocksdb/ruby/version.rb
+- rocksdb-ruby.gemspec
+- spec/db_null_spec.rb
+- spec/db_options_spec.rb
+- spec/db_readonly_spec.rb
+- spec/db_spec.rb
+- spec/iterator_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/isamu/rocksdb-ruby
+licenses:
+- mit
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- ext
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A simple RocksDB library for Ruby
+test_files:
+- spec/db_null_spec.rb
+- spec/db_options_spec.rb
+- spec/db_readonly_spec.rb
+- spec/db_spec.rb
+- spec/iterator_spec.rb
+- spec/spec_helper.rb