active-orient 0.42 → 0.79

data/lib/rest/change.rb

@@ -0,0 +1,147 @@
+module RestChange
+
+  ############### DATABASE ####################
+
+# Changes the working-database to {name}
+
+  def change_database name
+    @classes = []
+    @database = name
+    ActiveOrient.database = name
+  end
+
+  ############# OBJECTS #################
+
+=begin
+  Convient update of the dataset by calling sql-patch
+
+  The argument record can be specified as ActiveOrient::Model-instance or as rid-string( #0:0 )
+  
+  called from ModelRecord#update
+
+  if the update was successful, the updated data are returned as Hash.
+
+  First the cached object is retrieved
+  Its modified by the parameters provided
+  and then patched
+
+  better would be: update the cached object and patch that. 
+=end
+
+  def update record, attributes , version=0   
+    r = ActiveOrient::Model.autoload_object record.rid 
+    return(false) unless r.is_a?(ActiveOrient::Model)
+    version = r.version if version.zero?
+    result = patch_record(r.rid) do
+      attributes.merge({'@version' => version, '@class' => r.class.ref_name })
+    end
+    # returns a new instance of ActiveOrient::Model and updates any reference on rid
+    # It's assumed, that the version 
+    # if the patch is not successfull no string is returned and thus no record is fetched
+    # JSON.parse(result) if result.is_a?(String)
+    if result.is_a?(String)
+       JSON.parse(result) # return value
+    else
+      logger.error{ "REST::Update was not successfull" }
+       nil   # returnvalue
+    end
+  end
+
+
+=begin
+Example:
+  ORD.update_documents classname, set: {:symbol => 'TWR'}, where: {con_id: 340}
+
+Replaces the symbol to TWR in each record where the con_id is 340
+
+Both set and where take multiple attributes
+
+Returns the JSON-Response.
+
+# todo: clear the rid-cache 
+=end
+
+  def update_records o_class, set:{}, where: {}, remove: nil
+		logger.progname = 'RestChange#UpdateRecords'
+		count =  execute do 
+			if set.present?
+				"UPDATE #{classname(o_class)} SET #{generate_sql_list(set)} #{compose_where(where)}"
+			elsif remove.present?
+				"UPDATE #{classname(o_class)} remove #{remove} #{compose_where(where)}"
+			end 
+		end &.first
+	rescue Exception => e
+		logger.error{e.message}
+		nil
+
+
+	end
+
+# Lazy Updating of the given Record.
+# internal using while updating  records
+  def patch_record rid	    # :nodoc:   (used by #update )
+    logger.progname = 'RestChange#PatchRecord'
+    content = yield
+    if content.is_a? Hash
+      begin
+        @res["/document/#{ActiveOrient.database}/#{rid}"].patch content.to_orient.to_json
+      rescue RestClient::InternalServerError => e
+	sentence=  JSON.parse( e.response)['errors'].last['content']
+	  logger.error{sentence}
+	  logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
+	  logger.error{e.message.to_s}
+      end
+    else
+  	  logger.error{"PATCH FAILED: The Block must provide an Hash with properties to be updated"}
+    end
+  end
+  alias patch_document patch_record
+
+
+  #### EXPERIMENTAL ##########
+
+=begin
+  Used to add restriction or other properties to the Property of a Class.
+  See http://orientdb.com/docs/2.1/SQL-Alter-Property.html
+=end
+
+  def alter_property o_class, property:, attribute: "DEFAULT", alteration:  # :nodoc: because untested
+    logger.progname = 'RestChange#AlterProperty'
+    begin
+      attribute.to_s! unless attribute.is_a? String
+      attribute.capitalize_first_letter
+      case attribute
+      when "LINKEDCLASS", "LINKEDTYPE", "NAME", "REGEX", "TYPE", "REGEX", "COLLATE", "CUSTOM"
+        unless alteration.is_a? String
+          logger.error{"#{alteration} should be a String."}
+          return 0
+        end
+      when "MIN", "MAX"
+        unless alteration.is_a? Integer
+          logger.error{"#{alteration} should be an Integer."}
+          return 0
+        end
+      when "MANDATORY", "NOTNULL", "READONLY"
+        unless alteration.is_a? TrueClass or alteration.is_a? FalseClass
+          logger.error{"#{alteration} should be an Integer."}
+          return 0
+        end
+      when "DEFAULT"
+      else
+        logger.error{"Wrong attribute."}
+        return 0
+      end
+
+      name_class = classname(o_class)
+      execute name_class, transaction: false do # To execute commands
+        [{ type: "cmd",
+          language: 'sql',
+          command: "ALTER PROPERTY #{name_class}.#{property} #{attribute} #{alteration}"}]
+      end
+    rescue Exception => e
+      logger.error{e.message}
+    end
+  end
+
+
+end

data/lib/rest/create.rb

@@ -0,0 +1,279 @@
+module RestCreate
+
+  ######### DATABASE ##########
+
+=begin
+  Creates a database with the given name and switches to this database as working-database. Types are either 'plocal' or 'memory'
+
+  Returns the name of the working-database
+=end
+
+	def create_database type: 'plocal', database: 
+		logger.progname = 'RestCreate#CreateDatabase'
+		old_d = ActiveOrient.database
+		ActiveOrient.database_classes = {} 
+		ActiveOrient.database = database 
+		begin
+			response = @res["database/#{ActiveOrient.database}/#{type}"].post ""
+			if response.code == 200
+				logger.info{"Database #{ActiveOrient.database} successfully created and stored as working database"}
+			else
+				logger.error{"Database #{ActiveOrient.database} was NOT created. Working Database is still #{ActiveOrient.database}"}
+				ActiveOrient.database = old_d
+			end
+		rescue RestClient::InternalServerError => e
+			logger.error{"Database #{ActiveOrient.database} was NOT created. Working Database is still #{ActiveOrient.database}"}
+			ActiveOrient.database = old_d
+		end
+		ActiveOrient.database  # return_value
+	end
+
+
+
+=begin
+
+This is the historic method CreateClasses. It's just performing the database-stuff and now private
+
+it takes superclass and abstract (a hash) as block
+
+usually, only one classname is provided, however the method takes a row of classnames as argument
+
+#todo reintegrate the ability to create abstract classes
+=end
+private
+def create_this_class  *db_classname  #nodoc#
+	if block_given?
+		additional_args =     yield
+		superclass = additional_args[ :superclass ]
+		abstract = additional_args[ :abstract ].presence || nil
+	else 
+		superclass = nil
+		abstract =  nil
+	end
+	#
+	command= db_classname.map do | database_class |
+		c = if superclass.present?
+					"CREATE CLASS #{database_class} EXTENDS #{superclass}" 
+				else
+					"CREATE CLASS #{database_class} "
+				end
+		c << " ABSTRACT" if abstract.present?
+	#	{ type: "cmd", language: 'sql', command: c }  # return value 4 command
+	c	
+	end
+    # execute anything as batch, don't roll back in case of an error
+
+   execute transaction: false, tolerated_error_code: /already exists/ do
+      command
+    end
+   
+  rescue ArgumentError => e
+    logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
+	rescue ActiveOrient::Error::ServerError
+		# do nothing
+  end
+
+
+public
+
+  ############## OBJECT #############
+
+
+
+=begin
+Creates a Record in the Database and returns this as ActiveOrient::Model-Instance
+
+Creates a Record with the attributes provided in the attributes-hash e.g.
+   create_record @classname, attributes: {con_id: 343, symbol: 'EWTZ'}
+
+Puts the database-response into the cache by default
+
+
+=end
+
+  def create_record o_class, attributes: {}, cache: true    # use Model#create instead
+    logger.progname = 'RestCreate#CreateRecord'
+    attributes = yield if attributes.empty? && block_given?
+    # @class must not quoted! Quote only attributes(strings)
+    post_argument = {'@class' => classname(o_class)}.merge(attributes.to_orient)
+    begin
+      response = @res["/document/#{ActiveOrient.database}"].post post_argument.to_json
+      data = JSON.parse(response.body)
+      the_object = ActiveOrient::Model.orientdb_class(name: data['@class']).new data ## return_value
+      if cache 
+	  ActiveOrient::Base.store_rid( the_object ) 
+      else
+	the_object
+      end
+    rescue RestClient::InternalServerError => e
+      sentence=  JSON.parse( e.response)['errors'].last['content']
+#      puts sentence.to_s
+      if sentence =~ /found duplicated key/
+	rid = sentence.split("#").last
+	logger.info{ "found duplicated Key --> loaded #{rid} instead of creating "}
+	## reading database content -- maybe update attributes?
+	get_record rid
+      else
+	response = JSON.parse(e.response)['errors'].pop
+	logger.error{response['content'].split(':')[1..-1].join(':')}
+	logger.error{"No Object allocated"}
+	nil # return_value
+       end
+    rescue Errno::EADDRNOTAVAIL => e
+      sleep(2)
+      retry
+    end
+  end
+  alias create_document create_record
+
+# UPDATE <class>|CLUSTER:<cluster>|<recordID>
+#   [SET|INCREMENT|ADD|REMOVE|PUT <field-name> = <field-value>[,]*]|[CONTENT|MERGE <JSON>]
+#     [UPSERT]
+#       [RETURN <returning> [<returning-expression>]]
+#         [WHERE <conditions>]
+#           [LOCK default|record]
+#             [LIMIT <max-records>] [TIMEOUT <timeout>]
+
+=begin
+update or insert one record is implemented as upsert.
+The where-condition is merged into the set-attributes if its a hash.  
+Otherwise it's taken unmodified.
+
+The method returns the included or the updated dataset
+
+## to do
+# yield works for updated and for inserted datasets
+# upsert ( ) do | what, record |
+# if what == :insert 
+#   do stuff with insert
+#   if what ==  :update
+#   do stuff with update
+# end
+# returns nil if no insert and no update was made, ie. the dataset is identical to the given attributes
+=end
+	def upsert o_class, set: , where:    #    use Model#Upsert instead
+		logger.progname = 'RestCreate#Upsert'
+		specify_return_value =  "return after @rid"
+		#			set.merge! where if where.is_a?( Hash ) # copy where attributes to set 
+		command = "Update #{classname(o_class)} set #{generate_sql_list( set ){','}} upsert #{specify_return_value}  #{compose_where where}" 
+		result = execute( tolerated_error_code: /found duplicated key/){ command }	
+	#	puts "result #{result.inspect}"
+		result =result.pop if result.is_a? Array
+	end
+  ############### PROPERTIES #############
+
+=begin
+Creates properties  
+
+and (if defined in the provided block)  associates an index
+    create_properties(classname or class, properties as hash){index}
+
+The default-case
+    create_properties(:my_high_sophisticated_database_class,
+  		con_id: {type: :integer},
+  		details: {type: :link, linked_class: 'Contracts'}) do
+  		  contract_idx: :notunique
+  		end
+
+A composite index
+    create_properties(:my_high_sophisticated_database_class,
+  		con_id: {type: :integer},
+  		symbol: {type: :string}) do
+  	    {name: 'indexname',
+  			 on: [:con_id, :details]    # default: all specified properties
+  			 type: :notunique            # default: :unique
+  	    }
+  		end
+=end
+
+	def create_properties o_class, all_properties, &b
+		logger.progname = 'RestCreate#CreateProperties'
+		all_properties_in_a_hash = Hash.new  #WithIndifferentAccess.new
+		all_properties.each{|field, args| all_properties_in_a_hash.merge! translate_property_hash(field, args)}
+		count=0
+#		puts "all_properties_in_a_hash #{all_properties_in_a_hash.to_json}"
+		begin
+			if all_properties_in_a_hash.is_a?(Hash)
+				response = @res["/property/#{ActiveOrient.database}/#{classname(o_class)}"].post all_properties_in_a_hash.to_json
+#				puts response.inspect
+				# response.body.to_i returns  response.code, only to_f.to_i returns the correct value
+				count= response.body.to_f.to_i if response.code == 201
+			end
+		rescue RestClient::InternalServerError => e
+			logger.progname = 'RestCreate#CreateProperties'
+			response = JSON.parse(e.response)['errors'].pop
+			error_message = response['content'].split(':').last
+			logger.error{"Properties in #{classname(o_class)} were NOT created"}
+			logger.error{"The Error was: #{response['content'].split(':').last}"}
+			nil
+		end
+		### index
+		if block_given?# && count == all_properties_in_a_hash.size
+			index = yield
+			if index.is_a?(Hash)
+				if index.size == 1
+					create_index o_class, name: index.keys.first, on: all_properties_in_a_hash.keys, type: index.values.first
+				else
+					index_hash =  {type: :unique, on: all_properties_in_a_hash.keys}.merge index
+					create_index o_class,  name: index_hash[:name], on: index_hash[:on], type: index_hash[:type]
+				end
+			end
+		end
+		count  # return_value
+	end
+
+=begin
+Create a single property.
+
+Supported types: https://orientdb.com/docs/last/SQL-Create-Property.html
+ 
+If an index is to be specified, it's defined in the optional block
+
+  create_property(class, field){:unique | :notunique}	                    
+  --> creates an automatic-Index on the given field
+  
+  create_property(class, field){{»name« => :unique | :notunique | :full_text}} 
+  --> creates a manual index
+=end
+
+  def create_property o_class, field, index: nil, **args, &b
+    logger.progname = 'RestCreate#CreateProperty'
+    args= { type: :string} if args.blank?  # the default case
+    c = create_properties o_class, {field => args}
+    if index.nil? && block_given?
+      index = yield
+    end
+    if index.present?
+      if index.is_a?(String) || index.is_a?(Symbol)
+	create_index o_class, name: field, type: index
+      elsif index.is_a? Hash
+	bez = index.keys.first
+	create_index o_class, name: bez, type: index[bez], on: [field]
+      end
+    end
+  end
+
+  ################# INDEX ###################
+
+# Used to create an index
+
+  def create_index o_class, name:, on: :automatic, type: :unique
+    logger.progname = 'RestCreate#CreateIndex'
+      c = classname o_class
+			if  execute( transaction: false, tolerated_error_code: /found duplicated key/) do
+				if on == :automatic
+					"CREATE INDEX #{c}.#{name} #{type.to_s.upcase}"
+				elsif on.is_a? Array
+					"CREATE INDEX #{name} ON #{c}(#{on.join(', ')}) #{type.to_s.upcase}"
+				else
+					"CREATE INDEX #{name} ON #{c}(#{on.to_s}) #{type.to_s.upcase}"
+				end
+			end
+
+			logger.info{"Index on #{c} based on #{name} created."}
+			else
+				logger.error {"index #{name}.#{type} on  #{c}  NOT created"}
+			end
+	end
+
+end

data/lib/rest/delete.rb

@@ -0,0 +1,134 @@
+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 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:
+  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