odba 1.1.3 → 1.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2a275f0c5476fd282d1f7c67cce22d64357671f8
-  data.tar.gz: 7832d2977f9d568801af283a522ea5833ca8bf99
+SHA256:
+  metadata.gz: ea6d762105361b4b4d352bc10e485ecbffd0981f6ea6612b6128d0e1932a0264
+  data.tar.gz: 748b12ad5519b0afa70475174e06511260e7e6bf732d1fbe5fbcc1fa5f31ee87
 SHA512:
-  metadata.gz: 898f28dbabb3d7542ebeb6b7bbc3cf49934d036334da1f6042c82446189c8248a108903d0b285001b37a43ac0661c7e83d588680367378e7cc65dc3208eddefd
-  data.tar.gz: 639fa00ebbb43378e0a2ce97205d0fc367d703a85872c321ecc802061b4a63e9e6e384665d53c495209afc263f7de8fd7f63e12846d8e3f251f35377d57269ff
+  metadata.gz: 4d1b73f2969bbb84f45ba28320e58f3a4b7a8ea2749e51e39f3ce25e67328cc78935607ab77d30214fca4eec617ccfbdb5974f719b3c6c84746b0ea0cf65b6df
+  data.tar.gz: dbad2568c1ec84b5e247a7d11f60ac58ce5100ac26bc26b9b3fd364c5c16c5cc16a5e975d43281d4c6946e6b1be762eb5831c89def18b963939d4d64cad4b5af

data/.github/workflows/ruby.yml

@@ -0,0 +1,35 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+# Using a matrix fails, because /setup-ruby always invokes bundle install without any additional args
+# Fixed by adding not defining the debugger group in the Gemfile
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu]
+        ruby: [2.7, 3.0, head]
+    continue-on-error: ${{ endsWith(matrix.ruby, 'head') }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+
+    - name: Run tests via rake test
+      run: bundle exec rake test

data/Gemfile

@@ -2,16 +2,7 @@ source "https://rubygems.org"
 
 gemspec
 
-group 'test' do
-  gem 'flexmock', "~> 1.3.0"
-  gem 'test-unit'
-  gem 'minitest'
-end
-
-group 'debugger' do
-  gem 'pry'
-  gem 'pry-nav'
-  gem 'pry-rescue'
-  gem 'pry-stack_explorer'
-  gem 'pry-doc'
-end
+# The group debugger must be disabled for using a matrix build via github/actions
+group :debugger do
+  gem 'pry-byebug'
+end if false

data/History.txt

@@ -1,8 +1,32 @@
+=== 1.1.8 / 10.03.2021
+
+* Removed fixed dependency to pg (is optional like mysql2)
+
+=== 1.1.7 / 20.01.2021
+
+* Reworked some tests
+* Updated to use Ruby 3.0.0
+* Added github actions
+* Updated to use ydbi 0.5.7
+
+=== 1.1.6 / 23.01.2016
+
+* Updated to use ydbi 0.5.6
+
+=== 1.1.5 / 23.01.2016
+
+* Remove unused parameter dict for update_fulltext_index
+
+=== 1.1.4 / 13.12.2017
+
+* Drop text search dictionaries/configuration before recreating
+* Remove dictionary argument in fulltext search and index_definition
+
 === 1.1.3 / 12.12.2016
 
 * Avoid errors by always specifying "IF NOT EXISTS" when creating tables and indices
 * Add utility method get_server_version
-* Removed misleaading check in generate_dictionary
+* Removed misleading check in generate_dictionary
 
 === 1.1.2 / 10.05.2016
 
@@ -58,6 +82,6 @@
 
 === 1.0.0 / 20.12.2010
 
-* Add ODBA.cache.index_matches(index_name, substring) 
+* Add ODBA.cache.index_matches(index_name, substring)
 
   * this new method returns all search-terms of a given index (identified by index_name) that start with substring.

data/Rakefile

@@ -16,14 +16,13 @@ end
 desc "Run tests"
 task :default => :test
 
-desc 'Run odba with all commonly used combinations'
-task :test do
-  log_file = 'suite.log'
-  res = system("bash -c 'set -o pipefail && bundle exec ruby test/suite.rb 2>&1 | tee #{log_file}'")
-  puts "Running test/suite.rb returned #{res.inspect}. Output was redirected to #{log_file}"
-  exit 1 unless res
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
 end
 
+
 require 'rake/clean'
 CLEAN.include FileList['pkg/*.gem']
 

data/lib/odba/cache.rb

@@ -17,14 +17,15 @@ module ODBA
 	class Cache
 		include Singleton
     include DRb::DRbUndumped
-		CLEANER_PRIORITY = 0  # :nodoc: 
-		CLEANING_INTERVAL = 5 # :nodoc: 
+		CLEANER_PRIORITY = 0  # :nodoc:
+		CLEANING_INTERVAL = 5 # :nodoc:
     attr_accessor :cleaner_step, :destroy_age, :retire_age, :debug, :file_lock
-		def initialize # :nodoc: 
+		def initialize # :nodoc:
 			if(self::class::CLEANING_INTERVAL > 0)
 				start_cleaner
 			end
       @retire_age = 300
+      @receiver = nil
 			@cache_mutex = Mutex.new
       @deferred_indices = []
 			@fetched = Hash.new
@@ -36,9 +37,9 @@ module ODBA
       @loading_stats = {}
       @peers = []
       @file_lock = false
-      @debug ||= false
+      @debug ||= false # Setting @debug to true makes two unit test fail!
 		end
-		# Returns all objects designated by _bulk_fetch_ids_ and registers 
+		# Returns all objects designated by _bulk_fetch_ids_ and registers
 		# _odba_caller_ for each of them. Objects which are not yet loaded are loaded
 		# from ODBA#storage.
 		def bulk_fetch(bulk_fetch_ids, odba_caller)
@@ -79,7 +80,7 @@ module ODBA
       retire_horizon = now - @retire_age
       @cleaner_offset = _clean(retire_horizon, @fetched, @cleaner_offset)
 			if(@clean_prefetched)
-        @prefetched_offset = _clean(retire_horizon, @prefetched, 
+        @prefetched_offset = _clean(retire_horizon, @prefetched,
                                     @prefetched_offset)
 			end
       if(@debug)
@@ -93,8 +94,8 @@ module ODBA
         $stdout.flush
       end
 		end
-    def _clean(retire_time, holder, offset) # :nodoc: 
-      if(offset > holder.size) 
+    def _clean(retire_time, holder, offset) # :nodoc:
+      if(offset > holder.size)
         offset = 0
       end
       counter = 0
@@ -108,14 +109,14 @@ module ODBA
           return cutoff if(counter > cutoff)
         }
       }
