dohmysql 0.1.0

data/lib/doh/mysql/handle.rb

@@ -0,0 +1,218 @@
+require 'doh/array_to_hash'
+require 'doh/log/stub'
+require 'doh/mysql/error'
+require 'doh/mysql/typed_row_builder'
+require 'doh/mysql/writable_row'
+require 'doh/mysql/hash_row'
+require 'doh/mysql/smart_row'
+
+module DohDb
+
+class Handle
+  def initialize(mysqlh, row_builder = nil)
+    @mysqlh = mysqlh
+    @row_builder = row_builder || TypedRowBuilder.new
+  end
+
+  def close
+    unless closed?
+      dohlog.info("closing raw mysql handle: #@mysqlh")
+      @mysqlh.close
+      @mysqlh = nil
+    end
+  end
+
+  def closed?
+    @mysqlh.nil?
+  end
+
+  def query(statement)
+    generic_query(statement)
+    retval = @mysqlh.affected_rows
+    dohlog.info("affected #{retval} rows")
+    retval
+  end
+
+  def update(statement)
+    generic_query(statement)
+    retval = @mysqlh.affected_rows
+    dohlog.info("updated #{retval} rows")
+    retval
+  end
+
+  def update_row(statement)
+    retval = update(statement)
+    raise UnexpectedQueryResult, "updated #{retval} rows; expected 1" unless retval == 1
+    retval
+  end
+
+  def update_hash(hash, table, primary_key_value, primary_key_name)
+    items = hash.keys.collect {|key| key + ' = ' + hash[key].to_sql}
+    query("UPDATE #{table} SET #{items.join(', ')} WHERE #{primary_key_name} = #{primary_key_value.to_sql}")
+  end
+
+  def insert(statement)
+    generic_query(statement)
+    retval = @mysqlh.insert_id
+    dohlog.info("insert_id was #{retval}")
+    retval
+  end
+
+  def insert_hash(hash, table, ignore = nil)
+    if ignore then keyword = 'INSERT IGNORE' else keyword = 'INSERT' end
+    insert_hash_helper(hash, table, keyword)
+  end
+
+  def replace_hash(hash, table)
+    insert_hash_helper(hash, table, 'REPLACE')
+  end
+
+  # The most generic form of select.
+  # It calls to_s on the statement object to facilitate the use of sql builder objects.
+  def select(statement, row_builder = nil)
+    result_set = generic_query(statement)
+    dohlog.info("selected #{result_set.num_rows} rows")
+    rows = get_row_builder(row_builder).build_rows(result_set)
+    result_set.free
+    rows
+  end
+
+  # Simple convenience wrapper around the generic select call.
+  # Throws an exception unless the result set is a single row.
+  # Returns the row selected.
+  def select_row(statement, row_builder = nil)
+    rows = select(statement, row_builder)
+    raise UnexpectedQueryResult, "selected #{rows.size} rows; expected 1" unless rows.size == 1
+    rows[0]
+  end
+
+  # Simple convenience wrapper around the generic select call.
+  # Throws an exception unless the result set is empty or a single row.
+  # Returns nil if the result set is empty, or the row selected.
+  def select_optional_row(statement, row_builder = nil)
+    rows = select(statement, row_builder)
+    raise UnexpectedQueryResult, "selected #{rows.size} rows; expected 0 or 1" if rows.size > 1
+    if rows.empty? then nil else rows[0] end
+  end
+
+  # Simple convenience wrapper around select_row.
+  # Returns the first (and typically, the only) field from the selected row.
+  def select_field(statement, row_builder = nil)
+    select_row(statement, row_builder).at(0)
+  end
+
+  # Simple convenience wrapper around select_optional_row.
+  # Returns the first (and typically, the only) field from the selected row, if any, or nil.
+  def select_optional_field(statement, row_builder = nil)
+    row = select_optional_row(statement, row_builder)
+    row && row.at(0)
+  end
+
+  # Rows in the result set must have 2 or more fields.
+  # If there are 2 fields, returns a hash where each key is the first field in the result set, and the value is the second field.
+  # If there are more than 2 fields, returns a hash where each key is the first field in the result set,
+  # and the value is the row itself, as a Hash, and without the field used as a key.
+  def select_transpose(statement, row_builder = nil)
+    rows = select(statement, row_builder)
+    return {} if rows.empty?
+    field_count = rows.first.size
+    if field_count < 2
+      raise UnexpectedQueryResult, "must select at least 2 fields in order to transpose"
+    elsif field_count == 2
+      Doh::array_to_hash(rows) { |row| [row.at(0), row.at(1)] }
+    else
+      key_field = rows.first.keys.first
+      Doh::array_to_hash(rows) do |row|
+        value = row.to_h
+        value.delete(key_field)
+        [row.at(0), value]
+      end
+    end
+  end
+
+  # Returns an array of arrays, where the individual arrays contain just the values from each database row -- they lack field names.
+  def select_values(statement, row_builder = nil)
+    select(statement, row_builder).collect { |row| row.values }
+  end
+
+  # Returns an array of the first (and typically, the only) field of every row in the result set.
+  def select_list(statement, row_builder = nil)
+    select(statement, row_builder).collect { |row| row.at(0) }
+  end
+
+  def multi_select(statement_infos, dflt_row_builder = nil)
+    statements = []
+    row_builders = []
+    statement_infos.each do |info|
+      if info.is_a?(Array)
+        statements.push(info.first)
+        row_builders.push(info.last)
+      else
+        statements.push(info)
+        row_builders.push(nil)
+      end
+    end
+    sqlstr = statements.join(';')
+
+    dohlog.info(sqlstr)
+    @mysqlh.query(sqlstr)
+    retval = []
+    while true
+      custom_builder = row_builders.shift
+      if @mysqlh.field_count > 0
+        result_set = @mysqlh.store_result
+        dohlog.info("selected #{result_set.num_rows} rows")
+        rows = get_row_builder(custom_builder || dflt_row_builder).build_rows(result_set)
+        result_set.free
+        retval.push(rows)
+      end
+      break unless @mysqlh.next_result
+    end
+    retval
+  rescue Exception => excpt
+    dohlog.error("caught exception during query: #{sqlstr}", excpt)
+    raise
+  end
+
+private
+  def generic_query(statement)
+    sqlstr = statement.to_s
+    dohlog.info(sqlstr)
+    @mysqlh.query(sqlstr)
+    @mysqlh.store_result if @mysqlh.field_count > 0
+  rescue Exception => excpt
+    dohlog.error("caught exception during query: #{sqlstr}", excpt)
+    raise
+  end
+
+  def insert_hash_helper(hash, table, keyword)
+    names = []
+    values = []
+    hash.each_pair do |key, value|
+      names.push(key)
+      values.push(value.to_sql)
+    end
+
+    insert("#{keyword} INTO #{table} (#{names.join(',')}) VALUES (#{values.join(',')})")
+  end
+
+  def get_row_builder(row_builder = nil)
+    if row_builder.nil?
+      @row_builder
+    elsif row_builder == :read
+      TypedRowBuilder.new(ReadOnlyRow)
+    elsif row_builder == :hash
+      TypedRowBuilder.new(HashRow)
+    elsif row_builder == :write
+      TypedRowBuilder.new(WritableRow)
+    elsif row_builder == :smart
+      TypedRowBuilder.new(SmartRow)
+    elsif row_builder.respond_to?('build_rows')
+      row_builder
+    else
+      TypedRowBuilder.new(row_builder)
+    end
+  end
+end
+
+end

