active-orient 0.79 → 0.80

data/lib/rest/delete.rb

@@ -12,7 +12,10 @@ module RestDelete
     old_ds = ActiveOrient.database
     change_database database
     begin
-  	  response = @res["/database/#{ActiveOrient.database}"].delete
+		  response = nil
+			ActiveOrient.db_pool.checkout do | conn |
+				response = conn["/database/#{ActiveOrient.database}"].delete
+			end
   	  if database == old_ds
   	    change_database  'temp'
   	    logger.info{"Working database deleted, switched to temp"}
@@ -30,77 +33,93 @@ module RestDelete
   ######### CLASS ##########
 
 =begin
-  Deletes the specified class and returns true on success
-  todo: remove all instances of the class
-=end
+	Deletes the specified class and returns true on success
 
-  def delete_class o_class
-    cl = classname(o_class)
-    return if cl.nil?
-    logger.progname = 'RestDelete#DeleteClass'
+	The class-entries in ActiveOrient.database_classes and ORD.database_classes are removed.
+	
+	The Ruby-Class itself is untouched. 
+	However, any furter operation leads to an Error.
 
-    begin
-      ## to do: if cl contains special characters, enclose with backticks
-      response = @res["/class/#{ActiveOrient.database}/#{cl}"].delete
-      if response.code == 204
-	logger.info{"Class #{cl} deleted."}
-	ActiveOrient.database_classes.delete(cl)
-      end
-    rescue RestClient::InternalServerError => e
-      sentence=  JSON.parse( e.response)['errors'].last['content']
-      if ActiveOrient.database_classes.has_key? cl
-	logger.error{"Class #{cl} still present."}
-	logger.error{ sentence }
-	false
-      else
-	logger.error{e.inspect}
-	true
-      end
-    rescue Exception => e
-      logger.error{e.message}
-      logger.error{e.inspect}
-    end
-  end
+todo: remove all instances of the class
+=end
+
+	def delete_class o_class
+		cl = classname(o_class).to_s
+		return if cl.nil?
+		logger.progname = 'RestDelete#DeleteClass'
+
+		begin
+			## to do: if cl contains special characters, enclose with backticks
+			response = nil
+			ActiveOrient.db_pool.checkout do | conn |
+				response = conn["/class/#{ActiveOrient.database}/#{cl}"].delete
+			end
+			if response.code == 204
+				logger.info{"Class #{cl} deleted."}
+
+				ActiveOrient.database_classes.delete(cl)
+			end
+		rescue RestClient::InternalServerError => e
+			sentence=  JSON.parse( e.response)['errors'].last['content']
+			if ActiveOrient.database_classes.has_key? cl
+				logger.error{"Class #{cl} still present."}
+				logger.error{ sentence }
+				false
+			else
+				logger.error{e.inspect}
+				true
+			end
+		rescue Exception => e
+			logger.error{e.message}
+			logger.error{e.inspect}
+		end
+	end
 
   ############## RECORD #############
 
 =begin
   Deletes a single Record when providing a single rid-link (#00:00) or a record
+
   Deletes multible Records when providing a list of rid-links or a record
-  Todo: implement delete_edges after querying the database in one statement
+  
+	Todo: implement delete_edges after querying the database in one statement
 
   Example:
-  record =  Vertex.create_document attributes: { something: 'something' }
-  Vertex.delete_record record
+		V.create_class :test
+		record =  Test.new  something: 'something' 
+		V.db.delete_record record
 
-  records= (1..100).map{|x| Vertex.create_document attributes: { something: x } }
-  Vertex.delete_record *records
+		records= (1..100).map{|x| Test.create  something: x } 
+		V.db.delete_record *records
 
   delete_records provides the removal of datasets after quering the database.
 =end
 
-  def delete_record *rid
+  def delete_record *o
     logger.progname = "ActiveOrient::RestDelete#DeleteRecord"
-    ridvec= rid.map( &:to_orient).flatten
-    unless ridvec.empty?
-      ridvec.map do |rid|
-        begin
-	  ActiveOrient::Base.remove_rid(  ActiveOrient::Base.get_rid(rid) ) 
-          @res["/document/#{ActiveOrient.database}/#{rid[1..-1]}"].delete
-        rescue RestClient::InternalServerError => e
-          logger.error{"Record #{rid} NOT deleted"}
-        rescue RestClient::ResourceNotFound
-          logger.error{"Record #{rid} does not exist in the database"}
-        else
-          logger.info{"Record #{rid} deleted"}
-        end
-      end
-    else
-      logger.info{"No record deleted."}
-      return nil
-    end
-  end
-  alias delete_document delete_record
+		#o.map( &:to_orient ).map do |r|
+		o.orient_flatten.map do |r|
+			rr =  r.to_human
+			begin
+				ActiveOrient::Base.remove_rid r 
+#				rest_resource["/document/#{ActiveOrient.database}/#{r[1..-1].to_or}"].delete
+				ActiveOrient.db_pool.checkout do | conn |
+					conn["/document/#{ActiveOrient.database}/#{r.rid}"].delete
+				end
+
+			rescue RestClient::InternalServerError => e
+				logger.error{"Record #{rr} NOT deleted"}
+			rescue RestClient::ResourceNotFound
+				logger.error{"Record #{rr} does not exist in the database"}
+			rescue RestClient::BadRequest => e
+				logger.error{"tried to delete  #{rr}, but something went wrong"}
+				raise
+			else
+				logger.info{"Record #{rr} deleted"}
+			end
+		end
+	end
+	alias delete_document delete_record
 
 =begin
   Deletes records. They are defined by a query. All records which match the attributes are deleted.
@@ -109,12 +128,7 @@ module RestDelete
 
   def delete_records o_class, where: {}
     logger.progname = 'RestDelete#DeleteRecords'
-    records_to_delete = get_records(from: o_class, where: where)
-    if records_to_delete.empty?
-      logger.info{"No record found"}
-    else
-      delete_record records_to_delete
-    end
+    get_records(from: o_class, where: where).each{|y| delete_record  y}
   end
   alias delete_documents delete_records
 
@@ -123,8 +137,10 @@ module RestDelete
   def delete_property o_class, field
     logger.progname = 'RestDelete#DeleteProperty'
     begin
-  	  response =   @res["/property/#{ActiveOrient.database}/#{classname(o_class)}/#{field}"].delete
-  	  true if response.code == 204
+			response = ActiveOrient.db_pool.checkout do | conn |
+				r =  conn["/property/#{ActiveOrient.database}/#{classname(o_class)}/#{field}"].delete
+				true if r.code == 204
+			end
     rescue RestClient::InternalServerError => e
   	  logger.error{"Property #{field} in  class #{classname(o_class)} NOT deleted" }
   	    false

data/lib/rest/operations.rb

@@ -7,7 +7,8 @@ module RestOperations
   #     puts "uri:#{function_uri { args.join('/') } }"
     begin
       term = args.join('/')
-      @res["/function/#{@database}/#{term}"].post ''
+		rest_resource = Thread.current['resource'] || get_resource 
+     rest_resource["/function/#{@database}/#{term}"].post ''
     rescue RestClient::InternalServerError => e
   	  puts  JSON.parse(e.http_body)
     end
@@ -19,7 +20,7 @@ module RestOperations
   def count **args
     logger.progname = 'RestOperations#CountRecords'
     query = OrientSupport::OrientQuery.new args
-    query.projection << 'COUNT(*)'
+    query.projection  'COUNT(*)'
     result = get_records raw: true, query: query
     result.first["COUNT(*)"] rescue  0  # return_value
   end
@@ -98,56 +99,82 @@ Multible statements are transmitted at once if the Block provides an Array of st
 
 =end
 
-def read_transaction
-	@transaction
-end
-	def execute transaction: false, tolerated_error_code: nil, process_error: true, raw: nil
+	def read_transaction
+		@transaction
+	end
+
+	def manage_transaction kind, command
 		@transaction = []  unless @transaction.is_a?(Array)
-		if block_given?
-			command =  yield
-			command.is_a?(Array) ? command.each{|c| @transaction << c} : @transaction << command
-		else
-			logger.error { "No Block provided to execute" }
-			return nil
-		end
 
-#			puts "transaction #{@transaction.inspect}"
-		unless transaction == :prepare
+		# in any case:  add statement to array
+		command.is_a?(Array) ? command.each{|c| @transaction << c} : @transaction << command
+
+		# if kind is prepare, we a done. 
+		# now, combine anything
+		unless kind == :prepare
 			commands =  @transaction.map{|y| y if y.is_a? String }.compact
 			@transaction.delete_if{|y| y if y.is_a?(String)} 
 			#puts "tn #{commands.inspect}"
-			return nil if commands.empty?
-			if commands.size >1
-			@transaction <<	{ type: 'script', language: 'sql', script: commands } 
-			elsif  transaction ==  false
-				@transaction = 	commands.first
-			else
-				transaction =  true
-				@transaction <<		{ type: 'cmd', language: 'sql', command: commands.first } 
-			end	
- 			_execute transaction, tolerated_error_code, process_error, raw
+				@transaction <<	{ type: 'script', language: 'sql', script: commands } unless  commands.empty?
+	#		elsif  transaction ==  false
+	#			@transaction = 	commands.first
+	#		else
+	#			transaction =  true
+	#			@transaction <<		{ type: 'cmd', language: 'sql', command: commands.first } 
+
+				# transaction is true only for multible statements
+				#      batch[:transaction] = transaction & batch[:operations].size >1
+	#			logger.info{ @transaction.map{|y|y[:command]}.join(";\n ") } 
+#				logger.info{ @transaction.map{|y|y[:script]}.join(";\n ") } 
+		#		batch= { transaction: transaction, operations: @transaction  }
+		#		puts "batch:  #{batch.inspect}"
+
+		#		@res["/batch/#{ActiveOrient.database}"].post batch.to_json
+		end
+	end
+
+	# execute the command 
+	#
+	# thread-safe  ( transaction = false)
+	#
+	# 
+	def execute transaction: nil,
+		          command: nil,
+							tolerated_error_code: nil, 
+							process_error: true, 
+							raw: nil 
+		
+		if block_given?
+			command =  yield
+		end
+	  unless command.present?	
+			logger.error { "No Command  provided to execute" }
+			return nil
+		end
+		if ( transaction.present? || command.is_a?(Array) )
+			logger.error  "calling manage_transaction NOT IMPLEMENTED YET!"
+			manage_transaction transaction, command
+		end		
+	
+		 logger.info command.to_s								
+		_execute( tolerated_error_code, process_error, raw) do
+
+			ActiveOrient.db_pool.checkout do | conn |
+				conn["/command/#{ActiveOrient.database}/sql"].post command.to_s #.to_json
+			end
 		end
+
+#		rest_resource.delete #if resource.present?
+
 	end
 
 
-		def _execute transaction, tolerated_error_code, process_error, raw
+	def _execute tolerated_error_code, process_error, raw
 
 		logger.progname= "Execute"
+
 		begin
-			response = if @transaction.is_a?(Array) 
-									 @transaction.compact!
-									 return nil if @transaction.empty?
-									 # transaction is true only for multible statements
-									 #      batch[:transaction] = transaction & batch[:operations].size >1
-									 logger.info{ @transaction.map{|y|y[:command]}.join(";\n ") } 
-									 logger.info{ @transaction.map{|y|y[:script]}.join(";\n ") } 
-									batch= { transaction: transaction, operations: @transaction  }
-									puts "batch:  #{batch.inspect}"
-									 @res["/batch/#{ActiveOrient.database}"].post batch.to_json
-								 else
-									 logger.info{ @transaction } 
-									 @res["/command/#{ActiveOrient.database}/sql"].post @transaction #.to_json
-								 end
+			response = yield
 		rescue RestClient::BadRequest => f
 			# extract the misspelled query in logfile and abort
 			sentence=  JSON.parse( f.response)['errors'].last['content']
@@ -155,8 +182,13 @@ end
 			puts "Query not recognized"
 			puts sentence
 			raise
+		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{ e.inspect }
+			logger.error{ "RestClient::Error(409): Server is signaling a conflict ... retrying" }
+			retry
 		rescue RestClient::InternalServerError => e
-			@transaction = []
 			sentence=  JSON.parse( e.response)['errors'].last['content']
 			if tolerated_error_code.present? &&  e.response =~ tolerated_error_code
 				logger.debug('RestOperations#Execute'){ "tolerated_error::#{e.message}"}
@@ -164,8 +196,6 @@ end
 				nil  # return value
 			else
 				if process_error
-					#	    puts batch.to_json
-					#	  logger.error{e.response}
 					logger.error{sentence}
 					#logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
 					#	  logger.error{e.message.to_s}
@@ -177,35 +207,16 @@ end
 			sleep(2)
 			retry
 		else  # code to execute if no exception  is raised
-			@transaction = []
 			if response.code == 200
-				if response.body['result'].present?
-					result=JSON.parse(response.body)['result']
-					return result if raw.present?
-					result.map do |x|
-						if x.is_a? Hash
-							y = x.transform_keys{|y| y.delete('@').split('=').first.underscore.to_sym}
-							if y[:type] == 'd' #0.present?  #  == 'd'  # x.has_key?("@type")   && 
-								if y.has_key?(:class)
-									the_object = ActiveOrient::Model.orientdb_class( name: y[:class] ).new x
-									ActiveOrient::Base.store_rid( the_object )   # update cache
-								else   # create a dummy class and fill with attributes from result-set
-									ActiveOrient::Model.orientdb_class(name: 'query' ).new x
-								end
-							else
-  							 # return the result or the corresponding dataset
-								r= y.map{ | _,v | v.is_a?(String) && v.rid? ?  ActiveOrient::Model.get( v ): v }
-								y.size ==1 ? r.first : r   # return raw instead of array if only one value is present
-							end
-						end
-					end.compact # return_value
+				result=JSON.parse(response.body)['result']
+				if raw.present? 
+					result
 				else
-					response.body
-				end
+					result.from_orient
+				end # raw present?
 			else
-				nil
+				logger.error { "code : #{response.code}" }
 			end
 		end
 	end
-
 end

data/lib/rest/read.rb

@@ -7,7 +7,10 @@ module RestRead
 #    ORD.get_databases
 #     => ["temp", "GratefulDeadConcerts", (...)] 
   def get_databases
-    JSON.parse(@res["/listDatabases"].get.body)['databases']
+
+		ActiveOrient.db_pool.checkout do | conn |
+			JSON.parse(conn["/listDatabases"].get.body)['databases']
+		end
   end
 
 =begin
@@ -20,18 +23,20 @@ Returns an Array with (unmodified) Class-attribute-hash-Elements
       (...)    ]
 =end
   def get_classes *attributes
