active-orient 0.5 → 0.6

data/gratefuldeadconcerts.md

@@ -0,0 +1,94 @@
+# Experiments with the GratefuldDeadConcterts database
+
+First modify the database-entry (development) in /config/connect.yml to  «GreatfulDeadConerts».
+This should be present after the installation of the database
+Then execute « ./bin/active-orient-console d »
+```
+Present Classes (Hierarchy) 
+  ---
+  - - E
+  - - followed_by
+  - sung_by
+  - written_by
+  - V
+
+  Active Classes  ->  ActiveOrient ClassName
+  ---------------------------------------------
+  V ->  V
+  E ->  E
+  followed_by ->  FollowedBy
+  sung_by ->  SungBy
+  written_by ->  WrittenBy
+  ---------------------------------------------
+```
+
+Lets start with simple queries
+
+* Select all vertices (or object) in the database
+
+```ruby
+V.all
+```
+
+* Select the vertex with the id #9:8
+```ruby
+V.autoload_object '#9:8'
+```
+
+* Select all the artists
+
+```ruby
+V.where type: 'artist'
+```
+
+* Select all the songs that have been performed  10 times 
+
+Display songnames and authors
+
+
+```ruby
+song_10 = V.where type: 'song', performances:  10
+song_10.name
+=> ["TOMORROW IS FOREVER", "SHE BELONGS TO ME", "UNBROKEN CHAIN"]
+song_10.out_written_by.in.name 
+=> [["Dolly_Parton"], ["Bob_Dylan"], ["Petersen"]]
+```
+* Select all the songs that have been performed  more or less 10 times 
+
+```ruby
+V.where "type = 'song’ and performances > 10"
+V.where "type = 'song’ and performances < 10"
+```
+* Count all songs and artists
+
+```ruby
+V.count where: { type: 'song' }
+V.count where: { type: 'song', performances:  10 }
+
+V.count where: { type: 'artist' }
+```
+
+
+* Find all songs sung by the first artist 
+ 
+First get the artist
+```ruby
+ first_artist = OrientSupport::OrientQuery.new from: artist_vertex, where: { type: 'artist'} , limit: 1
+ first_artist.to_s => "select  from V where type = 'artist'  limit 1"
+```
+Traverse through the database. List any song and author that is sung by this artist
+
+```ruby
+songs = DB.execute{ "select expand(set(in('sung_by'))) from (#{first_artist.to_s}) " }
+songs.name
+==> ["ROSA LEE MCFALL", "ROW JIMMY", "THAT WOULD BE SOMETHING", "BETTY AND DUPREE", "WHISKEY IN THE JAR", ...]
+
+authors = DB.execute{ "select expand(set(in('sung_by').out('written_by'))) from (#{first_artist.to_s}) " }
+authors.name
+==>  ["Bob_Dylan", "Chuck_Berry", "Unknown", "Bernie_Casey_Pinkard", ...]
+
+```
+
+go [Back](./README.md) to the introduction page
+
+

data/lib/active-orient.rb

@@ -1,7 +1,7 @@
 
 module OrientDB
   UsingJava = RUBY_PLATFORM == 'java' ?  true : false
-  unless RUBY_PLATFORM == 'java'
+  unless UsingJava
    DocumentDatabase       = nil
    DocumentDatabasePool   = nil
    DocumentDatabasePooled = nil
@@ -26,12 +26,14 @@ module OrientDB
    # RecordSet             = nil
   end
 end  # module OrientDB
+require 'active_model'
+#require 'active_model/serializers'
 require_relative "support.rb"
 require_relative "base.rb"
 require_relative "base_properties.rb"
 require_relative "orient.rb"
 #require_relative "query.rb"
-if RUBY_PLATFORM == 'java'
+if OrientDB::UsingJava
   require_relative 'java-api.rb'
   end
 require_relative "orientdb_private.rb" # manage private functions

data/lib/base.rb

@@ -1,5 +1,5 @@
 module  ActiveOrient
-  require 'active_model'
+
 
 # Base class for tableless IB data Models, extends ActiveModel API
 
