active-orient 0.4 → 0.5

data/lib/jdbc.rb

@@ -0,0 +1,211 @@
+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 ActiveOrient
+
+
+  class API
+    include OrientSupport::Support
+    include DatabaseUtils
+    include ClassUtils
+    include OrientDbPrivate
+    include OrientDB
+
+    mattr_accessor :logger # borrowed from active_support
+    mattr_accessor :default_server
+    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?
+      self.default_server = {
+        :server => 'localhost',
+        :port => 2480,
+        :protocol => 'http',
+        :user => 'root',
+        :password => 'root',
+        :database => 'temp'
+      }.merge default_server.presence || {}
+      @database = database || default_server[:database]
+      @all_classes=[]
+      #puts   ["remote:#{default_server[:server]}/#{@database}",
+#					default_server[:user], default_server[:password] ]
+      connect() if connect
+#      @db  =   DocumentDatabase.connect("remote:#{default_server[:server]}/#{@database}",
+#					default_server[:user], default_server[:password] )
+      ActiveOrient::Model.api = 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
+
+      @db  =   DocumentDatabase.connect("remote:#{default_server[:server]}/#{@database}",
+					default_server[:user], default_server[:password] )
+      @classes =  get_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]
+      get_database_classes(requery: true)
+      selected_classes =  all_classes.map do | this_class |
+	this_class unless get_database_classes(requery: false).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, superClass: database_class.ref_name 
+	    end
+      end
+
+      # update the internal class hierarchy 
+      get_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
+      @db.schema.drop_class classname(o_class)
+      get_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
+=end
+
+    def create_properties o_class, **all_properties, &b
+      logger.progname = 'JavaApi#CreateProperties'
+      ap =  all_properties
+      created_properties = ap.map do |property, specification | 
+	puts "specification:  #{specification.inspect}"
+	field_type = ( specification.is_a?( Hash) ?  specification[:type] : specification ).downcase.to_sym rescue :string
+	the_other_class =  specification.is_a?(Hash) ?  specification[:other_class] : nil
+	other_class = if the_other_class.present? 
+			@db.get_class( the_other_class)
+		      end
+	index =  ap.is_a?(Hash) ?  ap[:index] : nil
+	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
+      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 = 'HavaApi#CreateRecord'
+    attributes = yield if attributes.empty? && block_given?
+    new_record = insert_document( o_class, attributes.to_orient )
+
+
+  end
+  alias create_document create_record
+
+  def insert_document o_class, attributes
+    d =  Document.create @db, classname(o_class), **attributes
+    d.save
+    ActiveOrient::Model.get_model_class(classname(o_class)).new attributes.merge( { "@rid" => d.rid,
+										  "@version" => d.version,
+										  "@type" => 'd',
+										  "@class" => classname(o_class) } )
+
+
+
+  end
+  end
+end
+

data/lib/model/edge.rb

@@ -0,0 +1,53 @@
+# to do 
+# instead of creating a class, use a module which is included on startup
+# then, after specifying the namespace and before autoaccolating the database-classes create the proper E-Base-class and include this stuff
+class E  < ActiveOrient::Model
+  ## link to the library-class
+  class << self
+=begin
+establish contrains on Edges
+
+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 "#{self.name}_idx", on: [ :in, :out ]
+  end
+=begin
+  Instantiate a new Edge between two Vertices 
+
+  The parameters »from« **or** »to« can take a list of model-records. Then subsequent edges are created.
+
+  :call-seq:
+  Model.create from:, to:,  attributes:{}
+=end
+
+
+  def create  **keyword_arguments
+    new_edge = db.create_edge self, **keyword_arguments
+    new_edge =  new_edge.pop if new_edge.is_a?( Array) && new_edge.size == 1
+    # vertices must be reloaded
+
+    new_edge # returns the created edge (or an array of created edges
+  end
+
+  # to do
+  # def delete
+  # delete an edge (as class method) 
+  # and 
+  # def remove
+  # delete an edge (as instance method)
+  #
+  def delete where: attributes
+    puts "work in progress"
+  end
+  
+  # remove works on record-level
+  end 
+  def remove
+    db.delete_edge self
+  end
+end

