lore 0.4.8 → 0.9.2

data/Manifest.txt

@@ -1,7 +1,16 @@
-History.txt
-Manifest.txt
-README.txt
-Rakefile
-bin/lore
-lib/lore.rb
-test/test_lore.rb
+
+'*',                      
+'benchmark/*', 
+'spec/*', 
+'spec/fixtures/*', 
+'lib/*', 
+'lib/lore/*', 
+'lib/lore/adapters/*', 
+'lib/lore/cache/*', 
+'lib/lore/exceptions/*', 
+'lib/lore/gui/*', 
+'lib/lore/gui/templates/*', 
+'lib/lore/model/*', 
+'lib/lore/strategies/*', 
+'lib/lore/validation/*', 
+'bin/*'].to_a

data/README.rdoc

@@ -0,0 +1,91 @@
+
+Didn't have the time to write a "real" readme, but let me show you ...
+
+= A short comparison
+
+== Use Case: 
+
+  class Content < Lore::Model
+    table :contents, :public
+    primary_key :id, :content_id_seq
+  end
+
+  class Article < Lore::Model
+    table :articles, :public
+    primary_key :id, :article_id_seq
+    is_a Content, :content_id
+  end
+
+== Selecting Articles using ActiveRecord
+
+   Article.find(:all, :include => :content, 
+                :conditions => "id between 1 AND 100")
+
+== Selecting Articles using Sequel
+
+  DB[:articles].left_outer_join(:contents, :id => :content_id).filter( :articles__id => (1..100))
+
+== Selecting Articles using Lore
+
+  Article.all_with(Article.id.in(1..100))  
+
+(joins Content automatically)
+
+== Benchmark results (1000 queries each returning 100 rows)
+Most recent benchmark results from lore/benchmark/results.txt, 
+generated by running
+
+    ruby lore/benchmarks/select.rb 1000
+
+Output on my machine: 
+
+        Rehearsal ------------------------------------------------------------
+        unprocessed query          0.030000   0.030000   0.060000 (  1.269820)
+        result fetching in lore    0.400000   0.050000   0.450000 (  1.661275)
+        result parsing in lore     0.540000   0.080000   0.620000 (  3.600497)
+        ac_instances unfiltered    2.440000   0.430000   2.870000 (  4.113851)
+        ac_instances filtered      4.650000   0.700000   5.350000 (  6.601500)
+        lore select unfiltered     2.720000   0.330000   3.050000 (  4.355712) 
+        lore shortcut filtered     5.110000   0.790000   5.900000 (  7.507479)
+    --> lore shortcut unfiltered   3.030000   0.420000   3.450000 (  4.675418) <--
+    --> activerecord              15.060000   1.960000  17.020000 ( 22.098705) <--
+    --> sequel                     8.400000   0.940000   9.340000 ( 11.373551) <--
+        lore using cache           2.060000   0.080000   2.140000 (  2.131782)
+        lore prepared              2.400000   0.460000   2.860000 (  4.334760)
+        -------------------------------------------------- total: 53.110000sec
+
+                                       user     system      total        real
+        unprocessed query          0.040000   0.020000   0.060000 (  1.255553)
+        result fetching in lore    0.380000   0.050000   0.430000 (  1.731519)
+        result parsing in lore     0.600000   0.120000   0.720000 (  3.630439)
+        ac_instances unfiltered    2.580000   0.330000   2.910000 (  4.138985)
+        ac_instances filtered      4.660000   0.710000   5.370000 (  6.590051)
+        lore select unfiltered     2.640000   0.490000   3.130000 (  4.357413)
+        lore shortcut filtered     5.150000   0.760000   5.910000 (  7.518942)
+        lore shortcut unfiltered   2.660000   0.450000   3.110000 (  4.647531)
+        activerecord              15.330000   2.180000  17.510000 ( 22.384284)
+        sequel                     8.470000   0.880000   9.350000 ( 11.396475)
+        lore using cache           2.070000   0.070000   2.140000 (  2.137200)
+        lore prepared              2.610000   0.390000   3.000000 (  4.199908)
+
+
+NOTE: Perhaps results for AR and Sequel can be improved by 
+doing things differently - i'm using default behaviours for 
+benchmarking, but all SQL queries look alright, so my benchmark 
+code can't be that wrong. 
+If you know how to optimize my usage or AR and Sequel, please 
+let me know! 
+
+Also be aware that most applications aren't slow because of 
+its ORM, but because of ... sub-optimal algorithms using them. 
+Don't choose an ORM just because of a benchmark. 
+
+I just want to state that an ORM with both great performance 
+and convenient usage is feasible, and Lore is an example. 
+
+Apart from that: In case you don't like Lore, use Sequel. It's 
+incredibly stable, well-maintained, not that inefficient and 
+inconvenient as AR (see above), and its maintainer is a nice 
+guy - which is more important than you might think. 
+
+

