active-orient 0.79 → 0.80

data/lib/other.rb

@@ -1,8 +1,26 @@
 
 class Array
+	
+	@@accepted_methods = []
+	## dummy for refining
+
+	def method_missing method, *args, &b
+		return if [:to_hash, :to_str].include? method
+		if @@accepted_methods.include? method
+			self.map{|x| x.public_send(method, *args, &b)}
+		else
+			raise ArgumentError.new("Method #{method} does not exist")
+		end
+	end
+
+
 # Class  extentions to manage to_orient and from_orient
   def to_orient
-    map( &:to_orient) # .join(',')
+   if all?{ |x| x.respond_to?(:rid?)}  && any?( &:rid? )
+		"["+ map{|x| x.rid? ? x.rid : x.to_or }.join(', ') + ']'
+		else
+	  	map(&:to_orient) # .join(',')
+		end
   end
 
   def to_or
@@ -16,6 +34,7 @@ class Array
 	def to_human
 		map &:to_human
 	end
+
   # used to enable 
   # def abc *key
   # where key is a Range, an comma separated List or an item
@@ -28,8 +47,15 @@ class Array
     else
       self
     end
-
   end
+
+	def orient_flatten
+		while( first.is_a?(Array) )
+			self.flatten!(1)
+		end
+		self.compact!
+		self ## return object
+	end
 end
 
 class Symbol
@@ -44,7 +70,7 @@ class Symbol
   "'"+self.to_orient+"'"
   end
 	
-	# inserted to prevent error message while initialising a model-recorda
+	# inserted to prevent error message while initializing a model-recorda
 =begin
 2.6.1 :008 > ii.first.attributes
  => {:zwoebelkuchen=>[7, 9, 9, 7, 8, 8, 3, 6, 9, ":zt:", ":zt:", ":zg:", ":zg:", ":tzu:", ":grotte:"], :created_at=>Wed, 27 Mar 2019 14:59:45 +0000} 
