active-orient 0.6 → 0.42

data/lib/jdbc.rb

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

@@ -1,55 +0,0 @@
-# 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 "#{ref_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
- #   to.reload! if to.is_a? ActiveOrient::Model
- #   from.reload! if from.is_a? ActiveOrient::Model
-    # vertices must be reloaded
-
-    new_edge # returns the created edge (or an array of created edges
-  end
-
-=begin
-Edge#delete fires a "delete edge" command to the database.
-The where statement can be empty ( "" or {}"), then all edges are removed 
-
-The rid-cache is reseted, too
-=end
-  def delete where: 
-    db.execute { "delete edge #{ref_name} #{db.compose_where(where)}" }
-    reset_rid_store
-  end
-  
-  # remove works on record-level
-  end 
-  def remove
-    db.delete_edge self
-  end
-end

data/lib/model/model.rb

@@ -1,91 +0,0 @@
-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 what= :all
-      orientdb.delete_class(  self ) if what == :all  # remove the database-class
-      ## namespace is defined in config/boot
-      ns =  namespace.to_s == 'Object' ? "" : namespace.to_s
-      ns_found = -> ( a_class ) do
-	to_compare = a_class.to_s.split(':')
-	if ns == "" && to_compare.size == 1 
-	  true
-	elsif to_compare.first == ns
-	  true
-	else
-	  false
-	end
-      end
-      self.allocated_classes.delete_if{|x,y| x == self.ref_name && ns_found[y]}  if allocated_classes.is_a?(Hash)
-      namespace.send(:remove_const, naming_convention.to_sym) if namespace.send( :const_defined?, naming_convention)
-    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 :keep_models_without_file  
-    mattr_accessor :allocated_classes
-
-#    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

@@ -1,500 +0,0 @@
-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
-    self.allocated_classes = HashWithIndifferentAccess.new( V: V, E: E) unless allocated_classes.present?
-
-    #update_my_array = ->(s) { self.allocated_classes[s.ref_name] = s unless allocated_classes[s.ref_name].present? }
-    update_my_array = ->(s) do
-      if  allocated_classes[s.ref_name].present? 
-#	puts "found ref_name: #{allocated_classes[s.ref_name]}"
-      else
-      self.allocated_classes[s.ref_name] = s 
-      end
-
-    end
-    get_class =  ->(n) { allocated_classes[n] }
-    extract_namespace = -> (n) do
-      if get_class[n].present?
-	separated_class_parts = get_class[n].to_s.split(':') 
-	separated_class_parts.size >1 ?  separated_class_parts.first.constantize :  namespace
-      else
-	namespace
-      end
-    end
-
-
-    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
-		   extract_namespace[name].send( :const_get, superclass.to_s )
-		 else
-		   superclass = orientdb.get_db_superclass( ref_name ) if superclass == :find_ME
-		   if superclass.present?
-		     extract_namespace[name].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
-    this_namespace =   extract_namespace[ref_name]
-    name = klass.naming_convention ref_name #
-    if this_namespace.send :const_defined?, name
-      retrieved_class = this_namespace.send :const_get, name
-    else
-
-      new_class = this_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  dir=nil
-  logger.progname = 'ModelClass#RequireModelFile'
-  dir = dir.presence ||  ActiveOrient::Model.model_dir 
-  if File.exists?( dir )
-    model= model.flatten.last if model.is_a?( Array )
-    filename =   dir + "/" + self.to_s.underscore + '.rb'
-    if  File.exists?(filename )
-      if load filename
-	logger.info{ "#{filename} sucessfully loaded"  }
-	self #return_value
-      else
-	logger.error{ "#{filename} load error" }
-	nil #return_value
-      end
-    else
-      logger.info{ "model-file not present: #{filename}" }
-      nil #return_value
-    end
-  else
-    logger.info{ "Directory #{ dir  } not present " }
-    nil  #return_value
-  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
-
-=begin
-Sets a value to certain attributes, overwrites existing entries, creates new attributes if nessesary
-
-  IB::Account.update_all connected: false
-  IB::Account.update_all where: "account containsText 'F'", set:{ connected: false }
-
-**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.
-=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
-  end
-
-=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
-
-
-=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
-
-
-
-  ##################### 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