data/benchmark/benchmark.sql

@@ -0,0 +1,11 @@
+
+create table contents ( id integer not null, title varchar(100) ); 
+create table articles ( id integer not null, content_id integer not null, content text ); 
+
+create sequence content_id_seq start with 1 increment by 1; 
+create sequence article_id_seq start with 1 increment by 1; 
+
+grant all on contents to cuba; 
+grant all on articles to cuba; 
+grant all on content_id_seq to cuba; 
+grant all on article_id_seq to cuba; 

data/benchmark/results.txt

@@ -0,0 +1,28 @@
+Rehearsal ------------------------------------------------------------
+unprocessed query          0.030000   0.030000   0.060000 (  1.269820)
+result fetching in lore    0.400000   0.050000   0.450000 (  1.661275)
+result parsing in lore     0.540000   0.080000   0.620000 (  3.600497)
+ac_instances unfiltered    2.440000   0.430000   2.870000 (  4.113851)
+ac_instances filtered      4.650000   0.700000   5.350000 (  6.601500)
+lore select unfiltered     2.720000   0.330000   3.050000 (  4.355712)
+lore shortcut filtered     5.110000   0.790000   5.900000 (  7.507479)
+lore shortcut unfiltered   3.030000   0.420000   3.450000 (  4.675418)
+activerecord              15.060000   1.960000  17.020000 ( 22.098705)
+sequel                     8.400000   0.940000   9.340000 ( 11.373551)
+lore using cache           2.060000   0.080000   2.140000 (  2.131782)
+lore prepared              2.400000   0.460000   2.860000 (  4.334760)
+-------------------------------------------------- total: 53.110000sec
+
+                               user     system      total        real
+unprocessed query          0.040000   0.020000   0.060000 (  1.255553)
+result fetching in lore    0.380000   0.050000   0.430000 (  1.731519)
+result parsing in lore     0.600000   0.120000   0.720000 (  3.630439)
+ac_instances unfiltered    2.580000   0.330000   2.910000 (  4.138985)
+ac_instances filtered      4.660000   0.710000   5.370000 (  6.590051)
+lore select unfiltered     2.640000   0.490000   3.130000 (  4.357413)
+lore shortcut filtered     5.150000   0.760000   5.910000 (  7.518942)
+lore shortcut unfiltered   2.660000   0.450000   3.110000 (  4.647531)
+activerecord              15.330000   2.180000  17.510000 ( 22.384284)
+sequel                     8.470000   0.880000   9.350000 ( 11.396475)
+lore using cache           2.070000   0.070000   2.140000 (  2.137200)
+lore prepared              2.610000   0.390000   3.000000 (  4.199908)

data/benchmark/select.rb