@@ -8,7 +8,7 @@ module  ActiveOrient
     extend ActiveModel::Callbacks
     include ActiveModel::Validations
     include ActiveModel::Serialization
-    include ActiveModel::Serializers::Xml
+#    include ActiveModel::Serializers::Xml
     include ActiveModel::Serializers::JSON
     include OrientDB
 
@@ -41,6 +41,10 @@ module  ActiveOrient
       @@rid_store[rid] 
     end
 
+    def self.reset_rid_store
+      @@rid_store = Hash.new
+    end
+
     def self.store_rid obj
       if obj.rid.present? && obj.rid.rid?
 	  # return the presence of a stored object as true by the block
@@ -104,16 +108,26 @@ The model instance fields are then set automatically from the opts Hash.
 	  end
 
 	  if @metadata[:fieldTypes ].present? && (@metadata[:fieldTypes] =~ /=g/)
+	    @metadata[:edges] = { :in => [], :out => [] }
 	    edges = @metadata['fieldTypes'].split(',').find_all{|x| x=~/=g/}.map{|x| x.split('=').first}
+	  #  puts "Detected EDGES: #{edges.inspect}"
 	    edges.each do |edge|
 	      operator, *base_edge = edge.split('_')
 	      base_edge = base_edge.join('_')
-	      unless self.class.instance_methods.detect{|x| x == base_edge}
-		## define two methods: out_{Edge}/in_{Edge} -> edge.
-		self.class.define_property base_edge, nil
-		self.class.send :alias_method, base_edge.underscore, edge
-	      end
+	      @metadata[:edges][operator.to_sym] << base_edge
 	    end
+	  #    unless self.class.instance_methods.detect{|x| x == base_edge}
+	  #      ## define two methods: out_{Edge}/in_{Edge} -> edge.
+	  #      self.class.define_property base_edge, nil
+	  #      allocate_edge_method = -> (edge)  do
+	  #        unless (ee=db.get_db_superclass(edge)) == "E"
+	  #          allocate_edge_method[ee]
+	  #          self.class.send :alias_method, base_edge.underscore, edge
+	  #      ## define inherented classes, tooa
+	  #      
+
+	  #    end
+	  #  end
 	  end
 	end
 	self.attributes = attributes # set_attribute_defaults is now after_init callback
@@ -132,6 +146,19 @@ The model instance fields are then set automatically from the opts Hash.
       attrs.keys.each{|key| self.send("#{key}=", attrs[key])}
     end
 
+    def my_metadata key: nil, symbol: nil
+      if @metadata[:fieldTypes].present?  
+	meta= Hash[ @metadata['fieldTypes'].split(',').map{|x| x.split '='} ]
+	if key.present?
+	  meta[key.to_s]
+	elsif symbol.present?
+	  meta.map{|x,y| x if y == symbol.to_s }.compact
+	else
+	  meta
+	end
+      end
+    end
+
 =begin
   ActiveModel-style read/write_attribute accessors
   Autoload mechanism and data conversion are defined in the method "from_orient" of each class
@@ -139,8 +166,12 @@ The model instance fields are then set automatically from the opts Hash.
 
     def [] key
       iv = attributes[key.to_sym]
-      if @metadata[:fieldTypes].present? && @metadata[:fieldTypes].include?(key.to_s+"=t")
+#      puts my_metadata( key: key) 
+       if my_metadata( key: key) == "t"
+#	puts "time detected"
 	iv =~ /00:00:00/ ? Date.parse(iv) : DateTime.parse(iv)
+      elsif my_metadata( key: key) == "x"
+	iv = ActiveOrient::Model.autoload_object iv
       elsif iv.is_a? Array
 	  OrientSupport::Array.new( work_on: self, work_with: iv.from_orient){ key.to_sym }
      elsif iv.is_a? Hash
@@ -154,9 +185,11 @@ The model instance fields are then set automatically from the opts Hash.
     end
 
     def []= key, val
+#      puts "here I am: #{key}, #{val}"
       val = val.rid if val.is_a?( ActiveOrient::Model ) && val.rid.rid?
       attributes[key.to_sym] = case val
 			       when Array
+#				 puts "I am an Array"
 				 if val.first.is_a?(Hash)
 				   v = val.map do |x|
 				     if x.is_a?(Hash)
