odba 1.0.0

data/lib/odba/cache_entry.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+#-- CacheEntry -- odba -- 29.04.2004 -- hwyss@ywesee.com mwalder@ywesee.com
+
+module ODBA
+	class CacheEntry # :nodoc: all
+    @@id_table = {}
+    @@finalizer = proc { |object_id|
+      if(odba_id = @@id_table.delete(object_id))
+        ODBA.cache.invalidate odba_id
+      end
+    }
+		attr_accessor :last_access
+		attr_reader :accessed_by, :odba_id, :odba_object_id
+    def initialize(obj)
+      @odba_id = obj.odba_id
+      update obj
+      @accessed_by = {}
+      @odba_observers = obj.odba_observers
+    end
+    def update obj
+      @last_access = Time.now
+      @odba_object = obj
+      @odba_class = obj.class
+      @odba_id = obj.odba_id
+      unless @odba_object_id == obj.object_id
+        @@id_table.delete @odba_object_id
+        @odba_object_id = obj.object_id
+        @@id_table.store @odba_object_id, @odba_id
+        ObjectSpace.define_finalizer obj, @@finalizer
+      end
+    end
+    def object_id2ref(object_id, odba_id)
+      if (obj = ObjectSpace._id2ref(object_id)) \
+        && obj.is_a?(Persistable) && !obj.odba_unsaved? \
+        && obj.odba_id == odba_id
+        obj
+      end
+    rescue RangeError, NoMethodError => e
+      nil
+    end
+    def odba_id2ref(odba_id)
+      odba_id && ODBA.cache.include?(odba_id) && ODBA.cache.fetch(odba_id)
+    end
+		def odba_add_reference(object)
+      @accessed_by.store(object.object_id, object.odba_id)
+			object
+		end
+		def odba_cut_connections!
+			@accessed_by.each { |object_id, odba_id|
+        if((item = odba_id2ref(odba_id) || object_id2ref(object_id, odba_id)) \
+          && item.respond_to?(:odba_cut_connection))
+					item.odba_cut_connection(_odba_object)
+				end
+			}
+		end
+    def odba_notify_observers(*args)
+      @odba_observers.each { |obs| obs.odba_update(*args) }
+    end
+		def odba_object
+			@last_access  = Time.now
+      @odba_object = _odba_object
+      @odba_object || ODBA.cache.fetch(@odba_id)
+    end
+    def _odba_object
+      @odba_object || object_id2ref(@odba_object_id, @odba_id)
+		end
+		def odba_old?(retire_horizon = Time.now - ODBA.cache.retire_age)
+      !_odba_object.odba_unsaved? \
+        && (retire_horizon > @last_access)
+		end
+		def odba_retire opts={}
+			# replace with stubs in accessed_by 
+      instance = _odba_object
+      if opts[:force]
+        @accessed_by.each do |object_id, odba_id|
+          if item = odba_id2ref(odba_id)
+            item.odba_stubize instance, opts
+          elsif(item = object_id2ref(object_id, odba_id))
+            if item.is_a?(Persistable) && !item.is_a?(Stub)
+              item.odba_stubize instance, opts
+            end
+          end
+        end
+        @accessed_by.clear
+        @odba_object = nil
+      else
+        @accessed_by.delete_if { |object_id, odba_id|
+          if(item = odba_id2ref(odba_id))
+            item.odba_stubize instance
+          elsif(item = object_id2ref(object_id, odba_id))
+            case item
+            when Stub
+              true
+            when Array, Hash
+              false
+            when Persistable
+              item.odba_stubize instance
+            else
+              true
+            end
+          else
+            true
+          end
+        }
+        if @accessed_by.empty?
+          @odba_object = nil
+        end
+      end
+		end
+		def odba_replace!(obj)
+      oldhash = _odba_object.hash
+			_odba_object.odba_replace!(obj)
+      if(_odba_object.hash != oldhash)
+        @accessed_by.each { |object_id, odba_id|
+          if(item = odba_id2ref(odba_id) || object_id2ref(object_id, odba_id))
+            item.rehash if(item.respond_to? :rehash)
+          end
+        }
+      end
+		end
+	end
+end

