dohmysql 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Makani Mason, Kem Mason
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/makedb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'doh/app/pwd'
+require 'doh/options'
+require 'doh/mysql/database_creator'
+
+opts = Doh::Options.new(
+{'drop_first' => [false, "-z", "--drop_first", "if true, will drop the database or tables before creating"] \
+,'database' => [Doh::config['primary_database'], "-d", "--database <database>", "name of the source database -- defaults to config['primary_database'], currently '#{Doh::config['primary_database']}'"] \
+,'all' => [false, "-a", "--all", "create all databases"] \
+,'target' => [Doh::config['target_database'], "-g", "--target <database>", "name of the target database -- defaults to same as source"] \
+,'tables' => [nil, "-t", "--tables <tables>", "comma-delimited list of tables to create; if specified, no databases are dropped or created"]
+})
+
+if opts.database.to_s.empty? && !opts.all
+  puts "You must specify a database (either here with -d or in your config) or all (with -a)"
+  exit 1
+end
+
+db_creator = DohDb::DatabaseCreator.new
+if opts.tables
+  db_creator.create_tables(opts.database, opts.drop_first, opts.tables.split(/,/))
+elsif opts.all
+  db_creator.create_all_databases(opts.drop_first)
+elsif opts.target
+  db_creator.create_database_copy(opts.target, opts.database, opts.drop_first)
+else
+  db_creator.create_database(opts.database, opts.drop_first)
+end

data/lib/doh/mysql/abstract_row.rb

@@ -0,0 +1,80 @@
+require 'doh/core_ext/class/force_deep_copy'
+
+module DohDb
+
+class AbstractRow
+  attr_reader :keys, :values
+  force_deep_copy :keys, :values
+
+  def at(index)
+    @values.at(index)
+  end
+
+  def get(key)
+    index = @keys.index(key)
+    if index
+      @values.at(index)
+    else
+      nil
+    end
+  end
+  alias [] get
+
+  def key?(key)
+    !@keys.index(key).nil?
+  end
+
+  def to_a
+    retval = []
+    @keys.size.times {|index| retval.push([@keys[index], @values[index]])}
+    retval
+  end
+
+  def to_h
+    retval = {}
+    @keys.each_with_index {|key, index| retval[key] = @values.at(index)}
+    retval
+  end
+
+  def inspect
+    ary = []
+    @keys.size.times {|index| ary.push([@keys[index], @values[index]])}
+    ary.inspect
+  end
+
+  def each_pair
+    @keys.size.times do |index|
+      yield(@keys.at(index), @values.at(index))
+    end
+  end
+
+  def size
+    @keys.size
+  end
+
+  def empty_field?(key)
+    return true if !key?(key)
+    val = get(key)
+    return val.nil? || (val.respond_to?(:empty?) && val.empty?)
+  end
+
+  def record_id
+    get('id')
+  end
+
+protected
+  def parse_initialize_args(*args)
+    if args.empty?
+      [[], []]
+    elsif args[0].is_a?(Array)
+      raise "first arg is array, second must be also" unless args[1].is_a?(Array)
+      raise "first two args are arrays, must be of the same size" unless args[0].size == args[1].size
+      args
+    else
+      hash = args[0]
+      [hash.keys, hash.values] + args[1..-1]
+    end
+  end
+end
+
+end

data/lib/doh/mysql/activate.rb

@@ -0,0 +1,31 @@
+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/config'
+
+module DohDb
+
+def self.activate
+  root_cfg = Doh::config
+  return unless root_cfg.fetch('enable_database', true)
+  return unless root_cfg.key?('database')
+  begin
+    require 'mysql'
+  rescue LoadError => e
+    return
+  end
+  db_cfg = root_cfg['database']
+  require 'doh/mysql'
+  require 'doh/mysql/require_dbtypes'
+  conn = DohDb::CacheConnector.new(db_cfg['host'], db_cfg['username'], db_cfg['password'], db_cfg['database'] || root_cfg['primary_database'])
+  conn.port = db_cfg['port']
+  conn.timeout = db_cfg['timeout'].to_i if db_cfg['timeout']
+  conn.row_builder = db_cfg['row_builder'] || root_cfg['row_builder']
+  DohDb::set_connector_instance(conn)
+  DohDb::require_dbtypes
+end
+
+end

data/lib/doh/mysql/cache_connector.rb

