active-orient 0.6 → 0.42

data/lib/rest/delete.rb

@@ -1,134 +0,0 @@
-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
-      sentence=  JSON.parse( e.response)['errors'].last['content']
-      if database_classes(requery: true).include?(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:
-  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

@@ -1,160 +0,0 @@
-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
-
-## 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
-=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"
-#    puts "batch: #{batch[:operations]}"
-    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 
-      rescue Errno::EADDRNOTAVAIL => e
-	sleep(2)
-	retry
-      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

@@ -1,150 +0,0 @@
-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 "REST_READ#GET_RECORDS.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

@@ -1,112 +0,0 @@
-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, model_dir: nil
-      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 
-      ActiveOrient::Model.keep_models_without_file ||= nil
-      preallocate_classes(model_dir)  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 database: database
-  	      retry
-        else
-  	      Kernel.exit
-        end
-      end
-    end
-
-  end
-end