@@ -194,20 +227,20 @@ The model instance fields are then set automatically from the opts Hash.
 
 # ActiveRecord::Base association API mocks
 #
-#    def self.belongs_to model, *args
-#      attr_accessor model
-#    end
+    def self.belongs_to model, *args
+      attr_accessor model
+    end
 #
-#    def self.has_one model, *args
-#      attr_accessor model
-#    end
+    def self.has_one model, *args
+      attr_accessor model
+    end
 #
-#    def self.has_many models, *args
-#      attr_accessor models
-#      define_method(models) do
-#        self.instance_variable_get("@#{models}") || self.instance_variable_set("@#{models}", [])
-#      end
-#    end
+    def self.has_many models, *args
+      attr_accessor models
+      define_method(models) do
+        self.instance_variable_get("@#{models}") || self.instance_variable_set("@#{models}", [])
+      end
+    end
 #
 #    def self.find *args
 #      []

data/lib/base_properties.rb

@@ -54,8 +54,7 @@ module ActiveOrient
 # Default attributes support
 
     def default_attributes
-      {:created_at => Time.now,
-       :updated_at => Time.now}
+      {:created_at => DateTime.now }
     end
 
     def set_attribute_defaults # :nodoc:
@@ -138,7 +137,7 @@ module ActiveOrient
       end
 
       unless defined?(ActiveRecord::Base) && ancestors.include?(ActiveRecord::Base)
-        prop :created_at, :updated_at
+        prop :created_at #, :updated_at
       end
 
     end # included

data/lib/class_utils.rb

@@ -13,7 +13,7 @@ module ClassUtils
               name_or_class.ref_name
 #	      name_or_class.to_s.split('::').last
 	else
-	  name_or_class.to_s #.to_s.camelcase # capitalize_first_letter
+	  name_or_class.to_s.split(':').last #.to_s.camelcase # capitalize_first_letter
     end
     ## 16/5/31  : reintegrating functionality to check wether the classname is 
     #		  present in the database or not
@@ -60,10 +60,10 @@ takes a classes-array as argument
 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
+	# if the class is predefined, 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"
+      #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
@@ -109,7 +109,6 @@ def allocate_classes_in_ruby classes  # :nodoc:
     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

data/lib/database_utils.rb

@@ -27,9 +27,9 @@ if abstract: true is given, only basic classes (Abstact-Classes) are returend
 =end
 
   def class_hierarchy base_class: '',  system_classes: nil
-    @all_classes = get_classes('name', 'superClass') #if requery || @all_classes.blank?
+    @actual_class_hash = 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']}
+  	@actual_class_hash.find_all{|x| x['superClass']== s}.map{|v| v['name']}
     end
 
     def fx v # :nodoc:
@@ -78,20 +78,29 @@ Service-Method for Model#OrientdbClass
   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?
+   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
+ def preallocate_classes from_model_dir= nil
    #  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
+    all_classes = allocate_classes_in_ruby(class_hierarchy).flatten.compact
+    classes_with_model_files = all_classes.map do |x| 
+      success = x.require_model_file(from_model_dir) 
+      if ActiveOrient::Model.keep_models_without_file.nil? && success.nil? && ![E,V].include?(x)
+	logger.info{ "Database-Class #{x.name} is not asseccible, model file is missing "}
+       x.delete_class :only_ruby_space
+      end
+      success # return_value
+    end
+
  end
 
 end # module

data/lib/init.rb

@@ -3,11 +3,21 @@ module ActiveOrient
 
 =begin
 Parameters: yml: hash from config.yml , namespace: Class to use as Namespace
+A custom Constant can be provided via Block
 
+i.e.
+  configyml =  YAML.load_file (...)  # with an entry "namespace:" 
+  ActiveOrient.define_namespace yml: configyml 
+  #or
+  ActiveOrient.define_namespace namespace: :self | :object | :active_orient
+  #or
+  ActiveOrient.define_namespace { IB }  
 =end
-    def define_namespace  yml: {}, namespace: nil
+    def self.define_namespace  yml: {}, namespace: nil
       ActiveOrient::Model.namespace = if namespace.present? 
 					namespace