@@ -0,0 +1,54 @@
+require 'doh/mysql/handle'
+require 'doh/mysql/typed_row_builder'
+
+module DohDb
+
+class CacheConnector
+  attr_accessor :host, :username, :password, :database, :row_builder, :timeout, :port
+
+  def initialize(host = nil, username = nil, password = nil, database = nil, row_builder = nil)
+    @host = host
+    @username = username
+    @password = password
+    @database = database
+    @timeout = 1800
+    @port = nil
+    @row_builder = row_builder || TypedRowBuilder.new
+  end
+
+  def request_handle(database = nil)
+    if @handle
+      close_handle("handle was unused for too long") if passed_timeout?
+      @handle = nil if @handle && @handle.closed?
+    end
+    @last_used = Time.now
+    @handle ||= get_new_handle(database)
+  end
+
+  def reset
+    close_handle("reset")
+  end
+
+private
+  def close_handle(msg)
+    return unless @handle
+    dohlog.debug("closing previous database connection - #{msg}")
+    @handle.close
+    @handle = nil
+  end
+
+  def get_new_handle(database = nil)
+    database ||= @database
+    dbmsg = database.to_s.strip.empty? ? 'no default database' : "database #{database}"
+    dohlog.info("connecting to #@host port #@port as username #@username, #{dbmsg}")
+    mysqlh = Mysql.connect(@host, @username, @password, database, @port, nil, Mysql::CLIENT_MULTI_STATEMENTS)
+    mysqlh.query_with_result = false
+    Handle.new(mysqlh, @row_builder)
+  end
+
+  def passed_timeout?
+    Time.now > @last_used + @timeout
+  end
+end
+
+end

data/lib/doh/mysql/connector_instance.rb

@@ -0,0 +1,79 @@
+module DohDb
+
+def self.set_connector_instance(conn)
+  @@connector_instance = conn
+end
+
+def self.connector_instance
+  @@connector_instance
+end
+
+def self.request_handle
+  connector_instance.request_handle
+end
+
+def self.query(statement)
+  request_handle.query(statement)
+end
+
+def self.update(statement)
+  request_handle.update(statement)
+end
+
+def self.update_row(statement)
+  request_handle.update_row(statement)
+end
+
+def self.update_hash(hash, table, primary_key_value, primary_key_name)
+  request_handle.update_hash(hash, table, primary_key_value, primary_key_name)
+end
+
+def self.insert(statement)
+  request_handle.insert(statement)
+end
+
+def self.insert_hash(hash, table, ignore = nil)
+  request_handle.insert_hash(hash, table, ignore)
+end
+
+def self.replace_hash(hash, table)
+  request_handle.replace_hash(hash, table)
+end
+
+def self.select(statement, row_builder = nil)
+  request_handle.select(statement, row_builder)
+end
+
+def self.select_row(statement, row_builder = nil)
+  request_handle.select_row(statement, row_builder)
+end
+
+def self.select_optional_row(statement, row_builder = nil)
+  request_handle.select_optional_row(statement, row_builder)
+end
+
+def self.select_field(statement, row_builder = nil)
+  request_handle.select_field(statement, row_builder)
+end
+
+def self.select_optional_field(statement, row_builder = nil)
+  request_handle.select_optional_field(statement, row_builder)
+end
+
+def self.select_transpose(statement, row_builder = nil)
+  request_handle.select_transpose(statement, row_builder)
+end
+
+def self.select_values(statement, row_builder = nil)
+  request_handle.select_values(statement, row_builder)
+end
+
+def self.select_list(statement, row_builder = nil)
+  request_handle.select_list(statement, row_builder)
+end
+
+def self.multi_select(statements)
+  request_handle.multi_select(statements)
+end
+
+end

data/lib/doh/mysql/connector_util.rb

@@ -0,0 +1,27 @@
+module DohDb
+
+def self.create_and_connect(connector, new_default_database = nil, drop_first = true)
+  connector.reset
+  connector.database = new_default_database if new_default_database
+  dbh = connector.request_handle('')
+  dbh.query("DROP DATABASE IF EXISTS #{connector.database}") if drop_first
+  dbh.query("CREATE DATABASE IF NOT EXISTS #{connector.database}")
+  dbh.query("USE #{connector.database}")
+  dbh
+end
+
+def self.drop_create_and_connect(connector, new_default_database = nil)
+  create_and_connect(connector, new_default_database, true)
+end
+
+def self.reconfigure_connector(cfg, connector = nil)
+  connector ||= DohDb::connector_instance
+  connector.reset
+  connector.host = cfg['host'] if cfg.key?('host')
+  connector.username = cfg['username'] if cfg.key?('username')
+  connector.password = cfg['password'] if cfg.key?('password')
+  connector.database = cfg['database'] if cfg.key?('database')
+  connector.port = cfg['port'] if cfg.key?('port')
+end
+
+end