data/lib/model/model.rb

@@ -0,0 +1,77 @@
+require_relative "the_class.rb"
+require_relative "the_record.rb"
+
+module ActiveOrient
+  class Model < ActiveOrient::Base
+
+    include BaseProperties
+    include ModelRecord # For objects (file: lib/record.rb)
+    extend ModelClass # For classes
+
+=begin
+Example:
+  ActiveOrient::Model.autoload_object "#00:00"
+
+either retrieves the object from the rid_store or loads it from the DB.
+
+The rid_store is updated!
+
+To_do: fetch for version in the db and load the object if a change is detected
+
+Note: This function is not in ModelClass since it needs to use @@rid_store
+=end
+
+    def self.autoload_object rid
+      rid = rid[1..-1] if rid[0]=='#'
+      if rid.rid?
+	if  @@rid_store[rid].present?
+	  @@rid_store[rid]  # return_value
+	else
+	   db.get_record(rid)
+	end
+      else
+        logger.progname = "ActiveOrient::Model#AutoloadObject"
+        logger.info{"#{rid} is not a valid rid."}
+      end
+    end
+
+    ## to prevent errors when calling to_a 
+    def to_ary   # :nodoc:
+      attributes.to_a
+    end
+
+    def document  # :nodoc:
+      @d
+    end
+
+=begin
+Deletes the database class and removes the ruby-class 
+=end
+    def self.delete_class
+      orientdb.delete_class self
+      ## namespace is defined in config/boot
+      namespace.send(:remove_const, naming_convention.to_sym)
+    end
+
+    # provides an unique accessor on the Class
+    # works with a class-variable, its unique through all Subclasses
+    mattr_accessor :orientdb  # points to the instance of the REST-DB-Client used for Administration
+			      # i.e. creation and deleting of classes and databases
+    mattr_accessor :db	      # points to the instance of the Client used for Database-Queries
+    mattr_accessor :api
+#    mattr_accessor :logger  ... already inherented from ::Base
+    mattr_accessor :namespace # Namespace in which  Model records are initialized, a constant ( defined in config.yml )
+    mattr_accessor :model_dir # path to model-files
+
+#    mattr_accessor  :ref_name    
+    # Used to read the metadata
+    attr_reader :metadata
+
+    # provides an accessor at class level 
+    # its unique on all instances 
+      class << self
+	    attr_accessor :ref_name
+	    attr_accessor :abstract
+      end
+  end
+end

data/lib/model/the_class.rb