-      cutoff 
+      cutoff
     # every once in a while we'll get a 'hash modified during iteration'-Error.
     # not to worry, we'll just try again later.
     rescue StandardError
       offset
     end
 		# overrides the ODBA_PREFETCH constant and @odba_prefetch instance variable
-		# in Persistable. Use this if a secondary client is more memory-bound than 
+		# in Persistable. Use this if a secondary client is more memory-bound than
 		# performance-bound.
 		def clean_prefetched(flag=true)
 			if(@clean_prefetched = flag)
@@ -133,7 +134,7 @@ module ODBA
         if(drop_existing && self.indices.include?(name))
           drop_index(name)
         end
-        unless(self.indices.include?(name)) 
+        unless(self.indices.include?(name))
           index = create_index(definition)
           if(index.target_klass.respond_to?(:odba_extent))
             index.fill(index.target_klass.odba_extent)
@@ -158,7 +159,7 @@ module ODBA
 			}
 		end
 		# Permanently deletes _object_ from the database and deconnects all connected
-		# Persistables 
+		# Persistables
 		def delete(odba_object)
 			odba_id = odba_object.odba_id
       name = odba_object.odba_name
@@ -199,7 +200,7 @@ module ODBA
 		def drop_index(index_name)
 			transaction {
 				ODBA.storage.drop_index(index_name)
-				self.delete(self.indices[index_name]) 
+				self.delete(self.indices[index_name])
 			}
 		end
     def drop_indices # :nodoc:
@@ -223,7 +224,7 @@ module ODBA
 		# Fetch a Persistable identified by _odba_id_. Registers _odba_caller_ with
 		# the CacheEntry. Loads the Persistable if it is not already loaded.
 		def fetch(odba_id, odba_caller=nil)
