active-orient 0.79 → 0.80

data/lib/model/custom.rb

@@ -14,13 +14,16 @@ The method does not accept further arguments.
 =end
   def like operation, order: 'asc'
     # remove all spaces and split the resulting word
-    p, s = operation.gsub(/\s+/, "").split("=")
+		case operation
+		when Hash
+			p,s = operation.keys.first, operation.values.first
+		else
+			p, s = operation.gsub(/\s+/, "").split("=")
+		end
     if ["%","*"].include?(s[-1])
       s.chop! 
     end
 
-    q =  OrientSupport::OrientQuery.new where: { "#{p}.left(#{s.length})" => s } ,order: { p => order }
-    query_database q
-
+    query( where: { "#{p}.left(#{s.length})" => s } ,order: { p => order }).execute
   end
 end

data/lib/model/e.rb

@@ -0,0 +1,6 @@
+class E #< ActiveOrient::Model
+      def self.naming_convention name=nil
+          name.present? ? name.upcase : ref_name.upcase
+      end
+  end
+

data/lib/model/edge.rb

@@ -1,6 +1,10 @@
 class E  < ActiveOrient::Model
   ## class methods
   class << self
+      def naming_convention name=nil
+          name.present? ? name.upcase : ref_name.upcase
+      end
+
 =begin
 Establish constrains on Edges
 
@@ -8,63 +12,103 @@ After applying this method Edges are uniq!
 
 Creates individual indices for child-classes if applied to the class itself.
 =end
-  def  uniq_index
-    create_property  :in,  type: :link, linked_class: :V
-    create_property  :out, type: :link, linked_class: :V
-    create_index "#{ref_name}_idx", on: [ :in, :out ]
-  end
+			def  uniq_index
+				create_property  :in,  type: :link, linked_class: :V
+				create_property  :out, type: :link, linked_class: :V
+				create_index "#{ref_name}_idx", on: [ :in, :out ]
+			end
 
 =begin
  Instantiate a new Edge between two Vertices 
 
+ Properties can be placed using the :set-directive or simply by adding key: value- parameter-pairs
+
+ if the creation of an edged is not possible, due to constrains (uniq_index), the already
+ connecting edge is returned 
+
+ the method is thread safe, if transaction and update_cache are set to false
 =end
-  def create from:, to: , attributes: {}, transaction:  false
-		return nil if from.blank? || to.blank?
-		statement = "CREATE EDGE #{ref_name} from #{from.to_or} to #{to.to_or}"
-		transaction = true if [:fire, :complete, :run].include?(transaction)
-		ir= db.execute( transaction: transaction ){ statement  }
-		from.reload! # get last version 
-		to.is_a?(Array)? to.each( &:reload! )  : to.reload!
-		ir
-		
-	rescue ArgumentError => e
-		logger.error{ "wrong parameters  #{keyword_arguments} \n\t\t required: from: , to: , attributes:\n\t\t Edge is NOT created"}
-  end
+			def create from:, to: , set: {}, transaction:  false, update_cache: false, **attributes
+				return nil if from.blank? || to.blank?
+				set.merge!(attributes) 
+				content =  set.empty? ? "" : "content #{set.to_orient.to_json}" 
+				statement = "CREATE EDGE #{ref_name} from #{from.to_or} to #{to.to_or} #{content}"
+				transaction = true if [:fire, :complete, :run].include?(transaction)
+				ir= db.execute( transaction: transaction, process_error: false ){ statement  }
+				if update_cache
+					from.reload! # get last version 
+					to.is_a?(Array)? to.each( &:reload! )  : to.reload!
+				end
+				to.is_a?(Array)  ? ir : ir.first   # return the plain edge, if only one is created
+			rescue RestClient::InternalServerError => e
+				sentence=  JSON.parse( e.response)['errors'].last['content']
+				if sentence =~ /found duplicated key/
+					ref_rid =  sentence.split.last.expand  # return expanded rid
+				else
+					raise
+				end
+			rescue ArgumentError => e
+				logger.error{ "wrong parameters  #{keyword_arguments} \n\t\t required: from: , to: , attributes:\n\t\t Edge is NOT created"}
+			end
 
 =begin
 Fires a "delete edge" command to the database.
 