@@ -0,0 +1,480 @@
+module ModelClass
+
+  ########### CLASS FUNCTIONS ######### SELF ####
+
+
+  ######## INITIALIZE A RECORD FROM A CLASS ########
+
+
+=begin
+NamingConvention provides a translation from database-names to class-names.
+
+Should provide 
+   to_s.capitalize_first_letter
+as minimum.
+Can be overwritten to provide different conventions for different classes, eg. Vertexes or edges.
+
+To overwrite use 
+  class Model < ActiveOrient::Model[:: ...]
+    def self.naming_convention
+    ( conversion code )
+    end
+ end
+=end
+  def naming_convention name=nil  # :nodoc:
+    name.present? ? name.to_s.camelize : ref_name.camelize
+  end
+
+=begin
+  orientdb_class is used to create or refer a ActiveOrient:Model:{class} by providing its name
+
+  Parameter: name: string or symbol
+  Parameter: superclass: If class, then this is used unmodified
+			 If string or symbol, its used to reference an existing class
+			 if :find_ME, its derived from the classes-hash
+  Attention: If a class is created by orientdb_class, its only allocated in ruby-space.
+	     The class is thus not present in the classes-array, which reflects the database-classes.
+	     If a class depending on a superclass is to be created, the superclass is derived from
+	     the classes-array. In such a case, the allocation only works, if the class itself is
+	     used as parameter "superclass" 
+	     i.e.
+	     ActiveOrient::Model.orientdb_class name: 'hurra'
+	     AvtiveOrient::Model.orientdb_class name: 'hip_hip' , superclass: Hurra
+=end
+
+  def orientdb_class name:, superclass: nil   # :nodoc:    # public method: autoload_class
+    logger.progname = "ModelClass#OrientDBClass"
+    # @s-class is a cash for actual String -> Class relations
+    @s_class = HashWithIndifferentAccess.new( V: V, E: E) unless @s_class.present?
+
+    update_my_array = ->(s) { @s_class[s.ref_name] = s unless @s_class[s.ref_name].present? }
+    get_class =  ->(n) { @s_class[n] }
+
+
+    ref_name =  name.to_s
+    klass = if superclass.present?   # superclass is parameter, use if class, otherwise transfer to class
+	      s= if superclass.is_a? Class
+		   namespace.send( :const_get, superclass.to_s )
+		 else
+		   superclass = orientdb.get_db_superclass( ref_name ) if superclass == :find_ME
+		   if superclass.present?
+		     namespace.send( :const_get, get_class[superclass].to_s )
+		   else
+		     self
+		   end
+		 end
+	      Class.new(s)
+	    else
+	      Class.new(self)
+	    end
+    # namespace is defined in config/boot
+    name = klass.naming_convention ref_name #
+    if namespace.send :const_defined?, name
+      retrieved_class = namespace.send :const_get, name
+    else
+
+      new_class = namespace.send :const_set, name, klass
+      new_class.ref_name =  ref_name
+      update_my_array[new_class]
+#      logger.debug{"created:: Class #{new_class} < #{new_class.superclass} "}
+#      logger.debug{"database-table:: #{ref_name} "}
+      new_class # return_value
+    end
+  rescue NameError => e
+      logger.error "ModelClass #{name.inspect} cannot be initialized."
+      logger.error e.message
+      logger.error e.backtrace.map {|l| "  #{l}\n"}.join  
+      nil  # return_value
+    #end
+  end
+=begin
+Retrieves the preallocated class derived from ActiveOrient::Model
+
+Only classes noted in the @classes-Array of orientdb are fetched.
+=end
+  def get_model_class name
+    if orientdb.database_classes.include?(name)
+      orientdb_class name: name, superclass: :find_ME
+    else
+      nil
+    end
+  end
+
+
+
+=begin
+requires the file specified in the model-dir
+
+In fact, the model-files are loaded instead of required. 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, but the interpreter thinks, they have already been required. Rebuilding the 
+class does not reestablish the connection to the required model file.
+
+Actual only a flat directory is supported. However -the Parameter model has the format: [ superclass, class ]. Its possible to extend the method adress a model-tree.
+=end
+def require_model_file 
+  logger.progname = 'ModelClass#RequireModelFile'
+  if File.exists?( ActiveOrient::Model.model_dir )
+    model= model.flatten.last if model.is_a?( Array )
+    filename =   ActiveOrient::Model.model_dir + "/" + self.to_s.underscore + '.rb'
+    puts "REQUIRE_MODEL_FILE: #{self.to_s} <-- #{self.superclass}"
+    if  File.exists?(filename )
+      if load filename
+	logger.info{ "#{filename} sucessfully loaded"  }
+      else
+	logger.error{ "#{filename} load error" }
+      end
+    else
+      logger.info{ "model-file not present: #{filename}" }
+    end
+  else
+    logger.info{ "Directory #{ ActiveOrient::Model.model_dir  } not present " }
+  end
+rescue TypeError => e
+     puts "TypeError:  #{e.message}" 
+     puts "Working on #{self.to_s} -> #{self.superclass}"
+     puts "Class_hierarchy: #{orientdb.class_hierarchy.inspect}."
+     print e.backtrace.join("\n") 
+     raise
+  #
+end
+
+  ########## CREATE ############
+
+=begin
+Universal method to create a new record. 
+It's obverloaded to create specific kinds, eg. edges 
+
+Example:
+  ORD.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' )
+
+=end
+  def create **attributes
+    attributes.merge :created_at => Time.new
+    db.create_record self, attributes: attributes 
+  end
+
+=begin 
+Creates or updates a record.
+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.
+If :where is omitted, #Upsert becomes #Create, attributes are taken from :set.
+
+returns the affected record
+=end
+  def upsert set: {}, where: {}, &b
+    db.upsert self, set: set, where: where, &b
+  end
+=begin
+Create a new Instance of the Class with the applied attributes if does not exists, 
+otherwise update it. It returns the freshly instantiated Objects
+=end
+
+  def update_or_create_records set: {}, where: {}, **args, &b
+    db.update_or_create_records self, set: set, where: where, **args, &b
+  end
+
+  alias update_or_create_documents update_or_create_records
+  alias create_or_update_document upsert
+  alias update_or_create upsert
+
+
+=begin
+  Create a Property in the Schema of the Class
+    :call-seq:  Model.create_property(field (required), type:'string', linked_class: nil, index: nil) do
+    	index
+    end
+
+    Examples:
+
+      create_property  :customer_id, type: integer, index: :unique
+      create_property  :name, type: :string, index: :not_unique
+      create_property  :in,  type: :link, linked_class: :V    (used by edges)
+=end
+
+  def create_property field, **keyword_arguments, &b
+    orientdb.create_property self, field, **keyword_arguments, &b
+  end
+
+# Create more Properties in the Schema of the Class
+
+  def create_properties argument_hash, &b
+    orientdb.create_properties self, argument_hash, &b
+  end
+
+
+# Add an Index
+  def create_index name, **attributes
+    orientdb.create_index self, name: name, **attributes
+  end
+
+  ########## GET ###############
+
+  def classname  # :nodoc: #
+     ref_name
+  end
+
+# get elements by rid
+
+  def get rid
+    db.get_record rid
+  end
+
+# get all the elements of the class
+
+  def all
+    db.get_records from: self
+  end
+
+# get the first element of the class
+
+  def first where: {}
+    db.get_records(from: self, where: where, limit: 1).pop
+  end
+
+# get the last element of the class
+
+  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
+
+  def count **args
+    orientdb.count from: self, **args
+  end
+
+# Get the properties of the class
+
+  def get_properties
+    object = orientdb.get_class_properties self
+    HashWithIndifferentAccess.new :properties => object['properties'], :indexes => object['indexes']
+  end
+  alias get_class_properties get_properties
+
+# Print the properties of the class
+
+  def print_class_properties
+    orientdb.print_class_properties self
+  end
+
+=begin
+  Parameter projection:
+  »select« is a method of enumeration, we use  »projection:« to specify anything between »select« and »from« in the query-string.
+    projection: a_string --> inserts the sting as it appearsb
+    an OrientSupport::OrientQuery-Object --> performs a sub-query and uses the result for further querying though the given parameters.
+    [a, b, c] --> "a, b, c" (inserts a comma-separated list)
+    {a: b, "sum(x)" => f} --> "a as b, sum(x) as f" (renames properties and uses functions)
+
+  Parameter distinct:
+  Performs a Query like » select distinct(property) [as property] from ...«
+    distinct: :property -->  the result is mapped to the property »distinct«.
+    [:property] --> the result replaces the property
+	  {property: :some_name} -->  the result is mapped to ModelInstance.some_name
+
+  Parameter Order
+  Sorts the result-set. If new properties are introduced via select:, distinct: etc. Sorting takes place on these properties
+    order: :property {property: asc, property: desc}[property, property, ..  ](orderdirection is 'asc')
+
+  Further supported Parameter:
+    group_by
+    skip
+    limit
+    unwind
+
+  see orientdb- documentation (https://orientdb.com/docs/last/SQL-Query.html)
+
+  Parameter query:
+    Instead of providing the parameter, the OrientSupport::OrientQuery can build and tested before the method-call. The OrientQuery-Object can be provided with the query-parameter. I.e.
+      q = OrientSupport::OrientQuery.new
+      ORD.create_class :test_model
+      q.from TestModel
+      q.where {name: 'Thomas'}
+      count = TestModel.count query: q
+      q.limit 10
+      0.step(count,10) do |x|
+        q.skip = x
+        puts TestModel.get_documents(query: q).map{|x| x.adress }.join('\t')
+      end
+    prints a Table with 10 columns.
+=end
+
+  def get_records **args
+    db.get_records(from: self, **args){self}
+  end
+  alias get_documents get_records
+
+=begin
+  Performs a query on the Class and returns an Array of ActiveOrient:Model-Records.
+
+  Example:
+    Log.where priority: 'high'
+    --> submited database-request: query/hc_database/sql/select from Log where priority = 'high'/-1
+    => [ #<Log:0x0000000480f7d8 @metadata={ ... },  ...
+=end
+
+  def custom_where search_string
+    q = OrientSupport::OrientQuery.new from: self, where: search_string
+    puts q.compose
+    query_database q
+  end
+  def where **attributes 
+    ##puts "ATTRIBUTES: "+attributes.inspect
+    q = OrientSupport::OrientQuery.new from: self, 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 returnd:
+  
+  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 send to the database
+    query            # important: block has to return the query 
+  end
+  => MATCH {class: Industry, as: Industries} <-- {} <-- { as: Subcategories }  RETURN Industries, Subcategories
+
+The result-set has two attributes: Industries and Subcategories, pointing to the filtered datasets.
+
+By using subsequent »connect« and »statement« method-calls even complex Match-Queries can be clearly constructed. 
+
+=end
+
+  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
+      logger.progname = 'ActiveOrient::Model#Match'
+      logger.error{ "Query-Details have to be specified in a Block" }
+    end
+
+  end
+
+
+# Get the superclass of the class
+
+  def superClass
+    { superclass => superclass.ref_name }
+#    logger.progname = 'ActiveOrient::Model#Superclass'
+#    r = orientdb.get_classes('name', 'superClass').detect{|x|
+#      x["name"].downcase == new.class.to_s.downcase.split(':')[-1].to_s
+#    }['superClass']
+#    if r.empty?
+#      logger.info{"#{self} does not have any superclass. Probably it is a Document"}
+#    end
+#    return r
+  end
+
+=begin
+  QueryDatabase sends the Query, direct to the database.
+  The result is not nessessary an Object of self.
+  However, if the query does not return an array of Active::Model-Objects, then the entries become self
+=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 }}
+    db.execute do
+      sql_cmd[query.to_s]
+    end
+  end
+
+  ########### DELETE ###############
+
+# Delete a property from the class
+
+  def delete_property field
+    orientdb.delete_property self, field
+  end
+
+# Delete a record
+
+  def delete_record *rid
+    db.delete_record rid
+  end
+  alias delete_document delete_record
+
+# Delete a record from the class
+
+  def delete_records where: {}
+    orientdb.delete_records self, where: where
+  end
+  alias delete_documents delete_records
+
+
+  ########### UPDATE #############
+
+# Update records of a class
+
+  def update_records set:, where:
+    db.update_records self, set: set, where: where
+  end
+  alias update_documents update_records
+
+  ##################### EXPERIMENT #################
+
+=begin
+  Suppose that you created a graph where vertexes month is connected with
+  the vertexes day by the edge TIMEOF.
+  Suppose we want to find all the days in the first month and in the third month..
+
+  Usually we can do in the following way.
+
+  ORD.create_class "Month"
+  (.. put some records into Month ... )
+  firstmonth = Month.first
+  thirdmonth = month.all[2]
+  days_firstmonth = firstmonth.out_TIMEOF.map{|x| x.in}
+  days_thirdmonth = thirdmonth.out_TIMEOF.map{|x| x.in}
+
+  However we can obtain the same result with the following command
+
+  Month.add_edge_link name: "days", direction: "out", edge: TIME_OF
+  firstmonth = month.first
+  thirdmonth = month.all[2]
+  days_firstmonth = firstmonth.days
+  days_thirdmonth = thirdmonth.days
+
+  To get their value you can do:
+  thirdmonth.days.value
+=end
+
+
+  def add_edge_link name:, direction: :out, edge:
+    dir =  direction.to_s == "out" ? :out : :in
+    define_method(name.to_sym) do
+      return self["#{dir}_#{edge.classname}"].map{|x| x["in"]}
+    end
+  end
+
+=begin
+ See http://orientdb.com/docs/2.1/SQL-Alter-Property.html
+=end
+
+  def alter_property property:, attribute: "DEFAULT", alteration:
+    orientdb.alter_property self, property: property, attribute: attribute, alteration: alteration
+  end
+
+end