@@ -85,9 +111,9 @@ iv [7, 9, 9, 7, 8, 8, 3, 6, 9, ":zt:", ":zt:", ":zg:", ":zg:", ":tzu:", ":grotte
   ./active-orient-console:51:in `<main>'
 =end
 
-	def coerce a  #nodoc#
-	 nil	
-	end
+	#def coerce a  #nodoc#
+	# nil	
+	#end
 end
 
 class Object
@@ -101,6 +127,23 @@ class Object
 end
 
 
+
+class Time
+	def to_or
+	 "date(\'#{self.strftime("%Y%m%d%H%M%S")}\',\'yyyyMMddHHmmss\')"
+	end
+end
+
+class Object 
+	def to_or
+		self
+	end
+end
+class NilClass
+	def to_or
+		"NULL"
+	end
+end
 class Date
   def to_orient
     if RUBY_PLATFORM == 'java'
@@ -109,8 +152,16 @@ class Date
       self
     end
   end
+	def to_or
+		"date(\'#{self.to_s}\',\'yyyy-MM-dd\')"
+	end
 end
 
+class DateTime
+ def to_or
+	 "date(\'#{self.strftime("%Y%m%d%H%M%S")}\',\'yyyyMMddHHmmss\')"
+ end
+end
 
 class Numeric
 
@@ -143,11 +194,18 @@ class String
     end
   end
 
+	# from orient translates the database response into active-orient objects
+	#
+	# symbols are representated via ":{something]:}"
+	# 
+	# database records respond to the "rid"-method
+	#
+	# other values are not modified
   def from_orient
 	  if rid?
 	    ActiveOrient::Model.autoload_object self
-	  elsif
-	    self =~ /^:.*:$/
+	  elsif  self =~ /^:.*:$/
+			# symbol-representation in the database
 	    self[1..-2].to_sym
 	  else
 	    self
@@ -169,6 +227,7 @@ class String
   def rid
       self["#"].nil? ? self : self[1..-1] if rid? 
   end
+	alias rrid rid
 
   def to_classname
     if self[0] == '$'
@@ -200,71 +259,64 @@ class String
 		end
 	end
 
-	def coerce a  #nodoc#
-	 nil	
-	end
+#	def coerce a  #nodoc#
+#	 nil	
+#	end
 
 	def to_human
 		self
 	end
 end
 
-class Hash #WithIndifferentAccess
+class Hash 
 
-	# converts "abc" => {anything} to :abc => {anything}
-	# converts "nn" => {anything} to nn => {anything}
+	# converts :abc => {anything} to "abc" => {anything}
+	#  
+	# converts nn => {anything} to nn => {anything}
+	#
+	# leaves "abc" => {anything} untouched
   def to_orient   # converts hast from activeorient to db
-    substitute_hash =  {} # HashWithIndifferentAccess.new
-#		puts "here to hash"
-    #keys.each{|k| puts self[k].inspect}
-    keys.each do |k| 
+    map do | k, v|
 			orient_k =  case k
 									when Numeric
 										k
 									when Symbol, String
 										k.to_s
 									else
-										nil
+										raise "not supported key: #[k} -- must a sting, symbol or number"
 									end
-			substitute_hash[orient_k] = self[k].to_orient
-		end
-    substitute_hash
+			[orient_k, v.to_orient]
+		end.to_h
   end
 
-  def from_orient   # converts hash from db to activeorient
+ # converts hash from db to activeorient
+	#
+	#
+  def from_orient  
     #puts "here hash.from_orient --> #{self.inspect}"
 		if keys.include?("@class" )
 			ActiveOrient::Model.orientdb_class( name: self["@class"] ).new self
+			# create a dummy class and fill with attributes from result-set
+		elsif keys.include?("@type") && self["@type"] == 'd'  
+			ActiveOrient::Model.orientdb_class(name: 'query' ).new self
 		else
-			substitute_hash = Hash.new
-			keys.each do |k| 
+			# populate the hash by converting keys: stings to symbols, values: proprocess through :from_orient
+			map do |k,v| 
 				orient_k = if  k.to_s.to_i.to_s == k.to_s
 										 k.to_i
 									 else
 										 k.to_sym
 									 end
 
-				substitute_hash[orient_k] = self[k].from_orient
-			end
-			substitute_hash
+				[orient_k, v.from_orient]
+			end.to_h
 		end
-  end
+	end
 
 	# converts a hash to a string appropiate to include in raw queries
 	def to_or
-		"{ " + to_orient.map{|k,v| "#{k.to_s.to_or}: #{v.to_or}"}.join(',') + "}"
+		"{ " + to_orient.map{|k,v| "#{k.to_or}: #{v.to_or}"}.join(',') + "}"
 	end
-## needs testing!!
-#  def as_json o=nli
-#    #puts "here hash"
-#    substitute_hash = Hash.new
-#    keys.each{|k| substitute_hash[k] = self[k].as_json}
-#    substitute_hash
-#  end
-#  def nested_under_indifferent_access
-#    HashWithIndifferentAccess.new self
-#		self
-#  end
 end
 
 #class RecordList

data/lib/rest/change.rb

@@ -31,6 +31,7 @@ module RestChange
   def update record, attributes , version=0   
     r = ActiveOrient::Model.autoload_object record.rid 
     return(false) unless r.is_a?(ActiveOrient::Model)
+		raise "Cannot update the record, version-information missing. please reload ! " if version.nil?
     version = r.version if version.zero?
     result = patch_record(r.rid) do
       attributes.merge({'@version' => version, '@class' => r.class.ref_name })
@@ -82,20 +83,27 @@ Returns the JSON-Response.
   def patch_record rid	    # :nodoc:   (used by #update )
     logger.progname = 'RestChange#PatchRecord'
     content = yield
-    if content.is_a? Hash
-      begin
-        @res["/document/#{ActiveOrient.database}/#{rid}"].patch content.to_orient.to_json
-      rescue RestClient::InternalServerError => e
-	sentence=  JSON.parse( e.response)['errors'].last['content']
-	  logger.error{sentence}
-	  logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
-	  logger.error{e.message.to_s}
-      end
-    else
-  	  logger.error{"PATCH FAILED: The Block must provide an Hash with properties to be updated"}
-    end
-  end
-  alias patch_document patch_record
+		if content.is_a? Hash
+			begin
+				ActiveOrient.db_pool.checkout do | conn |
+					conn["/document/#{ActiveOrient.database}/#{rid}"].patch content.to_orient.to_json
+				end
+			rescue RestClient::Conflict => e  # (409)
+				# most probably the server is busy. we  wait for a second  print an Error-Message and retry
+				sleep(1)
+				logger.error{ "RestClient::Error(409): Server is signaling a conflict ... retrying" }
+				retry
+			rescue RestClient::InternalServerError => e
+				sentence=  JSON.parse( e.response)['errors'].last['content']
+				logger.error{sentence}
+				logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
+				logger.error{e.message.to_s}
+			end
+		else
+			logger.error{"PATCH FAILED: The Block must provide an Hash with properties to be updated"}
+		end
+	end
+	alias patch_document patch_record
 
 
   #### EXPERIMENTAL ##########
@@ -132,12 +140,7 @@ Returns the JSON-Response.
         return 0
       end
 
-      name_class = classname(o_class)
-      execute name_class, transaction: false do # To execute commands
-        [{ type: "cmd",
-          language: 'sql',
-          command: "ALTER PROPERTY #{name_class}.#{property} #{attribute} #{alteration}"}]
-      end
+			execute { "ALTER PROPERTY #{class_name(o_class)}.#{property} #{attribute} #{alteration}"}
     rescue Exception => e
       logger.error{e.message}
     end

data/lib/rest/create.rb

@@ -13,19 +13,21 @@ module RestCreate
 		old_d = ActiveOrient.database
 		ActiveOrient.database_classes = {} 
 		ActiveOrient.database = database 
-		begin
-			response = @res["database/#{ActiveOrient.database}/#{type}"].post ""
-			if response.code == 200
-				logger.info{"Database #{ActiveOrient.database} successfully created and stored as working database"}
-			else
+			begin
+				response = ActiveOrient.db_pool.checkout do | conn |
+					 conn["database/#{ActiveOrient.database}/#{type}"].post ""
+				end
+				if response.code == 200
+					logger.info{"Database #{ActiveOrient.database} successfully created and stored as working database"}
+				else
+					logger.error{"Database #{ActiveOrient.database} was NOT created. Working Database is still #{ActiveOrient.database}"}
+					ActiveOrient.database = old_d
+				end
+			rescue RestClient::InternalServerError => e
 				logger.error{"Database #{ActiveOrient.database} was NOT created. Working Database is still #{ActiveOrient.database}"}
 				ActiveOrient.database = old_d
 			end
-		rescue RestClient::InternalServerError => e
-			logger.error{"Database #{ActiveOrient.database} was NOT created. Working Database is still #{ActiveOrient.database}"}
-			ActiveOrient.database = old_d
-		end
-		ActiveOrient.database  # return_value
+			ActiveOrient.database  # return_value
 	end
 
 
@@ -51,26 +53,23 @@ def create_this_class  *db_classname  #nodoc#
 		abstract =  nil
 	end
 	#
-	command= db_classname.map do | database_class |
+	 db_classname.map do | database_class |
 		c = if superclass.present?
 					"CREATE CLASS #{database_class} EXTENDS #{superclass}" 
 				else
 					"CREATE CLASS #{database_class} "
 				end
 		c << " ABSTRACT" if abstract.present?
-	#	{ type: "cmd", language: 'sql', command: c }  # return value 4 command
-	c	
+		execute( tolerated_error_code: /already exists/ ){ c }	
 	end
     # execute anything as batch, don't roll back in case of an error
 
-   execute transaction: false, tolerated_error_code: /already exists/ do
-      command
-    end
+#   execute transaction: false, tolerated_error_code: /already exists/ do
+#      command
+#    end
    
   rescue ArgumentError => e
     logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
-	rescue ActiveOrient::Error::ServerError
-		# do nothing
   end
 
 
@@ -88,37 +87,44 @@ Creates a Record with the attributes provided in the attributes-hash e.g.
 
 Puts the database-response into the cache by default
 
+Argument: silence
+  if silence is specified, no Error-Messages are raised. Instead 
+  
+	* if a record failes to be created, because an index-error occured,  it is replaced by that specified in the database response
 
 =end
 
-  def create_record o_class, attributes: {}, cache: true    # use Model#create instead
+  def create_record o_class, attributes: {}, cache: true, silence: true    # use Model#create instead
     logger.progname = 'RestCreate#CreateRecord'
     attributes = yield if attributes.empty? && block_given?
     # @class must not quoted! Quote only attributes(strings)
     post_argument = {'@class' => classname(o_class)}.merge(attributes.to_orient)
+		response = nil
     begin
-      response = @res["/document/#{ActiveOrient.database}"].post post_argument.to_json
+			response = ActiveOrient.db_pool.checkout do | conn |
+				conn["/document/#{ActiveOrient.database}"].post post_argument.to_json
+			end
       data = JSON.parse(response.body)
       the_object = ActiveOrient::Model.orientdb_class(name: data['@class']).new data ## return_value
       if cache 
-	  ActiveOrient::Base.store_rid( the_object ) 
+				ActiveOrient::Base.store_rid( the_object ) 
       else
-	the_object
+				the_object
       end
     rescue RestClient::InternalServerError => e
       sentence=  JSON.parse( e.response)['errors'].last['content']
-#      puts sentence.to_s
       if sentence =~ /found duplicated key/
-	rid = sentence.split("#").last
-	logger.info{ "found duplicated Key --> loaded #{rid} instead of creating "}
-	## reading database content -- maybe update attributes?
-	get_record rid
-      else
-	response = JSON.parse(e.response)['errors'].pop
-	logger.error{response['content'].split(':')[1..-1].join(':')}
-	logger.error{"No Object allocated"}
-	nil # return_value
-       end
+				raise "Duplicate Key" unless silence
+				rid = sentence.split("#").last
+				logger.info{ "found duplicated Key --> loaded #{rid} instead of creating "}
+				## reading database content -- maybe update attributes?
+				get_record rid
+			else
+				response = JSON.parse(e.response)['errors'].pop
+				logger.error{response['content'].split(':')[1..-1].join(':')}
+				logger.error{"No Object allocated"}
+				nil # return_value
+			end
     rescue Errno::EADDRNOTAVAIL => e
       sleep(2)
       retry
@@ -190,22 +196,24 @@ A composite index
 		logger.progname = 'RestCreate#CreateProperties'
 		all_properties_in_a_hash = Hash.new  #WithIndifferentAccess.new
 		all_properties.each{|field, args| all_properties_in_a_hash.merge! translate_property_hash(field, args)}
-		count=0
+		count, response = 0, nil
 #		puts "all_properties_in_a_hash #{all_properties_in_a_hash.to_json}"
-		begin
-			if all_properties_in_a_hash.is_a?(Hash)
-				response = @res["/property/#{ActiveOrient.database}/#{classname(o_class)}"].post all_properties_in_a_hash.to_json
-#				puts response.inspect
-				# response.body.to_i returns  response.code, only to_f.to_i returns the correct value
-				count= response.body.to_f.to_i if response.code == 201
+		if all_properties_in_a_hash.is_a?(Hash)
+			begin
+				response = ActiveOrient.db_pool.checkout do | conn |
+					 conn["/property/#{ActiveOrient.database}/#{classname(o_class)}"].post all_properties_in_a_hash.to_json
+				end
+					#				puts response.inspect
+					# response.body.to_i returns  response.code, only to_f.to_i returns the correct value
+					count= response.body.to_f.to_i if response.code == 201
+			rescue RestClient::InternalServerError => e
+				logger.progname = 'RestCreate#CreateProperties'
+				response = JSON.parse(e.response)['errors'].pop
+				error_message = response['content'].split(':').last
+				logger.error{"Properties in #{classname(o_class)} were NOT created"}
+				logger.error{"The Error was: #{response['content'].split(':').last}"}
+				nil
 			end
-		rescue RestClient::InternalServerError => e
-			logger.progname = 'RestCreate#CreateProperties'
-			response = JSON.parse(e.response)['errors'].pop
-			error_message = response['content'].split(':').last
-			logger.error{"Properties in #{classname(o_class)} were NOT created"}
-			logger.error{"The Error was: #{response['content'].split(':').last}"}
-			nil
 		end
 		### index
 		if block_given?# && count == all_properties_in_a_hash.size
@@ -236,22 +244,22 @@ If an index is to be specified, it's defined in the optional block
   --> creates a manual index
 =end
 
-  def create_property o_class, field, index: nil, **args, &b
-    logger.progname = 'RestCreate#CreateProperty'
-    args= { type: :string} if args.blank?  # the default case
-    c = create_properties o_class, {field => args}
-    if index.nil? && block_given?
-      index = yield
-    end
-    if index.present?
-      if index.is_a?(String) || index.is_a?(Symbol)
-	create_index o_class, name: field, type: index
-      elsif index.is_a? Hash
-	bez = index.keys.first
-	create_index o_class, name: bez, type: index[bez], on: [field]
-      end
-    end
-  end
+	def create_property o_class, field, index: nil, **args, &b
+		logger.progname = 'RestCreate#CreateProperty'
+		args= { type: :string} if args.blank?  # the default case
+		c = create_properties o_class, {field => args}
+		if index.nil? && block_given?
+			index = yield
+		end
+		if index.present?
+			if index.is_a?(String) || index.is_a?(Symbol)
+				create_index o_class, name: field, type: index
+			elsif index.is_a? Hash
+				bez = index.keys.first
+				create_index o_class, name: bez, type: index[bez], on: [field]
+			end
+		end
+	end
 
   ################# INDEX ###################