+				      elsif block_given?
+					yield
 				      else
 					n= yml[:namespace].presence || :self
 					case n

data/lib/model/edge.rb

@@ -14,7 +14,7 @@ Creates individual indices for child-classes if applied to the class itself.
   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 ]
+    create_index "#{ref_name}_idx", on: [ :in, :out ]
   end
 =begin
   Instantiate a new Edge between two Vertices 
@@ -29,20 +29,22 @@ Creates individual indices for child-classes if applied to the class itself.
   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
 
-  # 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"
+=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

data/lib/model/model.rb

@@ -47,10 +47,22 @@ Note: This function is not in ModelClass since it needs to use @@rid_store
 =begin
 Deletes the database class and removes the ruby-class 
 =end
-    def self.delete_class
-      orientdb.delete_class self
+    def self.delete_class what= :all
+      orientdb.delete_class(  self ) if what == :all  # remove the database-class
       ## namespace is defined in config/boot
-      namespace.send(:remove_const, naming_convention.to_sym)
+      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
@@ -62,6 +74,8 @@ Deletes the database class and removes the ruby-class
 #    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

data/lib/model/the_class.rb

@@ -45,20 +45,36 @@ To overwrite use
   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?
+    self.allocated_classes = HashWithIndifferentAccess.new( V: V, E: E) unless allocated_classes.present?
 
-    update_my_array = ->(s) { @s_class[s.ref_name] = s unless @s_class[s.ref_name].present? }
-    get_class =  ->(n) { @s_class[n] }
+    #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
-		   namespace.send( :const_get, superclass.to_s )
+		   extract_namespace[name].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 )
+		     extract_namespace[name].send( :const_get, get_class[superclass].to_s )
 		   else
 		     self
 		   end
@@ -68,12 +84,13 @@ To overwrite use
 	      Class.new(self)
 	    end
     # namespace is defined in config/boot
+    this_namespace =   extract_namespace[ref_name]
     name = klass.naming_convention ref_name #
-    if namespace.send :const_defined?, name
-      retrieved_class = namespace.send :const_get, name
+    if this_namespace.send :const_defined?, name
+      retrieved_class = this_namespace.send :const_get, name
     else
 
-      new_class = namespace.send :const_set, name, klass
+      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} "}
@@ -112,23 +129,27 @@ 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 
+def require_model_file  dir=nil
   logger.progname = 'ModelClass#RequireModelFile'
-  if File.exists?( ActiveOrient::Model.model_dir )
+  dir = dir.presence ||  ActiveOrient::Model.model_dir 
+  if File.exists?( 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}"
+    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 #{ ActiveOrient::Model.model_dir  } not present " }
+    logger.info{ "Directory #{ dir  } not present " }
+    nil  #return_value
   end
 rescue TypeError => e
      puts "TypeError:  #{e.message}" 
@@ -180,9 +201,28 @@ otherwise update it. It returns the freshly instantiated Objects
   end
 
   alias update_or_create_documents update_or_create_records
-  alias create_or_update_document upsert
-  alias update_or_create upsert
 
+=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
@@ -319,11 +359,11 @@ otherwise update it. It returns the freshly instantiated Objects
 
   def custom_where search_string
     q = OrientSupport::OrientQuery.new from: self, where: search_string
-    puts q.compose
+    #puts q.compose
     query_database q
   end
-  def where **attributes 
-    ##puts "ATTRIBUTES: "+attributes.inspect
+  def where *attributes 
+   ## puts "ATTRIBUTES: "+attributes.inspect
     q = OrientSupport::OrientQuery.new from: self, where: attributes
     query_database q
   end
@@ -373,20 +413,6 @@ By using subsequent »connect« and »statement« method-calls even complex Matc
   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.
@@ -424,14 +450,6 @@ By using subsequent »connect« and »statement« method-calls even complex Matc
   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 #################
 
@@ -477,4 +495,6 @@ By using subsequent »connect« and »statement« method-calls even complex Matc
     orientdb.alter_property self, property: property, attribute: attribute, alteration: alteration
   end
 
+
+  
 end