active-orient 0.4 → 0.80

data/lib/rest/delete.rb

@@ -0,0 +1,150 @@
+module RestDelete
+
+  ######### DATABASE ##########
+
+=begin
+  Deletes the database and returns true on success
+  After the removal of the database, the working-database might be empty
+=end
+
+  def delete_database database:
+    logger.progname = 'RestDelete#DeleteDatabase'
+    old_ds = ActiveOrient.database
+    change_database database
+    begin
+		  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"}
+  	  else
+  	    change_database old_ds
+  	    logger.info{"Database #{database} deleted, working database is still #{ActiveOrient.database}"}
+  	  end
+    rescue RestClient::InternalServerError => e
+      change_database old_ds
+  	  logger.info{"Database #{database} NOT deleted, working database is still #{ActiveOrient.database}"}
+    end
+    !response.nil? && response.code == 204 ? true : false
+  end
+
+  ######### CLASS ##########
+
+=begin
+	Deletes the specified class and returns true on success
+
+	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.
+
+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
+
+  Example:
+		V.create_class :test
+		record =  Test.new  something: 'something' 
+		V.db.delete_record record
+
+		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 *o
+    logger.progname = "ActiveOrient::RestDelete#DeleteRecord"
+		#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.
+  An Array with freed index-values is returned
+=end
+
+  def delete_records o_class, where: {}
+    logger.progname = 'RestDelete#DeleteRecords'
+    get_records(from: o_class, where: where).each{|y| delete_record  y}
+  end
+  alias delete_documents delete_records
+
+  ################ PROPERTY #############
+
+  def delete_property o_class, field
+    logger.progname = 'RestDelete#DeleteProperty'
+    begin
+			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
+    end
+  end
+
+end

data/lib/rest/operations.rb

@@ -0,0 +1,222 @@
+module RestOperations
+
+# Execute a predefined Function
+
+#  untested
+  def call_function *args  
+  #     puts "uri:#{function_uri { args.join('/') } }"
+    begin
+      term = args.join('/')
+		rest_resource = Thread.current['resource'] || get_resource 
+     rest_resource["/function/#{@database}/#{term}"].post ''
+    rescue RestClient::InternalServerError => e
+  	  puts  JSON.parse(e.http_body)
+    end
+  end
+
+# Used to count the Records in relation of the arguments
+#
+# Overwritten by Model#Count
+  def count **args
+    logger.progname = 'RestOperations#CountRecords'
+    query = OrientSupport::OrientQuery.new args
+    query.projection  'COUNT(*)'
+    result = get_records raw: true, query: query
+    result.first["COUNT(*)"] rescue  0  # return_value
+  end
+=begin
+--
+## historic method 
+#  def manipulate_relation record,  method, array, items  # :nodoc: #
+#    execute_array = Array.new
+#    method =  method.to_s.upcase
+#
+#    add_2_execute_array = -> (it) do
+#      command = "UPDATE ##{record.rid} #{method} #{array} = #{it.to_or } " #updating}"
+#      command.gsub!(/\"/,"") if it.is_a? Array
+#      puts "COMMAND:: #{command}"
+#      execute_array << {type: "cmd", language: "sql", command: command}
+#    end
+#
+#    items.to_a.each{|x| add_2_execute_array[x] }
+##    puts "******************"
+##    puts record.inspect
+##    puts "-----"
+##    puts execute_array.join('\n')
+#    r= execute{ execute_array }
+#    puts record.inspect
+#    puts r.inspect
+##    puts "******************"
+#    if r.present?
+#      case  method
+#      when 'ADD'
+#	items.each{|x| record.attributes[array] << x}
+#      when 'REMOVE'
+#	items.map{|x| record.attributes[array].delete x}
+#      else
+#      end
+#      record.increment_version
+#    end
+#  end
+++
+=end
+
+
+=begin
+Executes a list of commands and returns the result-array (if present)
+
+(External use)
+
+If soley a string is provided in the block, a minimal database-console is realized.
+i.e.
+
+  ORD.execute{ 'select from #25:0' }
+
+(Internal Use)
+
+Structure of the provided block:
+  [{type: "cmd", language: "sql",  command: "create class Person extends V"}, (...)]
+--
+  It was first used by ActiveOrient::Query.execute_queries
+  Later I (topofocus) discovered that some Queries are not interpretated correctly by #GetRecords but are submitted without Error via batch-processing.
+  For instance, this valid query
+   select expand(first_list[5].second_list[9]) from base where label = 9
+  can only be submitted via batch
+++
+Parameters:
+ 
+ transaction:  true|false   Perform the batch as transaction
+ tolerate_error_code: /a regular expression/   
+ Statements to execute are provided via block
+ These statements are translated to json and transmitted to the database. Example:
+
+    	{ type: "cmd",
+          language: 'sql',
+          command: "CREATE EDGE #{classname(o_class)} FROM #{from.to_orient} TO #{to.to_orient}"}
+
+Multible statements are transmitted at once if the Block provides an Array of statements.
+
+
+=end
+
+	def read_transaction
+		@transaction
+	end
+
+	def manage_transaction kind, command
+		@transaction = []  unless @transaction.is_a?(Array)
+
+		# 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}"
+				@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 tolerated_error_code, process_error, raw
+
+		logger.progname= "Execute"
+
+		begin
+			response = yield
+		rescue RestClient::BadRequest => f
+			# extract the misspelled query in logfile and abort
+			sentence=  JSON.parse( f.response)['errors'].last['content']
+			logger.fatal{ " BadRequest --> #{sentence.split("\n")[1]} " }
+			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
+			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}"}
+				logger.debug('RestOperations#Execute'){ e.message }
+				nil  # return value
+			else
+				if process_error
+					logger.error{sentence}
+					#logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
+					#	  logger.error{e.message.to_s}
+				else 
+					raise
+				end
+			end 
+		rescue Errno::EADDRNOTAVAIL => e
+			sleep(2)
+			retry
+		else  # code to execute if no exception  is raised
+			if response.code == 200
+				result=JSON.parse(response.body)['result']
+				if raw.present? 
+					result
+				else
+					result.from_orient
+				end # raw present?
+			else
+				logger.error { "code : #{response.code}" }
+			end
+		end
+	end
+end

