dohmysql 0.1.0

data/lib/doh/mysql/unquoted.rb

@@ -0,0 +1,17 @@
+module DohDb
+
+class Unquoted < String
+  def to_sql
+    to_s
+  end
+end
+
+def self.unquoted(str)
+  Unquoted.new(str)
+end
+
+NOW = Unquoted.new('NOW()').freeze
+TODAY = Unquoted.new('CURDATE()').freeze
+NULL = Unquoted.new('NULL').freeze
+
+end

data/lib/doh/mysql/version.rb

@@ -0,0 +1,102 @@
+require 'doh/mysql/connector_instance'
+require 'yaml'
+
+module DohDb
+
+def self.locked_filename(database)
+  File.join(Doh::root, 'database', database, 'migrate/locked.yml')
+end
+
+def self.migration_filename(database, version, upordown = 'up')
+  version_str = version.to_s.rjust(3, '0')
+  File.join(Doh::root, 'database', database, "migrate/#{version_str}_#{upordown}.sql")
+end
+
+def self.current_database_version(database = nil)
+  if database.nil?
+    table = 'version'
+  else
+    table = database + '.version'
+  end
+  DohDb::select_field("SELECT version FROM #{table}").to_i
+end
+
+def self.latest_database_version(database = nil)
+  locked_version = locked_database_version(database)
+  unlocked_version = locked_version + 1
+  unlocked_migration_file = migration_filename(database, unlocked_version)
+  if File.exist?(unlocked_migration_file)
+    unlocked_version
+  else
+    locked_version
+  end
+end
+
+def self.locked_version_info(database = nil)
+  database ||= (DohDb::connector_instance && DohDb::connector_instance.database) || Doh::config['primary_database']
+  filename = locked_filename(database)
+  return [0, nil] unless File.exist?(filename)
+  YAML.load_file(filename)
+end
+
+def self.locked_database_version(database = nil)
+  locked_version_info(database).first
+end
+
+def self.locked_svn_revision(database = nil)
+  locked_version_info(database).last
+end
+
+def self.update_locked_file(database)
+  locked_file = locked_filename(database)
+  if File.exist?(locked_file)
+    new_version = YAML.load_file(locked_file).first + 1
+  else
+    new_version = 0
+    need_to_add = true
+  end
+
+  file_to_check = ''
+  if need_to_add
+    file_to_check = File.join(Doh::root, "database")
+  else
+    unlocked_migration_file = migration_filename(database, new_version)
+    return [true, "nothing to lock"] unless File.exist?(unlocked_migration_file)
+
+    svnout = `svn st #{unlocked_migration_file}`
+    unless svnout.strip.empty?
+      return [false, "svn status shows local changes to #{unlocked_migration_file} -- this needs to be resolved before updating the migration locked file"]
+    end
+
+    file_to_check = unlocked_migration_file
+  end
+
+  `svn update #{file_to_check}`
+  svnout = `svn st -v #{file_to_check}`.split("\n")
+  svnout =~ /(\d+)/
+  revision = svnout.collect {|elem| elem =~ /(\d+)/; $1.to_i}.max
+  if !revision
+    return [false, "unable to extract svn revision from: '#{svnout}'"]
+  end
+
+  outfile = File.new(locked_file, 'w')
+  outfile.puts([new_version, revision.to_i].inspect)
+  outfile.close
+
+  if need_to_add
+    svnout = `svn add #{locked_file}`
+    if svnout[0,1] != 'A'
+      return [false, "failed to svn add #{locked_file}"]
+    end
+  end
+
+  msg = "migrate lock for #{database} database, version #{new_version}"
+  svnout = `svn ci -m \"#{msg}\"  #{locked_file}`
+  unless svnout.index("Committed revision")
+    return [false, "failed to svn ci #{locked_file}"]
+  end
+
+  [true, "#{locked_file} successfully updated"]
+end
+
+end

data/lib/doh/mysql/virtual.rb