data/lib/doh/mysql/convert.rb

@@ -0,0 +1,18 @@
+require 'doh/mysql/metadata_util'
+require 'doh/mysql/error'
+
+module DohDb
+
+def self.convert(table, column, value)
+  info = column_info(table)[column]
+#  raise UnknownColumn, "#{table}.#{column}" if info.nil?
+  return value if info.nil?
+  if value.nil?
+    raise CannotBeNull, "#{table}.#{column}" if info['is_nullable'] == 'NO'
+    return nil
+  end
+  return nil if value.is_a?(String) && value.empty? && info['is_nullable'] == 'YES'
+  value
+end
+
+end

data/lib/doh/mysql/current_date.rb

@@ -0,0 +1,22 @@
+require 'doh/current_date'
+require 'doh/mysql/db_date'
+require 'doh/mysql/parse'
+
+module DohDb
+
+def self.current_date_db
+  Doh::current_date(DohDb::today)
+end
+
+def self.current_datetime_db
+  Doh::current_datetime(DohDb::now)
+end
+
+def self.server_datetime
+  retval = DohDb::select_field("SELECT #{DohDb::current_datetime_db.to_sql}")
+  # if there is a fake datetime right now, will need to parse it
+  retval = DohDb::parse_datetime(retval) if retval.is_a?(String)
+  retval
+end
+
+end

data/lib/doh/mysql/database_creator.rb

@@ -0,0 +1,101 @@
+require 'doh/core_ext/dir'
+require 'doh/mysql/handle'
+require 'doh/mysql/load_sql'
+require 'doh/mysql/version'
+require 'doh/mysql/types'
+
+module DohDb
+
+class DatabaseCreator
+  def initialize(data_directory = nil, connector = nil)
+    @data_directory = data_directory || File.join(Doh::root, 'database')
+    @connector = connector || DohDb::connector_instance
+    @include_scripts = true
+  end
+
+  def create_database(dbname, drop_first = false)
+    create_one_database(get_nodb_handle, dbname, dbname, drop_first)
+  end
+
+  def create_database_copy(dest_db, source_db, drop_first = false)
+    create_one_database(get_nodb_handle, dest_db, source_db, drop_first)
+    DohDb::link_database_types(dest_db, source_db)
+  end
+
+  def create_all_databases(drop_first = false)
+    dbh = get_nodb_handle
+    Dir.directories(@data_directory).each {|elem| create_one_database(dbh, elem, elem, drop_first)}
+  end
+
+  def create_tables(database, drop_first, *table_and_view_names)
+    @connector.database = database
+    views, tables = table_and_view_names.flatten.sort.partition {|name| File.exist?(sql_filename(database, 'views', name))}
+    tables.each {|name| create_base_table(database, name, drop_first)}
+    views.each {|name| create_view(database, name, drop_first)}
+  end
+
+  def exclude_scripts
+    @include_scripts = false
+    self
+  end
+
+private
+  def get_nodb_handle
+    @connector.reset
+    @connector.database = ''
+    @connector.request_handle
+  end
+
+  def sql_filename(database, subdir, name)
+    File.join(@data_directory, database, subdir, name) + '.sql'
+  end
+
+  def find_files(source_db, subdir, ext = '.sql')
+    path = File.join(@data_directory, source_db, subdir)
+    return [] unless File.exist?(path)
+    Dir.entries(path).find_all {|entry| entry.end_with?(ext)}.sort.collect {|elem| File.join(path, elem)}
+  end
+
+  def view_files(source_db)
+    path = File.join(@data_directory, source_db, 'views')
+    return [] unless File.exist?(path)
+    ordered_filenames = YAML.load_file(File.join(path, 'order.yml')).collect {|uqfn| File.join(path, uqfn) + '.sql'}
+    ordered_filenames + (find_files(source_db, 'views') - ordered_filenames)
+  end
+
+  def create_base_table(database, table_name, drop_first)
+    DohDb::query("DROP TABLE IF EXISTS #{table_name}") if drop_first
+    files = [sql_filename(database, 'tables', table_name)]
+    inserts_file = sql_filename(database, 'insert_sql', table_name)
+    files.push(inserts_file) if File.exist?(inserts_file)
+    DohDb::load_sql_connector(files, DohDb::connector_instance)
+  end
+
+  def create_view(database, view_name, drop_first)
+    DohDb::query("DROP VIEW IF EXISTS #{view_name}") if drop_first
+    DohDb::load_sql_connector([sql_filename(database, 'views', view_name)], DohDb::connector_instance)
+  end
+
+  def create_one_database(dbh, dest_db, source_db, drop_first)
+    dohlog.info("creating database " + dest_db + " from source files at " + File.join(@data_directory, source_db))
+    dbh.query("DROP DATABASE IF EXISTS " + dest_db) if drop_first
+
+    dbh.query("CREATE DATABASE " + dest_db)
+    dbh.query("USE " + dest_db)
+    dbh.query("CREATE TABLE version (version INT UNSIGNED NOT NULL) ENGINE=MyISAM")
+    dbver = DohDb::latest_database_version(source_db)
+    dbh.query("INSERT INTO version VALUES (#{dbver})")
+
+    @connector.database = dest_db
+
+    files = find_files(source_db, 'tables') + find_files(source_db, 'insert_sql') + view_files(source_db)
+    DohDb::load_sql_connector(files, @connector, dest_db)
+    return unless @include_scripts
+    find_files(source_db, 'insert_scripts', '.rb').each do |filename|
+      dohlog.info("loading file: #{filename}")
+      load(filename)
+    end
+  end
+end
+
+end

