active-orient 0.4 → 0.80

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/custom.rb

@@ -0,0 +1,29 @@
+module CustomClass
+=begin
+The REST-Interface does not work with "select from SomeClass where a_property like 'pattern%' "
+
+This is rewritten as 
+
+  SomeClass.like "name = D*", order: 'asc'
+
+The order-argument is optional, "asc" is the default.
+This Primitiv-Version only accepts the wildcards "*" and "%" at the end of the seach-string.
+The Wildcard can be omitted.
+
+The method does not accept further arguments. 
+=end
+  def like operation, order: 'asc'
+    # remove all spaces and split the resulting word
+		case operation
+		when Hash
+			p,s = operation.keys.first, operation.values.first
+		else
+			p, s = operation.gsub(/\s+/, "").split("=")
+		end
+    if ["%","*"].include?(s[-1])
+      s.chop! 
+    end
+
+    query( where: { "#{p}.left(#{s.length})" => s } ,order: { p => order }).execute
+  end
+end

data/lib/model/e.rb

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

data/lib/model/edge.rb

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

data/lib/model/model.rb

@@ -0,0 +1,134 @@
+require_relative "the_class.rb"
+require_relative "the_record.rb"
+require_relative "custom.rb"
+module ActiveOrient
+  class Model < ActiveOrient::Base
+
+    include BaseProperties
+    include ModelRecord # For objects (file: lib/record.rb)
+    extend CustomClass # for customized class-methods aka like
+    extend ModelClass # For classes
+
+=begin
+Either retrieves the object from the rid_store or loads it from the DB.
+
+Example:
+  ActiveOrient::Model.autoload_object "#00:00"
+
+
+The rid_store is updated!
+
+_Todo:_ fetch for version in the db and load the object  only if a change is detected
+
+_Note:_ This function is not located 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
+					get(rid)
+				end
+			else
+				logger.progname = "ActiveOrient::Model#AutoloadObject"
+				logger.info{"#{rid} is not a valid rid."}
+			end
+		end
+
+    ## used for active-model-compatibility
+    def persisted?
+      true
+    end
+
+
+
+=begin
+Based on the parameter rid (as "#{a}:{b}" or "{a}:{b}") the cached value is used if found.
+Otherwise the provided Block is executed, which is responsible for the allocation of a new dataset
+
+i.e.
+  ActiveOrient::Model.use_or_allocated my_rid do
+      ActiveOrient::Model.orientdb_class(name: raw_data['@class']).new raw_data
+  end
+
+=end
+  
+		def self.use_or_allocate rid
+			cached_obj =  get_rid( rid ) 
+			if cached_obj.present? 
+				cached_obj
+			else
+				yield
+			end
+		end
+
+
+   def self._to_partial_path #:nodoc:
+     @_to_partial_path ||= begin
+	element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(name))
+	collection = ActiveSupport::Inflector.tableize(name)
+	"#{collection}/#{element}".freeze
+      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 
+    # (unique on all instances)
+      class << self
+	    attr_accessor :ref_name
+	    attr_accessor :abstract
+
+			def to_or
+				ref_name.to_or
+			end
+
+
+      end
+  end
+end