orientdb4r 0.2.7 → 0.2.8

data/changelog.txt

@@ -3,6 +3,10 @@
 - 'rest-client' replaced by 'excon' for HTTP communication with Keep-Alive
 - introduced support for distributed server
 
-0.3.0 07/07/12
+0.2.8 /07/07/xx
+- changed and stabilized exception handling
+- added feature Client#create_class(:properties)
+
+0.2.7 07/07/12
 - changed design to support distributed server
 - added method Client#class_exists?

data/fstudy/flat_class_perf.rb

@@ -0,0 +1,46 @@
+require 'study_case'
+
+# This class tests performance on a simple flat class.
+class FlatClassPerf < FStudy::Case
+
+#  def db; 'perf'; end
+
+  def drop
+    client.drop_class 'User'
+  end
+  def model
+    drop
+    client.create_class 'User' do |c|
+      c.property 'username', :string, :mandatory => true
+      c.property 'name', :string, :mandatory => true
+      c.property 'admin', :boolean
+    end
+  end
+  def del
+    client.command 'DELETE FROM User'
+  end
+  def data
+    1.upto(10) do |i|
+      Orientdb4r::logger.info "...done: #{i}" if 0 == (i % 1000)
+      first_name = dg.word
+      surname = dg.word
+      begin
+        client.create_document({ '@class' => 'User', \
+                          :username => "#{first_name}.#{surname}", \
+                          :name => "#{first_name.capitalize} #{surname.capitalize}", \
+                          :admin => (0 == rand(2)) })
+      rescue Exception => e
+        Orientdb4r::logger.error e
+      end
+    end
+  end
+
+  def count
+    puts client.query 'SELECT count(*) FROM User'
+  end
+
+end
+
+c = FlatClassPerf.new
+c.run
+puts 'OK'

data/fstudy/study_case.rb

@@ -0,0 +1,87 @@
+require 'orientdb4r'
+
+module FStudy
+
+  ###
+  # This class represents a elaboration infrastructure.
+  class Case
+
+    attr_reader :dg
+
+    def initialize
+      @dg = DataGenerator.new
+    end
+
+    def db
+      'temp' # default DB is 'temp'
+    end
+    def host
+      'localhost'
+    end
+
+    def client
+      Orientdb4r.client :host => host
+    end
+
+    def watch method
+        start = Time.now
+        self.send method.to_sym
+        Orientdb4r::logger.info "method '#{method}' performed in #{Time.now - start} [s]"
+    end
+
+    def run
+      threads = []
+      thread_cnt = 1
+      thc = ARGV.select { |arg| arg if arg =~ /-th=\d+/ }
+      thread_cnt = thc[0][4..-1].to_i unless thc.empty?
+
+      if thread_cnt > 1
+        1.upto(thread_cnt) do
+          threads << Thread.new do
+            run_threaded
+          end
+        end
+      else
+        run_threaded
+      end
+      threads.each { |th| th.join }
+    end
+
+
+    private
+
+    def run_threaded
+      Orientdb4r::logger.info "started thread #{Thread.current}"
+      client.connect :database => db, :user => 'admin', :password => 'admin'
+      ARGV.each do |arg|
+        watch arg[2..-1].to_sym if arg =~ /^--\w/
+      end
+      client.disconnect
+    end
+
+  end
+
+
+  class DataGenerator
+
+    def initialize
+      @words = IO.readlines('/usr/share/dict/words')
+      0.upto(@words.size - 1) do |i|
+        word = @words[i]
+        word.strip!.downcase!
+        idx = word.index("'")
+        word = word[0..(idx - 1)] unless idx.nil?
+        @words[i] = word
+      end
+      @words.uniq!
+      Orientdb4r::logger.info "DataGenerator: #{@words.size} words"
+    end
+
+    # Gets a random word.
+    def word
+      @words[rand(@words.size)]
+    end
+
+  end
+
+end

data/fstudy/technical_feasibility.rb