+
 The where statement can be empty ( "" or {}"), then all edges are removed 
 
 The rid-cache is resetted
 
+
+to_do: Implement :all=> true directive
+       support from: , to: syntax
+
   :call-seq:
   delete where: 
 =end
-  def delete where:  
+			def delete where:  
 
-    db.execute { "delete edge #{ref_name} #{db.compose_where(where)}" }
-    reset_rid_store
+				db.execute { "delete edge #{ref_name} #{db.compose_where(where)}" }
+				reset_rid_store
+
+			end
+
+
+			def connect dir= "-" , **args #  arguments: direction: :both, 
+				                 #             count: 1, 
+				#                #             as: nil
+				
+				direction = case dir
+										when "-"
+											:both
+										when '->'
+											:out
+										when '<-'
+											:in
+										when Symbol
+											dir
+										end
+				args[:direction] ||= direction
+
+
+				OrientSupport::MatchConnection.new self, **args
+			end
 
-  end
-  
 	end   # class methods
 
 	###  instance methods  ###
 
 =begin
-Removes the actual ActiveOrient::Model-Edge-Object
+Deletes the actual ActiveOrient::Model-Edge-Object
 
-This method overloads the unspecified ActiveOrient::Model#remove-Method
 =end
-  def remove
-  # remove works on record-level
-    db.delete_edge self
-  end
 
+	def delete
+		db.execute{ "delete edge #{ref_name} #{rrid}" }
+	end
 	def to_human
-		displayed_attributes =  content_attributes.reject{|k,_| [:in, :out].include?(k) }
-		"<#{self.class.to_s.demodulize}[#{rrid}] -i-> ##{ attributes[:in].rid} #{displayed_attributes.to_human} -o-> #{out.rrid}>"
+		displayed_attributes =  attributes.reject{|k,_| [:in, :out].include?(k) }
+		"<#{self.class.to_s.demodulize}[#{rrid}] :.: #{ attributes[:out].rid}->#{displayed_attributes.to_human}->#{attributes[:in].rid}>"
 	end
 
 end

data/lib/model/the_class.rb

@@ -13,7 +13,7 @@ include OrientSupport::Support
 NamingConvention provides a translation from database-names to class-names.
 
 It can be overwritten to provide different conventions for different classes, eg. Vertexes or edges
-and to introduce distinct naming-conventions in differrent namespaces
+and to introduce distinct naming-conventions in different namespaces
 
 To overwrite use 
   class Model # < ActiveOrient::Model[:: ...]
@@ -59,7 +59,7 @@ Override to change its behavior
 
   def orientdb_class name:, superclass: nil  # :nodoc:    # public method: autoload_class
 
-    ActiveOrient.database_classes[name].presence || ActiveOrient::Model
+    ActiveOrient.database_classes[name.to_s].presence || ActiveOrient::Model
   rescue NoMethodError => e
     logger.error { "Error in orientdb_class: is ActiveOrient.database_classes initialized ? \n\n\n" }
     logger.error{ e.backtrace.map {|l| "  #{l}\n"}.join  }
@@ -91,7 +91,7 @@ In fact, the model-files are loaded instead of required.
 Thus, even after recreation of a class (Class.delete_class, ORD.create_class classname) 
 custom methods declared in the model files are present. 
 
-Required modelfiles are gone, if the class is destroyed. 
+If a class is destroyed (i.e. the database class is deleted), the ruby-class and its methods vanish, too.
 
 The directory specified is expanded by the namespace. The  parameter itself is the base-dir.
 
@@ -100,32 +100,52 @@ Example:
   model_dir : 'lib/model'
   searched directory: 'lib/model/hc'
 
+
+ActiveOrient::Model.modeldir is aimed to be set to the application dir. It may be a String, Pathname or
+an array of strings or pathnames. 
+
+The parameter `dir` is used internally and by gems to ensure that basic methods are loaded first. 
+
+
 =end
-	def require_model_file  the_directory = nil
-		logger.progname = 'ModelClass#RequireModelFile'
-		the_directory = Pathname( the_directory.presence ||  ActiveOrient::Model.model_dir ) rescue nil  # the_directory is a Pathname
-		return nil if the_directory.nil?
+def require_model_file  dir = nil
+	logger.progname = 'ModelClass#RequireModelFile'
+	# model-dir can either be a string or an array of string or pathnames
+	default =  [ActiveOrient::Model.model_dir].flatten
+	# access the default dir's first
+	the_directories = case dir
+										when String, Pathname
+										  default.present? ? 	[dir] + default : [dir]
+										when Array
+											default.present? ? dir + default  : dir
+										else
+											default.present? ? default : []
+										end.uniq.compact
+	the_directories.uniq.map do |raw_directory|
+		the_directory = Pathname( raw_directory )
 		if File.exists?( the_directory )
 			model= self.to_s.underscore + ".rb"
 			filename =   the_directory +  model
 			if  File.exists?(filename )
 				if load filename
-					logger.info{ "#{filename} sucessfully loaded"  }
+					logger.debug{ "#{filename} sucessfully loaded"  }
 					self #return_value
 				else
 					logger.error{ "#{filename} load error" }
 					nil #return_value
 				end
 			else
-				logger.info{ "model-file not present: #{filename}" }
+				logger.debug{ "model-file not present: #{filename}  --> skipping" }
 				nil #return_value
 			end
 		else
-			logger.info{ "Directory #{ the_directory  } not present " }
+			logger.error{ "Directory #{ the_directory  } not present " }
 			nil  #return_value
 		end
+	end.compact.present?  # return true only if at least one model-file is present
+
 	rescue TypeError => e
-		puts "TypeError:  #{e.message}" 
+		puts "THE CLASS#require_model_file -> TypeError:  #{e.message}" 
 		puts "Working on #{self.to_s} -> #{self.superclass}"
 		puts "Class_hierarchy: #{orientdb.class_hierarchy.inspect}."
 		print e.backtrace.join("\n") 
@@ -133,6 +153,12 @@ Example:
 		#
 	end
 
+
+  # creates an inherent class
+	def create_class *c
+		orientdb.create_class( *c ){ self }
+	end
+
   ########## CREATE ############
 
 =begin
@@ -140,7 +166,7 @@ Universal method to create a new record.
 It's overloaded to create specific kinds, eg. edge and vertex  and is called only for abstract classes
 
 Example:
-  ORD.create_class :test
+  V.create_class :test
   Test.create string_attribute: 'a string', symbol_attribute: :a_symbol, array_attribute: [34,45,67]
   Test.create link_attribute: Test.create( :a_new_attribute => 'new' )
 
@@ -157,49 +183,61 @@ Example:
 		end
 	end
 
+
+	# returns a OrientSupport::OrientQuery 
+	def query **args
+		OrientSupport::OrientQuery.new( **( {from: self}.merge args))
+	end
+
 =begin 
-Creates or updates a record.
+Creates or updates  records.
 Parameter: 
 - set: A hash of attributes to insert or update unconditionally
 - where: A string or hash as condition which should return just one record.
 
 The where-part should be covered with an unique-index.
 
-returns the affected record
+
+returns the affected record, if the where-condition is set properly.
+Otherwise upsert acts as »update« and returns all updated records (as array).
 =end
-  def upsert set: nil, where: 
+  def upsert set: nil, where: , **args
 		set = where if set.nil?
-    db.upsert self, set: set, where: where
+		query( **args.merge( kind: :upsert, set: set, where: where )).execute(reduce: true){|y| y[:$current].reload!}
   end
 =begin
-Sets a value to certain attributes, overwrites existing entries, creates new attributes if nessesary
+Sets a value to certain attributes, overwrites existing entries, creates new attributes if necessary
 
-  IB::Account.update_all connected: false
-  IB::Account.update_all where: "account containsText 'F'", set:{ connected: false }
+returns the count of affected records
 
-**note: By calling UpdateAll, all records of the Class previously stored in the rid-cache are removed from the cache. Thus autoload gets the updated records.
+  IB::Account.update connected: false
+  IB::Account.update where: "account containsText 'F'", set:{ connected: false }
+#	or
+  IB::Account.update  connected: false, where: "account containsText 'F'"
 =end
 
-  def update_all where: {} , set: {},  **arg
-    if where.empty?
-      set.merge! arg
-    end
-    db.update_records  self, set: set, where: where
-
-  end
-  #
-# removes a property from the collection (where given) or the entire class 
-  def remove attribute, where:{}
-    db.update_records self, remove: attribute, where: where
+  def update! where: nil , set: {},  **arg
+		query( kind: :update!, set: set.merge(arg), where: where).execute(reduce: true){|y| y[:count]}
   end
 
+	alias update_all update!
+
+
+# same as update!, but returns a list of  updated records
+	def update where:  , set: {},  **arg
+		# In OrientDB V.3 the database only returns the affected rid's 
+		# We have to update the contents manually, this is done in the execute-block
+		query( kind: :update, set: set.merge(arg), where: where).execute{|y| y[:$current].reload!}
+	end
+
 =begin
-Create a Property in the Schema of the Class and optionaly create an automatic index
+Create a Property in the Schema of the Class and optionally create an automatic index
 
 Examples:
 
-      create_property  :customer_id, type: integer, index: :unique
+      create_property  :customer_id, type: :integer, index: :unique
       create_property(  :name, type: :string ) {  :unique  }
+      create_property(  :name, type: :string ) { name: 'some_index', on: :automatic, type: :unique  }
       create_property  :in,  type: :link, linked_class: V    (used by edges)
 
 :call-seq:  create_property(field (required), 
@@ -207,7 +245,7 @@ Examples:
 			    linked_class: nil
 
 supported types: 
-	:bool         :double       :datetime     :float        :decimal      
+	:bool         :double       :datetime  = :date    :float        :decimal      
 	:embedded_list = :list      :embedded_map = :map        :embedded_set = :set          
 	:int          :integer      :link_list    :link_map     :link_set     
 
@@ -231,6 +269,7 @@ a `linked_class:` parameter can be specified. Argument is the OrientDB-Class-Con
 			:bool          => "BOOLEAN",
 			:double        => "BYTE",
 			:datetime      => "DATE",
+			:date			     => "DATE",
 			:float         => "FLOAT",
 			:decimal       => "DECIMAL",
 			:embedded_list => "EMBEDDEDLIST",
@@ -284,6 +323,25 @@ a `linked_class:` parameter can be specified. Argument is the OrientDB-Class-Con
 
 
 # Add an Index
+	#
+	# Parameters:  
+	#							name (string / symbol), 
+	#             [ on: :automatic / single Column, Array of Columns,
+	#             [ type: :unique, :nonunique, :dictionary,:fulltext, {other supported index-types} ]]
+	#
+	# Default:
+	#							on: :automatic
+	#							type: :unique
+	#
+	# Example
+	#   
+	#   ORD.create_vertex_class :pagination
+  #  	Pagination.create_property :col1 , type: :string
+	#		Pagination.create_property :col2, type: :integer
+	#		Pagination.create_property :col3, type: :string
+	#		Pagination.create_property :col4, type: :integer
+	#		Pagination.create_index :composite,  :on => [:col1, :col2, :col3], type: 'dictionary'
+
   def create_index name, **attributes
     orientdb.create_index self, name: name, **attributes
   end
@@ -291,6 +349,30 @@ a `linked_class:` parameter can be specified. Argument is the OrientDB-Class-Con
 # list all Indexes
 	def indexes
 		properties[:indexes]
+	end
+
+
+	def migrate_property property, to: , linked_class: nil, via: 'tzr983'
+		if linked_class.nil?
+			create_property  via, type: to
+		else
+			create_property  via, type: to, linked_class: linked_class
+		end
+#			my_count = query.kind(:update!).set( "#{via} = #{property} ").execute(reduce: true){|c| c[:count]}
+#			logger.info{" migrate property: #{count} records prosessed"}
+		  all.each{ |r| r.update set:{ via => r[property.to_sym] }}
+			nullify =  query.kind(:update!).set( property: nil ).execute(reduce: true){|c| c[:count]}
+#		  raise "migrate property: count of erased items( #{nullify} differs from total count (#{my_count}) " if nullify != my_count
+			db.execute{" alter property #{ref_name}.#{via} name '#{property}' "}
+			logger.info{ "successfully migrated #{property} to #{:to} " }
+
+
+
+
+
+
+
+
 	end
   ########## GET ###############
 
@@ -311,31 +393,35 @@ a `linked_class:` parameter can be specified. Argument is the OrientDB-Class-Con
 # get all the elements of the class
 
   def all
-    db.get_records from: self
+		query.execute
   end
 
 # get the first element of the class
 
-  def first where: {}
-    db.get_records(from: self, where: where, limit: 1).pop
-  end
+  def first **args
+    query( **( { order: "@rid" , limit: 1 }.merge args)).execute(reduce: true)
+	end
+   # db.get_records(from: self, where: where, limit: 1).pop
+  #end
 
 # get the last element of the class
+  def last **args
+    query( **( { order: {"@rid" => 'desc'} , limit: 1 }.merge args)).execute(reduce: true)
+	end
 
-  def last where: {}
-    db.get_records(from: self, where: where, order: {"@rid" => 'desc'}, limit: 1).pop
-  end
 # Used to count of the elements in the class
-
+# 
+	# Examples
+	#    TestClass.count where: 'last_access is NULL'  # only records where 'last_access' is not set
+	#    TestClass.count                               # all records
   def count **args
-    orientdb.count from: self, **args
+		query( **( { projection:  'COUNT(*)' }.merge args )).execute(reduce: true){|x|  x[:"COUNT(*)"]}
   end
 
 # Get the properties of the class
 
   def properties
     object = orientdb.get_class_properties self
-    #HashWithIndifferentAccess.new :properties => object['properties'], :indexes => object['indexes']
     {:properties => object['properties'], :indexes => object['indexes']}
   end
   alias get_class_properties properties
@@ -348,7 +434,7 @@ a `linked_class:` parameter can be specified. Argument is the OrientDB-Class-Con
 
 =begin
 »GetRecords« uses the REST-Interface to query the database. The alternative »QueryDatabase« submits 
-the query via Batch. 
+the query via Execute. 
 
 Both methods rely on OrientSupport::OrientQuery and its capacity to support complex query-builds.
 The method requires a hash of arguments. The following keys are supported:
@@ -357,8 +443,8 @@ The method requires a hash of arguments. The following keys are supported:
 
 SQL-Queries use »select« to specify a projection (ie. `select sum(a), b+5 as z from class where ...`)
 
-In ruby »select« is a method of enumeration. To specify anything etween »select« and »from« in the query-string
-we use  »projection«, which acceps different arguments
+In ruby »select« is a method of enumeration. To specify what to »select« from  in the query-string
+we use  »projection«, which accepts different arguments
 
     projection: a_string --> inserts the sting as it appears
     projection: an OrientSupport::OrientQuery-Object --> performs a sub-query and uses the result for further querying though the given parameters.
@@ -413,100 +499,59 @@ tested prior to the method-call. The OrientQuery-Object is then provided with th
   alias get_documents get_records
 
 
-  def custom_where search_string
-    q = OrientSupport::OrientQuery.new from: self, where: search_string
-    #puts q.compose
-    query_database q
-  end
 =begin
 Performs a query on the Class and returns an Array of ActiveOrient:Model-Records.
 
+Fall-back method, is overloaded by Vertex.where 
+
+Is aliased by »custom_where»
+
 Example:
     Log.where priority: 'high'
-    --> submited database-request: query/hc_database/sql/select from Log where priority = 'high'/-1
+    --> submitted database-request: query/hc_database/sql/select from Log where priority = 'high'/-1
     => [ #<Log:0x0000000480f7d8 @metadata={ ... },  ...
   
-Multible arguments are joined via "and" eg
+Multiple arguments are joined via "and" eg:
     Aktie.where symbol: 'TSL, exchange: 'ASX'
     ---> select  from aktie where symbol = 'TLS' and exchange = 'ASX'
 
-
-Where performs a »match-Query« that returns only links to the queries records.
-These are autoloaded (and reused from the cache). If changed database-records should  be obtained,
-custom_query should be used. It performs a "select form class where ... " query which returns  records
-instead of links.
-
-    Property.custom_where( "'Hamburg' in exchanges.label")
-
 =end
 
   def where *attributes 
-    query= OrientSupport::OrientQuery.new kind: :match, start:{ class: self.classname }
-    query.match_statements[0].where =  attributes unless attributes.empty?
-		# the block contains a result-record : 
-		#<ActiveOrient::Model:0x0000000003972e00 
-		#		@metadata={:type=>"d", :class=>nil, :version=>0, :fieldTypes=>"test_models=x"}, @d=nil, 
-		#		@attributes={:test_models=>"#29:3", :created_at=>Thu, 28 Mar 2019 10:43:51 +0000}>]
-		#		             ^...........° -> classname.pluralize
-    query_database( query, set_from: false){| record | record.is_a?(ActiveOrient::Model) ? record : record.send( self.classnamepluralize.to_sym ) }
+    q= OrientSupport::OrientQuery.new  where: attributes 
+    query_database( q)
   end
-=begin
-Performs a Match-Query
 
-The Query starts at the given ActiveOrient::Model-Class. The where-cause narrows the sample to certain 
-records. In the simplest version this can be returned:
-  
-  Industry.match where:{ name: "Communications" }
-  => #<ActiveOrient::Model::Query:0x00000004309608 @metadata={"type"=>"d", "class"=>nil, "version"=>0, "fieldTypes"=>"Industries=x"}, @attributes={"Industries"=>"#21:1", (...)}>
-
-The attributes are the return-Values of the Match-Query. Unless otherwise noted, the pluralized Model-Classname is used as attribute in the result-set.
-
-  I.match( where: { name: 'Communications' }).first.Industries
-
-is the same then
-  Industry.where name: "Communications" 
-
-  
-The Match-Query uses this result-set as start for subsequent queries on connected records.
-These connections are defined in the Block
-
-  var = Industry.match do | query |
-    query.connect :in, count: 2, as: 'Subcategories'
-    puts query.to_s  # print the query before sending it to the database
-    query            # important: block has to return the query 
-  end
-  => MATCH {class: Industry, as: Industries} <-- {} <-- { as: Subcategories }  RETURN Industries, Subcategories
+	alias custom_where where
+=begin
+QueryDatabase sends the Query directly to the database.
 
-The result-set has two attributes: Industries and Subcategories, pointing to the filtered datasets.
+The query returns a hash if a result set is expected
+  select  {something} as {result} (...) 
+leads to
+  [ { :{result}  =>  {result of query} } ]
 
-By using subsequent »connect« and »statement« method-calls even complex Match-Queries can be clearly constructed. 
+It can be modified further by passing a block, ie.
 
-=end
+  	q =  OrientSupport::OrientQuery.new( from: :base )
+		                               .projection( 'first_list[5].second_list[9] as second_list' )
+		                               .where( label: 9 )
 
-  def match where: {}
-    query= OrientSupport::OrientQuery.new kind: :match, start:{ class: self.classname }
-    query.match_statements[0].where =  where unless where.empty?
-    if block_given?
-      query_database yield(query), set_from: false
-    else
-      send :where, where
-    end
+    q.to_s  => 'select first_list[5].second_list[9] as second_list from base where label = 9 '
 
-  end
+		second_list = Base.query_database( q ){|x|  x[:second_list]}.first
 
 
-=begin
-QueryDatabase sends the Query directly to the database.
+The query returns (a list of) documents of type ActiveOrient::Model if a document is queried i.e.
 
-The result is not nessessary an Object of the Class.
+	q =  OrientSupport::OrientQuery.new  from: :base
+	q.projection  'expand( first_list[5].second_list[9])'  #note: no 'as' statement
+	result2 = Base.query_database( q ).first
+	=> #<SecondList:0x000000000284e840 @metadata={}, @d=nil, @attributes={:zobel=>9, "@class"=>"second_list"}>
+  
 
-The result can be modified further by passing a block.
-This is helpful, if a match-statement is used and the records should be autoloaded:
 
-  result = query_database(query, set_from: false){| record | record[ self.classname.pluralize ] }
 
-This autoloads (fetches from the cache/ or database) the attribute self.classname.pluralize  (taken from method: where )
-  
 
 query_database is used on model-level and submits
   select (...) from class
@@ -517,16 +562,14 @@ query_database is used on model-level and submits
 =end
 
   def query_database query, set_from: true
-    query.from self if set_from && query.is_a?(OrientSupport::OrientQuery) && query.from.nil?
-    sql_cmd = -> (command) {{ type: "cmd", language: "sql", command: command }}
-    result = db.execute do
-    query.to_s #  sql_cmd[query.to_s]
-    end
-    if block_given?
-      result.is_a?(Array)? result.map{|x| yield x } : yield(result)
-    else
-      result
-    end
+    # note: the parameter is not used anymore
+		query.from self if query.is_a?(OrientSupport::OrientQuery) && query.from.nil?
+    result = db.execute{  query.to_s  }
+		result = if block_given?
+							 result.is_a?(Array) ? result.map{|x| yield(x) } : yield(result)
+						 else
+							 result
+						 end
     if result.is_a? Array  
       OrientSupport::Array.new work_on: self, work_with: result
     else
@@ -550,11 +593,18 @@ query_database is used on model-level and submits
   alias delete_document delete_record
 
 # Query the database and delete the records of the resultset
-
-  def delete_records where: {}
-    orientdb.delete_records self, where: where
-  end
-  alias delete_documents delete_records
+# 
+# Returns the count of datasets effected
+  def delete_records where: {} , **args
+		if args[:all] == true 
+			where = {}
+		else
+			where.merge!(args) if where.is_a?(Hash)
+			return 0 if where.empty?
+		end
+    orientdb.delete_records( self, where: where   ).count
+	end
+  alias delete delete_records
 
 
 
@@ -598,7 +648,7 @@ To get their value you can do:
  See http://orientdb.com/docs/2.1/SQL-Alter-Property.html
 =end
 
-  def alter_property property:, attribute: "DEFAULT", alteration:  # :nodoc:
+  def alter_property property, attribute: "DEFAULT", alteration:  # :nodoc:
     orientdb.alter_property self, property: property, attribute: attribute, alteration: alteration
   end