data/lib/doh/mysql/hash_row.rb

@@ -0,0 +1,13 @@
+module DohDb
+
+class HashRow
+  def self.new(keys, values)
+    hash = {}
+    keys.each_with_index do |key, index|
+      hash[key] = values.at(index)
+    end
+    hash
+  end
+end
+
+end

data/lib/doh/mysql/load_sql.rb

@@ -0,0 +1,26 @@
+require 'doh/mysql/connector_instance'
+
+module DohDb
+
+def self.mysql_arg(value, option_specifier)
+  return '' if value.to_s.strip.empty?
+  ' -' + option_specifier + value
+end
+
+def self.load_sql(filenames, host, username, password, database)
+  mysqlcmd = 'mysql' + mysql_arg(host, 'h') + mysql_arg(username, 'u') + mysql_arg(password, 'p') + ' ' + database
+  io = IO::popen(mysqlcmd, 'r+')
+  dohlog.debug("loading sql file: " + filenames.first) if filenames.size == 1
+  filenames.each do |elem|
+    open(elem) {|file| io << file.read}
+  end
+  io.close
+end
+
+def self.load_sql_connector(filenames, connector = nil, alternate_database = nil)
+  connector ||= DohDb::connector_instance
+  load_sql(filenames, connector.host, connector.username, connector.password, alternate_database || connector.database)
+end
+
+end
+

