leveldb 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81b89ea5959e4b60215fed39fadbddf1a75bac83
-  data.tar.gz: 03b75e199e7b944525d611a5dc402dc5bea3334d
+  metadata.gz: 5d547f092bdcb30953adbf70670bc8d6342eac11
+  data.tar.gz: d446c8980b3ee0c230932722e73c408ab70f4660
 SHA512:
-  metadata.gz: bd7ee6bc335740240553b41c422a7ea8fb5591a4b5cdbf5cda65e9cd8bcfc841264ddb3c8687674279d5e10e03a7b49b4cc5653c80621729aa20d3f6a377e54c
-  data.tar.gz: 038d6bf18789e79919113430dde4d34f796ee96e4843c6cffc01ee6c04fff9b51c6f345e7fc6d8960f2469b9ecb35925c39ddd57914c8a2c725c085780bac830
+  metadata.gz: da8e914f735c3846b8a0c24541cc9cd5bc203f32afd61c7b287ed7142401b5b74c8990ce77f17e894a8145dd5e23eae70e55fbe3ae5fcef05c8c4b1601a24da0
+  data.tar.gz: 3c4770ed0ff4f84ac01af8bcaa2a217a614c33ccbfb90211b82924a98b1336e51a6b1cb4f63068639b9121222537c3213445f5a477bfd472e2ae6f6df4851425

data/README.md

@@ -1,6 +1,7 @@
 # Leveldb
 
-Experimental FFI bindings for leveldb
+LevelDB is a database library (C++, 350 kB) written at Google. It is an
+embedded database. LevelDB is a persistent ordered map.
 
 ## Documentation
 
@@ -9,83 +10,105 @@ Experimental FFI bindings for leveldb
 
 ## Installation
 
+### Development
+
     $ brew install snappy
     $ git clone git://github.com/DAddYE/leveldb.git
     $ cd leveldb
     $ rake compile
     $ rake console
 
-## Usage
-
-Here a basic usage, for more advanced please see the doc.
-
-Right now is very **low** level, I'm planning to add an higher layer api.
+### Standard
 
-### Prepare
+    $ brew install snappy
+    $ gem install leveldb
+    $ irb -r leveldb
 
-If you plan to hack in a console ...
+## Usage
 
-Remember that `err` is important, we are going to use this var in all our calls
+Here a basic usage:
 
 ```rb
-require 'leveldb'
+db = LevelDB::DB.new '/tmp/foo'
 
-include Leveldb
+# Writing
+db.put('hello', 'world')
+db['hello'] = 'world'
 
-err = err_create
-```
+# Reading
+db.get('hello') # => world
+db['hello'] # => world
 
-### Open
+# Deleting
+db.delete('hello')
 
-```ruby
-options = options_create
-options.set_create_if_missing 1
-db = open options, './tmp/testdb', err
+# Iterating
+db.each { |key, val| puts "Key: #{key}, Val: #{val}" }
+db.reverse_each { |key, val| puts "Key: #{key}, Val: #{val}" }
+db.keys
+db.values
+db.map { |k,v| do_some_with(k, v) }
+db.reduce([]) { |memo, (k, v)| memo << k + v; memo }
+db.each # => enumerator
+db.reverse_each # => enumerator
 
-abort err.message unless err.null?
-```
+# Ranges
+db.range('c', 'd') { |k,v| do_some_with_only_keys_in_range }
+db.reverse_range('c', 'd') # => same as above but results are in reverse order
+db.range(...) # => enumerable
 
-### Write
+# Batches
+db.batch do |b|
+  b.put 'a', 1
+  b.put 'b', 2
+  b.delete 'c'
+end
 
-```ruby
-write_opts = writeoptions_create
-put(db, write_opts, "key", "value", err)
+b = db.batch
+b.put 'a', 1
+b.put 'b', 2
+b.delete 'c'
+b.write!
 
-abort err.message unless err.null?
-```
+# Snapshots
+db.put 'a', 1
+db.put 'b', 2
+db.put 'c', 3
 
-### Read
+snap = db.snapshot
 
-```ruby
-read_opts = readoptions_create
-read = get(db, read_opts, "key", 3, read_len, err)
+db.delete 'a'
+db.get 'a' # => nil
 
-abort err.message unless err.null?
-puts "Key is: #{read}"
-```
+snap.set!
 
-### Delete
+db.get('a') # => 1
 
-```ruby
-delete(db, write_opts, "key", 3, err)
+snap.reset!
 
-abort err.message unless err.null?
-```
+db.get('a') # => nil
 
