odba 1.1.2 → 1.1.7

data/lib/odba/persistable.rb

@@ -45,7 +45,7 @@ module ODBA
                 opts = keys.pop
               end
               if(keys.last.is_a?(Class))
-                origin_klass = keys.pop 
+                origin_klass = keys.pop
                 resolve = keys.pop
                 resolve_origin = keys.pop
               elsif(keys.last.is_a?(Symbol))
@@ -58,7 +58,7 @@ module ODBA
             else
               resolve = keys.first
             end
-            keys.each { |key| 
+            keys.each { |key|
               if RUBY_VERSION >= '1.9'
                 key = key.to_sym
               else
@@ -85,8 +85,8 @@ module ODBA
             opts.each { |key, val| index_definition.send "#{key}=", val }
             ODBA.cache.ensure_index_deferred(index_definition)
             meta_eval {
-              define_method(search_name) { |*vals| 
-                if(vals.size > 1) 
+              define_method(search_name) { |*vals|
+                if(vals.size > 1)
                   args = {}
                   vals.each_with_index { |val, idx|
                     cond = case val
@@ -95,7 +95,7 @@ module ODBA
                            else
                              'like'
                            end
-                    args.store(keys.at(idx), 
+                    args.store(keys.at(idx),
                                { 'value' => val, 'condition' => cond })
                   }
                   ODBA.cache.retrieve_from_index(index_name, args)
@@ -104,12 +104,12 @@ module ODBA
                 end
               }
               define_method(exact_name) {  |*vals|
-                if(vals.size > 1) 
+                if(vals.size > 1)
                   args = {}
                   vals.each_with_index { |val, idx|
                     args.store(keys.at(idx), val)
                   }
-                  ODBA.cache.retrieve_from_index(index_name, args, 
+                  ODBA.cache.retrieve_from_index(index_name, args,
                                                  ODBA::Persistable::Exact)
                 else
                   ODBA.cache.retrieve_from_index(index_name, vals.first,
@@ -117,7 +117,7 @@ module ODBA
                 end
               }
               define_method(find_name) {  |*vals|
-                if(vals.size > 1) 
+                if(vals.size > 1)
                   args = {}
                   vals.each_with_index { |val, idx|
                     cond = case val
@@ -126,7 +126,7 @@ module ODBA
                            else
                              'like'
                            end
-                    args.store(keys.at(idx), 
+                    args.store(keys.at(idx),
                                { 'value' => val, 'condition' => cond })
                   }
                   ODBA.cache.retrieve_from_index(index_name, args,
@@ -145,7 +145,7 @@ module ODBA
             index_definition
           end
           def odba_extent
-            all = ODBA.cache.extent(self) 
+            all = ODBA.cache.extent(self)
             if(block_given?)
               all.each { |instance| yield instance }
               nil
@@ -154,7 +154,7 @@ module ODBA
             end
           end
           def odba_count
-            ODBA.cache.count(self) 
+            ODBA.cache.count(self)
           end
         end
       }
@@ -164,7 +164,7 @@ module ODBA
       name.gsub(@@sanitize_ptrn, '_')
     end
 		attr_accessor :odba_name, :odba_prefetch
-		# Classes which include Persistable may override ODBA_EXCLUDE_VARS to 
+		# Classes which include Persistable may override ODBA_EXCLUDE_VARS to
 		# prevent data from being stored in the database (e.g. passwords, file
 		# descriptors). Simply redefine: ODBA_EXCLUDE_VARS = ['@foo']
 		ODBA_EXCLUDE_VARS = []
@@ -178,7 +178,7 @@ module ODBA
       ODBA_PREDEFINE_EXCLUDE_VARS = ['@odba_observers'] # :nodoc:
       ODBA_PREDEFINE_SERIALIZABLE = ['@odba_target_ids'] # :nodoc:, legacy
     end
-		# If you want to prevent Persistables from being disconnected and stored 
+		# If you want to prevent Persistables from being disconnected and stored
 		# separately (Array and Hash are Persistable by default), redefine:
 		# ODBA_SERIALIZABLE = ['@bar']
 		ODBA_SERIALIZABLE = []
@@ -188,7 +188,7 @@ module ODBA
     @@odba_id_name = RUBY_VERSION >= '1.9' ? :@odba_id : '@odba_id'
     def dup # :nodoc:
       twin = super
-      ## since twin may not be a Persistable, we need to do some magic here to 
+      ## since twin may not be a Persistable, we need to do some magic here to
       #  ensure that it does not have the same odba_id
       twin.instance_variable_set(@@odba_id_name, nil)
       twin
@@ -221,7 +221,7 @@ module ODBA
 		def odba_delete
 			ODBA.cache.delete(self)
 		end
-    # Delete _observer_ as an observer on this object. 
+    # Delete _observer_ as an observer on this object.
     # It will no longer receive notifications.
     def odba_delete_observer(observer)
       @odba_observers.delete(observer) if(@odba_observers)
@@ -251,7 +251,7 @@ module ODBA
               ODBA_PREDEFINE_EXCLUDE_VARS
             end
 			if(defined?(self::class::ODBA_EXCLUDE_VARS))
-        exc += self::class::ODBA_EXCLUDE_VARS 
+        exc += self::class::ODBA_EXCLUDE_VARS
       end
       if RUBY_VERSION >= '1.9'
         exc.map{|v| v.to_sym}
@@ -259,8 +259,8 @@ module ODBA
         exc
       end
     end
-		# Returns the odba unique id of this Persistable. 
-    # If no id had been assigned, this is now done. 
+		# Returns the odba unique id of this Persistable.
+    # If no id had been assigned, this is now done.
     # No attempt is made to store the Persistable in the db.
 		def odba_id
 			@odba_id ||= ODBA.cache.next_id
@@ -269,7 +269,7 @@ module ODBA
 			ODBA.marshaller.dump(odba_isolated_twin)
 		end
 		# Convenience method equivalent to ODBA.cache.store(self)
-		def odba_isolated_store 
+		def odba_isolated_store
 			@odba_persistent = true
 			ODBA.cache.store(self)
 		end
@@ -278,7 +278,7 @@ module ODBA
 		def odba_isolated_stub
 			Stub.new(self.odba_id, nil, self)
 		end
-		# Returns a duplicate of this Persistable, for which all connected 
+		# Returns a duplicate of this Persistable, for which all connected
 		# Persistables have been replaced by a Stub
 		def odba_isolated_twin
 			# ensure a valid odba_id
@@ -289,11 +289,12 @@ module ODBA
 			twin
 		end
 		# A Persistable instance can be _prefetchable_. This means that the object
-		# can be loaded at startup by calling ODBA.cache.prefetch, and that it will 
-		# never expire from the Cache. The prefetch status can be controlled per 
-		# instance by setting the instance variable @odba_prefetch, and per class by 
+		# can be loaded at startup by calling ODBA.cache.prefetch, and that it will
+		# never expire from the Cache. The prefetch status can be controlled per
+		# instance by setting the instance variable @odba_prefetch, and per class by
 		# overriding the module constant ODBA_PREFETCH
 		def odba_prefetch?
+      @odba_prefetch ||= nil
 			@odba_prefetch \
         || (defined?(self::class::ODBA_PREFETCH) && self::class::ODBA_PREFETCH)
 		end
@@ -301,9 +302,9 @@ module ODBA
 			@odba_indexable \
         || (defined?(self::class::ODBA_INDEXABLE) && self::class::ODBA_INDEXABLE)
 		end
-    # Invoke the update method in each currently associated observer 
+    # Invoke the update method in each currently associated observer
     # in turn, passing it the given arguments
-    def odba_notify_observers(*args) 
+    def odba_notify_observers(*args)
       odba_observers.each { |obs| obs.odba_update(*args) }
     end
     def odba_observers
@@ -313,6 +314,7 @@ module ODBA
 			instance_variables - odba_serializables - odba_exclude_vars
 		end
     def odba_replace!(obj) # :nodoc:
+      @odba_observers ||= []
       instance_variables.each { |name|
         instance_variable_set(name, obj.instance_variable_get(name))
       }
@@ -353,7 +355,7 @@ module ODBA
               ODBA_PREDEFINE_SERIALIZABLE
             end
 			if(defined?(self::class::ODBA_SERIALIZABLE))
-        srs += self::class::ODBA_SERIALIZABLE 
+        srs += self::class::ODBA_SERIALIZABLE
       end
       if RUBY_VERSION >= '1.9'
         srs.map{|s| s.to_sym}
@@ -369,7 +371,7 @@ module ODBA
 		end
 		# Stores this Persistable and recursively all connected unsaved persistables,
 		# until no more direcly connected unsaved persistables can be found.
-		# The optional parameter _name_ can be used later to retrieve this 
+		# The optional parameter _name_ can be used later to retrieve this
 		# Persistable using Cache#fetch_named
 		def odba_store(name = nil)
 			begin
@@ -379,7 +381,7 @@ module ODBA
 				end
 				odba_store_unsaved
         self
-			rescue 
+			rescue
 				@odba_name = old_name
 				raise
 			end
@@ -406,14 +408,14 @@ module ODBA
 				# must not be synchronized because of the following if
 				# statement (if an object has already been replaced by
 				# a	stub, it will have the correct id and it
-				# will be ignored) 
+				# will be ignored)
         case var
         when Stub
           # no need to make a new stub
         when Persistable
-					if(var.odba_id == id) 
+					if(var.odba_id == id)
             stub = ODBA::Stub.new(id, self, obj)
-            instance_variable_set(name, stub) 
+            instance_variable_set(name, stub)
           end
 				end
 			}
@@ -465,6 +467,7 @@ module ODBA
 				!@odba_persistent
 				#true
 			else
+        @odba_snapshot_level ||= 0
 				@odba_snapshot_level.to_i < snapshot_level
 			end
 		end
@@ -482,7 +485,7 @@ class Array # :nodoc: all
 	def odba_collection
 		coll = []
 		each_with_index { |item, index|
-			coll.push([index, item])	
+			coll.push([index, item])
 		}
 		coll
 	end
@@ -491,9 +494,9 @@ class Array # :nodoc: all
 		delete_if { |val| val.eql?(remove_object) }
 	end
 	def odba_prefetch?
-		super || any? { |item| 
+		super || any? { |item|
 			item.respond_to?(:odba_prefetch?) \
-				&& item.odba_prefetch? 
+				&& item.odba_prefetch?
 		}
 	end
   def odba_replace!(obj) # :nodoc:
@@ -505,7 +508,7 @@ class Array # :nodoc: all
 		super
 	end
 	def odba_restore(collection=[])
-		collection.each { |key, val| 
+		collection.each { |key, val|
 			self[key] = val
 		}
 	end
@@ -579,7 +582,7 @@ class Hash # :nodoc: all
 		super
 	end
 	def odba_restore(collection=[])
-		collection.each { |key, val| 
+		collection.each { |key, val|
 			self[key] = val
 		}
 	end

data/lib/odba/storage.rb

@@ -15,31 +15,31 @@ module ODBA
     TABLES = [
       # in table 'object', the isolated dumps of all objects are stored
       ['object', <<-'SQL'],
-CREATE TABLE object (
+CREATE TABLE IF NOT EXISTS object (
   odba_id INTEGER NOT NULL, content TEXT,
   name TEXT, prefetchable BOOLEAN, extent TEXT,
   PRIMARY KEY(odba_id), UNIQUE(name)
 );
       SQL
       ['prefetchable_index', <<-SQL],
-CREATE INDEX prefetchable_index ON object(prefetchable);
+CREATE INDEX IF NOT EXISTS prefetchable_index ON object(prefetchable);
       SQL
       ['extent_index', <<-SQL],
-CREATE INDEX extent_index ON object(extent);
+CREATE INDEX IF NOT EXISTS extent_index ON object(extent);
       SQL
       # helper table 'object_connection'
       ['object_connection', <<-'SQL'],
-CREATE TABLE object_connection (
+CREATE TABLE IF NOT EXISTS object_connection (
   origin_id integer, target_id integer,
   PRIMARY KEY(origin_id, target_id)
 );
       SQL
       ['target_id_index', <<-SQL],
-CREATE INDEX target_id_index ON object_connection(target_id);
+CREATE INDEX IF NOT EXISTS target_id_index ON object_connection(target_id);
       SQL
       # helper table 'collection'
       ['collection', <<-'SQL'],
-CREATE TABLE collection (
+CREATE TABLE IF NOT EXISTS collection (
   odba_id integer NOT NULL, key text, value text,
   PRIMARY KEY(odba_id, key)
 );
@@ -135,7 +135,7 @@ CREATE TABLE collection (
     end
     def create_condition_index(table_name, definition)
       self.dbi.do <<-SQL
-CREATE TABLE #{table_name} (
+CREATE TABLE IF NOT EXISTS #{table_name} (
   origin_id INTEGER,
   #{definition.collect { |*pair| pair.join(' ') }.join(",\n  ") },
   target_id INTEGER
@@ -143,62 +143,67 @@ CREATE TABLE #{table_name} (
       SQL
       #index origin_id
       self.dbi.do <<-SQL
-CREATE INDEX origin_id_#{table_name} ON #{table_name}(origin_id);
+CREATE INDEX IF NOT EXISTS origin_id_#{table_name} ON #{table_name}(origin_id);
       SQL
       #index search_term
       definition.each { |name, datatype|
         self.dbi.do <<-SQL
-CREATE INDEX #{name}_#{table_name} ON #{table_name}(#{name});
+CREATE INDEX IF NOT EXISTS #{name}_#{table_name} ON #{table_name}(#{name});
         SQL
       }
       #index target_id
       self.dbi.do <<-SQL
-CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
+CREATE INDEX IF NOT EXISTS target_id_#{table_name} ON #{table_name}(target_id);
       SQL
     end
     def create_fulltext_index(table_name)
       self.dbi.do <<-SQL
-CREATE TABLE #{table_name} (
+DROP TABLE IF EXISTS #{table_name};
+      SQL
+      self.dbi.do <<-SQL
+CREATE TABLE IF NOT EXISTS #{table_name}  (
   origin_id INTEGER,
   search_term tsvector,
   target_id INTEGER
-);
+) WITH OIDS ;
       SQL
       #index origin_id
       self.dbi.do <<-SQL
-CREATE INDEX origin_id_#{table_name} ON #{table_name}(origin_id);
+CREATE INDEX IF NOT EXISTS origin_id_#{table_name} ON #{table_name}(origin_id);
       SQL
-      #index search_term
       self.dbi.do <<-SQL
-CREATE INDEX search_term_#{table_name}
+CREATE INDEX IF NOT EXISTS search_term_#{table_name}
 ON #{table_name} USING gist(search_term);
       SQL
       #index target_id
       self.dbi.do <<-SQL
-CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
+CREATE INDEX IF NOT EXISTS target_id_#{table_name} ON #{table_name}(target_id);
       SQL
     end
     def create_index(table_name)
       self.dbi.do <<-SQL
-        CREATE TABLE #{table_name} (
+        DROP TABLE IF EXISTS #{table_name};
+      SQL
+      self.dbi.do <<-SQL
+        CREATE TABLE IF NOT EXISTS #{table_name} (
           origin_id INTEGER,
           search_term TEXT,
           target_id INTEGER
-        );
+        )  WITH OIDS;
       SQL
       #index origin_id
       self.dbi.do <<-SQL
-        CREATE INDEX origin_id_#{table_name}
+        CREATE INDEX IF NOT EXISTS origin_id_#{table_name}
         ON #{table_name}(origin_id)
       SQL
       #index search_term
       self.dbi.do <<-SQL
-        CREATE INDEX search_term_#{table_name}
+        CREATE INDEX IF NOT EXISTS search_term_#{table_name}
         ON #{table_name}(search_term)
       SQL
       #index target_id
       self.dbi.do <<-SQL
-        CREATE INDEX target_id_#{table_name}
+        CREATE INDEX IF NOT EXISTS target_id_#{table_name}
         ON #{table_name}(target_id)
       SQL
     end
@@ -206,7 +211,7 @@ CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
 			Thread.current[:txn] || @dbi
 		end
 		def drop_index(index_name)
-			self.dbi.do "DROP TABLE #{index_name}"
+			self.dbi.do "DROP TABLE IF EXISTS #{index_name}"
 		end
     def delete_index_element(index_name, odba_id, id_name)
       self.dbi.do <<-SQL, odba_id
@@ -267,7 +272,7 @@ CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
     def ensure_target_id_index(table_name)
       #index target_id
       self.dbi.do <<-SQL
-        CREATE INDEX target_id_#{table_name}
+        CREATE INDEX IF NOT EXISTS target_id_#{table_name}
         ON #{table_name}(target_id)
       SQL
     rescue
@@ -288,6 +293,9 @@ CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
         WHERE #{id_name} = ?
       SQL
     end
+    def get_server_version
+      /\s([\d\.]+)\s/.match(self.dbi.select_all("select version();").first.first)[1]
+    end
     def fulltext_index_target_ids(index_name, origin_id)
       sql = <<-SQL
         SELECT DISTINCT target_id
@@ -296,22 +304,23 @@ CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
       SQL
       self.dbi.select_all(sql, origin_id)
     end
-    def generate_dictionary(language, data_path='/usr/share/postgresql/tsearch_data/', file='fulltext')
-      found = true
-      %w{dict affix stop}.each do |ext|
-        filename = "#{language}_#{file}.#{ext}"
-        source   = File.join(data_path, filename)
-        unless File.exists?(source)
-          puts "ERROR:  \"#{filename}\" does not exist in #{data_path}."
-          found = false
-        end
-      end
-      return unless found
+    def generate_dictionary(language)
+      # postgres searches for the dictionary file in the directory share/tsearch_data of it installation location
+      # By default under gentoo, this is /usr/share/postgresql/tsearch_data/
+      # Use /usr/local/pgsql-10.1/bin/pg_config --sharedir to get the current value
+      # As we have no way to get the current installation path, we do not check whether the files are present or not
+      file='fulltext'
       # setup configuration
+      self.dbi.do <<-SQL
+        DROP TEXT SEARCH DICTIONARY IF EXISTS  public.default_#{language};
+      SQL
       self.dbi.do <<-SQL
         CREATE TEXT SEARCH CONFIGURATION public.default_#{language} ( COPY = pg_catalog.#{language} );
       SQL
       # ispell
+      self.dbi.do <<-SQL
+        DROP TEXT SEARCH DICTIONARY IF EXISTS  #{language}_ispell;
+      SQL
       self.dbi.do <<-SQL
         CREATE TEXT SEARCH DICTIONARY #{language}_ispell (
           TEMPLATE  = ispell,
@@ -464,7 +473,7 @@ CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
       end
       self.dbi.select_all(sql, *values)
     end
-		def retrieve_from_fulltext_index(index_name, search_term, dict, limit=nil)
+		def retrieve_from_fulltext_index(index_name, search_term, limit=nil)
       ## this combination of gsub statements solves the problem of 
       #  properly escaping strings of this form: "(2:1)" into 
       #  '\(2\:1\)' (see test_retrieve_from_fulltext_index)
@@ -472,19 +481,19 @@ CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
         .gsub(/[():]/i, '\\ \\&').gsub(/\s/, '')
 	    sql = <<-EOQ
 				SELECT target_id, 
-					max(ts_rank(search_term, to_tsquery(?, ?))) AS relevance
+					max(ts_rank(search_term, to_tsquery(?))) AS relevance
 				FROM #{index_name} 
-				WHERE search_term @@ to_tsquery(?, ?) 
+				WHERE search_term @@ to_tsquery(?)
 				GROUP BY target_id
 				ORDER BY relevance DESC
 			EOQ
       if(limit)
         sql << " LIMIT #{limit}"
       end
-			self.dbi.select_all(sql, dict, term, dict, term)
+			self.dbi.select_all(sql, term, term)
 		rescue DBI::ProgrammingError => e
 			warn("ODBA::Storage.retrieve_from_fulltext_index rescued a DBI::ProgrammingError(#{e.message}). Query:")
-			warn("self.dbi.select_all(#{sql}, #{dict}, #{term}, #{dict}, #{term})")
+			warn("self.dbi.select_all(#{sql}, #{term}, #{term})")
 			warn("returning empty result")
 			[]
 		end
@@ -526,7 +535,7 @@ CREATE INDEX target_id_#{table_name} ON #{table_name}(target_id);
       unless(self.dbi.columns('object').any? { |col| col.name == 'extent' })
         self.dbi.do <<-EOS
 ALTER TABLE object ADD COLUMN extent TEXT;
-CREATE INDEX extent_index ON object(extent);
+CREATE INDEX IF NOT EXISTS extent_index ON object(extent);
         EOS
       end
     end
@@ -584,20 +593,24 @@ WHERE origin_id = ?
         SQL
       end
     end
-    def update_fulltext_index(index_name, origin_id, search_term, target_id, dict)
+    def update_fulltext_index(index_name, origin_id, search_term, target_id)
       search_term = search_term.gsub(/\s+/, ' ').strip
       if(target_id)
-        self.dbi.do <<-SQL, origin_id, dict, search_term, target_id
+                         value = <<-SQL, origin_id.to_s, search_term, target_id
 INSERT INTO #{index_name} (origin_id, search_term, target_id)
-VALUES (?, to_tsvector(?, ?), ?)
+VALUES (?, to_tsvector(?), ?)
+        SQL
+        result = self.dbi.do <<-SQL, origin_id.to_s, search_term, target_id
+INSERT INTO #{index_name} (origin_id, search_term, target_id)
+VALUES (?, to_tsvector(?), ?)
         SQL
       else
-        self.dbi.do <<-SQL, dict, search_term, origin_id
-UPDATE #{index_name} SET search_term=to_tsvector(?, ?)
+        result = self.dbi.do <<-SQL, search_term, origin_id
+UPDATE #{index_name} SET search_term=to_tsvector(?)
 WHERE origin_id=?
         SQL
       end
-    end
+      end
 		def update_index(index_name, origin_id, search_term, target_id)
       if(target_id)
         self.dbi.do <<-SQL, origin_id, search_term, target_id