swift 0.14.0 → 1.0.0

data/API.rdoc

@@ -7,7 +7,7 @@ Public API minus the optional stuff like Pool, IdentityMap, Migrations etc.
   Swift
     .setup  #=> Adapter
     .db     #=> Adapter
-    .schema #=> [Scheme, ...]
+    .schema #=> [Record, ...]
     .trace
 
     # Abstract.
@@ -15,15 +15,15 @@ Public API minus the optional stuff like Pool, IdentityMap, Migrations etc.
       .new           #=> Adapter
       #begin         #=> Adapter
       #commit
-      #create        #=> Scheme or Result
+      #create        #=> Record or Result
       #delete        #=> Result
       #execute       #=> Result
       #async_execute #=> Result
-      #get           #=> Scheme
+      #get           #=> Record
       #prepare       #=> Statement
       #rollback
       #transaction   #=> Adapter
-      #update        #=> Scheme or Result
+      #update        #=> Record or Result
       #reconnect
 
     # Concrete.
@@ -32,7 +32,7 @@ Public API minus the optional stuff like Pool, IdentityMap, Migrations etc.
       Postgres < Adapter::Sql
       Sqlite3  < Adapter::Sql
 
-    # Enumerable collection of Scheme or Hash tuples.
+    # Enumerable collection of Record or Hash tuples.
     Result
       .new         #=> Result
       #insert_id   #=> Numeric
@@ -46,21 +46,21 @@ Public API minus the optional stuff like Pool, IdentityMap, Migrations etc.
       #execute #=> Result
       #command #=> String # The SQL command executed or to be executed
 
-    Scheme
+    Record
       .attribute #=> Type
-      .create    #=> Scheme or Result
-      .get       #=> Scheme
+      .create    #=> Record or Result
+      .get       #=> Record
       .header    #=> Header
-      .load      #=> Scheme
-      .new       #=> Scheme
+      .load      #=> Record
+      .new       #=> Record
       .store     #=> Symbol
       #execute   #=> Result
       #prepare   #=> Statement
-      #scheme    #=> Alias for self.class
+      #record    #=> Alias for self.class
       #tuple     #=> Hash
-      #update    #=> Scheme or Result
+      #update    #=> Record or Result
 
-    # Enumerable collection of Types for Scheme.
+    # Enumerable collection of Types for Record.
     Header
       .new        #=> Header
       #all        #=> [Type, ...]
@@ -79,7 +79,7 @@ Public API minus the optional stuff like Pool, IdentityMap, Migrations etc.
       #key                   #=> true or false
       #serial                #=> Symbol or nil
       #default               #=> Object
-      #define_scheme_methods
+      #define_record_methods
 
     # Concrete.
     Type

data/README.md

@@ -10,9 +10,26 @@ A rational rudimentary object relational mapper.
 
 ## Dependencies
 