-### Close (connection)
+snap.set!
 
-```ruby
-db.close
-```
+db.get('a') # => 1
 
-### Destroy (database)
+# Properties
+db.read_property('leveldb.stats')
 
-```ruby
-destroy_db(options, './tmp/testdb', err)
+# Level  Files Size(MB) Time(sec) Read(MB) Write(MB)
+# --------------------------------------------------
+#   0        1        0         0        0         0
+#   1        1        0         0        0         0
 
-abort err.message unless err.null?
+# same of:
+db.stats
 ```
 
+## Todo
+
+1. Add pluggable serializers
+2. Custom comparators
+
 ## Contributing
 
 1. Fork it

data/lib/fiddler.rb

@@ -0,0 +1,77 @@
+require 'fiddle'
+require 'fiddle/import'
+require 'rbconfig'
+
+module Fiddler
+  include Fiddle
+  include Fiddle::CParser
+  include Fiddle::Importer
+  extend Fiddle::Importer
+  extend self
+
+  LIBSUFFIX =
+    case RbConfig::CONFIG['host_os'].downcase
+    when /windows|cgywin/ then 'dll'
+    when /darwin/         then 'dylib'
+    else 'so'
+    end
+
+  LIBPATHS =
+    [ '/usr/local/lib',
+      '/opt/local/lib',
+      '/usr/lib64',
+      File.expand_path("../../ext/leveldb", __FILE__)]
+
+  def dlload(*libs)
+    libs.map! do |lib|
+      LIBPATHS.map { |l| File.join(l, "#{lib}.#{LIBSUFFIX}") }.
+      detect { |l| File.exist?(l) }
+    end
+    super(*libs)
+  end
+
+  # Alias CTypes
+  ::Fiddle.constants.each do |c|
+    next unless c.to_s =~ /^TYPE_(.+)$/
+    const_set $1, const_get(c)
+  end
+
+  ULONG  = -LONG
+  LLONG  =  LONG_LONG
+  ULLONG = -LONG_LONG
+  UCHAR  = -CHAR
+  USHORT = -SHORT
+  UINT   = -INT
+
+  def cdef(name, ret_type, args_types={}, options={})
+    address     = handler["#{@_prefix}#{name}"] || handler[name.to_s]
+    options     = {name: name}.merge(options)
+    call_type   = options.delete(:call_type) || Function::DEFAULT
+    params      = args_types.keys.join(', ')
+    values      = args_types.values
+    cdefs[name] = Function.new(address, values, ret_type, call_type, options)
+
+    module_eval <<-RB, __FILE__, __LINE__ + 1
+    def #{name}(#{params})
+      cdefs[#{name.inspect}].call(#{params})
+    end
+    module_function #{name.inspect}
+    RB
+  end
+
+  def cdefs
+    @_cdefs ||= {}
+  end
+
+  def [](val)
+    cdefs[val]
+  end
+
+  def prefix(value)
+    @_prefix = value
+  end
+
+  def self.included(base)
+    base.extend self
+  end
+end

data/lib/leveldb/batch.rb

@@ -0,0 +1,60 @@
+module LevelDB
+
+  class Batch
+    class Error < StandardError; end
+
+    def initialize(db, write_opts)
+      @_db = db
+      @_write_opts = write_opts
+      @_err = C::Pointer.malloc(C::SIZEOF_VOIDP)
+      @_err.free = C[:free]
+      @_batch = C.writebatch_create
+    end
+
+    def []=(key, val)
+      key, val = key.to_s, val.to_s
+      C.writebatch_put(@_batch, key, key.size, val, val.size)
+
+      val
+    end
+    alias put []=
+
+    def delete(key)
+      key = key.to_s
+      C.writebatch_delete(@_batch, key, key.size)
+
+      key
+    end
+
+    # def clear
+    #   C.writebatch_clear(@_batch)
+
+    #   true
+    # end
+    # alias clear! clear
+
+    def write!
+      C.write(@_db, @_write_opts, @_batch, @_err)
+
+      raise Error, error_message if errors?
+
+      true
+    end
+
+    def errors?
+      return unless @_err
+      !@_err.ptr.null?
+    end
+
+    def error_message
+      return unless errors?
+      @_err.ptr.to_s
+    ensure
+      if errors?
+        @_err = C::Pointer.malloc(C::SIZEOF_VOIDP)
+        @_err.free = C[:free]
+      end
+    end
+    alias clear_errors! error_message
+  end
+end

data/lib/leveldb/db.rb

@@ -0,0 +1,199 @@
+require 'thread'
+require 'leveldb/iterator'
+require 'leveldb/batch'
+require 'Leveldb/snapshot'
+
+module LevelDB
+  class DB
+    include Enumerable
+
+    class Error < StandardError; end
+    class ClosedError < StandardError; end
+
+    attr_reader :path
+    @@mutex = Mutex.new
+
+    DEFAULT = {
+      create_if_missing: true,
+      error_if_exists: false,
+      paranoid_checks: false,
+      write_buffer_size: 4 << 20,
+      block_size: 4096,
+      max_open_files: 1000,
+      block_cache_size: 8 * (2 << 20),
+      block_restart_interval: 16,
+      compression: false,
+      verify_checksums: false,
+      fill_cache: true
+    }
+
+    def initialize(path, options={})
+      @_db_opts    = C.options_create
+      @_write_opts = C.writeoptions_create
+      @_read_opts  = C.readoptions_create
+      @_read_len   = C.value('size_t')
+
+      options = DEFAULT.merge(options)
+
+      @_cache = C.cache_create_lru(options[:block_cache_size])
+
+      C.readoptions_set_verify_checksums(@_read_opts, options[:verify_checksums] ? 1 : 0)
+      C.readoptions_set_fill_cache(@_read_opts, options[:fill_cache] ? 1 : 0)
+
+      C.options_set_create_if_missing(@_db_opts, options[:create_if_missing] ? 1 : 0)
+      C.options_set_error_if_exists(@_db_opts, options[:error_if_exists] ? 1 : 0)
+      C.options_set_paranoid_checks(@_db_opts, options[:paranoid_checks] ? 1 : 0)
+      C.options_set_write_buffer_size(@_db_opts, options[:write_buffer_size])
+      C.options_set_block_size(@_db_opts, options[:block_size])
+      C.options_set_cache(@_db_opts, @_cache)
+      C.options_set_max_open_files(@_db_opts, options[:max_open_files])
+      C.options_set_block_restart_interval(@_db_opts, options[:block_restart_interval])
+      C.options_set_compression(@_db_opts, options[:compression] ? 1 : 0)
+
+      @_db_opts.free = @_write_opts.free = @_read_opts.free = C[:options_destroy]
+
+      @path = path
+
+      @_err = C::Pointer.malloc(C::SIZEOF_VOIDP)
+      @_err.free = @_read_len.to_ptr.free = C[:free]
+
+      @_db = C.open(@_db_opts, @path, @_err)
+      @_db.free = C[:close]
+
+      raise Error, error_message if errors?
+    end
+
+    def []=(key, val)
+      raise ClosedError if closed?
+
+      key = key.to_s
+      val = val.to_s
+
+      C.put(@_db, @_write_opts, key, key.size, val, val.size, @_err)
+
+      raise Error, error_message if errors?
+
+      val
+    end
+    alias put []=
+
+    def [](key)
+      raise ClosedError if closed?
+
+      key  = key.to_s
+      val  = C.get(@_db, @_read_opts, key, key.size, @_read_len, @_err)
+
+      raise Error, error_message if errors?
+
+      val.null? ? nil : val.to_s(@_read_len.value)
+    end
+    alias get []
+
+    def delete(key)
+      raise ClosedError if closed?
+
+      key = key.to_s
+      val = get(key)
+      C.delete(@_db, @_write_opts, key, key.size, @_err)
+
+      raise Error, error_message if errors?
+
+      val
+    end
+
+    def snapshot
+      Snapshot.new(@_db, @_read_opts)
+    end
+
+    def batch(&block)
+      raise ClosedError if closed?
+
+      batch = Batch.new(@_db, @_write_opts)
+
+      if block_given?
+        block[batch]
+        batch.write!
+      else
+        batch
+      end
+    end
+
+    def close
+      raise ClosedError if closed?
+
+      # Prevent double free, I can't free it since
+      # after this call we can still `destroy` it.
+      @_db.free = nil
+      C.close(@_db)
+      @@mutex.synchronize { @_closed = true }
+      raise Error, error_message if errors?
+
+      true
+    end
+
+    def each(&block)
+      raise ClosedError if closed?
+
+      iterator = Iterator.new(@_db, @_read_opts, @_read_len)
+      iterator.each(&block)
+      iterator
+    end
+
+    def reverse_each(&block)
+      each.reverse_each(&block)
+    end
+
+    def range(from, to, &block)
+      each.range(from, to, &block)
+    end
+
+    def reverse_range(from, to, &block)
+      reverse_each.range(from, to, &block)
+    end
+
+    def keys
+      map { |k, v| k }
+    end
+
+    def values
+      map { |k, v| v }
+    end
+
+    def closed?
+      @@mutex.synchronize { @_closed }
+    end
+
+    def destroy
+      C.destroy_db(@_db_opts, @path, @_err)
+      raise Error, error_message if errors?
+
+      true
+    end
+
+    def read_property(name)
+      raise ClosedError if closed?
+
+      C.property_value(@_db, name).to_s
+    end
+
+    def stats
+      read_property('leveldb.stats')
+    end
+
+    def errors?
+      return unless @_err
+      !@_err.ptr.null?
+    end
+
+    def error_message
+      return unless errors?
+      @_err.ptr.to_s
+    ensure
+      if errors?
+        @_err = C::Pointer.malloc(C::SIZEOF_VOIDP)
+        @_err.free = C[:free]
+      end
+    end
+    alias clear_errors! error_message
+  end
+end

data/lib/leveldb/iterator.rb

@@ -0,0 +1,126 @@
+module LevelDB
+  class Iterator
+    def initialize(db, read_opts, read_len, reverse=false)
+      @_db        = db
+      @_read_opts = read_opts
+      @_read_len  = read_len
+      @_reverse   = reverse
+      @_err       = C::Pointer.malloc(C::SIZEOF_VOIDP)
+      @_err.free  = C[:free]
+      @_iterator  = C.create_iterator(@_db, @_read_opts)
+      # @_iterator.free = C[:iter_destroy]
+      rewind
+    end
+
+    def rewind
+      if reverse?
+        C.iter_seek_to_last(@_iterator)
+      else
+        C.iter_seek_to_first(@_iterator)
+      end
+    end
+
+    def reverse_each(&block)
+      @_reverse = !@_reverse
+      rewind
+      each(&block)
+    end
+
+    def each(&block)
+      return self unless block_given?
+      if current = self.next
+        block[*current]
+      end while valid?
+      @_range = nil
+    end
+
+    def range(from, to, &block)
+      @_range = [from.to_s, to.to_s].sort
+      @_range = @_range.reverse if reverse?
+      each(&block)
+    end
+
+    def next
+      while valid? && !in_range?
+        move_next
+      end if range?
+
+      key, val = current
+
+      return unless key
+
+      [key, val]
+    ensure
+      move_next
+    end
+
+    def peek
+      self.next
+    ensure
+      move_prev
+    end
+
+    def valid?
+      C.iter_valid(@_iterator) == 1
+    end
+
+    def reverse?
+      @_reverse
+    end
+
+    def range?
+      !!@_range
+    end
+
+    private
+    def current
+      return unless valid?
+
+      key = C.iter_key(@_iterator, @_read_len).to_s(@_read_len.value)
+      val = C.iter_value(@_iterator, @_read_len).to_s(@_read_len.value)
+
+      [key, val]
+    end
+
+    def in_range?
+      reverse? ? (current[0] <= @_range[0] && current[0] >= @_range[1]) :
+                 (current[0] >= @_range[0] && current[0] <= @_range[1])
+    end
+
+    def move_next
+      return unless valid?
+
+      if reverse?
+        C.iter_prev(@_iterator)
+      else
+        C.iter_next(@_iterator)
+      end
+    end
+
+    def move_prev
+      return unless valid?
+
+      if reverse?
+        C.iter_next(@_iterator)
+      else
+        C.iter_prev(@_iterator)
+      end
+    end
+
+    def errors?
+      C.iter_get_error(@_iterator, @_err)
+      !@_err.ptr.null?
+    end
+
+    def error_message
+      return unless errors?
+      @_err.ptr.to_s
+    ensure
+      if errors?
+        @_err = C::Pointer.malloc(C::SIZEOF_VOIDP)
+        @_err.free = C[:free]
+      end
+    end
+    alias clear_errors! error_message
+  end
+end

data/lib/leveldb/snapshot.rb

@@ -0,0 +1,19 @@
+module LevelDB
+
+  class Snapshot
+
+    def initialize(db, read_opts)
+      @_db = db
+      @_read_opts = read_opts
+      @_snap = C.create_snapshot(@_db)
+    end
+
+    def set!
+      C.readoptions_set_snapshot(@_read_opts, @_snap)
+    end
+
+    def reset!
+      C.readoptions_set_snapshot(@_read_opts, nil)
+    end
+  end
+end

data/lib/leveldb/version.rb

@@ -1,3 +1,3 @@
-module Leveldb
-  VERSION = "0.0.1"
+module LevelDB
+  VERSION = '0.1.0'
 end