@@ -0,0 +1,17 @@
+require 'doh/mysql/metadata_util'
+require 'doh/mysql/readonly_row'
+require 'doh/mysql/types'
+
+module DohDb
+
+class LinkedRow
+  def self.build(field, idvalue)
+    return ReadOnlyRow.new([], []) if idvalue.to_i == 0
+    table = field.sub(/_id/, '')
+    table = table.rafter('_') unless DohDb::table_exist?(table)
+    raise "unable to determine child table name for field #{field}" unless DohDb::table_exist?(table)
+    DohDb::select_row("SELECT * FROM #{table} WHERE #{DohDb::find_primary_key(table)} = #{idvalue}", DohDb::find_row_type(table) || :smart)
+  end
+end
+
+end

data/lib/doh/mysql/writable_row.rb

@@ -0,0 +1,59 @@
+require 'doh/core_ext/string'
+require 'doh/mysql/abstract_row'
+require 'set'
+
+module DohDb
+
+class WritableRow < AbstractRow
+  attr_reader :changed_keys
+
+  # can accept 2 arguments: keys array, values array
+  # or 1 argument: a hash
+  def initialize(*args)
+    keys, values = parse_initialize_args(*args)
+    @keys = keys.dup
+    @values = values.dup
+    @changed_keys = Set.new
+  end
+
+  def initialize_copy(orig)
+    super(orig)
+    @changed_keys = Set.new
+  end
+
+  def set(key, value)
+    index = @keys.index(key)
+    if index
+      @values[index] = value
+    else
+      @keys.push(key)
+      @values.push(value)
+    end
+    @changed_keys.add(key)
+    value
+  end
+  alias []= set
+
+  def clear_changed_keys
+    @changed_keys.clear
+  end
+
+  def method_missing(sym, *args)
+    name = sym.to_s
+    if name.lastn(1) == '='
+      key = name[0..-2]
+      assign = true
+    else
+      key = name
+    end
+    raise RuntimeError.new("unknown field: " + name) unless key?(key)
+
+    if assign
+      set(key, args.first)
+    else
+      get(key)
+    end
+  end
+end
+
+end

data/lib/doh/mysql.rb

@@ -0,0 +1,7 @@
+require 'doh/mysql/cache_connector'
+require 'doh/mysql/connector_instance'
+require 'doh/mysql/handle'
+require 'doh/mysql/to_sql'
+require 'doh/mysql/db_date'
+require 'doh/mysql/unquoted'
+require 'doh/mysql/activate'

data/test/cache_connector.dt.rb

@@ -0,0 +1,41 @@
+require_relative 'db_unit_test'
+
+module DohDb
+
+class Test_CacheConnector < DohTest::TestGroup
+  def create_table
+    @cc.request_handle.query("CREATE TEMPORARY TABLE #@tbl (id INT AUTO_INCREMENT KEY)")
+  end
+
+  def insert_record
+    @cc.request_handle.insert("INSERT INTO #@tbl (id) VALUES (null)")
+  end
+
+  def test_stuff
+    sharedcc = DohDb::connector_instance
+    @cc = DohDb::CacheConnector.new(sharedcc.host, sharedcc.username, sharedcc.password, sharedcc.database, sharedcc.row_builder)
+    @tbl = 'doh_mysql_cache_connector_stuff_test'
+
+    create_table
+    assert_equal(1, insert_record)
+
+    dbh = @cc.request_handle
+    assert_equal(2, insert_record)
+    dbh.close
+    # temporary table gets deleted on handle close
+    create_table
+
+    #test it resets the handle
+    @cc.reset
+    create_table
+    @cc.reset
+    @cc.reset
+
+    # test it still works after timeout
+    create_table
+    @cc.timeout = -1
+    create_table
+  end
+end
+
+end

data/test/connector.yml

@@ -0,0 +1,4 @@
+host: localhost
+database: test
+username: root
+password:

data/test/connector.yml.tmpl