@@ -0,0 +1,352 @@
+
+require('rubygems')
+require('lore')
+require('lore/model')
+require('lore/cache/mmap_entity_cache')
+
+Lore::Model.use_entity_cache Lore::Cache::Mmap_Entity_Cache
+# Aurita.load_project :default
+# Aurita.import_plugin_model :wiki, :article
+
+# include Aurita::Plugins::Wiki
+
+require('benchmark')
+include Benchmark
+# require('profile')
+Lore.disable_logging
+Lore.disable_query_log
+
+require('rubygems')
+require('activerecord')
+require('sequel')
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'postgresql', 
+  :host     => 'localhost', 
+  :username => 'cuba', 
+  :password => 'cuba23', 
+  :database => 'artest'
+)
+
+Lore.add_login_data('artest' => ['cuba', 'cuba23'])
+Lore::Context.enter :artest
+
+DB = Sequel.connect('postgres://cuba:cuba23@localhost/artest')
+
+
+range_from = 1000
+range_to   = 1100
+
+
+module AR
+  class Content < ActiveRecord::Base
+  end
+
+  class Article < ActiveRecord::Base
+     belongs_to :content
+  end
+end
+
+module Lore
+  class Content < Lore::Model
+    table :contents, :public
+    primary_key :id, :content_id_seq
+  end
+
+  class Article < Lore::Model
+    table :articles, :public
+    primary_key :id, :article_id_seq
+    is_a Content, :content_id
+  end
+
+  Article.prepare(:id_in_range, Lore::Type.integer, Lore::Type.integer) { |a|
+    a.where(Article.id.between('$1', '$2'))
+    a.limit(100)
+  }
+
+end
+
+num_loops   = ARGV[0].to_i
+num_loops   = 100 if num_loops == 0
+
+  class Result_Parser
+  # {{{
+  require 'inline'
+
+    def initialize(result) # expects PGresult
+      
+      @result = result
+      @field_types      = nil
+      @result_rows      = Array.new
+      @num_fields       = @result.num_fields
+      @field_name_split = Array.new
+      @field_name       = String.new
+      @table_name       = String.new
+      @field_counter    = 0
+      
+    end # def initialize
+
+=begin
+    inline { |builder|
+      builder.c <<-EOC
+        VALUE get_row_c(VALUE result, int row_num) { 
+          unsigned int field_counter; 
+          VALUE row_result, field_name, table_name, field_name_split; 
+          VALUE value_set = rb_hash_new(); 
+          field_name = rb_string_new(); 
+          table_name = rb_string_new(); 
+          row_result = rb_hash_new(); 
+          for(field_counter = 0; field_counter < num_fields; field_counter++) { 
+             value_set = result->getvalue(row_num, UINT2NUM(field_counter)); 
+          // if(row_result[@table_name].nil?) then
+             if(rb_hash_aref(row_result, table_name) == QNil) { 
+            // row_result[@table_name] = Hash.new()
+               rb_hash_aset(row_result, table_name, value_set)
+             }
+             rb_hash_aset(rb_hash_aref)row_result, table_name), value_set); 
+          }
+          return row_result; 
+        }
+      EOC
+    }
+=end
+
+    def get_row(row_num=0)
+      
+      return if @result.num_tuples == 0
+
+      row_result        = Hash.new
+      
+      @field_name_split = Array.new
+      @field_name       = String.new
+      @table_name       = String.new
+      @field_counter = 0
+      for @field_counter in 0...@num_fields do
+        # admin.rd__content.name -> [admin, rd__content, name]
+        @field_name = @result.fieldname(@field_counter)
+
+        row_result[@field_name] = @result.getvalue(row_num,@field_counter)
+      end
+      
+      @result_rows[row_num] = row_result
+      
+    end
+    
+    def get_rows()
+      if !@result_rows.first then
+        for tuple_counter in 0...@result.num_tuples do
+          get_row(tuple_counter)
+        end
+      end
+      @result_rows
+    end
+
+  end # }}}
+
+  # SQL raw definitions
+  # {{{
+db_name    = 'artest'
+connection = PGconn.connect(Lore.pg_server, Lore.pg_port, '', '', db_name.to_s, Lore.user_for(db_name), Lore.pass_for(db_name.to_s))
+
+sql = "SELECT * 
+        FROM public.articles
+        JOIN public.contents on (public.contents.id = public.articles.content_id)
+        WHERE public.articles.id BETWEEN #{range_from} AND #{range_to} LIMIT #{range_to-range_from} OFFSET 0"
+
+sql_exec = "EXECUTE public_articles__id_in_range(#{range_from},#{range_to}); "
+
+sql_prep = 'PREPARE public_articles__id_in_range(integer,integer) AS
+    SELECT
+       public.contents.id AS "public.contents.id",
+       public.contents.user_group_id AS "public.contents.user_group_id",
+       public.contents.tags AS "public.contents.tags",
+       public.contents.changed AS "public.contents.changed",
+       public.contents.created AS "public.contents.created",
+       public.contents.hits AS "public.contents.hits",
+       public.contents.locked AS "public.contents.locked",
+       public.contents.deleted AS "public.contents.deleted",
+       public.contents.version AS "public.contents.version",
+       public.articles.id AS "public.articles.id",
+       public.articles.content_id AS "public.articles.content_id",
+       public.articles.template_id AS "public.articles.template_id",
+       public.articles.title AS "public.articles.title",
+       public.articles.view_count AS "public.articles.view_count",
+       public.articles.published AS "public.articles.published"
+    FROM public.articles
+    JOIN public.contents on (public.contents.id = public.articles.content_id)
+    WHERE public.articles.id BETWEEN $1 AND $2  LIMIT 100  OFFSET 0'
+
+    # }}}
+
+(0..3000).to_a.each { |i|
+# Lore::Article.create(:title   => "title_#{i}", 
+#                      :tags    => [ :foo, :bar, :wombat ], 
+#                      :text     => "text #{i}")
+}
+
+
+bmbm(12) { |test|
+  test.report("unprocessed query") { 
+    num_loops.times { 
+      result = connection.exec(sql)
+    }
+  }
+#  test.report("row parsing") { 
+#    num_loops.times { 
+#      result = connection.exec(sql)
+#      p = Result_Parser.new(result)
+#      p.get_rows
+#    }
+#  }
+# test.report("result fetching in lore") { 
+#   num_loops.times { 
+#     result = connection.exec(sql)
+#     result = Lore::Result.new('',result)
+#     result.get_rows.each { |row|
+#       # noop
+#     }
+#   }
+# }
+# test.report("result parsing in lore") { 
+#   num_loops.times { 
+#     result = connection.exec(sql)
+#     result = Lore::Connection.perform(sql)
+#     result.get_rows.each { |row|
+#       # noop
+#     }
+#   }
+# }
+# test.report("ac_instances unfiltered") { 
+#   Lore.disable_cache
+#   Lore::Article.disable_output_filters if Lore::Article.respond_to?(:disable_output_filters)
+#   num_loops.times { 
+#     result = Lore::Connection.perform(sql).get_rows()
+#     result.map! { |row|
+#       row = (Lore::Article.new(row))
+#     }
+#   }
+# }
+# test.report("ac_instances filtered") { 
+#   Lore.disable_cache
+#   Lore::Article.enable_output_filters if Lore::Article.respond_to?(:enable_output_filters)
+#   num_loops.times { 
+#     result = Lore::Connection.perform(sql).get_rows()
+#     result.map! { |row|
+#       row = (Lore::Article.new(row))
+#     }
+#   }
+# }
+  test.report("lore select unfiltered") { 
+    Lore.disable_cache
+    Lore::Article.disable_output_filters if Lore::Article.respond_to?(:disable_output_filters)
+    id_error = false
+    count = 0
+    num_loops.times { 
+      count = range_from
+      Lore::Article.select { |a|
+        a.where(Lore::Article.id.in(range_from..range_to))
+        a.limit(100)
+      }.each { |a|
+        raise ::Exception.new("ID ERROR: #{a.id.inspect} != #{count.inspect}") if a.id.to_s != count.to_s
+        count += 1
+      }
+    }
+  }
+  test.report("lore shortcut filtered") { 
+    id_error = false
+    Lore.disable_cache
+    Lore::Article.enable_output_filters if Lore::Article.respond_to?(:enable_output_filters)
+    count = 0
+    num_loops.times { 
+      count = range_from
+      r = Lore::Article.find(:all).with(Lore::Article.id.in(range_from..range_to)).each { |a|
+        # raise ::Exception.new("ID ERROR: #{a.id.inspect} != #{count.inspect}") if a.id != count
+        count += 1
+        valid = true
+        valid = valid && a.tags.is_a?(Array)
+        valid = valid && a.id.is_a?(Fixnum)
+        # raise ::Exception.new("TYPE ERROR") unless valid
+      }
+    }
+  }
+  test.report("lore shortcut unfiltered") { 
+    id_error = false
+    Lore.disable_cache
+    Lore::Article.disable_output_filters if Lore::Article.respond_to?(:disable_output_filters)
+    count = 0
+    num_loops.times { 
+      count = range_from
+      r = Lore::Article.all_with(Lore::Article.id.in(range_from..range_to)).each { |a|
+        # raise ::Exception.new("ID ERROR: #{a.id.inspect} != #{count.inspect}") if a.id != count
+        count += 1
+        valid = true
+        # raise ::Exception.new("TYPE ERROR") unless valid
+      }
+    }
+  }
+  test.report("sequel") { 
+    id_error = false
+    count = 0
+    num_loops.times { 
+      count = range_from
+      DB[:articles].inner_join(:contents, :id => :content_id).filter( :articles__id => (range_from..range_to)).each { |a| 
+        # raise ::Exception.new("ID ERROR: #{a.id.inspect} != #{count.inspect}") if a.id != count
+        count += 1
+        valid = true
+        # tags = a[:tags][1..-2].split(',')
+        # id   = a[:id].to_i
+        # raise ::Exception.new("TYPE ERROR") unless valid
+      }
+    }
+  }
+  test.report("activerecord") { 
+    id_error = false
+    count = 0
+    num_loops.times { 
+      count = range_from
+      for a in AR::Article.find(:all, :include => :content, :conditions => "id between #{range_from} AND #{range_to}") do
+        # raise ::Exception.new("ID ERROR: #{a.id.inspect} != #{count.inspect}") if a.id != count
+        count += 1
+        valid = true
+        valid = valid && a.tags.is_a?(Array)
+        valid = valid && a.id.is_a?(Fixnum)
+        # raise ::Exception.new("TYPE ERROR") unless valid
+      end
+    }
+  }
+  test.report('lore using cache') { 
+    id_error = false
+    Lore.enable_cache
+    Lore::Article.disable_output_filters if Lore::Article.respond_to?(:disable_output_filters)
+    count = 0
+    num_loops.times { 
+      count = range_from
+      Lore::Article.find(100).with(Lore::Article.id.in(range_from..range_to)).each { |a|
+        # raise ::Exception.new("ID ERROR: #{a.id.inspect} != #{count.inspect}") if a.id != count
+        count += 1
+        valid = true
+        valid = valid && a.tags.is_a?(Array)
+        valid = valid && a.id.is_a?(Fixnum)
+        # raise ::Exception.new("TYPE ERROR") unless valid
+      }
+    }
+  }
+  test.report("lore prepared") { 
+    id_error = false
+    Lore.disable_cache
+    count = 0
+    num_loops.times { 
+      count = range_from
+      Lore::Article.id_in_range(range_from,range_to).each { |a|
+        # raise ::Exception.new("ID ERROR: #{a.id.inspect} != #{count.inspect}") if a.id != count
+        count += 1
+        valid = true
+        valid = valid && a.tags.is_a?(Array)
+        valid = valid && a.id.is_a?(Fixnum)
+        # raise ::Exception.new("TYPE ERROR") unless valid
+      }
+    }
+  }
+}
+
+