data/lib/doh/mysql/metadata_util.rb

@@ -0,0 +1,73 @@
+require 'doh/mysql'
+require 'doh/mysql/to_sql'
+
+module DohDb
+
+@@cached_column_info = {}
+def self.column_info(table, database = nil)
+  database ||= DohDb::connector_instance.database
+  lookup_str = database + '.' + table
+  return @@cached_column_info[lookup_str] if @@cached_column_info[lookup_str]
+  stmt = "SELECT column_name, is_nullable, data_type, character_maximum_length, numeric_scale, column_type FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=#{database.to_sql} AND TABLE_NAME=#{table.to_sql}"
+  @@cached_column_info[lookup_str] = DohDb::select_transpose(stmt)
+end
+
+def self.field_character_size(table, field, database = nil)
+  column_info(table, database).fetch(field, {}).fetch('character_maximum_length')
+end
+
+def self.chop_character_fields!(table, row)
+  column_info(table).each do |field, attribs|
+    maxlen = attribs['character_maximum_length']
+    if maxlen && row[field].to_s.size > maxlen
+      row[field] = row[field].to_s[0, maxlen]
+    end
+  end
+  row
+end
+
+def self.chop_character_fields(table, row)
+  chop_character_fields!(table, row.dup)
+end
+
+def self.field_exist?(table, field, database = nil)
+  column_info(table, database).key?(field)
+end
+
+@@primary_keys = {}
+def self.find_primary_key(table, database = nil)
+  if table.index('.')
+    database = table.before('.')
+    table = table.after('.')
+  else
+    database ||= DohDb::connector_instance.database
+  end
+
+  dbhash = @@primary_keys[database]
+  if dbhash.nil?
+    dbhash = DohDb::select_transpose("SELECT table_name, column_name FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=#{database.to_sql} AND ORDINAL_POSITION=1")
+    raise "no information found for database #{database}" if dbhash.empty?
+    @@primary_keys[database] = dbhash
+  end
+
+  retval = dbhash[table]
+  raise "attempting to find_primary_key for table that doesn't exist: #{database}.#{table}" if retval.nil?
+  retval
+end
+
+def self.table_exist?(table, database = nil)
+  !find_primary_key(table, database).nil?
+end
+
+def self.field_list(table, database = nil)
+  column_info(table, database).keys
+end
+
+@@tables_by_database = {}
+def self.all_tables(database = nil)
+  database ||= DohDb::connector_instance.database
+  @@tables_by_database[database] ||
+    @@tables_by_database[database] ||= DohDb::select_list("SELECT table_name FROM information_schema.tables WHERE table_schema = '#{database}'")
+end
+
+end

data/lib/doh/mysql/parse.rb

@@ -0,0 +1,36 @@
+require 'bigdecimal'
+require 'date'
+
+module DohDb
+
+def self.parse_bool(str)
+  if str == '0'
+    false
+  elsif str == '1'
+    true
+  else
+    raise ArgumentError.new("unexpected value: " + str)
+  end
+end
+
+def self.parse_datetime(str)
+  raise ArgumentError.new("unexpected value: " + str) unless str.size == 19
+  return nil if str == '0000-00-00 00:00:00'
+  DateTime.parse(str)
+end
+
+def self.parse_date(str)
+  raise ArgumentError.new("unexpected value: " + str) unless str.size == 10
+  return nil if str == '0000-00-00'
+  Date.new(str[0..3].to_i, str[5..6].to_i, str[8..9].to_i)
+end
+
+def self.parse_decimal(str)
+  BigDecimal(str)
+end
+
+def self.parse_int(str)
+  str.to_i
+end
+
+end

data/lib/doh/mysql/raw_row_builder.rb