@@ -0,0 +1,4 @@
+host: localhost
+database: test
+username: doh_mysql
+password:

data/test/connector_instance.dt.rb

@@ -0,0 +1,32 @@
+require_relative 'db_unit_test'
+
+module DohDb
+
+class Test_ConnectorInstance < DohTest::TestGroup
+  def test_stuff
+    tbl = "doh_mysql_connector_instance_stuff_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (id INT UNSIGNED AUTO_INCREMENT NOT NULL KEY, value INT NOT NULL DEFAULT 0, created_on DATE, created_at DATETIME, money DECIMAL(7,2) NOT NULL DEFAULT 0)")
+    assert_equal(1, DohDb::insert("INSERT INTO #{tbl} (id, created_on, created_at, money) VALUES (null, CURDATE(), '2007-01-01 10:30:05', 10.5)"))
+    assert_equal(2, DohDb::insert("INSERT INTO #{tbl} (id, created_on) VALUES (null, 0)"))
+    assert_equal(1, DohDb::update("UPDATE #{tbl} SET money = 10.8 WHERE id = 1"))
+    assert_equal(BigDecimal('10.80'), DohDb::select_field("SELECT money FROM #{tbl} WHERE id = 1"))
+    assert_raises(UnexpectedQueryResult) {DohDb::select_row("SELECT * FROM #{tbl} WHERE id = 7")}
+    assert_equal(nil, DohDb::select_optional_row("SELECT * FROM #{tbl} WHERE id = 7"))
+    assert_raises(UnexpectedQueryResult){DohDb::select_optional_row("SELECT * FROM #{tbl} WHERE id < 3")}
+    assert_equal(nil, DohDb::select_optional_field("SELECT money FROM #{tbl} WHERE id = 7"))
+    assert_raises(UnexpectedQueryResult) {DohDb::select_field("SELECT money FROM #{tbl} WHERE id = 7")}
+    assert_equal(1, DohDb::update_row("UPDATE #{tbl} SET money = 10.95 WHERE id = 1"))
+    assert_raises(Mysql::Error){DohDb::query("some invalid sql here")}
+    # TODO: re-enable
+    # assert(DohTest::pop_error)
+    assert_raises(UnexpectedQueryResult) {DohDb::update_row("UPDATE #{tbl} SET money = 10.95 WHERE id = 7")}
+    onerow = DohDb::select_row("SELECT * FROM #{tbl} WHERE id = 1")
+    assert_equal(1, onerow['id'])
+    onerow = DohDb::select_optional_row("SELECT * FROM #{tbl} WHERE id = 1")
+    assert_equal(1, onerow['id'])
+    rows = DohDb::select("SELECT * FROM #{tbl}")
+    rows.each {|row| assert(row['id'] != 0)}
+  end
+end
+
+end

data/test/convert.dt.rb

@@ -0,0 +1,45 @@
+require_relative 'db_unit_test'
+require 'doh/mysql/convert'
+
+module DohDb
+
+class Test_Convert < DohTest::TestGroup
+  def before_each
+    @tbl = "doh_mysql_convert_tests"
+    DohDb::query("DROP TABLE IF EXISTS #@tbl")
+    DohDb::request_handle.query("CREATE TABLE #{@tbl} (not_null_field CHAR(1) NOT NULL, null_ok_field CHAR(1), int_field INT, bool_field TINYINT(1), date_field DATE, datetime_field DATETIME)")
+  end
+
+  def after_each
+    DohDb::query("DROP TABLE IF EXISTS #@tbl")
+  end
+
+  def convert(value)
+    DohDb::convert(@tbl, @field, value)
+  end
+
+  def verify(converted, original)
+    assert_equal(converted, convert(original))
+  end
+
+  def verify_same(value)
+    verify(value, value)
+  end
+
+  def verify_exception(value, exception_class)
+    assert_raises(exception_class) { convert(value) }
+  end
+
+  def test_nil_null
+#    assert_raises(UnknownColumn) { DohDb::convert('some_table_that_doesnt_exist', 'some_column_that_doesnt_exist', 'blah') }
+    assert_equal('blah', DohDb::convert('some_table_that_doesnt_exist', 'some_column_that_doesnt_exist', 'blah'))
+    assert_equal('blah', DohDb::convert('', 'some_column_that_doesnt_exist', 'blah'))
+    assert_raises(CannotBeNull) { DohDb::convert(@tbl, 'not_null_field', nil) }
+    assert_equal(nil, DohDb::convert(@tbl, 'null_ok_field', nil))
+    assert_equal('', DohDb::convert(@tbl, 'not_null_field', ''))
+    assert_equal(nil, DohDb::convert(@tbl, 'null_ok_field', ''))
+    assert_equal(nil, DohDb::convert(@tbl, 'int_field', ''))
+  end
+end
+
+end