data/lib/odba/connection_pool.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+#-- ConnectionPool -- ODBA -- 08.03.2005 -- hwyss@ywesee.com
+
+require 'dbi'
+require 'thread'
+
+module ODBA
+	class ConnectionPool
+		POOL_SIZE = 5
+		SETUP_RETRIES = 3
+		attr_reader :connections
+		# All connections are delegated to DBI. The constructor simply records
+		# the DBI-arguments and reuses them to setup connections when needed.
+		def initialize(*dbi_args)
+			@dbi_args = dbi_args
+      @opts = @dbi_args.last.is_a?(Hash) ? @dbi_args.pop : Hash.new
+			@connections = []
+			@mutex = Mutex.new
+			connect
+		end
+		def next_connection # :nodoc:
+			conn = nil
+			@mutex.synchronize {
+				conn = @connections.shift
+			}
+			yield(conn)
+		ensure
+			@mutex.synchronize {
+				@connections.push(conn)
+			}
+		end
+		def method_missing(method, *args, &block) # :nodoc:
+			tries = SETUP_RETRIES
+			begin
+				next_connection { |conn|
+					conn.send(method, *args, &block)
+				}
+			rescue NoMethodError, DBI::Error => e
+        warn e
+				if(tries > 0 && (!e.is_a?(DBI::ProgrammingError) \
+           || e.message == 'no connection to the server'))
+					sleep(SETUP_RETRIES - tries)
+					tries -= 1
+					reconnect
+					retry
+				else
+					raise
+				end
+			end
+		end
+		def size 
+			@connections.size
+		end
+    alias :pool_size :size
+		def connect # :nodoc:
+			@mutex.synchronize { _connect }
+		end
+    def _connect # :nodoc:
+      POOL_SIZE.times {
+        conn = DBI.connect(*@dbi_args)
+        if encoding = @opts[:client_encoding]
+          conn.execute "SET CLIENT_ENCODING TO '#{encoding}'"
+        end
+        @connections.push(conn)
+      }
+    end
+		def disconnect # :nodoc:
+			@mutex.synchronize { _disconnect }
+		end
+		def _disconnect # :nodoc:
+			while(conn = @connections.shift)
+				begin 
+					conn.disconnect
+				rescue DBI::InterfaceError, Exception
+					## we're not interested, since we are disconnecting anyway
+          nil
+				end
+			end
+		end
+		def reconnect # :nodoc:
+			@mutex.synchronize {
+				_disconnect
+				_connect
+			}
+		end
+	end
+end

