m4dbi 0.6.2 → 0.7.0

data/lib/m4dbi.rb

@@ -1,14 +1,26 @@
 require 'rubygems'
+require 'rdbi'
+require 'metaid'
+require 'thread'
 
-M4DBI_VERSION = '0.6.2'
+M4DBI_VERSION = '0.7.0'
 
 __DIR__ = File.expand_path( File.dirname( __FILE__ ) )
 
+require "#{__DIR__}/m4dbi/error"
 require "#{__DIR__}/m4dbi/traits"
 require "#{__DIR__}/m4dbi/hash"
 require "#{__DIR__}/m4dbi/array"
-require "#{__DIR__}/m4dbi/database-handle"
-require "#{__DIR__}/m4dbi/row"
-require "#{__DIR__}/m4dbi/timestamp"
+require "#{__DIR__}/m4dbi/database"
 require "#{__DIR__}/m4dbi/model"
 require "#{__DIR__}/m4dbi/collection"
+
+module M4DBI
+  ancestral_trait_class_reader :last_dbh
+
+  def self.connect( *args )
+    dbh = M4DBI::Database.new( RDBI.connect( *args ) )
+    trait :last_dbh => dbh
+    dbh
+  end
+end

data/lib/m4dbi/collection.rb

@@ -1,4 +1,4 @@
-module DBI
+module M4DBI
   class Collection
     def initialize( the_one, the_many_model, the_one_fk )
       @the_one = the_one
@@ -25,7 +25,7 @@ module DBI
     def delete( arg )
       case arg
         when @the_many_model
-          result = @the_many_model.dbh.do(
+          @the_many_model.dbh.execute(
             %{
               DELETE FROM #{@the_many_model.table}
               WHERE
@@ -34,15 +34,14 @@ module DBI
             },
             @the_one.pk,
             arg.pk
-          )
-          result > 0
+          ).affected_count > 0
         when Hash
           hash = arg
           keys = hash.keys
           where_subclause = keys.map { |k|
             "#{k} = ?"
           }.join( " AND " )
-          @the_many_model.dbh.do(
+          @the_many_model.dbh.execute(
             %{
               DELETE FROM #{@the_many_model.table}
               WHERE
@@ -51,19 +50,19 @@ module DBI
             },
             @the_one.pk,
             *( keys.map { |k| hash[ k ] } )
-          )
+          ).affected_count
       end
     end
 
     # Returns the number of records deleted
     def clear
-      @the_many_model.dbh.do(
+      @the_many_model.dbh.execute(
         %{
           DELETE FROM #{@the_many_model.table}
           WHERE #{@the_one_fk} = ?
         },
         @the_one.pk
-      )
+      ).affected_count
     end
   end
 end

data/lib/m4dbi/database.rb

@@ -0,0 +1,73 @@
+module M4DBI
+
+  class Database
+
+    def initialize( rdbi_dbh )
+      @dbh = rdbi_dbh
+    end
+
+    def execute( *args )
+      @dbh.execute *args
+    end
+
+    def select( sql, *bindvars )
+      execute( sql, *bindvars ).fetch( :all, RDBI::Result::Driver::Struct )
+    end
+
+    def select_one( sql, *bindvars )
+      select( sql, *bindvars )[ 0 ]
+    end
+
+    def select_column( sql, *bindvars )
+      rows = execute( sql, *bindvars ).fetch( 1, RDBI::Result::Driver::Array )
+      if rows.any?
+        rows[ 0 ][ 0 ]
+      else
+        raise RDBI::Error.new( "Query returned no rows.  SQL: #{@dbh.last_query}" )
+      end
+    end
+
+    alias select_all select
+    alias s select
+    alias s1 select_one
+    alias sc select_column
+    alias update execute
+    alias u execute
+    alias insert execute
+    alias i execute
+    alias delete execute
+    alias d execute
+
+    def connected?
+      @dbh.connected?
+    end
+
+    def disconnect
+      @dbh.disconnect
+    end
+
+    def table_schema( *args )
+      @dbh.table_schema( *args )
+    end
+
+    def database_name
+      @dbh.database_name
+    end
+
+    def transaction( &block )
+      @dbh.transaction &block
+    end
+
+    def last_query
+      @dbh.last_query
+    end
+
+    def driver
+      @dbh.driver
+    end
+  end
+end
+
+
+
+

