baza 0.0.17 → 0.0.18

data/lib/baza/drivers/active_record/columns.rb

@@ -0,0 +1,10 @@
+class Baza::Driver::ActiveRecord::Columns
+  def initialize(args)
+    @args = args
+    @proxy_to = ::Baza::Driver.const_get(StringCases.snake_to_camel(@args[:db].conn.conn_type)).const_get(:Columns).new(@args)
+  end
+
+  def method_missing(name, *args, &blk)
+    @proxy_to.__send__(name, *args, &blk)
+  end
+end

data/lib/baza/drivers/active_record/indexes.rb

@@ -0,0 +1,10 @@
+class Baza::Driver::ActiveRecord::Indexes
+  def initialize(args)
+    @args = args
+    @proxy_to = ::Baza::Driver.const_get(StringCases.snake_to_camel(@args[:db].conn.conn_type)).const_get(:Indexes).new(@args)
+  end
+
+  def method_missing(name, *args, &blk)
+    @proxy_to.__send__(name, *args, &blk)
+  end
+end

data/lib/baza/drivers/active_record/result.rb

@@ -0,0 +1,23 @@
+class Baza::Driver::ActiveRecord::Result < Baza::ResultBase
+  def initialize(driver, result)
+    @result = result
+    @type_translation = driver.baza.opts[:type_translation]
+  end
+
+  def fetch
+    begin
+      return to_enum.next
+    rescue StopIteration
+      return false
+    end
+  end
+
+  def each
+    return unless @result
+
+    @result.each do |result|
+      result = Hash[result.map { |k, v| [k, v.to_s] }] if @type_translation == :string
+      yield result.symbolize_keys
+    end
+  end
+end

data/lib/baza/drivers/active_record/tables.rb

@@ -0,0 +1,12 @@
+class Baza::Driver::ActiveRecord::Tables
+  def initialize(args)
+    @args = args
+
+    require "#{File.dirname(__FILE__)}/../#{@args[:db].conn.conn_type}"
+    @proxy_to = ::Baza::Driver.const_get(StringCases.snake_to_camel(@args[:db].conn.conn_type)).const_get(:Tables).new(@args)
+  end
+
+  def method_missing(name, *args, &blk)
+    @proxy_to.__send__(name, *args, &blk)
+  end
+end

data/lib/baza/drivers/mysql.rb