data/test/db_unit_test.rb

@@ -0,0 +1,10 @@
+require 'doh/mysql/connector_instance'
+require 'doh/mysql/cache_connector'
+require 'yaml'
+
+config_filename = File.join(File.dirname(__FILE__), 'connector.yml')
+raise RuntimeError.new("mysql connector configuration file (#{config_filename}) must exist (see #{config_filename}.tmpl for an example)") unless File.exist?(config_filename)
+config = YAML.load_file(config_filename)
+
+connector = DohDb::CacheConnector.new(config['host'], config['username'], config['password'], config['database'])
+DohDb::set_connector_instance(connector)

data/test/handle.dt.rb

@@ -0,0 +1,112 @@
+require_relative 'db_unit_test'
+require 'doh/core_ext/hash'
+
+module DohDb
+
+class Test_Handle < DohTest::TestGroup
+  def test_stuff
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_stuff_test"
+    dbh.query("CREATE TEMPORARY TABLE #{tbl} (id INT UNSIGNED AUTO_INCREMENT NOT NULL KEY, value INT NOT NULL DEFAULT 0, created_on DATE, created_at DATETIME, money DECIMAL(7,2) NOT NULL DEFAULT 0)")
+    assert_equal(1, dbh.insert("INSERT INTO #{tbl} (id, created_on, created_at, money) VALUES (null, CURDATE(), '2007-01-01 10:30:05', 10.5)"))
+    assert_equal(2, dbh.insert("INSERT INTO #{tbl} (id, created_on, created_at) VALUES (null, 0, 0)"))
+    assert_equal(3, dbh.insert("INSERT INTO #{tbl} (id) VALUES (null)"))
+    onerow = dbh.select_row("SELECT * FROM #{tbl} WHERE id = 1")
+    assert_equal(1, onerow['id'])
+    rows = dbh.select("SELECT * FROM #{tbl}")
+    rows.each {|row| assert(row['id'] != 0)}
+  end
+
+  def test_select_transpose_2fields
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_select_transpose_2fields_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (field CHAR(30) NOT NULL, value CHAR(30) NOT NULL)")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'some_name', value = 'some_value'")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'other_name', value = 'matching_other_value'")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'yet_another_name', value = 'strange_value'")
+    hash = DohDb::select_transpose("SELECT field, value FROM #{tbl}")
+    assert_equal('some_value', hash['some_name'])
+    assert_equal('matching_other_value', hash['other_name'])
+    assert_equal('strange_value', hash['yet_another_name'])
+  end
+
+  def test_select_transpose_3fields
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_select_transpose_3fields_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (field CHAR(30), some_value CHAR(30), other_value CHAR(30))")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'some_name', some_value = 'some_value', other_value = 'blah'")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'other_name', some_value = 'matching_other_value', other_value = 'blee'")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'yet_another_name', some_value = 'strange_value', other_value = 'bloo'")
+    hash = DohDb::select_transpose("SELECT field, some_value, other_value FROM #{tbl}")
+    assert_equal(hash['some_name'], {'some_value' => 'some_value', 'other_value' => 'blah'})
+    assert_equal(hash['other_name'], {'some_value' => 'matching_other_value', 'other_value' => 'blee'})
+    assert_equal(hash['yet_another_name'], {'some_value' => 'strange_value', 'other_value' => 'bloo'})
+  end
+
+  def test_select_values
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_select_values_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (field CHAR(30), some_value CHAR(30))")
+    DohDb::query("INSERT INTO #{tbl} SET field = 'some_name', some_value = 'some_value'")
+    assert_equal([['some_name', 'some_value']], DohDb::select_values("SELECT field, some_value FROM #{tbl}"))
+    assert_equal([['some_name']], DohDb::select_values("SELECT field FROM #{tbl}"))
+  end
+
+  def test_multi_select
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_handle_multi_select_test"
+    DohDb::query("CREATE TEMPORARY TABLE #{tbl} (value CHAR(30))")
+    DohDb::query("INSERT INTO #{tbl} SET value = 'first'")
+    DohDb::query("INSERT INTO #{tbl} SET value = 'second'")
+
+    stmts = []
+    stmts.push("SELECT * FROM #{tbl}")
+    stmts.push("INSERT INTO #{tbl} SET value = 'third'")
+    stmts.push(["SELECT * FROM #{tbl}", :hash])
+    stmts.push("SELECT * FROM #{tbl}")
+    stmts.push("INSERT INTO #{tbl} SET value = 'fourth'")
+    stmts.push(["SELECT * FROM #{tbl}", :smart])
+    select_results = DohDb::multi_select(stmts)
+    assert_equal(4, select_results.size)
+    assert_equal(4, DohDb::select_field("SELECT COUNT(*) FROM #{tbl}"))
+
+    curr_select = select_results[0]
+    assert_equal(2, curr_select.size)
+    assert_instance_of(ReadOnlyRow, curr_select[0])
+    assert_equal({'value' => 'first'}, curr_select[0].to_h)
+    assert_equal({'value' => 'second'}, curr_select[1].to_h)
+
+    curr_select = select_results[1]
+    assert_equal(3, curr_select.size)
+    assert_instance_of(Hash, curr_select[0])
+    assert_equal({'value' => 'first'}, curr_select[0].to_h)
+    assert_equal({'value' => 'second'}, curr_select[1].to_h)
+    assert_equal({'value' => 'third'}, curr_select[2].to_h)
+
+    curr_select = select_results[2]
+    assert_equal(3, curr_select.size)
+    assert_equal({'value' => 'first'}, curr_select[0].to_h)
+    assert_equal({'value' => 'second'}, curr_select[1].to_h)
+    assert_equal({'value' => 'third'}, curr_select[2].to_h)
+
+    curr_select = select_results[3]
+    assert_equal(4, curr_select.size)
+    assert_instance_of(SmartRow, curr_select[0])
+    assert_equal({'value' => 'first'}, curr_select[0].to_h)
+    assert_equal({'value' => 'second'}, curr_select[1].to_h)
+    assert_equal({'value' => 'third'}, curr_select[2].to_h)
+    assert_equal({'value' => 'fourth'}, curr_select[3].to_h)
+  end
+
+  def test_insert_hash
+    dbh = DohDb::request_handle
+    tbl = "doh_mysql_insert_hash_test"
+    dbh.query("CREATE TEMPORARY TABLE #{tbl} (value INT KEY)")
+    hash1 = {'value' => 1}
+    assert_equal(0, dbh.insert_hash(hash1, tbl))
+    assert_raises(Mysql::Error) { dbh.insert_hash(hash1, tbl) }
+    assert_equal(0, dbh.insert_hash(hash1, tbl, true))
+  end
+end
+
+end