data/lib/odba/drbwrapper.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# DRbWrapper -- ydim -- 11.01.2006 -- hwyss@ywesee.com
+
+require 'drb'
+require 'odba/persistable'
+require 'odba/stub'
+require 'odba/odba'
+require 'drb/timeridconv'
+
+module ODBA
+  class DRbWrapper 
+    instance_methods.each { |m| 
+      undef_method(m) unless m =~ /^(__)|(respond_to\?|object_id$)/ }
+    include DRb::DRbUndumped
+    def initialize(obj)
+      @obj = obj
+    end
+    def respond_to?(sym, *args)
+      super || @obj.respond_to?(sym, *args)
+    end
+    def method_missing(sym, *args)
+      if(block_given?)
+        res = @obj.__send__(sym, *args) { |*block_args|
+          yield *block_args.collect { |arg| __wrap(arg) }
+        }
+        __wrap(res)
+      else
+        res = @obj.__send__(sym, *args)
+        if(res.is_a?(Array))
+          res.collect { |item| __wrap(item) }
+        elsif(res.is_a?(Hash))
+          res.inject({}) { |memo, (key, value)|
+            memo.store(__wrap(key), __wrap(value))
+            memo
+          }
+        else
+          __wrap(res)
+        end
+      end
+    end
+    def __wrap(obj)
+      if(obj.is_a?(ODBA::Persistable))
+        DRbWrapper.new(obj.odba_instance)
+      else
+        obj
+      end
+    end
+    def __wrappee
+      @obj
+    end
+  end
+  class DRbIdConv < DRb::DRbIdConv
+    def initialize(*args)
+      super
+      @unsaved = {}
+    end
+    def odba_update(key, odba_id, object_id)
+      case key
+      when :store
+        @unsaved.store(object_id, odba_id)
+      when :clean, :delete
+        @unsaved.delete(object_id)
+      end
+    end
+    def to_obj(ref)
+      test = ref
+      if(test.is_a?(String) || (test = @unsaved[ref]))
+        DRbWrapper.new(ODBA.cache.fetch(test.to_i))
+      else
+        super
+      end
+    rescue RuntimeError => e
+      raise RangeError, e.message
+    end
+    def to_id(obj)
+      if(obj.is_a?(ODBA::Persistable))
+        if(obj.odba_unsaved?)
+          obj.odba_add_observer(self)
+          super
+        else
+          obj.odba_id.to_s
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/odba/id_server.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#-- IdServer -- odba -- 10.11.2004 -- hwyss@ywesee.com
+
+require 'odba/persistable'
+require 'thread'
+
+module ODBA
+	class IdServer
+		include Persistable
+		ODBA_SERIALIZABLE = ['@ids']
+		ODBA_EXCLUDE_VARS = ['@mutex']
+		def initialize
+			@ids = {}
+		end
+		def next_id(key, startval=1)
+			@mutex ||= Mutex.new
+			res = nil
+			@mutex.synchronize { 
+				@ids[key] ||= (startval - 1)
+				res = @ids[key] += 1
+			}
+			odba_store
+			res
+		end
+	end
+end

data/lib/odba/index.rb

