active-orient 0.42 → 0.79

data/lib/rest/operations.rb

@@ -0,0 +1,211 @@
+module RestOperations
+
+# Execute a predefined Function
+
+#  untested
+  def call_function *args  
+  #     puts "uri:#{function_uri { args.join('/') } }"
+    begin
+      term = args.join('/')
+      @res["/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 execute transaction: false, tolerated_error_code: nil, process_error: true, raw: nil
+		@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
+			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
+		end
+	end
+
+
+		def _execute transaction, 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
+		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::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}"}
+				logger.debug('RestOperations#Execute'){ e.message }
+				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}
+				else 
+					raise
+				end
+			end 
+		rescue Errno::EADDRNOTAVAIL => e
+			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
+				else
+					response.body
+				end
+			else
+				nil
+			end
+		end
+	end
+
+end

data/lib/rest/read.rb

@@ -0,0 +1,171 @@
+module RestRead
+
+  ############# DATABASE #############
+
+# Returns an Array with available Database-Names as Elements
+#
+#    ORD.get_databases
+#     => ["temp", "GratefulDeadConcerts", (...)] 
+  def get_databases
+    JSON.parse(@res["/listDatabases"].get.body)['databases']
+  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 = @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
+    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
+    JSON.parse(@res["/class/#{ActiveOrient.database}/#{classname(o_class)}"].get)
+  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 = @res["/document/#{ActiveOrient.database}/#{rid.to_orient[1..-1]}"].get
+				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 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'
+  	  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|
+	    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"}
+  	  sql_cmd = -> (command){{type: "cmd", language: "sql", command: command}}
+  	  response = execute{[sql_cmd[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

data/lib/rest/rest.rb

@@ -0,0 +1,112 @@
+require_relative "read.rb" # manage get
+require_relative "create.rb" # manage create
+require_relative "change.rb" # manage update
+require_relative "operations.rb" # manage count, functions and execute
+require_relative "delete.rb" # manage delete
+require_relative "../support/logging"
+require 'cgi'
+require 'rest-client'
+
+module ActiveOrient
+
+=begin
+OrientDB points to an OrientDB-Database.
+The communication is based on the OrientDB-REST-API.
+
+Its usually initialised through ActiveOrient::Init.connect
+
+=end
+
+  class OrientDB
+    include OrientSupport::Support
+    include OrientSupport::Logging
+    include OrientDbPrivate
+    include DatabaseUtils
+    include ClassUtils
+    include RestRead
+    include RestCreate
+    include RestChange
+    include RestOperations
+    include RestDelete
+
+
+    #### INITIALIZATION ####
+
+=begin
+OrientDB is conventionally initialized.
+
+
+The first call initialises database-name and -classes, server-adress and user-credentials.
+
+Subsequent initialisations are made to initialise namespaced database classes, ie.
+
+	ORD =  ActiveOrient.init.connect  database: 'temp'
+																server:  'localhost',
+																port:    2480,
+																user:   root, 
+																password: root 
+	module HC; end
+	ActiveOrient::Init.define_namespace { HC }
+	ActiveOrient::OrientDB.new  preallocate: true 
+
+
+
+
+
+=end
+
+    def initialize database: nil, preallocate: true, model_dir: nil, **defaults
+      ActiveOrient.database ||= database || 'temp'
+      ActiveOrient.database_classes ||=   Hash.new
+
+			ActiveOrient.default_server ||= { :server => defaults[:server] || 'localhost' ,
+																				:port   => defaults[:port] ||= 2480,
+																				:user   => defaults[:user].to_s ,
+																				:password => defaults[:password].to_s }
+
+      @res = get_resource 
+      connect() 
+      database_classes # initialize @classes-array and ActiveOrient.database_classes 
+			ActiveOrient::Base.logger =  logger
+      ActiveOrient::Model.orientdb = self 
+      ActiveOrient::Model.db = self 
+      ActiveOrient::Model.keep_models_without_file ||= nil
+      preallocate_classes( model_dir )  if preallocate
+
+    end
+
+    def get_resource
+      login = [ActiveOrient.default_server[:user] , ActiveOrient.default_server[:password]]
+      server_adress = "http://#{ActiveOrient.default_server[:server]}:#{ActiveOrient.default_server[:port]}"
+      RestClient::Resource.new(server_adress, *login)
+    end
+
+# Used to connect to the database
+
+    def connect
+      first_tentative = true
+      begin
+				database =  ActiveOrient.database
+        logger.progname = 'OrientDB#Connect'
+        r = @res["/connect/#{database}"].get
+        if r.code == 204
+  	      logger.info{"Connected to database #{database}"}
+  	      true
+  	    else
+  	      logger.error{"Connection to database #{database} could NOT be established"}
+  	      nil
+  	    end
+      rescue RestClient::Unauthorized => e
+        if first_tentative
+  	      logger.info{"Database #{database} NOT present --> creating"}
+  	      first_tentative = false
+  	      create_database database: database
+  	      retry
+        else
+  	      Kernel.exit
+        end
+      end
+    end
+
+  end
+end