m4dbi 0.5.0

data/lib/m4dbi/traits.rb

@@ -0,0 +1,91 @@
+# (taken from http://ramaze.net)
+
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+Traits = Hash.new{|h,k| h[k] = {}} unless defined?(Traits)
+
+# Extensions for Object
+
+class Object
+
+  # Adds a method to Object to annotate your objects with certain traits.
+  # It's basically a simple Hash that takes the current object as key
+  #
+  # Example:
+  #
+  #   class Foo
+  #     trait :instance => false
+  #
+  #     def initialize
+  #       trait :instance => true
+  #     end
+  #   end
+  #
+  #   Foo.trait[:instance]
+  #   # false
+  #
+  #   foo = Foo.new
+  #   foo.trait[:instance]
+  #   # true
+
+  def trait hash = nil
+    if hash
+      Traits[self].merge! hash
+    else
+      Traits[self]
+    end
+  end
+
+  # builds a trait from all the ancestors, closer ancestors
+  # overwrite distant ancestors
+  #
+  # class Foo
+  #   trait :one => :eins
+  #   trait :first => :erstes
+  # end
+  #
+  # class Bar < Foo
+  #   trait :two => :zwei
+  # end
+  #
+  # class Foobar < Bar
+  #   trait :three => :drei
+  #   trait :first => :overwritten
+  # end
+  #
+  # Foobar.ancestral_trait
+  # {:three=>:drei, :two=>:zwei, :one=>:eins, :first=>:overwritten}
+
+  def ancestral_trait
+    if respond_to?(:ancestors)
+      ancs = ancestors
+    else
+      ancs = self.class.ancestors
+    end
+    ancs.reverse.inject({}){|s,v| s.merge(v.trait)}.merge(trait)
+  end
+
+  # trait for self.class
+
+  #def class_trait
+    #if respond_to?(:ancestors)
+      #trait
+    #else
+      #self.class.trait
+    #end
+  #end
+  
+  def ancestral_trait_reader( *names )
+    names.each do |name|
+      name = name.to_sym
+      define_method( name ) { ancestral_trait[ name ] }
+    end
+  end
+  def ancestral_trait_class_reader( *names )
+    names.each do |name|
+      name = name.to_sym
+      meta_def( name ) { ancestral_trait[ name ] }
+    end
+  end
+end

data/lib/m4dbi.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+
+require 'm4dbi/traits'
+require 'm4dbi/hash'
+require 'm4dbi/database-handle'
+require 'm4dbi/row'
+require 'm4dbi/model'
+require 'm4dbi/collection'

data/spec/dbi.rb

@@ -0,0 +1,128 @@
+require 'spec/helper'
+
+$dbh = DBI.connect( "DBI:Pg:m4dbi", "m4dbi", "m4dbi" )
+# See test-schema.sql and test-data.sql
+
+describe 'DBI::DatabaseHandle#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'
+  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 'DBI::DatabaseHandle#one_transaction' do
+  
+  it 'turns off autocommit for the duration of a single transaction' do
+    $dbh.d( "DELETE FROM many_col_table;" )
+    $dbh.i( "INSERT INTO many_col_table ( id, c1 ) VALUES ( 1, 10 );" )
+    
+    # Here we will attempt to increment a value two times in parallel.
+    # If each multi-operation transaction is truly atomic, we expect that
+    # the final value will reflect two increments.
+    # If atomicity is not respected, the value should only reflect one
+    # increment.
+    
+    # First, we test the non-transactional case, to show failure.
+    
+    thread1 = Thread.new do
+      value = $dbh.sc "SELECT c1 FROM many_col_table WHERE id = 1;"
+      value.should.equal 10
+      sleep 2 # seconds
+      $dbh.u "UPDATE many_col_table SET c1 = ?", ( value + 1 )
+    end
+    
+    thread2 = Thread.new do
+      value = $dbh.sc "SELECT c1 FROM many_col_table WHERE id = 1;"
+      value.should.equal 10
+      # Update right away
+      $dbh.u "UPDATE many_col_table SET c1 = ?", ( value + 1 )
+    end
+    
+    thread2.join
+    thread1.join
+    
+    value = $dbh.sc "SELECT c1 FROM many_col_table WHERE id = 1;"
+    # Failure; two increments should give a final value of 12.
+    value.should.equal( 10 + 1 )
+    
+    # Now, we show that transactions keep things sane.
+    
+    thread1 = Thread.new do
+      $dbh.one_transaction do |dbh|
+        value = dbh.sc "SELECT c1 FROM many_col_table WHERE id = 1;"
+        sleep 2 # seconds
+        dbh.u "UPDATE many_col_table SET c1 = ?", ( value + 1 )
+      end
+    end
+    
+    thread2 = Thread.new do
+      $dbh.one_transaction do |dbh|
+        value = dbh.sc "SELECT c1 FROM many_col_table WHERE id = 1;"
+        # Update right away
+        dbh.u "UPDATE many_col_table SET c1 = ?", ( value + 1 )
+      end
+    end
+    
+    thread2.join
+    thread1.join
+    
+    value = $dbh.sc "SELECT c1 FROM many_col_table WHERE id = 1;"
+    value.should.equal( 11 + 1 + 1 )
+  end
+  
+end
+
+describe 'DBI::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._id.should.be.same_as row[ 'id' ]
+    row.id_.should.be.same_as row[ 'id' ]
+    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

data/spec/hash.rb

@@ -0,0 +1,27 @@
+require 'spec/helper'
+
+describe 'Hash' do
+  it 'is convertible to an SQL subclause and matching value Array' do
+    h = {
+      :a => 2,
+      :b => 'foo',
+      :abc => Time.now,
+      :xyz => 9.02,
+    }
+    clause, values = h.to_clause( " AND " )
+    where_clause, where_values = h.to_where_clause
+    
+    s = "a = ? AND b = ? AND abc = ? AND xyz = ?"
+    clause.length.should.equal s.length
+    where_clause.length.should.equal s.length
+    
+    h.each do |key,value|
+      clause.should.match /#{key} = ?/
+      where_clause.should.match /#{key} = ?/
+      values.find { |v| v == value }.should.not.be.nil
+      where_values.find { |v| v == value }.should.not.be.nil
+    end
+    values.size.should.equal h.keys.size
+    where_values.size.should.equal h.keys.size
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bacon'
+
+$LOAD_PATH.unshift(
+  File.expand_path(
+    File.join(
+      File.dirname( __FILE__ ),
+      "../lib"
+    )
+  )
+)
+
+require 'm4dbi'