-			fetch_or_do(odba_id, odba_caller) { 
+			fetch_or_do(odba_id, odba_caller) {
         load_object(odba_id, odba_caller)
 			}
 		end
@@ -233,24 +234,26 @@ module ODBA
     @@receiver_name = RUBY_VERSION >= '1.9' ? :@receiver : '@receiver'
 		def fetch_collection(odba_obj) # :nodoc:
 			collection = []
-			bulk_fetch_ids = [] 
+			bulk_fetch_ids = []
 			rows = ODBA.storage.restore_collection(odba_obj.odba_id)
       return collection if rows.empty?
+      idx = 0
 			rows.each { |row|
-				key = ODBA.marshaller.load(row[0])
-				value = ODBA.marshaller.load(row[1])
+				key = row[0].is_a?(Integer) ? row[0] : ODBA.marshaller.load(row[0])
+				value = row[1].is_a?(Integer) ? row[1] : ODBA.marshaller.load(row[1])
+                idx += 1
         item = nil
         if([key, value].any? { |item| item.instance_variable_get(@@receiver_name) })
           odba_id = odba_obj.odba_id
           warn "stub for #{item.class}:#{item.odba_id} was saved with receiver in collection of #{odba_obj.class}:#{odba_id}"
           warn "repair: remove [#{odba_id}, #{row[0]}, #{row[1].length}]"
-          ODBA.storage.collection_remove(odba_id, row[0])	
+          ODBA.storage.collection_remove(odba_id, row[0])
           key = key.odba_isolated_stub
           key_dump = ODBA.marshaller.dump(key)
           value = value.odba_isolated_stub
           value_dump = ODBA.marshaller.dump(value)
           warn "repair: insert [#{odba_id}, #{key_dump}, #{value_dump.length}]"
-          ODBA.storage.collection_store(odba_id, key_dump, value_dump)	
+          ODBA.storage.collection_store(odba_id, key_dump, value_dump)
         end
 				bulk_fetch_ids.push(key.odba_id)
 				bulk_fetch_ids.push(value.odba_id)
@@ -259,8 +262,8 @@ module ODBA
 			bulk_fetch_ids.compact!
 			bulk_fetch_ids.uniq!
 			bulk_fetch(bulk_fetch_ids, odba_obj)
-			collection.each { |pair| 
-				pair.collect! { |item| 
+			collection.each { |pair|
+				pair.collect! { |item|
 					if(item.is_a?(ODBA::Stub))
             ## don't fetch: that may result in a conflict when storing.
             #fetch(item.odba_id, odba_obj)
@@ -271,7 +274,7 @@ module ODBA
             ce.odba_add_reference(odba_obj)
             ce.odba_object
 					else
-						item 
+						item
 					end
 				}
 			}
@@ -294,7 +297,7 @@ module ODBA
 			end
 		end
 		def fetch_named(name, odba_caller, &block) # :nodoc:
-			fetch_or_do(name, odba_caller) { 
+			fetch_or_do(name, odba_caller) {
 				dump = ODBA.storage.restore_named(name)
 				if(dump.nil?)
 					odba_obj = block.call
@@ -303,7 +306,7 @@ module ODBA
 					odba_obj
 				else
 					fetch_or_restore(name, dump, odba_caller)
-				end	
+				end
 			}
 		end
 		def fetch_or_do(obj_id, odba_caller, &block) # :nodoc:
@@ -332,7 +335,7 @@ module ODBA
         }
       }
     end
-		def fill_index(index_name, targets) 
+		def fill_index(index_name, targets)
 			self.indices[index_name].fill(targets)
 		end
 		# Checks wether the object identified by _odba_id_ has been loaded.
@@ -347,7 +350,7 @@ module ODBA
 			index = indices.fetch(index_name)
 			index.matches substring, limit, offset
 		end
-		# Returns a Hash-table containing all stored indices. 
+		# Returns a Hash-table containing all stored indices.
 		def indices
 			@indices ||= fetch_named('__cache_server_indices__', self) {
 				{}
@@ -420,14 +423,14 @@ module ODBA
     def print_stats
       fmh = " %-20s | %10s | %5s | %6s | %6s | %6s | %-20s\n"
       fmt = " %-20s | %10.3f | %5i | %6.3f | %6.3f | %6.3f | %s\n"
-      head = sprintf(fmh, 
+      head = sprintf(fmh,
                      "class", "total", "count", "min", "max", "avg", "callers")
-      line = "-" * head.length  
+      line = "-" * head.length
       puts line
       print head
       puts line
-      @loading_stats.sort_by { |key, val| 
-        val[:total_time] 
+      @loading_stats.sort_by { |key, val|
+        val[:total_time]
       }.reverse.each { |key, val|
         key = key.to_s
         if(key.length > 20)
@@ -482,13 +485,13 @@ module ODBA
     def size
       @prefetched.size + @fetched.size
     end
-		def start_cleaner # :nodoc: 
+		def start_cleaner # :nodoc:
 			@cleaner = Thread.new {
 				Thread.current.priority = self::class::CLEANER_PRIORITY
 				loop {
 					sleep(self::class::CLEANING_INTERVAL)
 					begin
-						clean 
+						clean
 					rescue StandardError => e
 						puts e
 						puts e.backtrace
@@ -547,14 +550,14 @@ module ODBA
         ODBA.storage.collection_remove(odba_id, key_dump)
       }.size
       changes + (collection - old_collection).each { |key_dump, value_dump|
-        ODBA.storage.collection_store(odba_id, key_dump, value_dump)	
+        ODBA.storage.collection_store(odba_id, key_dump, value_dump)
       }.size
     end
 		def store_object_connections(odba_id, target_ids) # :nodoc:
 			ODBA.storage.ensure_object_connections(odba_id, target_ids)
 		end
-		# Executes the block in a transaction. If the transaction fails, all 
-		# affected Persistable objects are reloaded from the db (which by then has 
+		# Executes the block in a transaction. If the transaction fails, all
+		# affected Persistable objects are reloaded from the db (which by then has
 		# also performed a rollback). Rollback is quite inefficient at this time.
 		def transaction(&block)
 			Thread.current[:txids] = []

data/lib/odba/cache_entry.rb

@@ -52,7 +52,7 @@ module ODBA
 			object
 		end
 		def odba_cut_connections!
-      @cache_entry_mutex.synchronize do 
+      @cache_entry_mutex.synchronize do
         @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))
@@ -77,10 +77,10 @@ module ODBA
         && (retire_horizon > @last_access)
 		end
 		def odba_retire opts={}
-			# replace with stubs in accessed_by 
+			# replace with stubs in accessed_by
       instance = _odba_object
       if opts[:force]
-        @cache_entry_mutex.synchronize do 
+        @cache_entry_mutex.synchronize do
           @accessed_by.each do |object_id, odba_id|
             if item = odba_id2ref(odba_id)
               item.odba_stubize instance, opts

data/lib/odba/index.rb

@@ -23,7 +23,7 @@ module ODBA
       ]
     end
 		attr_accessor :origin_klass, :target_klass, :resolve_origin, :resolve_target,
-			:resolve_search_term, :index_name, :dictionary, :class_filter
+			:resolve_search_term, :index_name, :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)
@@ -31,7 +31,6 @@ module ODBA
 			@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:
@@ -381,15 +380,12 @@ module ODBA
     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)
+			rows = ODBA.storage.retrieve_from_fulltext_index(@index_name, search_term, 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)
+      ODBA.storage.update_fulltext_index(@index_name, origin_id, search_text, target_id)
     end
   end
 end

data/lib/odba/index_definition.rb

@@ -5,8 +5,8 @@ module ODBA
 	# IndexDefinition is a convenience class. Load a yaml-dump of this and pass it
 	# to Cache#create_index to introduce new indices 
 	class IndexDefinition
-		attr_accessor :index_name, :dictionary, :origin_klass, 
-			:target_klass, :resolve_search_term, :resolve_target, 
+		attr_accessor :index_name, :origin_klass,
+			:target_klass, :resolve_search_term, :resolve_target,
 			:resolve_origin, :fulltext, :init_source, :class_filter
 		def initialize
 			@index_name = ""
@@ -15,7 +15,6 @@ module ODBA
 			@resolve_search_term = ""
 			@resolve_target = ""
 			@resolve_origin = ""
-			@dictionary = ""
 			@init_source = ""
 			@fulltext = false
       @class_filter = :is_a?