-    begin
-    	response = @res["/database/#{ActiveOrient.database}"].get
-    	if response.code == 200
-    	  classes = JSON.parse(response.body)['classes']
-    	  unless attributes.empty?
-    	    classes.map{|y| y.select{|v,_| attributes.include?(v)}}
-    	  else
-    	    classes
-    	  end
-      else
-        []
-      end
+		begin
+			response = ActiveOrient.db_pool.checkout do | conn |
+				conn["/database/#{ActiveOrient.database}"].get
+			end
+			if response.code == 200
+				classes = JSON.parse(response.body)['classes']
+				unless attributes.empty?
+					classes.map{|y| y.select{|v,_| attributes.include?(v)}}
+				else
+					classes
+				end
+			else
+				[]
+			end
     rescue Exception => e
       logger.progname = 'RestRead#GetClasses'
       logger.error{e.message}
@@ -48,11 +53,13 @@ Returns an Array with (unmodified) Class-attribute-hash-Elements
 #    => {"name"=>"a", "superClass"=>"V", "superClasses"=>["V"], "alias"=>nil, "abstract"=>false, "strictmode"=>false, "clusters"=>[65, 66, 67, 68], "defaultCluster"=>65, "clusterSelection"=>"round-robin", "records"=>3} 
 #
   def get_class_properties o_class