data/lib/m4dbi/error.rb

@@ -0,0 +1,4 @@
+module M4DBI
+  class Error < ::RDBI::Error
+  end
+end

data/lib/m4dbi/model.rb

@@ -1,7 +1,4 @@
-require 'dbi'
-require 'metaid'
-
-module DBI
+module M4DBI
   class Model
     #attr_reader :row
     ancestral_trait_reader :dbh, :table
@@ -120,11 +117,11 @@ module DBI
       value_placeholders = values.map { |v| '?' }.join( ',' )
       rec = nil
 
-      dbh.one_transaction do |dbh_|
-        num_inserted = dbh_.do(
+      dbh.transaction do |dbh_|
+        num_inserted = dbh_.execute(
           "INSERT INTO #{table} ( #{cols} ) VALUES ( #{value_placeholders} )",
           *values
-        )
+        ).affected_count
         if num_inserted > 0
           pk_hash = hash.slice( *(
             self.pk.map { |pk_col| pk_col.to_sym }
@@ -152,7 +149,7 @@ module DBI
 
     def self.find_or_create( hash = nil )
       item = nil
-      error = DBI::Error.new( "Failed to find_or_create( #{hash.inspect} )" )
+      error = M4DBI::Error.new( "Failed to find_or_create( #{hash.inspect} )" )
       item = self.one_where( hash )
       if item.nil?
         item =
@@ -201,7 +198,7 @@ module DBI
 
       set_clause, set_params = set_hash.to_set_clause
       params = set_params + where_params
-      dbh.do(
+      dbh.execute(
         "UPDATE #{table} SET #{set_clause} WHERE #{where_clause}",
         *params
       )
@@ -211,19 +208,19 @@ module DBI
       set_clause, set_params = args[ -1 ].to_set_clause
       pk_values = args[ 0..-2 ]
       params = set_params + pk_values
-      dbh.do(
+      dbh.execute(
         "UPDATE #{table} SET #{set_clause} WHERE #{pk_clause}",
         *params
       )
     end
 
     # Example:
-    #   DBI::Model.one_to_many( Author, Post, :posts, :author, :author_id )
+    #   M4DBI::Model.one_to_many( Author, Post, :posts, :author, :author_id )
     #   her_posts = some_author.posts
     #   the_author = some_post.author
     def self.one_to_many( the_one, the_many, many_as, one_as, the_one_fk )
       the_one.class_def( many_as.to_sym ) do
-        DBI::Collection.new( self, the_many, the_one_fk )
+        M4DBI::Collection.new( self, the_many, the_one_fk )
       end
       the_many.class_def( one_as.to_sym ) do
         the_one[ @row[ the_one_fk ] ]
@@ -234,7 +231,7 @@ module DBI
     end
 
     # Example:
-    #   DBI::Model.many_to_many(
+    #   M4DBI::Model.many_to_many(
     #     @m_author, @m_fan, :authors_liked, :fans, :authors_fans, :author_id, :fan_id
     #   )
     #   her_fans = some_author.fans
@@ -278,11 +275,11 @@ module DBI
     # ------------------- :nodoc:
 
     def initialize( row )
-      if not row.respond_to?( "[]".to_sym ) or not row.respond_to?( "[]=".to_sym )
-        raise DBI::Error.new( "Attempted to instantiate DBI::Model with an invalid argument (#{row.inspect}).  (Expecting DBI::Row.)" )
+      if ! row.respond_to?( "[]".to_sym ) || ! row.respond_to?( "[]=".to_sym )
+        raise M4DBI::Error.new( "Attempted to instantiate M4DBI::Model with an invalid argument (#{row.inspect}).  (Expecting something accessible [] and []= .)" )
       end
       if caller[ 1 ] !~ %r{/m4dbi/model\.rb:}
-        warn "Do not call DBI::Model#new directly; use DBI::Model#create instead."
+        warn "Do not call M4DBI::Model#new directly; use M4DBI::Model#create instead."
       end
       @row = row
     end
@@ -354,10 +351,10 @@ module DBI
     def set( hash )
       set_clause, set_params = hash.to_set_clause
       set_params << pk
-      num_updated = dbh.do(
+      num_updated = dbh.execute(
         "UPDATE #{table} SET #{set_clause} WHERE #{pk_clause}",
         *set_params
-      )
+      ).affected_count
       if num_updated > 0
         hash.each do |key,value|
           @row[ key ] = value
@@ -368,10 +365,10 @@ module DBI
 
     # Returns true iff the record and only the record was successfully deleted.
     def delete
-      num_deleted = dbh.do(
+      num_deleted = dbh.execute(
         "DELETE FROM #{table} WHERE #{pk_clause}",
         *pk_values
-      )
+      ).affected_count
       num_deleted == 1
     end
 
@@ -381,35 +378,34 @@ module DBI
     end
   end
 
-  # Define a new DBI::Model like this:
-  #   class Post < DBI::Model( :posts ); end
+  # Define a new M4DBI::Model like this:
+  #   class Post < M4DBI::Model( :posts ); end
   # You can specify the primary key column(s) using an option, like so:
-  #   class Author < DBI::Model( :authors, pk: [ 'auth_num' ] ); end
+  #   class Author < M4DBI::Model( :authors, pk: [ 'auth_num' ] ); end
   def self.Model( table, options = Hash.new )
-    h = options[ :dbh ] || DBI::DatabaseHandle.last_handle
-    if h.nil? or not h.connected?
-      raise DBI::Error.new( "Attempted to create a Model class without first connecting to a database." )
+    h = options[ :dbh ] || M4DBI.last_dbh
+    if h.nil? || ! h.connected?
+      raise M4DBI::Error.new( "Attempted to create a Model class without first connecting to a database." )
     end
     pk_ = options[ :pk ] || [ 'id' ]
     if not pk_.respond_to? :each
-      raise DBI::Error.new( "Primary key must be enumerable (was given #{pk_.inspect})" )
+      raise M4DBI::Error.new( "Primary key must be enumerable (was given #{pk_.inspect})" )
     end
 
     model_key =
-      # DBD-dependent.  Not all DBDs have dbname implemented by M4DBI.
-      if h.respond_to? :dbname
-        "#{h.dbname}::#{table}"
+      if h.respond_to? :database_name
+        "#{h.database_name}::#{table}"
       else
         table
       end
 
     @models ||= Hash.new
-    @models[ model_key ] ||= Class.new( DBI::Model ) do |klass|
+    @models[ model_key ] ||= Class.new( M4DBI::Model ) do |klass|
       klass.trait( {
         :dbh => h,
         :table => table,
         :pk => pk_,
-        :columns => h.columns( table.to_s ),
+        :columns => h.table_schema( table.to_sym ).columns,
       } )
 
       meta_def( 'pk_str'.to_sym ) do
@@ -420,43 +416,61 @@ module DBI
         end
       end
 
-      if defined?( DBI::DBD::Pg::Database ) and DBI::DBD::Pg::Database === h.handle
+      if defined?( RDBI::Driver::PostgreSQL ) && RDBI::Driver::PostgreSQL === h.driver
         # TODO: This is broken for non-SERIAL or multi-column primary keys
         meta_def( "last_record".to_sym ) do |dbh_|
           self.s1 "SELECT * FROM #{table} WHERE #{pk_str} = currval( '#{table}_#{pk_str}_seq' );"
         end
-      elsif defined?( DBI::DBD::Mysql::Database ) and DBI::DBD::Mysql::Database === h.handle
+      elsif defined?( RDBI::Driver::MySQL ) && RDBI::Driver::MySQL === h.driver
         meta_def( "last_record".to_sym ) do |dbh_|
           self.s1 "SELECT * FROM #{table} WHERE #{pk_str} = LAST_INSERT_ID();"
         end
-      elsif defined?( DBI::DBD::SQLite3::Database ) and DBI::DBD::SQLite3::Database === h.handle
+      elsif defined?( RDBI::Driver::SQLite3 ) && RDBI::Driver::SQLite3 === h.driver
         meta_def( "last_record".to_sym ) do |dbh_|
           self.s1 "SELECT * FROM #{table} WHERE #{pk_str} = last_insert_rowid();"
         end
-      # TODO: more DBDs
+      # TODO: more DB drivers
       end
 
       klass.trait[ :columns ].each do |col|
+
         colname = col[ 'name' ]
+        method = colname.to_sym
+        while klass.method_defined? method
+          method = "#{method}_".to_sym
+        end
 
         # Column readers
-        class_def( colname.to_sym ) do
+        class_def( method ) do
           @row[ colname ]
         end
 
         # Column writers
-        class_def( "#{colname}=".to_sym ) do |new_value|
-          num_changed = dbh.do(
+
+        class_def( "#{method}=".to_sym ) do |new_value|
+          num_changed = dbh.execute(
+            "UPDATE #{table} SET #{colname} = ? WHERE #{pk_clause}",
+            new_value,
+            *pk_values
+          ).affected_count
+          if num_changed > 0
+            @row[ colname ] = new_value
+          end
+        end
+
+        class_def( '[]='.to_sym ) do |colname, new_value|
+          num_changed = dbh.execute(
             "UPDATE #{table} SET #{colname} = ? WHERE #{pk_clause}",
             new_value,
             *pk_values
-          )
+          ).affected_count
           if num_changed > 0
             @row[ colname ] = new_value
           end
         end
+
       end
     end
   end
 
-end
+end

data/spec/database.rb

@@ -0,0 +1,84 @@
+require_relative 'helper'
+
+$dbh = connect_to_spec_database
+reset_data
+
+describe 'M4DBI.last_dbh' do
+  it 'provides the last database handle connected to' do
+    M4DBI.last_dbh.should.equal $dbh
+  end
+end
+
+describe 'M4DBI::Database#select_column' do
+
+  it 'selects one column' do
+    name = $dbh.select_column(
+      "SELECT name FROM authors LIMIT 1"
+    )
+    name.class.should.not.equal Array
+    name.should.equal 'author1'
+
+    null = $dbh.select_column(
+      "SELECT c4 FROM many_col_table WHERE c3 = 40"
+    )
+    null.should.be.nil
+
+    should.raise( RDBI::Error ) do
+      $dbh.select_column( "SELECT name FROM authors WHERE 1+1 = 3" )
+    end
+
+    begin
+      $dbh.select_column( "SELECT name FROM authors WHERE 1+1 = 3" )
+    rescue RDBI::Error => e
+      e.message.should.match /SELECT name FROM authors WHERE 1\+1 = 3/
+    end
+  end
+
+  it 'selects one column of first row' do
+    name = $dbh.select_column(
+      "SELECT name FROM authors ORDER BY name DESC"
+    )
+    name.should.equal 'author3'
+  end
+
+  it 'selects first column of first row' do
+    name = $dbh.select_column(
+      "SELECT name, id FROM authors ORDER BY name DESC"
+    )
+    name.should.equal 'author3'
+  end
+end
+
+describe 'row accessors' do
+
+  it 'provide read access via #fieldname' do
+    row = $dbh.select_one(
+      "SELECT * FROM posts ORDER BY author_id DESC LIMIT 1"
+    )
+    row.should.not.equal nil
+
+    row.author_id.should.be.same_as row[ 'author_id' ]
+    row.text.should.be.same_as row[ 'text' ]
+
+    row.text.should.equal 'Second post.'
+  end
+
+  it 'provide in-memory (non-syncing) write access via #fieldname=' do
+    row = $dbh.select_one(
+      "SELECT * FROM posts ORDER BY author_id DESC LIMIT 1"
+    )
+    row.should.not.equal nil
+
+    old_id = row[ :id ]
+    row[ :id ] = old_id + 1
+    row[ :id ].should.not.equal old_id
+    row[ :id ].should.equal( old_id + 1 )
+
+    old_text = row.text
+    new_text = 'This is the new post text.'
+    row.text = new_text
+    row.text.should.not.equal old_text
+    row.text.should.equal new_text
+  end
+
+end