data/test/metadata_util.dt.rb

@@ -0,0 +1,53 @@
+require_relative 'db_unit_test'
+require 'doh/mysql/metadata_util'
+
+module DohDb
+
+class Test_metadata_util < DohTest::TestGroup
+  def tbl
+    "doh_mysql_metadata_util_test"
+  end
+
+  def test_stuff
+    dbh = DohDb::request_handle
+    dbh.query("CREATE TABLE #{tbl} (num INT, str CHAR(7))")
+    column_info = DohDb::column_info(tbl)
+    info = column_info['str']
+    assert_equal('char', info['data_type'])
+    assert_equal(7, info['character_maximum_length'])
+    info = column_info['num']
+    assert_equal('int', info['data_type'])
+    assert_equal(nil, info['character_maximum_length'])
+
+    assert_equal(7, DohDb::field_character_size(tbl, 'str'))
+    assert_equal(nil, DohDb::field_character_size(tbl, 'num'))
+
+    row = {'num' => 'blahblahblah', 'str' => 'blahblahblah'}
+    DohDb::chop_character_fields!(tbl, row)
+    assert_equal('blahblahblah', row['num'])
+    assert_equal('blahbla', row['str'])
+
+    row = {'num' => 'blahblahblah', 'str' => 'blahblahblah'}
+    newrow = DohDb::chop_character_fields(tbl, row)
+    assert_equal('blahblahblah', newrow['num'])
+    assert_equal('blahbla', newrow['str'])
+    assert_equal('blahblahblah', row['num'])
+    assert_equal('blahblahblah', row['str'])
+
+    assert(DohDb::table_exist?(tbl))
+
+    assert_equal('num', DohDb::find_primary_key(tbl))
+    assert_raises(RuntimeError) { DohDb::find_primary_key(tbl, "this_database_doesnt_exist") }
+    assert_raises(RuntimeError) { DohDb::find_primary_key("this table doesn't exist") }
+  end
+
+  def before_each
+    DohDb::query("DROP TABLE IF EXISTS #{tbl}")
+  end
+
+  def after_each
+    DohDb::query("DROP TABLE IF EXISTS #{tbl}")
+  end
+end
+
+end

