dbi 0.4.0

data/test/dbi/tc_dbi.rb

@@ -0,0 +1,178 @@
+######################################################################
+# tc_dbi.rb
+#
+# Test case for the DBI module (dbi.rb).
+######################################################################
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(File.dirname(Dir.pwd))
+$LOAD_PATH.unshift("../../lib")
+$LOAD_PATH.unshift("../../lib/dbi")
+$LOAD_PATH.unshift("lib")
+
+require 'dbi'
+require 'test/unit'
+
+class TC_DBI < Test::Unit::TestCase
+   def setup
+      @db_error  = DBI::DatabaseError.new("test", 1, "montana")
+      @db_binary = DBI::Binary.new("test")
+      @url_basic = 'dbi:foo:bar'
+      @url_inter = 'dbi:foo:bar:host'
+      @url_advan = 'dbi:foo:database=db;host=xx;port=99'
+   end
+
+   def test_dbi_version
+      assert_equal("0.4.0", DBI::VERSION)
+   end
+
+   def test_dbd_module
+      assert_equal("0.3", DBI::DBD::API_VERSION)
+   end
+
+   def test_fetch_scroll_constants
+      assert_equal(1, DBI::SQL_FETCH_NEXT)
+      assert_equal(2, DBI::SQL_FETCH_PRIOR)
+      assert_equal(3, DBI::SQL_FETCH_FIRST)
+      assert_equal(4, DBI::SQL_FETCH_LAST)
+      assert_equal(5, DBI::SQL_FETCH_ABSOLUTE)
+      assert_equal(6, DBI::SQL_FETCH_RELATIVE)
+   end
+
+   def test_sql_type_constants
+      assert_equal(1, DBI::SQL_CHAR)
+      assert_equal(2, DBI::SQL_NUMERIC)
+      assert_equal(3, DBI::SQL_DECIMAL)
+      assert_equal(4, DBI::SQL_INTEGER)
+      assert_equal(5, DBI::SQL_SMALLINT)
+      assert_equal(6, DBI::SQL_FLOAT)
+      assert_equal(7, DBI::SQL_REAL)
+      assert_equal(8, DBI::SQL_DOUBLE)
+      assert_equal(9, DBI::SQL_DATE)
+      assert_equal(10, DBI::SQL_TIME)
+      assert_equal(11, DBI::SQL_TIMESTAMP)
+      assert_equal(12, DBI::SQL_VARCHAR)
+      assert_equal(100, DBI::SQL_OTHER)
+      assert_equal(-1, DBI::SQL_LONGVARCHAR)
+      assert_equal(-2, DBI::SQL_BINARY)
+      assert_equal(-3, DBI::SQL_VARBINARY)
+      assert_equal(-4, DBI::SQL_LONGVARBINARY)
+      assert_equal(-5, DBI::SQL_BIGINT)
+      assert_equal(-6, DBI::SQL_TINYINT)
+      assert_equal(-7, DBI::SQL_BIT)
+      assert_equal(-10, DBI::SQL_BLOB)
+      assert_equal(-11, DBI::SQL_CLOB)
+   end
+
+   def test_sql_type_names
+      assert_equal('BIT', DBI::SQL_TYPE_NAMES[DBI::SQL_BIT])
+      assert_equal('TINYINT', DBI::SQL_TYPE_NAMES[DBI::SQL_TINYINT])
+      assert_equal('SMALLINT', DBI::SQL_TYPE_NAMES[DBI::SQL_SMALLINT])
+      assert_equal('INTEGER', DBI::SQL_TYPE_NAMES[DBI::SQL_INTEGER])
+      assert_equal('BIGINT', DBI::SQL_TYPE_NAMES[DBI::SQL_BIGINT])
+      assert_equal('FLOAT', DBI::SQL_TYPE_NAMES[DBI::SQL_FLOAT])
+      assert_equal('REAL', DBI::SQL_TYPE_NAMES[DBI::SQL_REAL])
+      assert_equal('DOUBLE', DBI::SQL_TYPE_NAMES[DBI::SQL_DOUBLE])
+      assert_equal('NUMERIC', DBI::SQL_TYPE_NAMES[DBI::SQL_NUMERIC])
+      assert_equal('DECIMAL', DBI::SQL_TYPE_NAMES[DBI::SQL_DECIMAL])
+      assert_equal('CHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_CHAR])
+      assert_equal('VARCHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_VARCHAR])
+      assert_equal('LONG VARCHAR', DBI::SQL_TYPE_NAMES[DBI::SQL_LONGVARCHAR])
+      assert_equal('DATE', DBI::SQL_TYPE_NAMES[DBI::SQL_DATE])
+      assert_equal('TIME', DBI::SQL_TYPE_NAMES[DBI::SQL_TIME])
+      assert_equal('TIMESTAMP', DBI::SQL_TYPE_NAMES[DBI::SQL_TIMESTAMP])
+      assert_equal('BINARY', DBI::SQL_TYPE_NAMES[DBI::SQL_BINARY])
+      assert_equal('VARBINARY', DBI::SQL_TYPE_NAMES[DBI::SQL_VARBINARY])
+      assert_equal('LONG VARBINARY',
+         DBI::SQL_TYPE_NAMES[DBI::SQL_LONGVARBINARY])
+      assert_equal('BLOB', DBI::SQL_TYPE_NAMES[DBI::SQL_BLOB])
+      assert_equal('CLOB', DBI::SQL_TYPE_NAMES[DBI::SQL_CLOB])
+      assert_equal(nil, DBI::SQL_TYPE_NAMES[DBI::SQL_OTHER])
+   end
+
+   def test_dbi_exception_classes
+      assert(DBI::Error)
+      assert(DBI::Warning)
+      assert(DBI::InterfaceError)
+      assert(DBI::NotImplementedError)
+      assert(DBI::DatabaseError)
+      assert(DBI::DataError)
+      assert(DBI::OperationalError)
+      assert(DBI::IntegrityError)
+      assert(DBI::InternalError)
+      assert(DBI::ProgrammingError)
+      assert(DBI::NotSupportedError)
+   end
+
+   # This error class gets extra testing since it defines some custom
+   # accessors.
+   def test_dbi_database_error
+      assert_respond_to(@db_error, :errstr)
+      assert_respond_to(@db_error, :err)
+      assert_respond_to(@db_error, :state)
+      assert_equal("test", @db_error.errstr)
+      assert_equal(1, @db_error.err)
+      assert_equal("montana", @db_error.state)
+   end
+
+   def test_binary_datatype
+      assert_respond_to(@db_binary, :data)
+      assert_respond_to(@db_binary, :to_s)
+      assert_equal("test", @db_binary.data)
+      assert_equal("test", @db_binary.to_s)
+   end
+
+   def test_misc_constants
+      assert_equal(2, DBI::DEFAULT_TRACE_MODE)
+      assert_equal(STDERR, DBI::DEFAULT_TRACE_OUTPUT)
+   end
+
+   def test_connect
+      assert_respond_to(DBI, :connect)
+   end
+
+   def test_available_drivers
+      assert_respond_to(DBI, :available_drivers)
+   end
+   
+   # PRIVATE METHODS
+   def test_parse_url
+      assert_nothing_raised{ DBI.send(:parse_url, "dbi:foo:bar") }
+      assert_equal(["foo","bar"], DBI.send(:parse_url, @url_basic))
+      assert_equal(["foo","bar:host"], DBI.send(:parse_url, @url_inter))
+      assert_equal(["foo","database=db;host=xx;port=99"],
+         DBI.send(:parse_url, @url_advan)
+      )
+   end
+
+   def test_parse_url_expected_errors
+      assert_raises(DBI::InterfaceError){ DBI.send(:parse_url, 'dbi') }
+      assert_raises(DBI::InterfaceError){ DBI.send(:parse_url, 'dbi::foo') }
+
+      # XXX we're looking for a specific exception message here
+      assert_nothing_raised do
+          begin 
+              DBI.send(:parse_url, 'dbi:blah')
+          rescue DBI::InterfaceError => e
+              assert true
+              assert_kind_of DBI::InterfaceError, e
+              assert_equal "Invalid Data Source Name", e.message
+          end
+      end
+   end
+
+   def test_available_drivers
+       assert_equal(
+       [
+            "dbi:Mysql:",
+            "dbi:ODBC:",
+            "dbi:Pg:",
+            "dbi:SQLite3:",
+            "dbi:SQLite:"
+       ], DBI.available_drivers.sort)
+   end
+
+   def teardown
+      @db_error  = nil
+      @db_binary = nil
+   end
+end

data/test/dbi/tc_row.rb

@@ -0,0 +1,256 @@
+######################################################################
+# tc_row.rb
+#
+# Test case for the DBI::Row class. 
+######################################################################
+$LOAD_PATH.unshift(Dir.pwd)
+$LOAD_PATH.unshift(File.dirname(Dir.pwd))
+$LOAD_PATH.unshift("../../lib")
+$LOAD_PATH.unshift("../../lib/dbi")
+$LOAD_PATH.unshift("lib")
+
+require 'test/unit'
+require 'dbi'
+
+class TC_DBI_Row < Test::Unit::TestCase
+   def setup
+      @data = %w/Daniel Berger 36/
+      @cols = %w/first last age/
+      @coltypes = [DBI::Type::Varchar, DBI::Type::Varchar, DBI::Type::Integer]
+      @row  = DBI::Row.new(@cols, @coltypes, @data.clone)
+      @row_noconv = DBI::Row.new(@cols, @coltypes, @data.clone, false) 
+   end
+
+   def teardown
+      @data = nil
+      @cols = nil
+      @row  = nil
+   end
+
+   def test_row_multiassign # this should only be an issue in 1.8.7 and up, if at all.
+       first, last, age = @row
+       assert_equal("Daniel", first)
+       assert_equal("Berger", last)
+       assert_equal(36, age)
+   end
+
+   def test_row_noconv
+       assert_nothing_raised do
+           assert_equal(
+               [
+                   'Daniel',
+                   'Berger',
+                   36
+               ], @row
+           )
+           assert_equal(@data, @row_noconv)
+       end
+   end
+   
+   # Ensure that constructor only allows Integers or Arrays (or nil)
+   def test_row_constructor
+      assert_nothing_raised{ DBI::Row.new(@cols, @coltypes) }
+      assert_nothing_raised{ DBI::Row.new(@cols, @coltypes, 1) }
+      assert_nothing_raised{ DBI::Row.new(@cols, @coltypes, nil) }
+      assert_nothing_raised{ DBI::Row.new(@cols, @coltypes, [1,2,3])}
+      assert_raises(ArgumentError){ DBI::Row.new }
+      assert_raises(ArgumentError){ DBI::Row.new(@cols) }
+      assert_raises(TypeError){ DBI::Row.new(@cols, @coltypes, {}) }
+   end
+
+   # Test added to ensure that Row#at is equivalent to Row#by_index.  When the
+   # latter method is (hopefully) removed, this test can be removed as well.
+   def test_at
+      assert_respond_to(@row, :at)
+      assert_equal(@data[0].to_s, @row.at(0).to_s)
+      assert_equal(@data[1].to_s, @row.at(1).to_s)
+      assert_equal(@data[2].to_s, @row.at(2).to_s)
+      assert_equal(@data[99].to_s, @row.at(99).to_s)
+   end
+   
+   # Should respond to Array and Enumerable methods
+   def test_row_delegate
+      assert_respond_to(@row, :length)
+      assert_respond_to(@row, :each)
+      assert_respond_to(@row, :grep)
+   end
+   
+   def test_row_length
+      assert_equal(3, @row.length)
+      assert_equal(3, DBI::Row.new(@cols, @coltypes).length)
+   end
+
+   def test_row_data_by_index
+      assert_equal(@data[0], @row.by_index(0))
+      assert_equal(@data[1], @row.by_index(1))
+      assert_equal(@data[2], @row.by_index(2).to_s)
+      assert_nil(@row.by_index(3))
+   end
+   
+   def test_row_data_by_field
+      assert_equal @data[0], @row.by_field('first')
+      assert_equal @data[1], @row.by_field('last')
+      assert_equal @data[2], @row.by_field('age').to_s
+      assert_equal nil, @row.by_field('unknown')
+   end
+   
+   def test_row_set_values
+      assert_respond_to(@row, :set_values)
+      assert_nothing_raised{ @row.set_values(["John", "Doe", 23]) }
+      assert_equal("John", @row.by_index(0))
+      assert_equal("Doe", @row.by_index(1))
+      assert_equal(23, @row.by_index(2))
+   end
+   
+   def test_row_to_h
+      assert_respond_to(@row, :to_h)
+      assert_nothing_raised{ @row.to_h }
+      assert_kind_of(Hash, @row.to_h)
+      assert_equal({"first"=>"Daniel", "last"=>"Berger", "age"=>36}, @row.to_h)
+   end
+   
+   def test_row_column_names
+      assert_respond_to(@row, :column_names)
+      assert_nothing_raised{ @row.column_names }
+      assert_kind_of(Array, @row.column_names)
+      assert_equal(["first", "last", "age"], @row.column_names)
+   end
+
+   # An alias for column_names
+   def test_row_field_names
+      assert_respond_to(@row, :column_names)
+      assert_nothing_raised{ @row.column_names }
+      assert_kind_of(Array, @row.column_names)
+      assert_equal(["first", "last", "age"], @row.column_names)
+   end
+   
+   def test_indexing_numeric
+      assert_equal(@data[0], @row[0])   
+      assert_equal(@data[1], @row[1])  
+      assert_equal(@data[2], @row[2].to_s)      
+   end
+   
+   def test_indexing_string_or_symbol
+      assert_equal(@data[0], @row['first'])
+      assert_equal(@data[0], @row[:first])
+      assert_equal(@data[1], @row['last'])
+      assert_equal(@data[2], @row['age'].to_s)
+      assert_equal(nil, @row['unknown'])
+   end
+   
+   def test_indexing_regexp
+      assert_equal(["Daniel"], @row[/first/])
+      assert_equal(["Berger"], @row[/last/])
+      assert_equal([36], @row[/age/])
+      assert_equal(["Daniel", "Berger"], @row[/first|last/])
+      assert_equal([], @row[/bogus/])
+   end
+
+   def test_indexing_array
+      assert_equal(["Daniel"], @row[[0]])
+      assert_equal(["Daniel"], @row[["first"]])
+      assert_equal(["Berger"], @row[[1]])
+      assert_equal([36], @row[[2]])
+      assert_equal([nil], @row[[3]])
+      assert_equal(["Daniel", 36], @row[[0,2]])
+      assert_equal(["Daniel", 36], @row[[0,:age]])
+   end
+
+   def test_indexing_range
+      assert_equal(["Daniel","Berger"], @row[0..1])
+      assert_equal(["Berger",36], @row[1..2])
+      assert_equal(["Berger",36], @row[1..99])
+      assert_equal(nil, @row[90..100])
+   end
+
+   # The two argument reference should behave like the second form of Array#[]
+   def test_indexing_two_args
+      assert_equal([], @row[0,0])
+      assert_equal(["Daniel"], @row[0,1])
+      assert_equal(["Daniel", "Berger"], @row[0,2])
+      assert_equal(["Daniel", "Berger", 36], @row[0,3])
+      assert_equal(["Daniel", "Berger", 36], @row[0,99])
+   end
+
+   def test_indexing_multiple_args
+      assert_equal(["Berger", 36, "Daniel"], @row[:last, :age, :first])
+      assert_equal(["Berger", 36, "Daniel"], @row[1, :age, :first])
+      assert_equal(["Berger", 36, "Daniel"], @row[1, 2, :first])
+      assert_equal(["Berger", 36, "Daniel"], @row[1, 2, 0])
+      assert_equal(["Berger", 36, "Daniel", nil], @row[1, 2, 0, 9])
+      assert_equal(["Berger", 36, "Daniel", nil], @row[1, 2, 0, :bogus])
+   end
+
+   def test_indexing_assignment
+      assert_nothing_raised{ @row[0] = "kirk" }
+      assert_equal("kirk", @row[0])
+
+      assert_nothing_raised{ @row[:age] = 29 }
+      assert_equal(29, @row[:age])
+
+      assert_nothing_raised{ @row[1,2] = "francis" }
+      assert_equal("francis", @row[:last])
+      assert_nil(@row[:age])
+   end
+
+   def test_clone_with
+      another_row = @row.clone_with(["Jane", "Smith", 33])
+      assert_kind_of(DBI::Row, another_row)
+      assert_equal "Jane", another_row.by_index(0)
+      assert_equal "Smith", another_row.by_index(1)
+      assert_equal 33, another_row.by_index(2)
+      assert(@row != another_row)
+   end
+
+   def test_iteration
+      expect = @data.clone
+      @row.each { |value|
+         assert_equal(expect.shift, value.to_s)
+      }
+      assert_equal([], expect)
+      @row.collect { |value| "Field=#{value}" }
+   end
+
+   def test_row_each_with_name
+      assert_respond_to(@row, :each_with_name)
+      assert_nothing_raised{ @row.each_with_name{ } }
+
+      @row.each_with_name{ |value, column|
+         assert(@cols.include?(column))
+         assert(@data.include?(value.to_s))
+      }
+   end
+
+   def test_to_a
+      assert_respond_to(@row, :to_a)
+      assert_equal(@data, DBI::Row.new(@cols, @coltypes, @data).to_a.collect { |x| x.to_s })
+   end
+
+   def test_dup_clone
+      dupped = nil
+      cloned = nil
+
+      assert_nothing_raised{ dupped = @row.dup }
+      assert_nothing_raised{ cloned = @row.clone }
+      assert_nothing_raised{ @row.set_values(["Bill", "Jones", 16])}
+
+      assert_equal(@data, dupped.to_a.collect { |x| x.to_s })
+      assert_equal(@data, cloned.to_a.collect { |x| x.to_s })
+
+      assert(dupped.object_id != @row.object_id)
+      assert(cloned.object_id != @row.object_id)
+   end
+
+   def test_dup_ruby18
+      res = []
+      r = DBI::Row.new(["col1","col2"],[nil,nil])
+
+      [["one",1],["two",2],["three",3]].each do |x,y|
+         r["col1"] = x
+         r["col2"] = y
+         res << r.dup
+      end
+
+      assert_equal res, [["one", 1], ["two", 2], ["three", 3]]
+   end
+end

data/test/dbi/tc_sqlbind.rb

@@ -0,0 +1,168 @@
+$: << 'lib'
+require 'test/unit'
+require "dbi/sql"
+
+# ====================================================================
+class TestSqlBind < Test::Unit::TestCase
+
+  def bind(quoter, sql, args)
+      ps = DBI::SQL::PreparedStatement.new(quoter, sql)
+      ps.bind(DBI::Utils::ConvParam.conv_param('default', *args))
+  end
+
+  def test_one
+    assert_equal "10", bind(self, "?", [10])
+    assert_equal "'hi'", bind(self, "?", ["hi"])
+    assert_equal "I 'don''t' know", bind(self, "I ? know", ["don't"])
+  end
+
+  def test_many
+    assert_equal "WHERE age=12 AND name='Jim'",
+      bind(self, "WHERE age=? AND name=?", [12, 'Jim'])
+  end
+
+  def test_too_many
+    assert_raise (RuntimeError) {
+      bind(self, "age=?", [10, 11])
+    }
+  end
+
+  def test_too_few
+    assert_raise (RuntimeError) {
+      bind(self, "age in (?, ?, ?)", [10, 11])
+    }
+  end
+
+  def test_embedded_questions
+    assert_equal "10 ? 11", bind(self, "? ?? ?", [10, 11])
+    assert_equal "????", bind(self, "????????", [])
+  end
+
+  def test_questions_in_param
+    assert_equal "WHERE c='connected?'",
+      bind(self, "WHERE c=?", ["connected?"])
+
+    assert_equal "WHERE c='connected?' AND d='???'",
+      bind(self, "WHERE c=? AND d=?", ["connected?", "???"])
+  end
+
+  def test_questions_in_quotes
+    assert_equal "WHERE c='connected?' AND d=10",
+      bind(self, "WHERE c='connected?' AND d=?", [10])
+  end
+
+  def test_comment_dan
+    sql = %{--Dan's query\n--random comment\nselect column1, column2\nfrom table1\nwhere somevalue = ?}
+    res = %{--Dan's query\n--random comment\nselect column1, column2\nfrom table1\nwhere somevalue = 10}
+    assert_equal res, bind(self, sql, [10])
+  end
+
+  def test_minus_bug
+    sql = "SELECT 1 - 3"
+    res = "SELECT 1 - 3"
+    assert_equal res, bind(self, sql, []) 
+  end
+
+  def test_minus2
+    sql = "SELECT * from test --Dan's query" 
+    assert_equal sql, bind(self, sql, []) 
+  end
+
+  def test_slash
+    sql = "SELECT 5 / 4"
+    res = "SELECT 5 / 4"
+    assert_equal res, bind(self, sql, []) 
+  end
+
+  def test_much
+    sql = <<ENDSQL
+SELECT s.id, cwajga_magic_number((cwajga_product(r.rating) ^ (1 / 1)), MAX(lastplay.lastheard), 5) as magic
+INTO TEMP magic_order
+FROM song AS s LEFT OUTER JOIN rating AS r ON s.id = r.song LEFT OUTER JOIN last play ON lastplay.song = s.id
+WHERE r.name ILIKE 'omega697'
+GROUP BY s.id;
+
+SELECT SUM(magic) as total INTO TEMP magic_tot FROM magic_order;
+
+SELECT id, 100.0*magic/total as percent
+FROM magic_order, magic_tot
+order by percent;
+ENDSQL
+    res = sql
+    assert_equal res, bind(self, sql, [])
+  end
+
+  def test_nested_insert
+    sql = "insert into logins (user_id, hostmask) values ((select id from users where username = ?), ?)"
+    res = sql.sub(/\?/, "1")
+    res.sub!(/\?/, "'foo@bar'")
+    assert_equal res, bind(self, sql, [1, "foo@bar"])
+  end
+
+end
+
+######################################################################
+class TestLex < Test::Unit::TestCase
+
+    def tokens(sql)
+        DBI::SQL::PreparedStatement.tokens(sql)
+    end
+
+  def test_non_strings
+    assert_equal ['This is _a t35t'],
+      tokens("This is _a t35t")
+  end
+
+  def test_simple_strings
+    assert_equal ["hi ", "'hello world'"],
+      tokens("hi 'hello world'")
+    assert_equal ["c = ", "''"],
+      tokens("c = ''")
+  end
+
+  def test_strings_with_quotes
+    assert_equal ["hi ", "'''lo world'"],
+      tokens("hi '''lo world'")
+    assert_equal ['a', "''''", 'b'],
+      tokens("a''''b")
+  end
+
+  def test_strings_with_escaped_quotes
+    assert_equal ["hi ", "'don\\'t do that'"],
+      tokens("hi 'don\\'t do that'")
+    assert_equal ['a', "'\\''", 'b'],
+      tokens("a'\\''b")
+  end
+
+  def test_simple_dq_strings
+    assert_equal ["hi ", '"hello world"'],
+      tokens('hi "hello world"')
+    assert_equal ["c = ", '""'],
+      tokens('c = ""')
+  end
+
+  def test_dq_strings_with_quotes
+    assert_equal ["hi ", '"""lo world"'],
+      tokens('hi """lo world"')
+    assert_equal ['a', '""""', 'b'],
+      tokens('a""""b')
+  end
+
+  def test_dq_strings_with_escaped_quotes
+    assert_equal ["hi ", '"don\"t do that"'],
+      tokens('hi "don\"t do that"')
+    assert_equal ['a', '"\""', 'b'],
+      tokens('a"\""b')
+  end
+
+  def test_qmarks
+    assert_equal ["a = ", "?"],
+      tokens("a = ?")
+    assert_equal ["'?'", " = ", "?"],
+      tokens("'?' = ?")
+    assert_equal ["'?'", " = ", "??"],
+      tokens("'?' = ??")
+  end
+
+end
+