data/lib/rest/read.rb

@@ -0,0 +1,189 @@
+module RestRead
+
+  ############# DATABASE #############
+
+# Returns an Array with available Database-Names as Elements
+#
+#    ORD.get_databases
+#     => ["temp", "GratefulDeadConcerts", (...)] 
+  def get_databases
+
+		ActiveOrient.db_pool.checkout do | conn |
+			JSON.parse(conn["/listDatabases"].get.body)['databases']
+		end
+  end
+
+=begin
+Returns an Array with (unmodified) Class-attribute-hash-Elements
+
+»get_classes 'name', 'superClass'« returns
+      [ {"name"=>"E", "superClass"=>""},
+      {"name"=>"OFunction", "superClass"=>""},
+      {"name"=>"ORole", "superClass"=>"OIdentity"}
+      (...)    ]
+=end
+  def get_classes *attributes
+		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}
+    end
+  end
+
+
+  ############### CLASS ################
+
+# Returns a JSON of the property of a class
+#
+#   ORD.create_vertex_class a:
+#   ORD.get_class_properties A
+#    => {"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
+			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
+    puts "Detected Properties for class #{classname(o_class)}"
+    rp = get_class_properties o_class
+    n = rp['name']
+    if rp['properties'].nil?
+      puts "No property available"
+    else
+      puts rp['properties'].map{|x| "\t"+[n+'.'+x['name'], x['type'],x['linkedClass']].compact.join("\t-> ")}.join("\n")
+    end
+  rescue NoMethodError
+    puts "Class #{o_class} not present in database"
+  end
+
+  ############## OBJECT #################
+
+=begin
+Retrieves a Record from the Database 
+
+The argument can either be a rid "#{x}:{y}" or a link "{x}:{y}".
+
+(to be specific: it must provide the methods rid? and to_orient, the latter must return the rid: "#[a}:{b}".)
+
+If no Record is found, nil is returned
+
+The rid-cache is not used or updated
+=end
+
+	def get_record rid
+		begin
+			logger.progname = 'RestRead#GetRecord'
+			if rid.rid?
+
+				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
+				ActiveOrient::Base.store_rid( the_object )   # update cache
+			else
+				logger.error { "Wrong parameter #{rid.inspect}. " }
+				nil
+			end
+		rescue RestClient::InternalServerError => e
+			if e.http_body.split(':').last =~ /was not found|does not exist in database/
+				nil
+			else
+				logger.error { "Something went wrong" }
+				logger.error { e.http_body.inspect }
+				raise
+			end
+		rescue RestClient::ResourceNotFound => e
+			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}" }
+			raise
+		end
+	end
+	alias get_document get_record
+
+=begin
+Retrieves Records from a query
+
+If raw is specified, the JSON-Array is returned, e.g.
+    {"@type"=>"d", "@rid"=>"#15:1", "@version"=>1,    "@class"=>"DocumebntKlasse10", "con_id"=>343, "symbol"=>"EWTZ"}
+
+Otherwise  ActiveModel-Instances are created and returned. 
+In this case cached data are used in favour and its not checked if the database contents have changed.
+=end
+
+  def get_records raw: false, query: nil, **args
+    query = OrientSupport::OrientQuery.new(args) if query.nil?
+    begin
+      logger.progname = 'RestRead#GetRecords'
+			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
+	    elsif record['@class'].blank?
+	      block_given? ? yield.new(record) : ActiveOrient::Model.orientdb_class(name: 'query' ).new( record )
+	    else
+		the_object = ActiveOrient::Model.orientdb_class(name: record['@class']).new record
+		ActiveOrient::Base.store_rid( the_object )   # update cache
+#	      end
+	    end
+	  end
+	  # returns an array of updated objects
+     
+    rescue RestClient::BadRequest  => e
+      #puts e.inspect
+	  logger.error { "-"*30 }
+	  logger.error { "REST_READ#GET_RECORDS.URL ---> Wrong Query" }
+	  logger.error {  query.compose( destination: :rest).to_s }
+	  logger.error { "Fired Statement: #{url.to_s} " }
+	response=""
+    rescue RestClient::InternalServerError => e
+  	  response = JSON.parse(e.response)['errors'].pop
+	  logger.error{ "Interbak Server ERROR" }
+  	  logger.error{response['content'].split(':').last}
+    rescue URI::InvalidURIError => e
+  	  logger.error{"Invalid URI detected"}
+  	  logger.error query.to_s
+  	  logger.info{"Trying batch processing"}
+  	  response = execute{ query.to_s}
+  	  logger.info{"Success: to avoid this delay use ActiveOrient::Model#query_database instead"}
+      response
+    end
+  end
+  alias get_documents get_records
+
+end