data/test/parse.dt.rb

@@ -0,0 +1,39 @@
+require 'doh/mysql/parse'
+
+module DohDb
+
+class Test_Parse < DohTest::TestGroup
+  def test_bool
+    assert_equal(false, DohDb::parse_bool('0'))
+    assert_equal(true, DohDb::parse_bool('1'))
+    assert_raises(ArgumentError) {DohDb::parse_bool('blah')}
+  end
+
+  def test_date
+    assert_raises(ArgumentError) {DohDb::parse_date('blah')}
+    assert_equal(Date.new(2008,2,14), DohDb::parse_date('2008-02-14'))
+    assert_raises(ArgumentError) {DohDb::parse_date('20080214')}
+    assert_not_equal(Date.new(2008,2,14), DohDb::parse_date('2008-02-15'))
+    assert_equal(nil, DohDb::parse_date('0000-00-00'))
+  end
+
+  def test_datetime
+    assert_raises(ArgumentError) {DohDb::parse_date('blah')}
+    assert_raises(ArgumentError) {DohDb::parse_datetime('zzzzzzzzzzzzzzzzzzz')}
+    assert_equal(DateTime.new(2008,2,14,10,20,30), DohDb::parse_datetime('2008-02-14 10:20:30'))
+    assert_not_equal(DateTime.new(2008,2,14,10,20,30), DohDb::parse_datetime('2008-02-14 10:20:31'))
+    assert_equal(nil, DohDb::parse_datetime('0000-00-00 00:00:00'))
+  end
+
+  def test_decimal
+    assert_equal(BigDecimal.new('3.14'), DohDb::parse_decimal('3.14'))
+    assert_equal(BigDecimal.new('0.0'), DohDb::parse_decimal('sjdkflsdjl'))
+  end
+
+  def test_int
+    assert_equal(3, DohDb::parse_int('3'))
+    assert_equal(0, DohDb::parse_int('sjdkflsdjl'))
+  end
+end
+
+end

