rocksdb-ruby 0.2.3 → 1.0.0

data/ext/rocksdb/rocksdb_rb.cc

@@ -5,41 +5,52 @@
 #include "rocksdb_iterator_rb.h"
 
 extern "C" {
+  VALUE cRocksdb;
   VALUE cRocksdb_iterator;
 
+  VALUE cRocksdb_database_closed;
+  VALUE cRocksdb_iterator_closed;
+  VALUE cRocksdb_status_error;
+  VALUE cRocksdb_readonly;
+
   void Init_RocksDB(){
-   
-    VALUE cRocksdb;
     VALUE cRocksdb_db;
     VALUE cRocksdb_write_batch;
     VALUE cRocksdb_read_options;
     VALUE cRocksdb_write_options;
     VALUE cRocksdb_status;
-    
+    VALUE cRocksdb_error;
+
+    VALUE rb_cStandardError = rb_const_get(rb_cObject, rb_intern("StandardError"));
+
     cRocksdb = rb_define_module("RocksDB");
+    rb_define_singleton_method(cRocksdb, "library_version", (METHOD)rocksdb_version, 0);
+
+    cRocksdb_error = rb_define_class_under(cRocksdb, "Error", rb_cStandardError);
+
+    cRocksdb_readonly = rb_define_class_under(cRocksdb, "ReadOnly", cRocksdb_error);
+    cRocksdb_status_error = rb_define_class_under(cRocksdb, "StatusError", cRocksdb_error);
+    cRocksdb_database_closed = rb_define_class_under(cRocksdb, "DatabaseClosed", cRocksdb_error);
+    cRocksdb_iterator_closed = rb_define_class_under(cRocksdb, "IteratorClosed", cRocksdb_error);
+
     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_private_method(cRocksdb_db, "__initialize2", (METHOD)rocksdb_db_init2, -1);
+    rb_define_private_method(cRocksdb_db, "__initialize", (METHOD)rocksdb_db_init, 3);
     rb_define_method(cRocksdb_db, "property", (METHOD)rocksdb_db_property, 1);
+    rb_define_method(cRocksdb_db, "options_strings", (METHOD)rocksdb_db_options, 0);
     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, "get_one", (METHOD)rocksdb_db_get, 1);
+    rb_define_method(cRocksdb_db, "get_many", (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_private_method(cRocksdb_db, "__close", (METHOD)rocksdb_db_close, 0);
+    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, "to_iterator", (METHOD)rocksdb_db_to_iterator, 0);
     rb_define_method(cRocksdb_db, "compact", (METHOD)rocksdb_db_compact, -1);
-    rb_define_method(cRocksdb_db, "is_readonly?", (METHOD)rocksdb_db_is_readonly, 0);
-    rb_define_method(cRocksdb_db, "is_open?", (METHOD)rocksdb_db_is_open, 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);
+    rb_define_method(cRocksdb_db, "writable?", (METHOD)rocksdb_db_is_writable, 0);
+    rb_define_method(cRocksdb_db, "open?", (METHOD)rocksdb_db_is_open, 0);
 
     cRocksdb_write_batch = rb_define_class_under(cRocksdb, "Batch", rb_cObject);
     rb_define_alloc_func(cRocksdb_write_batch, batch_alloc);
@@ -49,18 +60,40 @@ extern "C" {
 
     cRocksdb_iterator = rb_define_class_under(cRocksdb, "Iterator", rb_cObject);
     rb_define_alloc_func(cRocksdb_iterator, rocksdb_iterator_alloc);
+
+    rb_define_method(cRocksdb_iterator, "valid?", (METHOD)rocksdb_iterator_valid, 0);
     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);
+#if ROCKSDB_VERSION >= 41100
+    rb_define_method(cRocksdb_iterator, "seek_for_previous", (METHOD)rocksdb_iterator_seek_for_prev, 1);
+#endif
+    rb_define_method(cRocksdb_iterator, "next", (METHOD)rocksdb_iterator_next, 0);
+    rb_define_method(cRocksdb_iterator, "previous", (METHOD)rocksdb_iterator_prev, 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);
 
+    rb_define_method(cRocksdb_iterator, "each", (METHOD)rocksdb_iterator_each, 0);
+    rb_define_method(cRocksdb_iterator, "reverse_each", (METHOD)rocksdb_iterator_reverse_each, 0);
+    rb_define_method(cRocksdb_iterator, "each_key", (METHOD)rocksdb_iterator_each_key, 0);
+    rb_define_method(cRocksdb_iterator, "reverse_each_key", (METHOD)rocksdb_iterator_reverse_each_key, 0);
+    rb_define_method(cRocksdb_iterator, "each_pair", (METHOD)rocksdb_iterator_each_pair, 0);
+    rb_define_method(cRocksdb_iterator, "reverse_each_pair", (METHOD)rocksdb_iterator_reverse_each_pair, 0);
+
+    rb_define_method(cRocksdb_iterator, "each_prefix", (METHOD)rocksdb_iterator_each_prefix, 1);
+    rb_define_method(cRocksdb_iterator, "each_range", (METHOD)rocksdb_iterator_each_range, 2);
+
     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);
+  }
 