data/lib/doh/mysql/db_date.rb

@@ -0,0 +1,28 @@
+require 'date'
+require 'doh/mysql/to_sql'
+
+module DohDb
+
+class DateToday < Date
+  def to_sql
+    'CURDATE()'
+  end
+end
+
+class DateTimeNow < DateTime
+  def to_sql
+    'NOW()'
+  end
+end
+
+def self.today
+  day = Date.today
+  DateToday.new(day.year, day.month, day.mday)
+end
+
+def self.now
+  dt = DateTime.zow
+  DateTimeNow.new(dt.year, dt.month, dt.mday, dt.hour, dt.min, dt.sec, dt.zone)
+end
+
+end

data/lib/doh/mysql/default_type_guesser.rb

@@ -0,0 +1,37 @@
+require 'mysql'
+require 'doh/mysql/parse'
+require 'doh/to_display'
+require 'doh/mysql/types'
+require 'doh/core_ext/string'
+
+module DohDb
+
+class DefaultTypeGuesser
+  # for compatibility with older mysql gems
+  if !MysqlField.const_defined?('TYPE_NEWDECIMAL')
+    MysqlField::TYPE_NEWDECIMAL = 246
+  end
+  DECIMAL_TYPES = [MysqlField::TYPE_DECIMAL, MysqlField::TYPE_NEWDECIMAL]
+  INT_TYPES = [MysqlField::TYPE_TINY,MysqlField::TYPE_SHORT,MysqlField::TYPE_LONG,MysqlField::TYPE_LONGLONG,MysqlField::TYPE_INT24]
+
+  def self.guess_type(value, meta)
+    return nil if value.nil?
+
+    custom_type = DohDb::find_column_type(nil, meta.table, meta.name) || DohDb::find_column_type(nil, nil, meta.name)
+    return custom_type.build(meta.name, value) if custom_type
+
+    return DohDb::parse_bool(value) if (meta.type == MysqlField::TYPE_TINY) && (meta.length == 1) && (meta.max_length == 1)
+    return DohDb::parse_datetime(value) if meta.type == MysqlField::TYPE_DATETIME
+    return DohDb::parse_date(value) if meta.type == MysqlField::TYPE_DATE
+    return DohDb::parse_decimal(value) if DECIMAL_TYPES.include?(meta.type)
+    return DohDb::parse_int(value) if INT_TYPES.include?(meta.type)
+    if meta.type == MysqlField::TYPE_STRING || meta.type == MysqlField::TYPE_VAR_STRING
+      return PhoneDisplayString.new(value) if (value.size == 10) && (meta.name.lastn(5) == 'phone')
+      return SsnDisplayString.new(value) if (value.size == 9) && (meta.max_length == 9) && (meta.name.lastn(3) == 'ssn')
+      return PostalDisplayString.new(value) if [5,9].include?(value.size) && [5,9].include?(meta.max_length) && ((meta.name.lastn(6) == 'postal') || (meta.name.lastn(3) == 'zip'))
+    end
+    value
+  end
+end
+
+end

data/lib/doh/mysql/error.rb

@@ -0,0 +1,7 @@
+module DohDb
+
+class UnexpectedQueryResult < StandardError; end
+class UnknownColumn < StandardError; end
+class CannotBeNull < StandardError; end
+
+end