active-orient 0.4 → 0.5

data/lib/class_utils.rb

@@ -0,0 +1,301 @@
+module ClassUtils
+  # ClassUitils is included in Rest- and Java-Api-classes
+
+=begin
+  Returns a valid database-class name, nil if the class does not exists
+=end
+
+  def classname name_or_class  # :nodoc:
+    name = case  name_or_class
+	when ActiveOrient::Model
+              name_or_class.class.ref_name
+	when Class
+              name_or_class.ref_name
+#	      name_or_class.to_s.split('::').last
+	else
+	  name_or_class.to_s #.to_s.camelcase # capitalize_first_letter
+    end
+    ## 16/5/31  : reintegrating functionality to check wether the classname is 
+    #		  present in the database or not
+          if database_classes.include?(name)
+	             name
+	  elsif database_classes.include?(name.underscore)
+	           name.underscore
+	  else
+	     logger.progname =  'ClassUtils#Classname'
+	      logger.warn{ "Classname #{name_or_class.inspect} ://: #{name} not present in #{ActiveOrient.database}" }
+	  nil
+
+	  end
+  end
+=begin
+create a single class and provide properties as well
+
+  ORB.create_class( the_class_name as String or Symbol (nessesary) ,
+		    properties: a Hash with property- and Index-descriptions (optional)){
+		    {superclass: The name of the superclass as String or Symbol , 
+		     abstract: true|false } (optional Block provides a Hash ) }
+
+=end
+ def create_class classname, properties: nil, &b
+   the_class= create_classes( classname, &b )
+    # if multible classes are specified, don't process properties
+    # ( if multible classes need the same properties, consider a nested class-design )
+   if the_class.is_a?(Array)
+     if the_class.size == 1
+       the_class = the_class.first
+     else
+       properties =  nil
+     end
+    end
+   create_properties( the_class.ref_name , properties )  if properties.present?
+   the_class # return_value
+ end
+
+
+=begin
+AllocateClassesInRuby acts as a proxy to OrientdbClass,
+takes a classes-array as argument
+=end
+def allocate_classes_in_ruby classes  # :nodoc:
+    generate_ruby_object = ->( name, superclass, abstract ) do
+      begin
+	# if the class is prefined, use specs from get_classes
+	or_def =  get_classes('name', 'superClass', 'abstract' ).detect{|x| x['name']== name.to_s }
+	superclass, abstract = or_def.reject{|k,v| k=='name'}.values unless or_def.nil?
+#      print "GENERATE_RUBY_CLASS: #{name} / #{superclass} \n"
+	 m= ActiveOrient::Model.orientdb_class name: name,  superclass: superclass
+	 m.abstract = abstract
+	 m.ref_name = name.to_s
+      #puts "-->  #{m.object_id}"
+	 m
+      rescue NoMethodError => w
+	logger.progname = "ClassUtils#AllocateClassesInRuby"
+	logger.error{ w.message }
+	logger.error{ w.backtrace.map {|l| "  #{l}\n"}.join  }
+	nil
+#	raise
+      end 
+
+    end
+
+    superclass, abstract  = if block_given? 
+			      s =  yield
+			      if s.is_a? Hash
+				[s[:superclass],s[:abstract]]
+				else
+				  [s,false]
+			      end
+			    else
+			      [nil,false]
+			    end
+    #superclass_object = generate_ruby_object[superclass,nil,nil] if superclass.present?
+
+    consts = case classes 
+    when  Array
+      next_superclass=  superclass
+      classes.map do |singleclass|
+	if singleclass.is_a?( String) || singleclass.is_a?( Symbol)
+	next_superclass = generate_ruby_object[singleclass,superclass,abstract]
+	elsif singleclass.is_a?(Array) || singleclass.is_a?(Hash) 
+	  allocate_classes_in_ruby( singleclass){ {superclass: next_superclass, abstract: abstract}}
+	end
+      end
+    when Hash
+      classes.keys.map  do| h_superclass |
+[	generate_ruby_object[h_superclass,superclass,abstract], 
+        allocate_classes_in_ruby(classes[ h_superclass ]){{ superclass: h_superclass, abstract: abstract }} ]
+      end
+    when String, Symbol
+      generate_ruby_object[classes,superclass, abstract]
+    end
+#    consts.unshift superclass_object if superclass_object.present?  rescue [ superclass_object, consts ]
+    consts
+end
+=begin
+  Creating a new Database-Entry (where is omitted)
+  Or updating the Database-Entry (if present)
+
+  The optional Block should provide a hash with attributes (properties). These are used if a new dataset is created.
+  Based on the query specified in :where records are updated according to :set
+
+  Returns an Array of updated documents
+=end
+
+  def update_or_create_records o_class, set: {}, where: {}, **args, &b
+    logger.progname = 'ClassUtils#UpdateOrCreateRecords'
+    if where.blank?
+      [create_record(o_class, attributes: set)]
+    else
+  	  set.extract!(where.keys) if where.is_a?(Hash) # removes any keys from where in set
+  	  possible_records = get_records from: classname(o_class), where: where, **args
+    	if possible_records.empty?
+    	  if block_given?
+    	    more_where = yield   # do Preparations prior to the creation of the dataset
+          # if the block returns a Hash, it is merged into the insert_query.
+    	    where.merge! more_where if more_where.is_a?(Hash)
+    	  end
+    	  [create_record(o_class, attributes: set.merge(where))]
+    	else
+    	  possible_records.map{|doc| doc.update(set: set)} unless set.empty?
+    	end
+    end
+  end
+
+
+=begin
+  create_edge connects two vertexes
+
+  The parameter o_class can be either a class or a string
+
+  if batch is specified, the edge-statement is prepared and returned 
+  else the statement is transmitted to the database
+
+  The method takes a block as well. 
+  It must provide a Hash with :from and :to- Key's, e.g.
+  Vertex1, Vertex2 are two vertex-classes and TheEdge is an edge-class
+
+      record1 = ( 1 .. 100 ).map{ |y| Vertex1.create( testentry: y } }
+      record2 = ( :a .. :z ).map{ |y| Vertex2.create( testentry: y } }
+
+      edges = ORD.create_edge( TheEdge ) do | attributes |
+	 ('a'.ord .. 'z'.ord).map do |o| 
+	       { from: record1.find{|x| x.testentry == o },
+		 to:   record2.find{ |x| x.testentry.ord == o },
+		 attributes: attributes.merge{ key: o.chr } }
+	  end
+  or
+
+      edges = ORD.create_edge( TheEdge ) do | attributes |
+	 ('a'.ord .. 'z'.ord).map do |o| 
+	       { from: Vertex1.where( testentry:  o ).pop ,
+		 to:   Vertex2.where( testentry.ord =>  o).pop ,
+		 attributes: attributes.merge{ key: o.chr } }
+	  end
+
+  Benefits: The statements are transmitted as batch.
+
+  The pure-ruby-solution minimizes traffic to the database-server and is prefered.
+
+=end
+  def create_edge o_class, attributes: {}, from:nil, to:nil, unique: false, batch: nil  
+    logger.progname = "ClassUtils#CreateEdge"
+
+# -------------------------------
+    create_command =  -> (attr, from, to ) do
+      attr_string =  attr.blank? ? "" : "SET #{generate_sql_list attr}"
+      if from.present? && to.present? 
+      [from, to].each{|y| remove_record_from_hash y }
+      { type: "cmd",
+	  language: 'sql',
+	  command: "CREATE EDGE #{classname(o_class)} FROM #{from.to_orient} TO #{to.to_orient} #{attr_string}"
+		      }
+      end
+    end
+# -------------------------------
+
+    if block_given?
+      a =  yield(attributes)
+      command = if a.is_a? Array
+		  batch =  nil
+		  command=  a.map do | record | 
+#		  puts record.inspect
+		    this_attributes =  record[:attributes].presence || attributes
+		    create_command[ this_attributes, record[:from],  record[:to]]
+		  end
+		else
+		  this_attributes =  a[:attributes].presence || attributes
+		  command = create_command[ this_attributes, a[:from],  a[:to]]
+		end
+    elsif from.is_a?( Array ) && to.is_a?(Array)
+      command = Array.new
+      while from.size >1
+	this_attributes = attributes.is_a?(Array) ? attributes.shift : attributes
+	command << create_command[ this_attributes, from.shift, to.shift]
+      end
+    elsif from.is_a? Array
+      command = from.map{|f| create_command[ attributes, f, to] }
+    elsif to.is_a? Array
+      command = to.map{|f| create_command[ attributes, from, f] }
+#      puts "COMMAND: #{command.inspect}"
+    elsif from.present? && to.present?
+      #      if unique
+      #	wwhere = {out: from.to_orient, in: to.to_orient }.merge(attributes.to_orient)
+      #	existing_edge = get_records(from: o_class, where: wwhere)
+      #	if existing_edge.size >1 
+      #	  logger.error{ "Unique specified, but there are #{existing_edge.size} Records in the Database. returning the first"}
+      #	  command =  existing_edge.first
+      #	  batch = true
+      #	elsif existing_edge.size ==1  && existing_edge.first.is_a?(ActiveOrient::Model)
+      #	  #logger.debug {"Reusing edge #{classname(o_class)} from #{from.to_orient} to #{to.to_orient}"}
+      #	  command=  existing_edge.first
+      #	  batch= true
+      #	else
+      command = create_command[ attributes, from, to]
+      #	end
+      #	#logger.debug {"Creating edge #{classname(o_class)} from #{from.to_orient} to #{to.to_orient}"}
+      #
+    elsif from.to_orient.nil? || to.to_orient.nil? 
+      logger.error{ "Parameter :from or :to is missing"}
+    else 
+      # for or to are not set
+      return nil
+    end
+#   puts "RUNNING EDGE: #{command.inspect}"
+    if command.present?
+      begin
+	response = execute(transaction: false, tolerated_error_code: /found duplicated key/) do
+	  command.is_a?(Array) ? command.flatten.compact : [ command ]
+	end
+	if response.is_a?(Array) && response.size == 1
+	  response.pop # RETURN_VALUE
+	else
+	  response  # return value (the normal case)
+	end
+      rescue ArgumentError => e
+	puts "ArgumentError "
+	puts e.inspect
+      end  # begin
+    end
+
+  end
+=begin
+Deletes the specified vertices and unloads referenced edges from the cache
+=end
+  def delete_vertex *vertex
+    create_command =  -> do
+      { type: "cmd",
+	  language: 'sql',
+	  command: "DELETE VERTEX #{vertex.map{|x| x.to_orient }.join(',')} "
+		      }
+      end
+
+    vertex.each{|v| v.edges.each{| e | remove_record_from_hash e} }
+    execute{ create_command[] }
+  end
+
+=begin
+Deletes the specified edges and unloads referenced vertices from the cache
+=end
+  def delete_edge *edge
+    create_command =  -> do
+      { type: "cmd",
+	  language: 'sql',
+	  command: "DELETE EDGE #{edge.map{|x| x.to_orient }.join(',')} "
+		      }
+      end
+
+    edge.each do |r|
+      [r.in, r.out].each{| e | remove_record_from_hash e}
+      remove_record_from_hash r
+    end
+    execute{ create_command[] }
+  end
+
+  private
+	def remove_record_from_hash r
+	  obj= ActiveOrient::Base.get_rid(r.rid) unless r.nil?
+	  ActiveOrient::Base.remove_rid( obj ) unless obj.nil?
+	end
+
+end # module