data/test/readonly_row.dt.rb

@@ -0,0 +1,85 @@
+require 'doh/mysql/readonly_row'
+
+module DohDb
+
+class Test_ReadOnlyRow < DohTest::TestGroup
+  def before_each
+    @row = ReadOnlyRow.new(['id', 'fname', 'lname', 'other', 'flag', 'emptystr'], [3, 'george', 'bob', nil, true, ''])
+  end
+
+  def test_keys
+    assert_equal(['id', 'fname', 'lname', 'other', 'flag', 'emptystr'], @row.keys)
+  end
+
+  def test_at_bad
+    assert_raises(TypeError) {@row.at(nil)}
+    assert_raises(TypeError) {@row.at('id')}
+    assert_equal(nil, @row.at(8))
+    assert_equal(nil, @row.at(-10))
+  end
+
+  def test_bracket_get_bad
+    assert_equal(nil, @row[nil])
+    assert_equal(nil, @row['blee'])
+    assert_equal(nil, @row[8])
+    assert_equal(nil, @row[-10])
+  end
+
+  def test_bracket_get_valid
+    assert_equal(3, @row['id'])
+    assert_equal('george', @row['fname'])
+    assert_equal('bob', @row['lname'])
+    assert_equal(nil, @row['other'])
+  end
+
+  def test_key_exists_bad
+    assert_equal(false, @row.key?(nil))
+    assert_equal(false, @row.key?('blee'))
+    assert_equal(false, @row.key?(8))
+    assert_equal(false, @row.key?(-10))
+    assert_equal(false, @row.key?(-10))
+  end
+
+  def test_key_exists_valid
+    assert_equal(true, @row.key?('id'))
+    assert_equal(true, @row.key?('fname'))
+    assert_equal(true, @row.key?('lname'))
+    assert_equal(true, @row.key?('other'))
+  end
+
+  def test_to_a
+    ary = @row.to_a
+    assert_equal(6, ary.size)
+    assert_equal(['id', 3], ary.at(0))
+    assert_equal(['fname','george'], ary.at(1))
+    assert_equal(['lname', 'bob'], ary.at(2))
+    assert_equal(['other', nil], ary.at(3))
+    assert_equal(['flag', true], ary.at(4))
+    assert_equal(['emptystr', ''], ary.at(5))
+  end
+
+  def test_to_h
+    hsh = @row.to_h
+    assert_equal(6, hsh.size)
+    assert_equal(3, hsh['id'])
+    assert_equal('george', hsh['fname'])
+    assert_equal('bob', hsh['lname'])
+    assert_equal(nil, hsh['other'])
+  end
+
+  def test_method_missing
+    assert_equal('george', @row.fname)
+    assert_equal('bob', @row.lname)
+    assert_equal(nil, @row.other)
+    assert_raises(RuntimeError) {@row.this_field_doesnt_exist}
+  end
+
+  def test_empty_field
+    assert(!@row.empty_field?('id'))
+    assert(@row.empty_field?('other'))
+    assert(@row.empty_field?('emptystr'))
+    assert(@row.empty_field?('unknown_field_name'))
+  end
+end
+
+end

data/test/smart_row.dt.rb

@@ -0,0 +1,21 @@
+require 'doh/mysql/smart_row'
+
+module DohDb
+
+class Test_SmartRow < DohTest::TestGroup
+  def test_display
+    row = SmartRow.new(['flag'], [true])
+    assert_equal('', row.display('this_field_doesnt_exist'))
+    assert_raises(RuntimeError) { row.display.this_field_doesnt_exist }
+    assert_equal('yes', row.display('flag'))
+    assert_equal('yes', row.display.flag)
+    row2 = row.dup
+    assert_equal(true, row2.flag)
+    row2.flag = false
+    assert_equal(false, row2.flag)
+    assert_equal(true, row.flag)
+    assert_raises(RuntimeError) { row.this_field_doesnt_exist }
+  end
+end
+
+end