+  VALUE rocksdb_version(VALUE self){
+    VALUE v_version;
+    v_version = rb_sprintf("%i.%i.%i", ROCKSDB_MAJOR, ROCKSDB_MINOR, ROCKSDB_PATCH);
+    return v_version;
   }
 }

data/ext/rocksdb/rocksdb_rb.h

@@ -1,25 +1,48 @@
 #include "rocksdb/db.h"
 #include "rocksdb/write_batch.h"
+#include "rocksdb/version.h"
 
 #ifndef RUBY_ROCKSDB_H
 #define RUBY_ROCKSDB_H 1
 
+#ifndef NDEBUG
+#include <iostream>
+#define TRACE(Out) (std::cerr << __FILE__ << ":" << __LINE__ << "(" << __func__ << ") " << Out << std::endl);
+#else
+#define TRACE(Out)
+#endif
 
-extern "C" {
+#define ROCKSDB_VERSION (ROCKSDB_MAJOR * 10000 \
+                       + ROCKSDB_MINOR * 100 \
+                       + ROCKSDB_PATCH)
 
+extern "C" {
 #include <ruby.h>
+
+#define SLICE_TO_RB_STRING(slice) (rb_enc_str_new(slice.data(), slice.size(), rb_utf8_encoding()))
+#define SLICE_FROM_RB_VALUE(entity) ({ VALUE _string = StringValue((entity)); rocksdb::Slice(RSTRING_PTR(_string), RSTRING_LEN(_string)); })
+#define STRING_FROM_RB_VALUE(entity) ({ VALUE _string = StringValue(entity); std::string(RSTRING_PTR(_string), RSTRING_LEN(_string)); })
+
+  extern VALUE cRocksdb;
   extern VALUE cRocksdb_iterator;
-  
+
+  extern VALUE cRocksdb_database_closed;
+  extern VALUE cRocksdb_iterator_closed;
+  extern VALUE cRocksdb_status_error;
+  extern VALUE cRocksdb_readonly;
+
   typedef VALUE (*METHOD)(...);
-  
-  struct rocksdb_pointer{ 
+
+  struct rocksdb_pointer{
     rocksdb::DB* db;
     bool readonly;
   };
 
-  struct rocksdb_iterator_pointer{ 
+  struct rocksdb_iterator_pointer{
     rocksdb::Iterator* it;
+    rocksdb_pointer* db_pointer;
   };
-  
+
+  VALUE rocksdb_version(VALUE self);
 }
 #endif

data/lib/rocksdb.rb

@@ -1,61 +1,82 @@
 require "rocksdb/RocksDB" # the c extension
 require "rocksdb/ruby/version"
 
+require 'forwardable'
+
 module RocksDB
-  class DBError < StandardError; end
-  class DB
+  class Error < StandardError; end
+  class ReadOnly < RocksDB::Error; end
+  class StatusError < RocksDB::Error; end
+  class DatabaseClosed < RocksDB::Error; end
+  class IteratorClosed < RocksDB::Error; end
+
+  class Iterator
     include Enumerable
+  end
 
-    @@cache = {}
-    
-    class << self
-      def get_instance *args
-        readonly = !!(args[1] && args[1][:readonly])
-        key = args[0]
-        
-        if readonly
-          return new(*args)
-        end
-        unless @@cache[key]
-          @@cache[key] = new(*args)
-        end
-        @@cache[key]
-      end
+  class << self
+    def open(db_path, db_options = "")
+      ::RocksDB::DB.new(db_path, db_options, readonly: false)
     end
-    
-    def initialize *args
-      readonly = !!(args[1] && args[1][:readonly])
-      @key = args[0]
-      if !readonly and @@cache[@key]
-        __initialize2(*args)
-        raise DBError.new("error #{@key.to_s} alread open")
-      end
-      __initialize(*args)
-      unless readonly
-        @@cache[@key] = self
+
+    def open_readonly(db_path, db_options = "")
+      ::RocksDB::DB.new(db_path, db_options, readonly: true)
+    end
+  end
+
+  class DB
+    extend Forwardable
+
+    def initialize(path, rocksdb_options = "", options = {})
+      is_readonly = options[:readonly] || false
+
+      if rocksdb_options.is_a? Hash
+        is_readonly = rocksdb_options.delete(:readonly)
+
+        rocksdb_options = rocksdb_options.map do |key, value|
+          [key, value].join("=")
+        end.join(";")
       end
+
+      __initialize(path, is_readonly, rocksdb_options.to_s)
     end
 
-    def close
-      @@cache.delete(@key)
-      __close
+    def get(*args)
+      args.flatten!
+
+      if args.size == 1
+        get_one args.first
+      else
+        get_many args
+      end
     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)
+
+    def options
+      options_strings.each_with_object({}) do |(option_group, value), result|
+        pairs = value.split(/;\s*/)
+        pairs.map do |pair|
+          key, value = pair.split("=")
+          result[key] = value
         end
-      else
-        self.iterator
       end
     end
+
+    alias_method :includes?, :exists?
+    alias_method :contains?, :exists?
+    alias_method :member?, :exists?
+    alias_method :member?, :exists?
+    alias_method :[], :get
+    alias_method :[]=, :put
+    alias_method :close!, :close
+
+    def_delegators :to_iterator,
+                   :each, :reverse_each, :each_key, :reverse_each_key,
+                   :each_pair, :reverse_each_pair,
+                   :each_prefix, :each_range
+
+    alias_method :each_index, :each_key
+    alias_method :each_with_index, :each_pair
   end
 end
+
+require 'rocksdb/ruby/deprecated'

data/lib/rocksdb/ruby/deprecated.rb

@@ -0,0 +1,29 @@
+# Deprecated methods, kept for backward compatibility
+module RocksDB
+  class DBError < ::RocksDB::Error; end;
+
+  class Iterator
+    extend Gem::Deprecate
+
+    alias_method :valid, :valid?
+    deprecate :valid, :valid?, 2019, 12
+  end
+
+  class DB
+    extend Gem::Deprecate
+
+    alias_method :new_iterator, :to_iterator
+    deprecate :new_iterator, :to_iterator, 2019, 12
+
+    def is_readonly?
+      !writable?
+    end
+    deprecate :is_readonly?, :writable?, 2019, 12
+
+    alias_method :is_open?, :open?
+    deprecate :is_open?, :open?, 2019, 12
+
+    alias_method :multi_get, :get_many
+    deprecate :multi_get, :get_many, 2019, 12
+  end
+end

data/lib/rocksdb/ruby/version.rb

@@ -1,5 +1,5 @@
 module Rocksdb
   module Ruby
-    VERSION = "0.2.3"
+    VERSION = "1.0.0"
   end
 end

data/rocksdb-ruby.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["ext", "lib"]
 
   spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rspec-core"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-core", "~> 3.0"
 end

data/spec/db_null_spec.rb

@@ -3,38 +3,38 @@ require 'spec_helper'
 require "rocksdb"
 
 describe RocksDB do
-  before do
-    @rocksdb = RocksDB::DB.new "/tmp/file"
-  end
+  context "null-terminated strings" do
+    before do
+      @rocksdb = RocksDB.open temp_db_path
 
-  it 'should get null contained data' do
-    @aaa = "aa\0aa"
+      @rocksdb.put("test:text1\0a", "hello")
+      @rocksdb.put("test:plain", "he\0llo")
+      @rocksdb.put("test:null\0a", "he\0llo")
+      @rocksdb.put("test:nullmulti1\0a", "a\0a1")
+      @rocksdb.put("test:nullmulti2\0a", "b\0a2")
+      @rocksdb.put("test:nullmulti3\0a", "c\0a3")
+    end
 
-    @rocksdb.put("test:null", @aaa)
-    expect(@rocksdb.get("test:null")).to eq "aa\0aa"
-  end
+    it 'should get key with null bytes' do
+      expect(@rocksdb.get("test:text1\0a")).to eq "hello"
+    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
+    it 'should get value with null bytes' do
+      expect(@rocksdb.get("test:plain")).to eq "he\0llo"
+    end
 
-  end
+    it 'should get key and value with null bytes' do
+      expect(@rocksdb.get("test:null\0a")).to eq "he\0llo"
+    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")
+    it 'should get all pairs' do
+      expect(@rocksdb.get("test:nullmulti1\0a", "test:nullmulti2\0a", "test:nullmulti3\0a")).to eq ["a\0a1", "b\0a2", "c\0a3"]
 
-    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
+      expect(@rocksdb.get("test:nullmulti1", "test:nullmulti2", "test:nullmulti3")).to eq [nil, nil, nil]
+    end
+
+    after do
+      @rocksdb.close
+    end
   end
-  
 end

data/spec/db_options_spec.rb

@@ -3,16 +3,51 @@ 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
+  context "options" do
+    let(:rocksdb) { RocksDB.open temp_db_path, "WAL_size_limit_MB=16" }
+
+    it "returns RocksDB options as a hash" do
+      expect(rocksdb.options).to be_a Hash
+    end
+
+    it "returns database options" do
+      expect(rocksdb.options).to include("use_fsync")
+    end
 
-  it 'should get data' do
-    @rocksdb.put("test:multi_db", "10")
-    expect(@rocksdb.get("test:multi_db")).to eq "10"
+    it "returns column family options" do
+      expect(rocksdb.options).to include("table_factory")
+    end
   end
 
-  after do
-    @rocksdb.close
+  context "open" do
+    it 'should work without options' do
+      rocksdb = RocksDB.open temp_db_path
+
+      expect(rocksdb).to be_open
+    end
+
+    it 'should set valid string options' do
+      rocksdb = RocksDB.open temp_db_path, "WAL_size_limit_MB=16"
+
+      expect(rocksdb.options["WAL_size_limit_MB"])
+        .to eq "16"
+    end
+
+    it 'should set valid hash options' do
+      rocksdb = RocksDB.open temp_db_path, WAL_size_limit_MB: "42"
+
+      expect(rocksdb.options["WAL_size_limit_MB"])
+        .to eq "42"
+    end
+
+    it 'should not set invalid option' do
+      expect { RocksDB.open temp_db_path, "Omg_totaly_fake=4" }
+        .to raise_error(RocksDB::StatusError)
+    end
+
+    it 'should not segfault on gibberish' do
+      expect { RocksDB.open temp_db_path, "%28324!@4912=4AAS\00DAD2-;1421" }
+        .to raise_error(RocksDB::StatusError)
+    end
   end
 end