-    JSON.parse(@res["/class/#{ActiveOrient.database}/#{classname(o_class)}"].get)
-  rescue => e
-    logger.error  e.message
-    nil
-  end
+			ActiveOrient.db_pool.checkout do | conn |
+				JSON.parse(conn["/class/#{ActiveOrient.database}/#{classname(o_class)}"].get)
+			end
+			rescue => e
+				logger.error  e.message
+				nil
+			end
 
 
   def print_class_properties o_class
@@ -86,7 +93,10 @@ The rid-cache is not used or updated
 		begin
 			logger.progname = 'RestRead#GetRecord'
 			if rid.rid?
-				response = @res["/document/#{ActiveOrient.database}/#{rid.to_orient[1..-1]}"].get
+
+				response =  ActiveOrient.db_pool.checkout do | conn |
+					 conn["/document/#{ActiveOrient.database}/#{rid.to_orient[1..-1]}"].get
+				end
 				raw_data = JSON.parse(response.body) 
 				#	ActiveOrient::Model.use_or_allocate( raw_data['@rid'] ) do 
 				the_object=   ActiveOrient::Model.orientdb_class(name: raw_data['@class']).new raw_data
@@ -107,6 +117,13 @@ The rid-cache is not used or updated
 			logger.error { "RID: #{rid} ---> No Record present " }
 			ActiveOrient::Model.remove_rid rid      #  remove rid from cache
 			nil
