active-orient 0.4 → 0.5

data/lib/rest/delete.rb

@@ -0,0 +1,133 @@
+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 = @res["/database/#{ActiveOrient.database}"].delete
+  	  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
+  todo: remove all instances of the class
+=end
+
+  def delete_class o_class
+    cl = classname(o_class)
+    return if cl.nil?
+    logger.progname = 'RestDelete#DeleteClass'
+
+    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
+      if get_database_classes(requery: true).include?(cl)
+	logger.error{"Class #{cl} still present."}
+	logger.error{e.inspect}
+	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:
+  record =  Vertex.create_document attributes: { something: 'something' }
+  Vertex.delete_record record
+
+  records= (1..100).map{|x| Vertex.create_document attributes: { something: x } }
+  Vertex.delete_record *records
+
+  delete_records provides the removal of datasets after quering the database.
+=end
+
+  def delete_record *rid
+    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
+
+=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'
+    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
+  end
+  alias delete_documents delete_records
+
+  ################ PROPERTY #############
+
+  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
+    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,150 @@
+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
+
+
+  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_orient } " #updating}"
+      command.gsub!(/\"/,"") if it.is_a? Array
+      #puts "COMMAND:: #{command}"
+      execute_array << {type: "cmd", language: "sql", command: command}
+    end
+
+    items.each{|x| add_2_execute_array[x] }
+    r= execute{ execute_array }
+
+    if r.present?
+      case  method
+      when 'ADD'
+	items.each{|x| record.attributes[array] << x}
+      when 'REMOVE'
+	items.map{|x| record.attributes[array].delete x.is_a?(ActiveOrient::Model) ? x.rid : x}
+      else
+      end
+      record.increment_version
+    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 execute transaction: true, tolerated_error_code: nil, process_error: true, raw: nil # Set up for classes
+    batch = {transaction: transaction, operations: yield}
+    logger.progname= "Execute"
+    unless batch[:operations].blank?
+      batch[:operations] = {:type=>"cmd", :language=>"sql", :command=> batch[:operations]} if batch[:operations].is_a? String
+      batch[:operations] = [batch[:operations]] unless batch[:operations].is_a? Array
+      batch[:operations].compact!
+      # transaction is true only for multible statements
+#      batch[:transaction] = transaction & batch[:operations].size >1
+      begin
+	logger.debug{ batch[:operations].map{|y|y[:command]}.join("; ") } 
+        response = @res["/batch/#{ActiveOrient.database}"].post batch.to_json
+      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
+        logger.progname = 'RestOperations#Execute'
+	sentence=  JSON.parse( e.response)['errors'].last['content']
+	if tolerated_error_code.present? &&  e.response =~ tolerated_error_code
+	  logger.info{ "tolerated_error::#{e.message}"}
+	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 
+      end
+      if response.present? && 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
+              if x.has_key?('@class')
+                ActiveOrient::Model.orientdb_class(name: x['@class'], superclass: :find_ME ).new x
+              elsif x.has_key?('value')
+                x['value']
+              else   # create a dummy class and fill with attributes from result-set
+                ActiveOrient::Model.orientdb_class(name: 'query' ).new x
+              end
+            end
+          end.compact # return_value
+        else
+          response.body
+        end
+      else
+        nil
+      end
+    end
+  end
+
+end

data/lib/rest/read.rb

@@ -0,0 +1,150 @@
+module RestRead
+
+  ############# DATABASE #############
+
+# Returns an Array with available Database-Names as Elements
+
+  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 ################
+
+# Return a JSON of the property of a class
+
+  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 as ActiveOrient::Model::{class}
+  The argument can either be a rid (#[x}:{y}) or a link({x}:{y})
+  If no Record is found, nil is returned
+=end
+
+  def get_record rid
+    begin
+      logger.progname = 'RestRead#GetRecord'
+      if rid.rid?
+	rid = rid[1..rid.length] if rid[0]=='#'
+	response = @res["/document/#{ActiveOrient.database}/#{rid}"].get
+	raw_data = JSON.parse(response.body) #.merge( "#no_links" => "#no_links" )
+	ActiveOrient::Model.orientdb_class(name: raw_data['@class'], superclass: :find_ME).new raw_data
+      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 { "Not data found" }
+      logger.error { e.message }
+    rescue Exception => e
+      logger.error { "Something went wrong" }
+      logger.error { "RID: #{rid} - #{e.message}" }
+    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 a ActiveModel-Instance of o_class is created and returned
+=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}"
+#	  puts "URL"
+#	  puts query.compose( destination: :rest).to_s
+#	  puts url.to_s
+  	  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?
+#	      puts "RECORD:\n"+record.inspect
+	      block_given? ? yield.new(record) : ActiveOrient::Model.orientdb_class(name: 'query' ).new( record )
+	    else
+	      ActiveOrient::Model.orientdb_class(name: record['@class'], superclass: :find_ME).new record
+	    end
+	  end
+	  # returns the JSON-Object
+     
+
+    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,111 @@
+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 'cgi'
+require 'rest-client'
+
+module ActiveOrient
+
+=begin
+OrientDB performs queries to a OrientDB-Database
+The communication is based on the ActiveOrient-API.
+The OrientDB-Server is specified in config/connect.yml
+A Sample:
+ :orientdb:
+   :server: localhost
+     :port: 2480
+   :database: working-database
+   :admin:
+     :user: admin-user
+     :pass: admin-password
+=end
+
+  class OrientDB
+    include OrientSupport::Support
+    include OrientDbPrivate
+    include DatabaseUtils
+    include ClassUtils
+    include RestRead
+    include RestCreate
+    include RestChange
+    include RestOperations
+    include RestDelete
+
+    mattr_accessor :logger # borrowed from active_support
+    attr_reader :database # Used to read the working database
+
+    #### INITIALIZATION ####
+
+=begin
+  Contructor: OrientDB is conventionally initialized.
+  Thus several instances pointing to the same or different databases can coexist
+
+  A simple
+   xyz =  ActiveOrient::OrientDB.new
+  uses the database specified in the yaml-file »config/connect.yml« and connects
+   xyz = ActiveOrient::OrientDB.new database: my_fency_database
+  accesses the database »my_fency_database«. The database is created if its not existing.
+
+  *USECASE*
+   xyz =  ActiveOrient::Model.orientdb = ActiveOrient::OrientDB.new
+  initialises the Database-Connection and publishes the Instance to any ActiveOrient::Model-Object
+=end
+
+    def initialize database: nil, connect: true, preallocate: true
+      self.logger = Logger.new('/dev/stdout') unless logger.present?
+    #  self.default_server = {
+    #    :server => 'localhost',
+    #    :port => 2480,
+    #    :protocol => 'http',
+    #    :user => 'root',
+    #    :password => 'root',
+    #    :database => 'temp'
+    #  }.merge default_server.presence || {}
+    #  @res = get_resource
+      ActiveOrient.database = database if database.present?
+      @res = get_resource
+      connect() if connect
+      database_classes # initialize @classes-array
+      ActiveOrient::Model.orientdb = self 
+      ActiveOrient::Model.db = self 
+      preallocate_classes  if preallocate
+
+    end
+
+    def get_resource
+      login = [ActiveOrient.default_server[:user].to_s , ActiveOrient.default_server[:password].to_s]
+      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
+  	      retry
+        else
+  	      Kernel.exit
+        end
+      end
+    end
+
+  end
+end