@@ -0,0 +1,251 @@
+require 'study_case'
+
+# This class represents model and data for Technical Feasibility Study.
+# See here for more info:
+# https://github.com/veny/orientdb4r/wiki/Technical-Feasibility
+class TechnicalFeasibility < FStudy::Case
+
+  def db; 'perf'; end
+
+  # Dropes the document model.
+  def drop
+    classes_definition.reverse.each do |clazz|
+      client.drop_class clazz[:class]
+      puts "droped class: #{clazz[:class]}"
+    end
+  end
+
+  # Creates the document model.
+  def model
+    drop
+    classes_definition.each do |clazz|
+      class_name = clazz.delete :class
+      client.create_class(class_name, clazz)
+      puts "created class: #{class_name}"
+    end
+  end
+
+  # Deletes data.
+  def del
+    classes_definition.each do |clazz|
+      client.command "DELETE FROM #{clazz[:class]}"
+      puts "deleted from class: #{clazz[:class]}"
+    end
+  end
+
+  # Prepares data.
+  def data
+    communities = insert_communities
+    units = insert_org_units
+    users = insert_users(10000, units, communities)
+    insert_contacts(users, 7) # max pro user => ~ coeficient 4.0 pro user
+    contents = insert_contents(users, communities, 1.0) # coeficient pro user
+    insert_activities(users, communities, contents, 100) # coeficient pro user
+  end
+
+  def count
+    puts client.query 'SELECT count(*) FROM User'
+  end
+
+
+  private
+
+    def insert_communities
+      communities = [
+        { :name => 'Pianists' },
+        { :name => 'Violinists' },
+        { :name => 'Dog fanciers' },
+        { :name => 'Cat fanciers' },
+        { :name => 'Soccer fans' },
+        { :name => 'Ski fans' },
+        { :name => 'Basket fans' },
+        { :name => 'Gourmets' },
+        { :name => 'Scifi reader' },
+        { :name => 'Comic reader' }
+      ]
+
+      start = Time.now
+      communities.each do |c|
+        c['@class'] = 'Community'
+        c[:rid] = client.create_document(c)
+      end
+      puts "Created Communities: #{communities.size}, time = #{Time.now - start} [s]"
+      communities
+    end
+
+    def insert_org_units
+      units = [
+          { :name => 'BigCompany', :descendants => [ 'Automotive', 'Research', 'Infrastructure' ] },
+          { :name => 'Automotive', :descendants => [ 'Sales', 'Marketing', 'Design' ] },
+          { :name => 'Sales' },
+          { :name => 'Marketing' },
+          { :name => 'Design' },
+          { :name => 'Research', :descendants => [ 'Scientist', 'Spies' ] },
+          { :name => 'Scientist' },
+          { :name => 'Spies' },
+          { :name => 'Infrastructure', :descendants => [ 'Accounting', 'HumanResources' ] },
+          { :name => 'Accounting' },
+          { :name => 'HumanResources' , :descendants => [ 'Recruitment' ] },
+          { :name => 'Recruitment' }
+      ]
+
+      start = Time.now
+      units.each { |unit| insert_org_unit_helper(unit, units) }
+      puts "Created OrgUnits: #{units.size}, time = #{Time.now - start} [s]"
+      units
+    end
+    def insert_org_unit_helper(unit, all)
+        return if unit.include? :rid
+
+        if unit.include? :descendants
+          # recursion
+          unit[:descendants].each do |desc_name|
+            next_unit = all.select { |u| u if u[:name] == desc_name }[0]
+            insert_org_unit_helper(next_unit, all) unless next_unit.include? :rid
+          end
+        end
+
+        cloned = unit.clone
+        cloned['@class'] = 'OrgUnit'
+        cloned.delete :descendants
+
+        if unit.include? :descendants
+          descendants = []
+          unit[:descendants].each do |name|
+            descendants << all.select { |ou| ou if ou[:name] == name }[0][:rid]
+          end
+          cloned[:descendants] = descendants
+        end
+
+        rid = client.create_document(cloned)
+        unit[:rid] = rid
+    end
+
+    def insert_users(count, units, communities)
+      start = Time.now
+      users = []
+      1.upto(count) do
+        firstname = dg.word
+        surname = dg.word
+        username =  "#{firstname}.#{surname}"
+        # random distribution of Units (1) & Communities (0..3)
+        unit = units[rand(units.size)]
+        comms = []
+        0.upto(rand(4)) { |i| comms << communities[rand(communities.size)][:rid] if i > 0 }
+
+        user = { '@class' => 'User', \
+                 :username => username, \
+                 :firstname => firstname.capitalize, \
+                 :surname => surname.capitalize, \
+                 :unit => unit[:rid], \
+                 :communities => comms }
+        rid = client.create_document(user)
+        user[:rid] = rid
+        users << user
+      end
+      puts "Created Users: #{users.size}, time = #{Time.now - start} [s]"
+      users
+    end
+
+    def insert_contacts(users, max_contacts)
+      start = Time.now
+      count = 0
+      types = [:friend, :family, :coworker, :enemy]
+      0.upto(users.size - 1) do |i|
+        a = users[i]
+        0.upto(rand(max_contacts)) do
+          b = users[rand(users.size)]
+          client.create_document({'@class' => 'Contact', :a => a[:rid], :b => b[:rid], :type => rand(types.size)})
+          count += 1
+        end
+      end
+      puts "Created Contacts: #{count}, time = #{Time.now - start} [s]"
+    end
+
+    def insert_contents(users, communities, user_coef = 1.0)
+      start = Time.now
+      contents = []
+      classes = [['Article', 'body'], ['Gallery', 'description'], ['Term', 'topic']]
+      limit = (users.size * user_coef).to_i
+
+      1.upto(limit) do
+        clazz = classes[rand(classes.size)]
+        content = {'@class' => clazz[0], :title => "#{dg.word} #{dg.word}", clazz[1] => dg.word}
+        # random distribution of Users (1) & Communities (0..3)
+        content[:author] = users[rand(users.size)][:rid]
+        comms = []
+        0.upto(rand(4)) { |i| comms << communities[rand(communities.size)][:rid] if i > 0 }
+        content[:communities] = comms
+
+        rid = client.create_document(content)
+        content[:rid] = rid
+        contents << content
+      end
+      puts "Created ContentTypes: #{contents.size}, time = #{Time.now - start} [s]"
+      contents
+    end
+
+    def insert_activities(users, communities, contents, user_coef)
+      start = Time.now
+      types = [:login, :logout, :likeit, :rated, :saw, :commented]
+      limit = users.size * user_coef
+      1.upto(limit) do |i|
+        puts "... #{i}" if 0 == i % 100000
+        type = rand(types.size)
+        activity = { '@class' => 'Activity', :type => type, :stamp => (Time.now.to_i - rand(3600*23*30)) }
+        # random distribution of Users (1) & the same communities as user
+        user = users[rand(users.size)]
+        activity[:source] = user[:rid]
+        activity[:communities] = user[:communities]
+        # content
+        content = (types[type] == :login or types[type] == :logout) ? nil : contents[rand(contents.size)]
+        activity[content['@class'].downcase] = content[:rid] unless content.nil?
+
+        client.create_document(activity)
+      end
+      puts "Created Activities: #{limit}, time = #{Time.now - start} [s]"
+    end
+
+    def classes_definition
+      # TODO rdbms_id
+      [
+        { :class => 'OrgUnit', :properties => [
+            { :property => 'name', :type => :string, :mandatory => true },
+            # TODO domain
+            { :property => 'descendants',  :type => :linkset, :linked_class => 'OrgUnit' }]},
+        { :class => 'Community', :properties => [
+            { :property => 'name', :type => :string, :mandatory => true }]},
+        { :class => 'User', :properties => [
+            { :property => 'username', :type => :string, :mandatory => true },
+            { :property => 'firstname', :type => :string, :mandatory => true },
+            { :property => 'surname', :type => :string, :mandatory => true },
+            # TODO roles
+            { :property => 'unit',  :type => :link, :linked_class => 'OrgUnit', :mandatory => true },
+            { :property => 'communities',  :type => :linkset, :linked_class => 'Community' }]},
+        { :class => 'Contact', :properties => [
+            { :property => 'type', :type => :integer, :mandatory => true },
+            { :property => 'a',  :type => :link, :linked_class => 'User', :mandatory => true },
+            { :property => 'b',  :type => :link, :linked_class => 'User', :mandatory => true }]},
+        { :class => 'Content', :properties => [
+            { :property => 'title', :type => :string, :mandatory => true },
+            { :property => 'author',  :type => :link, :linked_class => 'User', :mandatory => true },
+            { :property => 'accessible_in', :type => :linkset, :linked_class => 'Community' }]},
+        { :class => 'Article', :extends => 'Content', :properties => [
+            { :property => 'body', :type => :string, :mandatory => true }]},
+        { :class => 'Gallery', :extends => 'Content', :properties => [
+            { :property => 'description', :type => :string, :mandatory => true }]},
+        { :class => 'Term', :extends => 'Content', :properties => [
+            { :property => 'topic', :type => :string, :mandatory => true }]},
+        { :class => 'Activity', :properties => [
+            { :property => 'type', :type => :integer, :mandatory => true },
+            { :property => 'stamp', :type => :integer, :mandatory => true },
+            { :property => 'source',  :type => :link, :linked_class => 'User', :mandatory => true },
+            { :property => 'communities', :type => :linkset, :linked_class => 'Community' }]}
+      ]
+    end
+
+end
+
+c = TechnicalFeasibility.new
+c.run
+puts 'OK'