@@ -0,0 +1,15 @@
+require 'mysql'
+require 'doh/mysql/readonly_row'
+
+module DohDb
+
+class RawRowBuilder
+  def build_rows(result_set)
+    field_names = result_set.fetch_fields.collect {|elem| elem.name}
+    retval = []
+    result_set.each {|elem| retval.push(DohDb::ReadOnlyRow.new(field_names, elem))}
+    retval
+  end
+end
+
+end

data/lib/doh/mysql/readonly_row.rb

@@ -0,0 +1,26 @@
+require 'doh/mysql/abstract_row'
+
+module DohDb
+
+class ReadOnlyRow < AbstractRow
+  # can accept 2 arguments: keys array, values array
+  # or 1 argument: a hash
+  def initialize(*args)
+    keys, values = parse_initialize_args(*args)
+    @keys = keys.freeze
+    @values = values.freeze
+    freeze
+  end
+
+  def method_missing(sym, *ignore)
+    key = sym.to_s
+    index = @keys.index(key)
+    if index
+      @values.at(index)
+    else
+      raise RuntimeError.new("unknown field: " + key)
+    end
+  end
+end
+
+end

data/lib/doh/mysql/require_dbtypes.rb

@@ -0,0 +1,8 @@
+module DohDb
+
+def self.require_dbtypes
+  lib_dbtypes_file = File.join(Doh::root, 'lib/dbtypes.rb')
+  require(lib_dbtypes_file) if File.exist?(lib_dbtypes_file)
+end
+
+end

data/lib/doh/mysql/smart_row.rb

@@ -0,0 +1,156 @@
+require 'doh/mysql/writable_row'
+require 'doh/to_display'
+require 'doh/mysql/virtual'
+
+module DohDb
+
+class RowDisplayProxy
+  def initialize(row)
+    @row = row
+  end
+
+  def method_missing(sym, *ignore_args)
+    @row.send(sym.to_s).to_display
+  end
+end
+
+class AbstractSmartRow < AbstractRow
+  attr_accessor :table
+  attr_reader :changed_keys
+
+  def initialize(keys, values)
+    @keys = keys.dup
+    @values = values.dup
+    @changed_keys = Set.new
+    @cached_virtuals = {}
+  end
+
+  def initialize_copy(orig)
+    @keys = @keys.dup
+    @values = @values.dup
+    @changed_keys = @changed_keys.dup
+    @cached_virtuals = @cached_virtuals.dup
+    @display_proxy = nil
+  end
+
+  def display(key = nil)
+    if key.nil?
+      @display_proxy ||= RowDisplayProxy.new(self)
+    else
+      get(key).to_display
+    end
+  end
+
+  def set(key, value, flag_changed = true)
+    index = @keys.index(key)
+    if index
+      if @values[index] != value
+        @values[index] = value
+        @changed_keys.add(key)
+      end
+    else
+      @keys.push(key)
+      @values.push(value)
+      @changed_keys.add(key)
+    end
+    value
+  end
+  alias []= set
+
+  def clear_changed_keys
+    @changed_keys.clear
+  end
+
+  def method_missing(sym, *args)
+    name = sym.to_s
+    if name.end_with?('=')
+      guess_missing_set(name[0..-2], args.first)
+    else
+      guess_missing_get(name)
+    end
+  end
+
+  def merge!(hash)
+    hash.each_pair { |key, value| set(key, value) }
+  end
+
+  def delete(key)
+    index = @keys.index(key)
+    return unless index
+    @keys.delete_at(index)
+    @values.delete_at(index)
+  end
+
+  def record_id=(value)
+    set(primary_key, value)
+  end
+
+  def db_insert
+    newid = DohDb::insert_hash(self, @table)
+    if newid != 0
+      set(primary_key, newid, false)
+    end
+    newid
+  end
+
+  def db_update
+    return if @changed_keys.empty?
+    before_db_update
+    builder = BuildSQL::SimpleUpdateRow.new(@table, nil, get(primary_key), primary_key)
+    @changed_keys.each {|key| builder.setc(key, get(key).to_sql)}
+    DohDb::query(builder)
+    after_db_update
+    @changed_keys.clear
+  end
+
+protected
+  def primary_key
+    DohDb::find_primary_key(@table)
+  end
+
+  def before_db_update
+  end
+
+  def after_db_update
+  end
+
+  def guess_missing_get(key)
+    return get(key) if key?(key)
+    retval = get_virtual_field(key)
+    raise "unknown field: #{key}" unless retval
+    retval
+  end
+
+  def guess_missing_set(key, value)
+    set(key, value)
+  end
+
+  def get_virtual_field(name)
+    cached = @cached_virtuals[name]
+    return cached if cached
+    if idvalue = get(name + '_id')
+      @cached_virtuals[name] = DohDb::LinkedRow.build(name, idvalue.to_i)
+    else
+      nil
+    end
+  end
+end
+
+class SmartRow < AbstractSmartRow
+  def initialize(*args)
+    parsed_args = parse_initialize_args(*args)
+    if parsed_args.size == 3
+      @table = parsed_args.pop
+    end
+    super(*parsed_args)
+  end
+end
+
+class CustomSmartRow < AbstractSmartRow
+  def initialize(*args)
+    super(*parse_initialize_args(*args))
+    @table = self.class.default_table
+  end
+end
+
+end