data/lib/database_utils.rb

@@ -0,0 +1,97 @@
+module DatabaseUtils
+=begin
+returns the classes set by OrientDB
+Parameter: abstract: true|false
+if abstract: true is given, only basic classes (Abstact-Classes) are returend
+=end
+    def system_classes abstract: false
+
+  	basic=   [  "ORestricted", "OSchedule", "OTriggered", "OSequence"]
+	## "ORid" dropped in V2.2
+	extended = ["OIdentity","ORole",  "OUser", "OFunction", "_studio"]
+        if abstract
+	  basic
+	else
+	  basic + extended
+	end
+    end
+=begin
+  Returns the class_hierachy
+
+  To fetch all Vertices use:
+   class_hiearchie(base_class: 'V').flatten
+  To fetch all Edges uses:
+   class_hierachy(base_class: 'E').flatten
+
+  To retrieve the class hierarchy from Objects avoid calling classname,  because it depends on class_hierarchy.
+=end
+
+  def class_hierarchy base_class: '',  system_classes: nil
+    @all_classes = get_classes('name', 'superClass') #if requery || @all_classes.blank?
+    def fv s   # :nodoc:
+  	@all_classes.find_all{|x| x['superClass']== s}.map{|v| v['name']}
+    end
+
+    def fx v # :nodoc:
+  	  fv(v.strip).map{|x| ar = fx(x); ar.empty? ? x : [x, ar]}
+    end
+    complete_hierarchy = fx base_class.to_s
+    complete_hierarchy - system_classes()  - [ ["OIdentity", ["ORole", "OUser"]]] unless system_classes
+  end
+
+
+=begin
+  Returns an array with all names of the classes of the database
+  caches the result.
+  Parameters: include_system_classes: false|true, requery: false|true
+=end
+
+  def database_classes system_classes: nil, requery: false
+    requery = true if ActiveOrient.database_classes.blank?
+    if requery
+  	  class_hierarchy system_classes: system_classes #requery: true
+  	  all_classes = get_classes('name').map(&:values).sort.flatten
+  	  ActiveOrient.database_classes = system_classes.present? ? all_classes : all_classes - system_classes()
+    end
+    ActiveOrient.database_classes
+  end
+
+  def create_vertex_class *name, properties: nil 
+#    create_class( :V ) unless database_classes.include? "V"
+    r= name.map{|n| create_class( n, properties: properties){ :V } }
+    @actual_class_hash = get_classes( 'name', 'superClass')
+ r.size == 1 ? r.pop : r
+  end
+
+  def create_edge_class *name,  properties: nil
+    # not nessesary. In V 2.2m E+V are present after creation of a database
+    #create_class( :E ) unless database_classes.include? "E"  
+    r = name.map{|n| create_class( n, properties: properties){ :E  } }
+    @actual_class_hash = get_classes( 'name', 'superClass')
+    r.size == 1 ? r.pop : r  # returns the created classes as array if multible classes are provided
+  end
+
+=begin
+Service-Method for Model#OrientdbClass
+=end
+
+  def get_db_superclass name
+    @actual_class_hash = get_classes( 'name', 'superClass') if @actual_class_hash.nil? 
+   z= @actual_class_hash.find{|x,y|  x['name'] == name.to_s }
+   z['superclass'] unless z.nil?
+
+  end
+
+=begin
+preallocate classes reads any class from the  @classes-Array and allocates adequat Ruby-Objects
+=end
+ def preallocate_classes
+   #  first fetch all non-system-classes
+#    io = class_hierarchy 
+  # allocate them and call require_model_file on each model
+    # if something goes wrong, allocate_classes_in_ruby returns nil, thus compact prevents
+    # from calling NilClass.require_model_file
+    allocate_classes_in_ruby(class_hierarchy).flatten.compact.each &:require_model_file
+ end
+
+end # module