data/lib/orientdb4r/client.rb

@@ -106,7 +106,7 @@ module Orientdb4r
     # Creates a new class in the schema.
     def create_class(name, options={})
       raise ArgumentError, "class name is blank" if blank?(name)
-      opt_pattern = { :extends => :optional , :cluster => :optional, :force => false }
+      opt_pattern = { :extends => :optional , :cluster => :optional, :force => false, :properties => :optional }
       verify_options(options, opt_pattern)
 
       sql = "CREATE CLASS #{name}"
@@ -117,6 +117,19 @@ module Orientdb4r
 
       command sql
 
+      # properties given?
+      if options.include? :properties
+        props = options[:properties]
+        raise ArgumentError, 'properties have to be an array' unless props.is_a? Array
+
+        props.each do |prop|
+          raise ArgumentError, 'property definition has to be a hash' unless prop.is_a? Hash
+          prop_name = prop.delete :property
+          prop_type = prop.delete :type
+          create_property(name, prop_name, prop_type, prop)
+        end
+      end
+
       if block_given?
         proxy = Orientdb4r::Utils::Proxy.new(self, name)
         def proxy.property(property, type, options={})
@@ -145,7 +158,7 @@ module Orientdb4r
       rslt = true
       begin
         get_class name
-      rescue NotFoundError
+      rescue OrientdbError
         rslt = false
       end
       rslt

data/lib/orientdb4r/node.rb

@@ -18,6 +18,12 @@ module Orientdb4r
     end
 
 
+    ###
+    # Identifies technology backgound of this node implementation.
+    def identification
+      raise NotImplementedError, 'this should be overridden by subclass'
+    end
+
     ###
     # Cleans up resources used by the node.
     def cleanup