@@ -0,0 +1,220 @@
+class Baza::Driver::Mysql < Baza::BaseSqlDriver
+  path = "#{File.dirname(__FILE__)}/mysql"
+
+  autoload :Table, "#{path}/table"
+  autoload :Tables, "#{path}/tables"
+  autoload :Column, "#{path}/column"
+  autoload :Columns, "#{path}/columns"
+  autoload :Index, "#{path}/index"
+  autoload :Indexes, "#{path}/indexes"
+  autoload :Result, "#{path}/result"
+  autoload :UnbufferedResult, "#{path}/unbuffered_result"
+  autoload :Sqlspecs, "#{path}/sqlspecs"
+
+  attr_reader :conn
+
+  def self.from_object(args)
+    raise 'Mysql does not support auth extraction' if args[:object].class.name == 'Mysql'
+  end
+
+  def initialize(baza)
+    super
+
+    @opts = @baza.opts
+
+    require 'monitor'
+    @mutex = Monitor.new
+
+    if baza.opts[:conn]
+      @conn = baza.opts[:conn]
+    else
+      if @opts[:encoding]
+        @encoding = @opts[:encoding]
+      else
+        @encoding = 'utf8'
+      end
+
+      if @baza.opts.key?(:port)
+        @port = @baza.opts[:port].to_i
+      else
+        @port = 3306
+      end
+
+      reconnect
+    end
+  end
+
+  #This method handels the closing of statements and results for the Java MySQL-mode.
+  def java_mysql_resultset_killer(id)
+    data = @java_rs_data[id]
+    return nil unless data
+
+    data[:res].close
+    data[:stmt].close
+    @java_rs_data.delete(id)
+  end
+
+  #Cleans the wref-map holding the tables.
+  def clean
+    tables.clean if tables
+  end
+
+  #Respawns the connection to the MySQL-database.
+  def reconnect
+    @mutex.synchronize do
+      require 'mysql' unless ::Object.const_defined?(:Mysql)
+      @conn = ::Mysql.real_connect(@baza.opts[:host], @baza.opts[:user], @baza.opts[:pass], @baza.opts[:db], @port)
+      query("SET NAMES '#{self.esc(@encoding)}'") if @encoding
+    end
+  end
+
+  #Executes a query and returns the result.
+  def query(str)
+    str = str.to_s
+    str = str.force_encoding("UTF-8") if @encoding == "utf8" and str.respond_to?(:force_encoding)
+    tries = 0
+
+    begin
+      tries += 1
+      @mutex.synchronize do
+        return Baza::Driver::Mysql::Result.new(self, @conn.query(str))
+      end
+    rescue => e
+      if tries <= 3
+        if e.message == "MySQL server has gone away" || e.message == "closed MySQL connection" or e.message == "Can't connect to local MySQL server through socket"
+          sleep 0.5
+          reconnect
+          retry
+        elsif e.message.include?("No operations allowed after connection closed") or e.message == "This connection is still waiting for a result, try again once you have the result" or e.message == "Lock wait timeout exceeded; try restarting transaction"
+          reconnect
+          retry
+        end
+      end
+
+      raise e
+    end
+  end
+
+  #Executes an unbuffered query and returns the result that can be used to access the data.
+  def query_ubuf(str)
+    @mutex.synchronize do
+      @conn.query_with_result = false
+      return Baza::Driver::Mysql::UnbufferedResult.new(@conn, @opts, @conn.query(str))
+    end
+  end
+
+  #Escapes a string to be safe to use in a query.
+  def escape_alternative(string)
+    return @conn.escape_string(string.to_s)
+  end
+
+  #Returns the last inserted ID for the connection.
+  def last_id
+    @mutex.synchronize { return @conn.insert_id.to_i }
+  end
+
+  #Closes the connection threadsafe.
+  def close
+    @mutex.synchronize { @conn.close }
+  end
+
+  #Destroyes the connection.
+  def destroy
+    @conn = nil
+    @baza = nil
+    @mutex = nil
+    @subtype = nil
+    @encoding = nil
+    @query_args = nil
+    @port = nil
+  end
+
+  #Inserts multiple rows in a table. Can return the inserted IDs if asked to in arguments.
+  def insert_multi(tablename, arr_hashes, args = nil)
+    sql = "INSERT INTO `#{tablename}` ("
+
+    first = true
+    if args && args[:keys]
+      keys = args[:keys]
+    elsif arr_hashes.first.is_a?(Hash)
+      keys = arr_hashes.first.keys
+    else
+      raise "Could not figure out keys."
+    end
+
+    keys.each do |col_name|
+      sql << "," unless first
+      first = false if first
+      sql << "`#{self.esc_col(col_name)}`"
+    end
+
+    sql << ") VALUES ("
+
+    first = true
+    arr_hashes.each do |hash|
+      if first
+        first = false
+      else
+        sql << "),("
+      end
+
+      first_key = true
+      if hash.is_a?(Array)
+        hash.each do |val|
+          if first_key
+            first_key = false
+          else
+            sql << ","
+          end
+
+          sql << @baza.sqlval(val)
+        end
+      else
+        hash.each do |key, val|
+          if first_key
+            first_key = false
+          else
+            sql << ","
+          end
+
+          sql << @baza.sqlval(val)
+        end
+      end
+    end
+
+    sql << ")"
+
+    return sql if args && args[:return_sql]
+
+    self.query(sql)
+
+    if args && args[:return_id]
+      first_id = self.last_id
+      raise "Invalid ID: #{first_id}" if first_id.to_i <= 0
+      ids = [first_id]
+      1.upto(arr_hashes.length - 1) do |count|
+        ids << first_id + count
+      end
+
+      ids_length = ids.length
+      arr_hashes_length = arr_hashes.length
+      raise "Invalid length (#{ids_length}, #{arr_hashes_length})." unless ids_length == arr_hashes_length
+
+      return ids
+    else
+      return nil
+    end
+  end
+
+  def transaction
+    @baza.q("START TRANSACTION")
+
+    begin
+      yield @baza
+      @baza.q("COMMIT")
+    rescue
+      @baza.q("ROLLBACK")
+      raise
+    end
+  end
+end

data/lib/baza/drivers/mysql/result.rb