@@ -0,0 +1,395 @@
+#!/usr/bin/env ruby
+#-- Index -- odba -- 13.05.2004 -- rwaltert@ywesee.com
+
+require 'odba/persistable'
+
+module ODBA
+	# Indices in ODBA are defined by origin and target (which may be identical)
+	# Any time a Persistable of class _target_klass_ or _origin_klass_ is stored,
+	# all corresponding indices are updated. To make this possible, we have to tell
+	# Index, how to navigate from _origin_ to _target_ and vice versa.
+	# This entails the Limitation that these paths must not change without
+	# _origin_ and/or _target_ being stored.
+	# Further, _search_term_ must be resolved in relation to _origin_.
+	class IndexCommon # :nodoc: all
+		include Persistable
+    if RUBY_VERSION >= '1.9'
+      ODBA_EXCLUDE_VARS = [
+        :@proc_origin, :@proc_target, :@proc_resolve_search_term
+      ]
+    else
+      ODBA_EXCLUDE_VARS = [
+        '@proc_origin', '@proc_target', '@proc_resolve_search_term'
+      ]
+    end
+		attr_accessor :origin_klass, :target_klass, :resolve_origin, :resolve_target,
+			:resolve_search_term, :index_name, :dictionary, :class_filter
+		def initialize(index_definition, origin_module)
+			@origin_klass = origin_module.instance_eval(index_definition.origin_klass.to_s)
+			@target_klass = origin_module.instance_eval(index_definition.target_klass.to_s)
+			@resolve_origin = index_definition.resolve_origin
+			@resolve_target = index_definition.resolve_target
+			@index_name = index_definition.index_name
+			@resolve_search_term = index_definition.resolve_search_term
+			@dictionary = index_definition.dictionary
+      @class_filter = index_definition.class_filter
+		end
+    def current_origin_ids(target_id) # :nodoc:
+      ODBA.storage.index_origin_ids(@index_name, target_id)
+    end
+    def current_target_ids(origin_id) # :nodoc:
+      ODBA.storage.index_target_ids(@index_name, origin_id)
+    end
+    def delete(object) # :nodoc:
+      if(object.is_a?(@origin_klass))
+        ODBA.storage.delete_index_element(@index_name, object.odba_id, 
+                                          'origin_id')
+      end
+      if(object.is_a?(@target_klass))
+        ODBA.storage.delete_index_element(@index_name, object.odba_id, 
+                                          'target_id')
+      end
+    end
+    def delete_origin(origin_id, term) # :nodoc:
+      ODBA.storage.index_delete_origin(@index_name, origin_id, term)
+    end
+    def delete_target(origin_id, old_term, target_id) # :nodoc:
+      ODBA.storage.index_delete_target(@index_name, origin_id,
+                                       old_term, target_id)
+    end
+		def do_update_index(origin_id, term, target_id=nil) # :nodoc:
+      ODBA.storage.update_index(@index_name, origin_id, term, target_id)
+		end
+		def fill(targets)
+			@proc_origin = nil
+			rows = []
+			targets.flatten.each { |target|
+				target_id = target.odba_id
+				origins = proc_instance_origin.call(target)
+				origins.each { |origin|
+          search_terms(origin).each { |term|
+            do_update_index( origin.odba_id, term, target_id)
+          }
+				}
+			}
+		end
+		def keys(length=nil)
+			ODBA.storage.index_fetch_keys(@index_name, length).delete_if { |k|
+        k.empty? }
+		end
+    def matches(substring, limit=nil, offset=0)
+      ODBA.storage.index_matches @index_name, substring, limit, offset
+    end
+		def origin_class?(klass)
+			(@origin_klass == klass)
+		end
+		def proc_instance_origin # :nodoc:
+			if(@proc_origin.nil?)
+				if(@resolve_origin.to_s.empty?)
+					@proc_origin = Proc.new { |odba_item|  [odba_item] }
+				else
+					src = <<-EOS
+						Proc.new { |odba_item| 
+							res = [odba_item.#{@resolve_origin}]
+							res.flatten!
+							res.compact!
+							res
+						}
+					EOS
+					@proc_origin = eval(src)
+				end
+			end
+			@proc_origin
+		end
+    def proc_instance_target # :nodoc:
+      if(@proc_target.nil?)
+        if(@resolve_target.to_s.empty?)
+          @proc_target = Proc.new { |odba_item|  [odba_item] }
+        #elsif(@resolve_target == :odba_skip)
+        #  @proc_target = Proc.new { [] }
+        else
+          src = <<-EOS
+            Proc.new { |odba_item| 
+              res = [odba_item.#{@resolve_target}]
+              res.flatten!
+              res.compact!
+              res
+            }
+          EOS
+          @proc_target = eval(src)
+        end
+      end
+      @proc_target
+    end
+    def proc_resolve_search_term # :nodoc:
+			if(@proc_resolve_search_term.nil?)
+				if(@resolve_search_term.to_s.empty?)
+					@proc_resolve_search_term = Proc.new { |origin| 
+            origin.to_s.downcase
+          }
+				else
+					src = <<-EOS
+						Proc.new { |origin| 
+							begin
+								origin.#{@resolve_search_term}
+							rescue NameError => e
+								nil
+							end
+						}
+					EOS
+					@proc_resolve_search_term = eval(src)
+				end
+			end
+			@proc_resolve_search_term
+		end
+		def search_term(origin) # :nodoc:
+			proc_resolve_search_term.call(origin)
+		end
+    def search_terms(origin)
+      [search_term(origin)].flatten.compact.uniq
+    end
+		def set_relevance(meta, rows) # :nodoc:
+			if(meta.respond_to?(:set_relevance))
+				rows.each { |row|
+					meta.set_relevance(row.at(0), row.at(1))
+				}
+			end
+		end
+		def update(object)
+      @class_filter ||= :is_a?
+			if(object.send(@class_filter, @target_klass))
+				update_target(object)
+			elsif(object.send(@class_filter, @origin_klass))
+				update_origin(object)
+			end
+    rescue StandardError => err
+      warn <<-EOS
+#{err.class}: #{err.message} when updating index '#{@index_name}' with a #{object.class}
+#{err.backtrace[0,4]}
+[...]
+      EOS
+		end
+		def update_origin(object) # :nodoc:
+			origin_id = object.odba_id
+			search_terms = search_terms(object)
+      current = current_target_ids(origin_id)
+      target_ids = []
+      current_terms = []
+      current.each { |row|
+        target_ids.push(row[0])
+        current_terms.push(row[1])
+      }
+      current_terms.uniq!
+      target_ids.uniq!
+      (current_terms - search_terms).each { |term|
+        delete_origin(origin_id, term)
+      }
+      new_terms = search_terms - current_terms
+      unless(new_terms.empty?)
+        target_ids.each { |target_id|
+          new_terms.each { |term|
+            do_update_index(origin_id, term, target_id)
+          }
+        }
+      end
+		end
+		def update_target(target) # :nodoc:
+      target_id = target.odba_id
+      current = current_origin_ids(target_id)
+      old_terms = current.collect { |row|
+        [row[0], row[1]]
+      }
+      origins = proc_instance_origin.call(target)
+      new_terms = []
+      origins.each { |origin|
+        origin_id = origin.odba_id
+        search_terms(origin).each { |term|
+          new_terms.push([origin_id, term])
+        }
+      }
+      (old_terms - new_terms).each { |origin_id, terms|
+        delete_target(origin_id, terms, target_id)
+      }
+      (new_terms - old_terms).each { |origin_id, terms|
+        do_update_index(origin_id, terms, target_id)
+      }
+		end
+	end
+	# Currently there are 3 predefined Index-classes
+	# For Sample Code see
+	# http://dev.ywesee.com/wiki.php/ODBA/SimpleIndex
+	# http://dev.ywesee.com/wiki.php/ODBA/ConditionIndex
+	# http://dev.ywesee.com/wiki.php/ODBA/FulltextIndex
+	class Index < IndexCommon # :nodoc: all
+		def initialize(index_definition, origin_module) # :nodoc:
+			super(index_definition, origin_module)
+			ODBA.storage.create_index(index_definition.index_name)
+		end
+		def fetch_ids(search_term, meta=nil) # :nodoc:
+			exact = meta.respond_to?(:exact) && meta.exact
+			limit = meta.respond_to?(:limit) && meta.limit
+			rows = ODBA.storage.retrieve_from_index(@index_name, 
+                                              search_term.to_s.downcase,
+                                              exact, limit)
+			set_relevance(meta, rows)
+			rows.collect { |row| row.at(0) }
+		end
+		def update_origin(object) # :nodoc:
+      # Possible changes:
+      # - search_terms of origin have changed
+      # - targets have changed, except if @resolve_target == :none
+      # => we need a matrix of all current [term, target_id]
+      #                     and of all new [term, target_id]
+			origin_id = object.odba_id
+			search_terms = search_terms(object)
+      current = current_target_ids(origin_id)
+      target_ids = if @resolve_target == :none
+                     current.dup
+                   else
+                     proc_instance_target.call(object).collect { |obj| 
+                       obj.odba_id }
+                   end
+      target_ids.compact!
+      target_ids.uniq!
+      current_ids = []
+      current_terms = []
+      current.each { |row|
+        current_ids.push(row[0])
+        current_terms.push(row[1])
+      }
+      current_ids.uniq!
+      current_terms.uniq!
+      current_combinations = current_ids.inject([]) { |memo, id|
+        current_terms.each { |term| memo.push [term, id] }
+        memo
+      }
+      combinations = target_ids.inject([]) { |memo, id|
+        search_terms.each { |term| memo.push [term, id] }
+        memo
+      }
+      (current_combinations - combinations).each { |pair|
+        delete_target(origin_id, *pair)
+      }
+      (combinations - current_combinations).each { |pair|
+        do_update_index(origin_id, *pair)
+      }
+		end
+    def search_terms(origin)
+      super.collect { |term| term.to_s.downcase }.uniq
+    end
+	end
+	class ConditionIndex < IndexCommon # :nodoc: all  
+		def initialize(index_definition, origin_module) # :nodoc:
+			super(index_definition, origin_module)
+			definition = {}
+			@resolve_search_term = {}
+			index_definition.resolve_search_term.each { |name, info|
+				if(info.is_a?(String))
+					info = { 'resolve' => info }
+				end
+				if(info['type'].nil?)
+					info['type'] = 'text'
+				end
+				@resolve_search_term.store(name, info)
+				definition.store(name, info['type'])
+			}
+			ODBA.storage.create_condition_index(@index_name, definition)
+		end
+    def current_ids(rows, id_name)
+      rows.collect { |row| 
+        [
+          row[id_name], 
+          @resolve_search_term.keys.collect { |key|
+            [key.to_s, row[key]] }.sort,
+        ]
+      }
+    end
+    def current_origin_ids(target_id)
+      current_ids(ODBA.storage.condition_index_ids(@index_name,
+                                                   target_id,
+                                                   'target_id'), 
+                 'origin_id')
+    end
+    def current_target_ids(origin_id)
+      current_ids(ODBA.storage.condition_index_ids(@index_name,
+                                                   origin_id,
+                                                   'origin_id'),
+                  'target_id')
+    end
+    def delete_origin(origin_id, search_terms)
+      ODBA.storage.condition_index_delete(@index_name, origin_id,
+                                          search_terms)
+    end
+    def delete_target(origin_id, search_terms, target_id)
+      ODBA.storage.condition_index_delete(@index_name, origin_id,
+                                          search_terms, target_id)
+    end
+    def do_update_index(origin_id, search_terms, target_id=nil) # :nodoc:
+      ODBA.storage.update_condition_index(@index_name, origin_id, 
+                                          search_terms, target_id)
+    end
+		def fetch_ids(conditions, meta=nil)  # :nodoc:
+			limit = meta.respond_to?(:limit) && meta.limit
+			rows = ODBA.storage.retrieve_from_condition_index(@index_name, 
+                                                        conditions, 
+                                                        limit)
+			set_relevance(meta, rows)
+      rows.collect { |row| row.at(0) }
+		end
+		def proc_resolve_search_term # :nodoc:
+			if(@proc_resolve_search_term.nil?)
+				src = <<-EOS
+					Proc.new { |origin| 
+						values = {}
+				EOS
+				@resolve_search_term.each { |name, info|
+					src << <<-EOS
+						begin
+							values.store('#{name}', origin.#{info['resolve']})
+						rescue NameError
+						end
+					EOS
+				}
+				src << <<-EOS 
+						values
+					}
+				EOS
+				@proc_resolve_search_term = eval(src)
+			end
+			@proc_resolve_search_term
+		end
+    def search_terms(origin)
+      super.collect { |data| data.to_a.sort }
+    end
+	end
+	class FulltextIndex < IndexCommon # :nodoc: all
+		def initialize(index_definition, origin_module)  # :nodoc:
+			super(index_definition, origin_module)
+			ODBA.storage.create_fulltext_index(@index_name)
+		end
+    def current_origin_ids(target_id)
+      ODBA.storage.fulltext_index_delete(@index_name, target_id,
+                                         'target_id')
+      []
+    end
+    def current_target_ids(origin_id)
+      ODBA.storage.fulltext_index_target_ids(@index_name, origin_id)
+    end
+    def delete_origin(origin_id, term)
+      ODBA.storage.fulltext_index_delete(@index_name, origin_id, 
+                                         'origin_id')
+    end
+		def fetch_ids(search_term, meta=nil)  # :nodoc:
+      limit = meta.respond_to?(:limit) && meta.limit
+			rows = ODBA.storage.retrieve_from_fulltext_index(@index_name, 
+				search_term, @dictionary, limit)
+			set_relevance(meta, rows)
+			rows.collect { |row| row.at(0) }
+		end
+    def do_update_index(origin_id, search_text, target_id=nil) # :nodoc:
+      ODBA.storage.update_fulltext_index(@index_name, origin_id,
+                                         search_text, target_id, 
+                                         @dictionary)
+    end
+  end
+end