data/lib/init.rb

@@ -0,0 +1,35 @@
+module ActiveOrient
+  module Init
+
+=begin
+Parameters: yml: hash from config.yml , namespace: Class to use as Namespace
+
+=end
+    def define_namespace  yml: {}, namespace: nil
+      ActiveOrient::Model.namespace = if namespace.present? 
+					namespace
+				      else
+					n= yml[:namespace].presence || :self
+					case n
+					when :self
+					  ActiveOrient::Model
+					when :object
+					  Object
+					when :active_orient
+					  ActiveOrient
+					end
+				      end
+      ## initialitze Edge and Vertex classes in the namespace
+#      ActiveOrient::Model.orientdb_class( name:"E", superclass: "").new
+#      ActiveOrient::Model.orientdb_class( name:"V", superclass: "").new
+  end # define namespace
+
+
+    def vertex_and_edge_class
+      ORD.create_classes 'E', 'V'
+      E.ref_name = 'E'
+      V.ref_name = 'V'
+
+    end
+  end # module Init
+end  # module ActiveOrient

data/lib/java-api.rb

@@ -0,0 +1,437 @@
+require 'orientdb'
+require_relative "database_utils.rb" #common methods without rest.specific content
+require_relative "class_utils.rb" #common methods without rest.specific content
+require_relative "orientdb_private.rb" 
+
+module OrientDB
+
+	class Document
+	  def update_attributes attributes
+	    attributes.each do |y,x| 
+	      self[ y ] =  x.to_orient
+	    end
+	  end
+	end  # class Document
+end
+
+module ActiveOrient
+#  class Date
+#     def proxy_object
+#       java.util.Date.new year, month - 1, day, 0, 0, 0 
+#     end
+#  end
+#  class DateTime
+#     def proxy_object
+#       java.util.Date.new year, month - 1, day, hour, min, sec
+#     end
+#  end
+
+  class API
+    include OrientSupport::Support
+    include DatabaseUtils
+    include ClassUtils
+    include OrientDbPrivate
+    include OrientDB
+
+    mattr_accessor :logger # borrowed from active_support
+    attr_reader :database # Used to read the working database
+
+    #### INITIALIZATION ####
+
+
+    def initialize database: nil, connect: true, preallocate: true
+      self.logger = Logger.new('/dev/stdout') unless logger.present?
+      ActiveOrient.database= database if database.present?
+      connect() if connect
+      ActiveOrient::Model.db = self 
+      preallocate_classes  if preallocate
+
+    end
+
+    def db
+      @db
+    end
+
+# Used for the connection on the server
+    #
+
+# Used to connect to the database
+
+    def connect
+      begin
+      logger.progname = 'JavaApi#connect'
+      @db  =   DocumentDatabase.connect("remote:#{ActiveOrient.default_server[:server]}/#{ActiveOrient.database}",
+					ActiveOrient.default_server[:user], ActiveOrient.default_server[:password] )
+      rescue Java::ComOrientechnologiesOrientCoreException::OConfigurationException => e
+	  logger.fatal{ e.message}
+	  logger.fatal{ "ServerAdim not implemented in ActiveOrient#JavaApi "}
+#	  OrientDB::ServerAdmin("remote:localhost").connect( default_server[:user], default_server[:password] )
+#	  OrientDB::ServerAdmin.createDatabase(@database, "document", "remote");
+#	  OrientDB::ServerAdmin.close();
+	  Kernel.exit
+      end
+      database_classes( requery:true ) # returns all allocated database_classes
+    end
+
+  
+
+    def get_classes *attributes
+      classes=  @db.metadata.schema.classes.map{|x| { 'name' => x.name , 'superClass' => x.get_super_class.nil? ? '': x.get_super_class.name } }
+      unless attributes.empty?
+	classes.map{|y| y.select{|v,_| attributes.include?(v)}}
+      else
+	classes
+      end
+
+    end
+
+
+    def create_classes classes , &b
+      consts = allocate_classes_in_ruby( classes , &b )
+
+      all_classes = consts.is_a?( Array) ? consts.flatten : [consts]
+      database_classes(requery: true)
+      selected_classes =  all_classes.map do | this_class |
+	this_class unless database_classes(requery: true).include?( this_class.ref_name ) rescue nil
+      end.compact.uniq
+      command= selected_classes.map do | database_class |
+	## improper initialized ActiveOrient::Model-classes lack a ref_name class-variable
+	next if database_class.ref_name.blank?  
+	c = if database_class.superclass == ActiveOrient::Model || database_class.superclass.ref_name.blank?
+	      puts "CREATE CLASS #{database_class.ref_name} "
+	      OClassImpl.create @db, database_class.ref_name 
+	    else
+	      puts "CREATE CLASS #{database_class.ref_name} EXTENDS #{database_class.superclass.ref_name}"
+	      OClassImpl.create @db, database_class.ref_name, superClass: database_class.superclass.ref_name 
+	    end
+      end
+
+      # update the internal class hierarchy 
+      database_classes requery: true
+      # return all allocated classes, no matter whether they had to be created in the DB or not.
+      #  keep the format of the input-parameter
+      consts.shift if block_given? && consts.is_a?( Array) # remove the first element
+      # remove traces of superclass-allocations
+      if classes.is_a? Hash
+	consts =  Hash[ consts ] 
+	consts.each_key{ |x| consts[x].delete_if{|y| y == x} if consts[x].is_a? Array  }
+      end
+      consts
+    end
+
+
+
+    def delete_class o_class
+      begin
+      logger.progname = 'JavaApi#DeleteClass'
+      @db.schema.drop_class classname(o_class)
+      rescue Java::ComOrientechnologiesOrientCoreException::OSchemaException => e
+	logger.error{ e.message }
+      end
+      database_classes requery: true 
+    end
+=begin
+  Creates properties and optional an associated index as defined  in the provided block
+    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
+supported  types:
+{
+  :bool          => "BOOLEAN",
+  :double        => "BYTE",
+  :datetime      => "DATE",
+  :float         => "FLOAT",
+  :decimal       => "DECIMAL",
+  :embedded_list => "EMBEDDEDLIST",
+  :list          => "EMBEDDEDLIST",
+  :embedded_map  => "EMBEDDEDMAP",
+  :map           => "EMBEDDEDMAP",
+  :embedded_set  => "EMBEDDEDSET",
+  :set           => "EMBEDDEDSET",
+  :int           => "INTEGER",
+  :integer       => "INTEGER",
+  :link_list     => "LINKLIST",
+  :link_map      => "LINKMAP",
+  :link_set      => "LINKSET",
+  }
+
+=end
+    def create_properties o_class, **all_properties, &b
+      logger.progname = 'JavaApi#CreateProperties'
+      ap =  all_properties
+      index =  ap.is_a?(Hash) ?  ap[:index] : nil
+      created_properties = ap.map do |property, specification | 
+	field_type = ( specification.is_a?( Hash) ?  specification[:type] : specification ).downcase.to_sym rescue :string
+	if  specification.is_a?(Hash) 
+	  the_other_class =  specification[:other_class].presence || specification[:linked_class] 
+	  other_class =	@db.get_class( the_other_class.to_sym ) if the_other_class.present?
+	  if other_class.present?
+	    @db.get_class(classname(o_class)).add property,[ field_type, other_class ], { :index => index }
+	  else
+	    @db.get_class(classname(o_class)).add property, field_type, { :index => index }
+	  end
+	end
+      end
+      if block_given?
+	attr =  yield
+	index_parameters = case attr 
+			   when String, Symbol
+			     { name: attr }
+			   when Hash
+			     { name: attr.keys.first , type: attr.values.first, on: all_properties.keys.map(&:to_s) }
+			   else
+			     nil
+			   end
+	create_index o_class, **index_parameters unless index_parameters.blank?
+      end
+      created_properties.size # return_value
+
+    end
+
+    def get_properties o_class
+      @db.get_class(classname(o_class)).propertiesMap
+    end
+
+
+
+    def create_index o_class, name:, on: :automatic, type: :unique
+      logger.progname = 'JavaApi#CreateIndex'
+      begin
+	c = @db.get_class( classname( o_class ))
+	index = if on == :automatic
+		  nil   # not implemented
+		elsif on.is_a? Array
+		  c.createIndex name.to_s, INDEX_TYPES[type],  *on
+		else
+		  c.createIndex name.to_s, INDEX_TYPES[type],  on
+		end
+      end
+    end
+    def create_record o_class, attributes: {}
+      logger.progname = 'JavaApi#CreateRecord'
+      attributes = yield if attributes.empty? && block_given?
+      new_record = insert_document( classname(o_class), attributes.to_orient )
+
+
+    end
+    alias create_document create_record
+
+    def upsert o_class, set: {}, where: {} 
+      logger.progname = 'JavaApi#Upsert'
+      if where.blank?
+	new_record = create_record(o_class, attributes: set)
+	yield new_record if block_given?	  # in case if insert execute optional block
+	new_record			  # return_value
+      else
+	specify_return_value =  block_given? ? "" : "return after @this"
+	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 =  @db.run_command command
+
+	case result
+	when  Java::JavaUtil::ArrayList
+	  update_document result[0]
+	when ActiveOrient::Model
+	  result   # just return the result
+	when String, Numeric
+	  the_record=  get_records(from: o_class, where: where, limit: 1).pop
+	  if result.to_i == 1  # one dataset inserted, block is specified
+	    yield the_record 	
+	  end
+	  the_record # return_value
+	else
+	  logger.error{ "Unexpected result form Query \n  #{command} \n Result: #{result}" }
+	end
+      end
+    end
+    def get_records raw: false, query: nil, **args
+      query = OrientSupport::OrientQuery.new(args) if query.nil?
+      logger.progname = 'JavaApi#GetRecords'
+      result =  @db.custom query.compose
+      result.map do |record|
+	update_document record
+      end
+    end
+    alias get_documents get_records
+
+# called by Model.autoload
+    def get_record rid
+      logger.progname = 'JavaApi#GetRecord'
+      rid = "#"+ rid unless rid[0]=='#'
+      record = @db.custom "select from #{rid}"
+      if record.count.zero?
+	logger.error{ "No record found for rid= #{rid}" }
+      else
+	yield( record[0] ) if block_given?
+	update_document record[0]
+      end
+    end
+    alias get_document get_record
+
+=begin
+executes a command as sql-query
+
+
+=end
+    def execute transaction: true, tolerated_error_code: nil , process_error: true# Set up for classes
+      batch = {transaction: transaction, operations: yield}
+
+      logger.progname= "Execute"
+      unless batch[:operations].blank?
+	unless batch[:operations].is_a? Array
+	  batch[:operations] = [batch[:operations]] 	
+	  was_array =  true
+	else
+	  was_array =  false
+	end
+	answer = batch[:operations].map do |command_record|
+	  return if command_record.blank? 
+	  begin
+	  response = @db.run_command  command_record.is_a?(Hash) ?  command_record[:command] : command_record 
+	  rescue Java::ComOrientechnologiesOrientCoreStorage::ORecordDuplicatedException => e
+#	    puts e.inspect
+#	    puts "GetMESSAGE: "+e.getMessage.split(/\r/).first
+#	    puts "GetComponentName: "+e.getComponentName.to_s
+#	    puts  e.getMessage =~ tolerated_error_code
+#	    puts "----"
+	    if tolerated_error_code.present? &&  e.getMessage =~ tolerated_error_code
+	      logger.info{ "tolerated_error::#{ e.get_message.split(/\r/).first }"}
+	      next
+	    else
+#	    if process_error
+	      logger.progname = 'JavaApi#Execute'
+	      logger.error{ e }
+#	    else 
+#	      puts e.inspect
+#	      raise ArgumentError, e, caller
+	    end
+	  end
+	  if response.is_a? Fixnum
+	    response
+	  else
+	    response.map do | r |
+	      if r.is_a? Document
+		if r.rid.rid? 
+		  update_document r 
+		else
+		  ActiveOrient::Model.orientdb_class( name: 'query').new  r
+		end
+	      else 
+		puts "Strange things happen in execute: #{r.inspect}"
+		r.values
+	      end
+	    end  # map response
+	  end	#  branch response_is_a
+	end	# map batch
+	answer.pop if answer.size==1 && answer.first.is_a?(Array)
+      end	# unless
+    end
+
+
+    def delete_record  *object_or_rid
+      object_or_rid.map do |o|
+	d= case o
+	   when  String 
+	     @db.custom "select from #{o}" if o.rid?
+	   when  ActiveOrient::Model
+	     @db.custom "select from #{o.to_orient}"
+	   when Array
+	     o.map{|y| delete_record y }
+	     return o
+	   else
+	     o
+	   end
+	if d.is_a? Java::ComOrientechnologiesOrientCoreSqlQuery::OConcurrentResultSet
+	  d.each &:delete      
+	else
+	  logger.progname = 'JavaApi#DeleteRecord'
+	  logger.error{ "Removal Failed: #{d.inspect} " }
+	end
+      end
+    end
+
+=begin
+Transfer changes in attributes to document first and save the document
+No SQL involved 
+=end
+
+    def update rid, attributes=nil, version=nil
+      record = ActiveOrient::Model.autoload_object rid.rid
+      record.document.update_attributes attributes if attributes.present?
+      record.document.save
+      record.attributes.merge! attributes if attributes.present?
+      record # return_value
+    end
+
+#      old code
+#      get_record( rid.rid ) do | db_obj |
+#	db_obj.update_attributes attributes
+##	puts db_obj.inspect
+#	db_obj.save
+#      end if rid.rid.present?
+#    end
+
+
+    
+#private   
+
+    def insert_document o_class, attributes
+      logger.progname = 'JavaApi#InsertDocument'
+      d = Document.new  classname(o_class)
+      d.update_attributes attributes
+      d.save
+      ActiveOrient::Model.get_model_class(o_class).new  d
+    rescue Java::ComOrientechnologiesOrientCoreException::ODatabaseException => e
+      logger.fatal{ "Insert failed => #{d.inspect}"}
+      logger.error{ "Parameter: Class: #{classname(o_class)} attributes: #{attributes.inspect}" }
+      logger.fatal{ e }
+    rescue Java::ComOrientechnologiesOrientCoreException::OSchemaException => e
+      logger.error{ e }
+
+      logger.error{ "Parameter: DB: #{@db.name}, Class: #{classname(o_class)} attributes: #{attributes.inspect}" }
+      logger.error{ database_classes.inspect }
+    end
+    #  returns a valid model-instance
+    def update_document java_document
+      if java_document.is_a? Document
+	o_class =  java_document.class_name
+	java_document.save
+	d =  java_document
+	ActiveOrient::Model.get_model_class(o_class).new  java_document
+      else
+	logger.progname = 'JavaApi#UpdateDocument'
+	logger.error{ "Wrong Parameter: #{java_document.inspect} "}
+      end
+    end  #def
+
+
+    def manipulate_relation record,  method, array, items
+      java_document = record.document
+      method =  method.to_s.downcase.to_sym
+      case method 
+      when :add
+	items.each{|x| java_document[array] << x}
+      when :remove
+	items.each{|x| java_document[array].delete x}
+      else
+
+      end
+	java_document.save
+    end
+  end
+end