data/lib/doh/mysql/to_sql.rb

@@ -0,0 +1,65 @@
+require 'bigdecimal'
+require 'date'
+begin
+  require 'mysql'
+  $mysql_loaded = true
+rescue
+  $mysql_loaded = false
+end
+
+class Object
+  def to_sql
+    if $mysql_loaded
+      str = Mysql.escape_string(to_s)
+    else
+      str = non_mysql_escape_string
+    end
+    '"' + str + '"'
+  end
+private
+  def non_mysql_escape_string
+    str.gsub('\\', '\\\\').gsub('\'', '\\\'').gsub('"', '\\"')
+  end
+end
+
+class NilClass
+  def to_sql
+    'NULL'
+  end
+end
+
+class Numeric
+  def to_sql
+    to_s
+  end
+end
+
+class DateTime
+  def to_sql
+    '"' + strftime('%Y-%m-%d %H:%M:%S') + '"'
+  end
+end
+
+class TrueClass
+  def to_sql
+    '1'
+  end
+end
+
+class FalseClass
+  def to_sql
+    '0'
+  end
+end
+
+class BigDecimal
+  def to_sql
+    to_s('F')
+  end
+end
+
+class Array
+  def to_sql
+    '(' + collect { |elem| elem.to_sql }.join(',') + ')'
+  end
+end

data/lib/doh/mysql/typed_row_builder.rb

@@ -0,0 +1,28 @@
+require 'doh/mysql/readonly_row'
+require 'doh/mysql/default_type_guesser'
+
+module DohDb
+
+class TypedRowBuilder
+  def initialize(row_klass = nil, guesser = nil)
+    @row_klass = row_klass || ReadOnlyRow
+    @guesser = guesser || DefaultTypeGuesser
+  end
+
+  def build_rows(result_set)
+    meta_info = result_set.fetch_fields
+    field_names = meta_info.collect {|elem| elem.name}
+
+    retval = []
+    result_set.each do |row|
+      typed_values = []
+      row.each_with_index do |field, index|
+        typed_values[index] = @guesser.guess_type(field, meta_info[index])
+      end
+      retval.push(@row_klass.new(field_names, typed_values))
+    end
+    retval
+  end
+end
+
+end

data/lib/doh/mysql/types.rb

@@ -0,0 +1,33 @@
+module DohDb
+
+@@column_types = {}
+def self.register_column_type(database, table, column, klass)
+  database = '__global__' # until database support is available
+  @@column_types[database] ||= {}
+  table = '__global__' if table.nil?
+  @@column_types[database][table] ||= {}
+  @@column_types[database][table][column] = klass
+end
+
+def self.find_column_type(database, table, column)
+  database = '__global__' # until database support is available
+  db_hash = @@column_types[database]; return nil unless db_hash
+  table = '__global__' if table.nil?
+  table_hash = db_hash[table]; return nil unless table_hash
+  table_hash[column]
+end
+
+def self.link_database_types(dest_db, source_db)
+  @@column_types[dest_db] = @@column_types[source_db]
+end
+
+@@row_types = {}
+def self.register_row_type(table, klass)
+  @@row_types[table] = klass
+end
+
+def self.find_row_type(table)
+  @@row_types[table]
+end
+
+end