@@ -0,0 +1,81 @@
+#This class controls the results for the normal MySQL-driver.
+class Baza::Driver::Mysql::Result < Baza::ResultBase
+  INT_TYPES = {
+    ::Mysql::Field::TYPE_DECIMAL => true,
+    ::Mysql::Field::TYPE_TINY => true,
+    ::Mysql::Field::TYPE_LONG => true,
+    ::Mysql::Field::TYPE_YEAR => true
+  }
+  FLOAT_TYPES = {
+    ::Mysql::Field::TYPE_DECIMAL => true,
+    ::Mysql::Field::TYPE_FLOAT => true,
+    ::Mysql::Field::TYPE_DOUBLE => true
+  }
+  TIME_TYPES = {
+    ::Mysql::Field::TYPE_DATETIME => true
+  }
+  DATE_TYPES = {
+    ::Mysql::Field::TYPE_DATE => true
+  }
+
+  #Constructor. This should not be called manually.
+  def initialize(driver, result)
+    @driver = driver
+    @result = result
+    @mutex = Mutex.new
+    @type_translation = driver.baza.opts[:type_translation]
+
+    if @result
+      @keys = []
+      @types = [] if @type_translation
+
+      @result.fetch_fields.each do |key|
+        @keys << key.name.to_sym
+        @types << key.type if @type_translation
+      end
+    end
+  end
+
+  #Returns a single result as a hash with symbols as keys.
+  def fetch
+    fetched = nil
+    @mutex.synchronize do
+      fetched = @result.fetch_row
+    end
+
+    return false unless fetched
+
+    if @type_translation == true
+      fetched.collect!.with_index do |value, count|
+        translate_value_to_type(value, @types[count])
+      end
+    end
+
+    return Hash[*@keys.zip(fetched).flatten]
+  end
+
+  #Loops over every result yielding it.
+  def each
+    while data = fetch
+      yield data
+    end
+  end
+
+private
+
+  def translate_value_to_type(value, type_no)
+    unless value === nil
+      if INT_TYPES[type_no]
+        return value.to_i
+      elsif FLOAT_TYPES[type_no]
+        return value.to_f
+      elsif TIME_TYPES[type_no]
+        return Time.parse(value)
+      elsif DATE_TYPES[type_no]
+        return Date.parse(value)
+      else
+        return value.to_s
+      end
+    end
+  end
+end

data/{include/drivers/mysql/mysql_table.rb → lib/baza/drivers/mysql/table.rb}

@@ -5,7 +5,6 @@ class Baza::Driver::Mysql::Table < Baza::Table
     @args = args
     @db = args[:db]
     @data = args[:data]
-    @subtype = @db.opts[:subtype]
     @list = Wref::Map.new
     @indexes_list = Wref::Map.new
     @name = @data[:Name].to_sym
@@ -32,7 +31,8 @@ class Baza::Driver::Mysql::Table < Baza::Table
 
   #Returns true if the table is safe to drop.
   def native?
-    return true if @db.q("SELECT DATABASE() AS db").fetch[:db] == "mysql"
+    data = @db.q("SELECT DATABASE() AS db").fetch
+    return true if data[:db] == "mysql"
     return false
   end
 

data/{include/drivers/mysql/mysql_tables.rb → lib/baza/drivers/mysql/tables.rb}

@@ -8,7 +8,6 @@ class Baza::Driver::Mysql::Tables
   def initialize(args)
     @args = args
     @db = @args[:db]
-    @subtype = @db.opts[:subtype]
     @list_mutex = Monitor.new
     @list = Wref::Map.new
     @list_should_be_reloaded = true

data/{include/drivers/mysql/mysql_result_unbuffered.rb → lib/baza/drivers/mysql/unbuffered_result.rb}

@@ -1,5 +1,5 @@
 #This class controls the unbuffered result for the normal MySQL-driver.
-class Baza::Driver::Mysql::ResultUnbuffered
+class Baza::Driver::Mysql::UnbufferedResult < Baza::ResultBase
   #Constructor. This should not be called manually.
   def initialize(conn, opts, result)
     @conn = conn
@@ -14,15 +14,6 @@ class Baza::Driver::Mysql::ResultUnbuffered
     end
   end
 
-  #Lods the keys for the object.
-  def load_keys
-    @keys = []
-    keys = @res.fetch_fields
-    keys.each do |key|
-      @keys << key.name.to_sym
-    end
-  end
-
   #Returns a single result.
   def fetch
     if @enum
@@ -40,7 +31,7 @@ class Baza::Driver::Mysql::ResultUnbuffered
         @enum = @res.to_enum
         ret = @enum.next
       rescue Mysql::Error
-        #Reset it to run non-unbuffered again and then return false.
+        # Reset it to run non-unbuffered again and then return false.
         @conn.query_with_result = true
         return false
       rescue StopIteration
@@ -49,24 +40,29 @@ class Baza::Driver::Mysql::ResultUnbuffered
       end
     end
 
-    if !@as_hash
-      return ret
+    if @as_hash
+      load_keys unless @keys
+      return Hash[*@keys.zip(ret).flatten]
     else
-      self.load_keys if !@keys
-
-      ret_h = {}
-      @keys.each_index do |key_no|
-        ret_h[@keys[key_no]] = ret[key_no]
-      end
-
-      return ret_h
+      return ret
     end
   end
 
   #Loops over every single result yielding it.
   def each
-    while data = self.fetch
-      yield(data)
+    while row = fetch
+      yield row
+    end
+  end
+
+private
+
+  #Lods the keys for the object.
+  def load_keys
+    @keys = []
+    keys = @res.fetch_fields
+    keys.each do |key|
+      @keys << key.name.to_sym
     end
   end
 end