+		rescue NoMethodError => e
+			logger.fatal { "---------------- Serious Trouble ----------------" }
+			logger.fatal { "GetRecord  raw-data: #{raw_data}" }
+			logger.error { "GetRecord  could not allocate Model-Instance" }
+			logger.error { "is a model file required but missing?" }
+			raise
+
 		rescue Exception => e
 			logger.error { "Something went wrong" }
 			logger.error { "RID: #{rid} - #{e.message}" }
@@ -129,9 +146,11 @@ In this case cached data are used in favour and its not checked if the database
     query = OrientSupport::OrientQuery.new(args) if query.nil?
     begin
       logger.progname = 'RestRead#GetRecords'
-  	  url = "/query/#{ActiveOrient.database}/sql/" + query.compose(destination: :rest) + "/#{query.get_limit}"
-  	  response = @res[URI.encode(url)].get
-	  JSON.parse(response.body)['result'].map do |record|
+			response =  ActiveOrient.db_pool.checkout do | conn |
+				url = "/query/#{ActiveOrient.database}/sql/" + query.compose(destination: :rest) + "/#{query.get_limit}"
+				conn[URI.encode(url)].get
+			end
+			JSON.parse(response.body)['result'].map do |record|
 	    if raw
 	      record
 	      # query returns an anonymus class: Use the provided Block or the Dummy-Model MyQuery
@@ -160,8 +179,7 @@ In this case cached data are used in favour and its not checked if the database
   	  logger.error{"Invalid URI detected"}
   	  logger.error query.to_s
   	  logger.info{"Trying batch processing"}
-  	  sql_cmd = -> (command){{type: "cmd", language: "sql", command: command}}
-  	  response = execute{[sql_cmd[query.to_s]]}
+  	  response = execute{ query.to_s}
   	  logger.info{"Success: to avoid this delay use ActiveOrient::Model#query_database instead"}
       response
     end