-* ruby   >= 1.9.1
-* [dbic++](http://github.com/deepfryed/dbicpp) >= 0.6.0
-* mysql  >= 5.0.17, postgresql >= 8.4 or sqlite3 >= 3.7
+* MRI Ruby >= 1.9.1
+* swift-db-sqlite3 or swift-db-postgres or swift-db-mysql
+
+## Installation
+
+### Dependencies
+
+Install one of the following drivers you would like to use.
+
+```
+gem install swift-db-sqlite3
+gem install swift-db-postgres
+gem install swift-db-mysql
+```
+
+### Install Swift
+
+```
+gem install swift
+```
 
 ## Features
 
@@ -24,20 +41,13 @@ A rational rudimentary object relational mapper.
 * IdentityMap.
 * Migrations.
 
-## Performance notes
-
-1. The current version creates DateTime objects for timestamp fields and this is roughly 80% slower on
-   rubies older than 1.9.3.
-2. On rubies older than 1.9.3, Swift will try using [home_run](https://github.com/jeremyevans/home_run)
-   for performance.
-
 ### DB
 
 ```ruby
   require 'swift'
 
   Swift.trace true # Debugging.
-  Swift.setup :default, Swift::DB::Postgres, db: 'swift'
+  Swift.setup :default, Swift::Adapter::Postgres, db: 'swift'
 
   # Block form db context.
   Swift.db do |db|
@@ -62,7 +72,7 @@ A rational rudimentary object relational mapper.
   end
 ```
 
-### DB Scheme Operations
+### DB Record Operations
 
 Rudimentary object mapping. Provides a definition to the db methods for prepared (and cached) statements plus native
 primitive Ruby type conversion.
@@ -72,9 +82,9 @@ primitive Ruby type conversion.
   require 'swift/migrations'
 
   Swift.trace true # Debugging.
-  Swift.setup :default, Swift::DB::Postgres, db: 'swift'
+  Swift.setup :default, Swift::Adapter::Postgres, db: 'swift'
 
-  class User < Swift::Scheme
+  class User < Swift::Record
     store     :users
     attribute :id,         Swift::Type::Integer, serial: true, key: true
     attribute :name,       Swift::Type::String
@@ -85,7 +95,7 @@ primitive Ruby type conversion.
   Swift.db do |db|
     db.migrate! User
 
-    # Select Scheme instance (relation) instead of Hash.
+    # Select Record instance (relation) instead of Hash.
     users = db.prepare(User, 'select * from users limit 1').execute
 
     # Make a change and update.
@@ -98,18 +108,18 @@ primitive Ruby type conversion.
   end
 ```
 
-### Scheme CRUD
+### Record CRUD
 
-Scheme/relation level helpers.
+Record/relation level helpers.
 
 ```ruby
   require 'swift'
   require 'swift/migrations'
 
   Swift.trace true # Debugging.
-  Swift.setup :default, Swift::DB::Postgres, db: 'swift'
+  Swift.setup :default, Swift::Adapter::Postgres, db: 'swift'
 
-  class User < Swift::Scheme
+  class User < Swift::Record
     store     :users
     attribute :id,    Swift::Type::Integer, serial: true, key: true
     attribute :name,  Swift::Type::String
@@ -142,7 +152,7 @@ SQL is easy and most people know it so Swift ORM provides simple #to_s
 attribute to table and field name typecasting.
 
 ```ruby
-  class User < Swift::Scheme
+  class User < Swift::Record
     store     :users
     attribute :id,    Swift::Type::Integer, serial: true, key: true
     attribute :age,   Swift::Type::Integer, field: 'ega'
@@ -167,7 +177,7 @@ Swift comes with a simple identity map. Just require it after you load swift.
   require 'swift/identity_map'
   require 'swift/migrations'
 
-  class User < Swift::Scheme
+  class User < Swift::Record
     store     :users
     attribute :id,    Swift::Type::Integer, serial: true, key: true
     attribute :age,   Swift::Type::Integer, field: 'ega'
@@ -204,7 +214,7 @@ But you can do it almost as fast in ruby,
 ```ruby
   require 'swift'
 
-  Swift.setup :default, Swift::DB::Mysql, db: 'swift'
+  Swift.setup :default, Swift::Adapter::Mysql, db: 'swift'
 
   # MySQL packet size is the usual limit, 8k is the packet size by default.
   Swift.db do |db|
@@ -226,7 +236,7 @@ which implicitly uses `rb_thread_wait_fd`
 ```ruby
   require 'swift'
 
-  pool = 3.times.map.with_index {|n| Swift.setup n, Swift::DB::Postgres, db: 'swift' }
+  pool = 3.times.map.with_index {|n| Swift.setup n, Swift::Adapter::Postgres, db: 'swift' }
 
   Thread.new do
     pool[0].async_execute('select pg_sleep(3), 1 as qid') {|row| p row}
@@ -243,31 +253,43 @@ which implicitly uses `rb_thread_wait_fd`
   Thread.list.reject {|thread| Thread.current == thread}.each(&:join)
 ```
 
+or use the `swift/eventmachine` api.
+
 ```ruby
-  require 'swift'
-  require 'eventmachine'
-  
-  pool = 3.times.map.with_index {|n| Swift.setup n, Swift::DB::Postgres, db: 'swift'}
-  
-  module Handler
-    attr_reader :result
-  
-    def initialize result
-      @result = result
-    end
-  
-    def notify_readable
-      result.retrieve
-      result.each {|row| p row }
-      unbind
+  require 'swift/eventmachine'
+
+  EM.run do
+    pool = 3.times.map { Swift.setup(:default, Swift::Adapter::Postgres, db: "swift") }
+
+    3.times.each do |n|
+      defer = pool[n].execute("select pg_sleep(3 - #{n}), #{n + 1} as qid")
+
+      defer.callback do |res|
+        p res.first
+      end
+
+      defer.errback do |e|
+        p 'error', e
+      end
     end
   end
-  
+```
+
+or use the `em-synchrony` api for `swift`
+
+```ruby
+  require 'swift/synchrony'
+
   EM.run do
-    EM.watch(pool[0].fileno, Handler, pool[0].async_execute('select pg_sleep(3), 1 as qid')){|c| c.notify_readable = true}
-    EM.watch(pool[1].fileno, Handler, pool[1].async_execute('select pg_sleep(2), 2 as qid')){|c| c.notify_readable = true}
-    EM.watch(pool[2].fileno, Handler, pool[2].async_execute('select pg_sleep(1), 3 as qid')){|c| c.notify_readable = true}
-    EM.add_timer(4) { EM.stop }
+    3.times.each do |n|
+      EM.synchrony do
+        db     = Swift.setup(:default, Swift::Adapter::Postgres, db: "swift")
+        result = db.execute("select pg_sleep(3 - #{n}), #{n + 1} as qid")
+
+        p result.first
+        EM.stop if n == 0
+      end
+    end
   end
 ```
 
@@ -284,8 +306,35 @@ http://github.com/shanna/swift/tree/master/benchmarks
 
 The test environment:
 
-* ruby 1.9.3p0
-* Intel Core2Duo P8700 2.53GHz, 4G RAM and Kingston SATA2 SSD
+```
+$ uname -a
+
+Linux deepfryed.local 3.0.0-1-amd64 #1 SMP Sun Jul 24 02:24:44 UTC 2011 x86_64 GNU/Linux
+
+$ cat /proc/cpuinfo | grep "processor\|model name"
+
+processor    : 0
+model name   : Intel(R) Core(TM) i7-2677M CPU @ 1.80GHz
+processor    : 1
+model name   : Intel(R) Core(TM) i7-2677M CPU @ 1.80GHz
+processor    : 2
+model name   : Intel(R) Core(TM) i7-2677M CPU @ 1.80GHz
+processor    : 3
+model name   : Intel(R) Core(TM) i7-2677M CPU @ 1.80GHz
+
+$ ruby -v
+
+ruby 1.9.3p125 (2012-02-16 revision 34643) [x86_64-linux]
+```
+
+PostgreSQL config:
+
+```
+shared_buffers           = 800MB     # min 128kB
+effective_cache_size     = 512MB
+work_mem                 = 64MB      # min 64kB
+maintenance_work_mem     = 64MB      # min 1MB
+```
 
 The test setup:
 
@@ -300,25 +349,25 @@ The test setup:
 ```
     ./simple.rb -n1 -r10000 -s ar -s dm -s sequel -s swift
 
-    benchmark       sys     user    total  real      rss
-    ar #create      0.75    7.18    7.93   10.5043   366.95m
-    ar #select      0.07    0.26    0.33    0.3680    40.71m
-    ar #update      0.96    7.92    8.88   11.7537   436.38m
+    benchmark           sys         user       total       real        rss
+
+    ar #create          1.960000    15.81000   17.770000   22.753109   266.21m
+    ar #select          0.020000     0.38000    0.400000    0.433041    50.82m
+    ar #update          2.000000    17.90000   19.900000   26.674921   317.48m
 
-    dm #create      0.33    3.73    4.06    5.0908   245.68m
-    dm #select      0.08    1.51    1.59    1.6154    87.95m
-    dm #update      0.44    7.09    7.53    8.8685   502.77m
+    dm #create          0.660000    11.55000   12.210000   15.592424   236.86m
+    dm #select          0.030000     1.30000    1.330000    1.351911    87.18m
+    dm #update          0.950000    17.25000   18.200000   22.109859   474.81m
 
-    sequel #create  0.60    5.07    5.67    7.9804   236.69m
-    sequel #select  0.02    0.12    0.14    0.1778    12.75m
-    sequel #update  0.82    4.95    5.77    8.2062   230.00m
+    sequel #create      1.960000    14.48000   16.440000   23.004864   226.68m
+    sequel #select      0.000000     0.09000    0.090000    0.134619    12.77m
+    sequel #update      1.900000    14.37000   16.270000   22.945636   200.20m
 
-    swift #create   0.27    0.59    0.86    1.5085    84.85m
-    swift #select   0.03    0.06    0.09    0.1037    11.24m
-    swift #update   0.20    0.69    0.89    1.5867    62.19m
+    swift #create       0.520000     1.95000    2.470000    5.828846    75.26m
+    swift #select       0.010000    0.070000    0.080000    0.095124    11.23m
+    swift #update       0.440000     1.95000    2.390000    6.044971    59.35m
+    swift #write        0.010000    0.050000    0.060000    0.117195    13.46m
 
-    -- bulk insert api --
-    swift #write    0.04    0.06    0.10    0.1699    14.05m
 ```
 
 ## TODO

data/Rakefile

@@ -9,8 +9,7 @@ begin
     gem.email       = %w{shane.hanna@gmail.com deepfryed@gmail.com}
     gem.homepage    = 'http://github.com/shanna/swift'
     gem.authors     = ["Shane Hanna", "Bharanee 'Barney' Rathna"]
-    gem.extensions = FileList['ext/extconf.rb']
-    gem.files.reject!{|f| f =~ %r{\.gitignore|examples|benchmarks|memory/.*}}
+    gem.files.reject!{|f| f =~ %r{\.gitignore|examples|benchmarks|memory|gems/.*|Gemfile}}
 
     gem.add_development_dependency 'minitest', '>= 1.7.0'
   end
@@ -26,11 +25,9 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-task :test    => :check_dependencies
 task :default => :test
 
 require 'yard'
 YARD::Rake::YardocTask.new do |yard|
-  yard.files   = ['lib/**/*.rb', 'ext/*.cc']
+  yard.files = Dir["lib/**/*.rb"].reject {|file| %r{eventmachine|synchrony}.match(file)}
 end
-

data/VERSION

@@ -1 +1 @@
-0.14.0
+1.0.0

data/lib/swift/adapter/mysql.rb

@@ -0,0 +1,30 @@
+require 'swift/db/mysql'
+require 'swift/adapter/sql'
+
+module Swift
+  class Adapter
+    class Mysql < Sql
+      def initialize options = {}
+        super Swift::DB::Mysql.new(options)
+      end
+
+      def returning?
+        false
+      end
+
+      # TODO Swift::Type::Bignum ?
+      # serial is an alias for bigint in mysql, we want integer type to be migrated as integer
+      # type in the database (not bigint or smallint or shortint or whatever).
+      def field_type attribute
+        case attribute
+          when Type::Integer then attribute.serial ? 'integer auto_increment' : 'integer'
+          else super
+        end
+      end
+
+      def tables
+        execute("show tables").map(&:values).flatten
+      end
+    end # Mysql
+  end # Adapter
+end # Swift

data/lib/swift/adapter/postgres.rb

@@ -0,0 +1,27 @@
+require 'swift/db/postgres'
+require 'swift/adapter/sql'
+
+module Swift
+  class Adapter
+    class Postgres < Sql
+      def initialize options = {}
+        super Swift::DB::Postgres.new(options)
+      end
+
+      def returning?
+        true
+      end
+
+      def field_type attribute
+        case attribute
+          when Type::IO then 'bytea'
+          else super
+        end
+      end
+
+      def tables
+        execute('select tablename from pg_tables where schemaname = current_schema').map(&:values).flatten
+      end
+    end # Postgres
+  end # Adapter
+end # Swift

data/lib/swift/adapter/sql.rb

@@ -1,19 +1,26 @@
 require 'swift/adapter'
+require 'forwardable'
 
 module Swift
   class Adapter
-
     # Abstract SQL Adapter.
     #
     # @abstract
     class Sql < Adapter
+      extend Forwardable
+      def_delegators :db, :begin, :commit, :rollback, :close, :closed?, :query, :fileno, :result, :write
+
       def tables
         raise NotImplementedError
       end
 
       def fields table
         result = execute("select * from #{table} limit 0")
-        Hash[result.fields.map(&:to_sym).zip(result.field_types)]
+        Hash[result.fields.map(&:to_sym).zip(result.types)]
+      end
+
+      def transaction *args
+        db.transaction(*args) {|db| yield self}
       end
 
       protected
@@ -21,39 +28,26 @@ module Swift
           raise NotImplementedError
         end
 
-        def prepare_cached scheme, name, &block
-          @prepared               ||= Hash.new{|h,k| h[k] = Hash.new}
-          @prepared[scheme][name] ||= prepare(scheme, yield)
-        end
-
-        def prepare_get scheme
-          prepare_cached(scheme, :get) do
-            where = scheme.header.keys.map{|key| "#{key} = ?"}.join(' and ')
-            "select * from #{scheme.store} where #{where} limit 1"
-          end
+        def command_get record
+          where = record.header.keys.map{|key| "#{key} = ?"}.join(' and ')
+          "select * from #{record.store} where #{where} limit 1"
         end
 
-        def prepare_create scheme
-          prepare_cached(scheme, :create) do
-            values    = (['?'] * scheme.header.insertable.size).join(', ')
-            returning = "returning #{scheme.header.serial}" if scheme.header.serial and returning?
-            "insert into #{scheme.store} (#{scheme.header.insertable.join(', ')}) values (#{values}) #{returning}"
-          end
+        def command_create record
+          values    = (['?'] * record.header.insertable.size).join(', ')
+          returning = "returning #{record.header.serial}" if record.header.serial and returning?
+          "insert into #{record.store} (#{record.header.insertable.join(', ')}) values (#{values}) #{returning}"
         end
 
-        def prepare_update scheme
-          prepare_cached(scheme, :update) do
-            set   = scheme.header.updatable.map{|field| "#{field} = ?"}.join(', ')
-            where = scheme.header.keys.map{|key| "#{key} = ?"}.join(' and ')
-            "update #{scheme.store} set #{set} where #{where}"
-          end
+        def command_update record
+          set   = record.header.updatable.map{|field| "#{field} = ?"}.join(', ')
+          where = record.header.keys.map{|key| "#{key} = ?"}.join(' and ')
+          "update #{record.store} set #{set} where #{where}"
         end
 
-        def prepare_delete scheme
-          prepare_cached(scheme, :delete) do
-            where = scheme.header.keys.map{|key| "#{key} = ?"}.join(' and ')
-            "delete from #{scheme.store} where #{where}"
-          end
+        def command_delete record
+          where = record.header.keys.map{|key| "#{key} = ?"}.join(' and ')
+          "delete from #{record.store} where #{where}"
         end
 
         def field_definition attribute

data/lib/swift/adapter/sqlite3.rb

@@ -0,0 +1,59 @@
+require 'swift/db/sqlite3'
+require 'swift/adapter/sql'
+
+module Swift
+  class Adapter
+    class Sqlite3 < Sql
+      def initialize options = {}
+        super Swift::DB::Sqlite3.new(options)
+      end
+
+      def returning?
+        false
+      end
+
+      def migrate! record
+        keys   =  record.header.keys
+        serial =  record.header.find(&:serial)
+        fields =  record.header.map{|p| field_definition(p)}.join(', ')
+        fields += ", primary key (#{keys.join(', ')})" unless serial or keys.empty?
+
+        execute("drop table if exists #{record.store}")
+        execute("create table #{record.store} (#{fields})")
+      end
+
+      def field_type attribute
+        case attribute
+          when Type::String     then 'text'
+          when Type::Integer    then attribute.serial ? 'integer primary key' : 'integer'
+          when Type::Float      then 'float'
+          when Type::BigDecimal then 'numeric'
+          when Type::Time       then 'timestamp' # deprecated
+          when Type::DateTime   then 'timestamp'
+          when Type::Date       then 'date'
+          when Type::Boolean    then 'boolean'
+          when Type::IO         then 'blob'
+          else 'text'
+        end
+      end
+
+      def tables
+        execute('select name from sqlite_master where type = ?', 'table').map(&:values).flatten
+      end
+
+      def write table, fields = nil, io
+        fields    = execute("select * from #{table} limit 0").fields if fields.nil? or fields.empty?
+        statement = prepare("insert into #{table}(#{fields.join(',')}) values (%s)" % (['?'] * fields.size).join(','))
+
+        r  = 0
+        io = io.read if io.respond_to?(:read)
+        io.split(/\n+/).each do |line|
+          r += statement.execute(*line.split(/\t/).map {|value| value == '\N' ? nil : value}).affected_rows
+        end
+
+        # TODO: a better way to return a pretend result
+        Struct.new(:affected_rows).new(r)
+      end
+    end # Sqlite3
+  end # Adapter
+end # Swift