baza 0.0.17 → 0.0.18

data/include/cloner.rb

@@ -1,18 +0,0 @@
-class Baza::Cloner
-  def self.from_active_record_connection(connection)
-    if connection.class.name.include?('Mysql2Adapter')
-      config = connection.instance_variable_get(:@connection).instance_variable_get(:@query_options)
-
-      Baza::Db.new(
-        type: :mysql,
-        subtype: :mysql2,
-        host: config[:host],
-        user: config[:username],
-        pass: config[:password],
-        db: config[:database]
-      )
-    else
-      raise "Unsupported adapter: #{connection.class.name}"
-    end
-  end
-end

data/include/drivers/active_record/active_record.rb

@@ -1,159 +0,0 @@
-class Baza::Driver::ActiveRecord
-  attr_reader :baza, :conn, :sep_table, :sep_col, :sep_val, :symbolize, :conn_type
-  attr_accessor :tables, :cols, :indexes
-
-  def self.from_object(args)
-    if args[:object].class.name.include?("ActiveRecord::ConnectionAdapters")
-      if args[:object].class.name.include?("ConnectionPool")
-        object_to_use = args[:object].connection
-      else
-        object_to_use = args[:object]
-      end
-
-      return {
-        type: :success,
-        args: {
-          type: :active_record,
-          conn: object_to_use
-        }
-      }
-    end
-
-    return nil
-  end
-
-  def initialize(baza)
-    @baza = baza
-    @conn = @baza.opts[:conn]
-    conn_name = @conn.class.name.to_s.downcase
-
-    if conn_name.include?("mysql")
-      @sep_table = "`"
-      @sep_col = "`"
-      @sep_val = "'"
-      @conn_type = :mysql
-    elsif conn_name.include?("sqlite")
-      @sep_table = "`"
-      @sep_col = "`"
-      @sep_val = "'"
-      @conn_type = :sqlite3
-    else
-      raise "Unknown type: '#{conn_name}'."
-    end
-  end
-
-  def query(str)
-    Baza::Driver::ActiveRecord::Result.new(@conn.execute(str))
-  end
-
-  def escape(str)
-    @conn.quote_string(str.to_s)
-  end
-
-  def esc_col(string)
-    string = string.to_s
-    raise "Invalid column-string: #{string}" if string.include?(@sep_col)
-    return string
-  end
-
-  def esc_table(string)
-    string = string.to_s
-    raise "Invalid column-string: #{string}" if string.include?(@sep_col)
-    return string
-  end
-
-  def close
-    @conn.close
-  end
-
-  def transaction
-    if @conn_type == :mysql
-      query("START TRANSACTION")
-    elsif @conn_type == :sqlite3
-      query("BEGIN TRANSACTION")
-    end
-
-    begin
-      yield @baza
-      query("COMMIT")
-    rescue
-      query("ROLLBACK")
-      raise
-    end
-  end
-end
-
-class Baza::Driver::ActiveRecord::Result
-  def initialize(res)
-    @res = res
-  end
-
-  def enum
-    @enum ||= Enumerator.new do |y|
-      each do |data|
-        y << data
-      end
-    end
-  end
-
-  def fetch
-    begin
-      return enum.next
-    rescue StopIteration
-      return false
-    end
-  end
-
-  def each(&blk)
-    return unless @res
-
-    if RUBY_ENGINE == "jruby"
-      @res.each do |result|
-        yield result.symbolize_keys
-      end
-    else
-      @res.each(as: :hash) do |result|
-        yield result.symbolize_keys
-      end
-    end
-  end
-end
-
-class Baza::Driver::ActiveRecord::Tables
-  def initialize(args)
-    @args = args
-
-    require_relative "../#{@args[:db].conn.conn_type}/#{@args[:db].conn.conn_type}_tables"
-    @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
-
-class Baza::Driver::ActiveRecord::Columns
-  def initialize(args)
-    @args = args
-
-    require_relative "../#{@args[:db].conn.conn_type}/#{@args[:db].conn.conn_type}_columns"
-    @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
-
-class Baza::Driver::ActiveRecord::Indexes
-  def initialize(args)
-    @args = args
-
-    require_relative "../#{@args[:db].conn.conn_type}/#{@args[:db].conn.conn_type}_indexes"
-    @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/include/drivers/mysql/mysql.rb

@@ -1,443 +0,0 @@
-class Baza::Driver::Mysql
-  autoload :Table, "#{File.dirname(__FILE__)}/mysql_table"
-  autoload :Tables, "#{File.dirname(__FILE__)}/mysql_tables"
-  autoload :Column, "#{File.dirname(__FILE__)}/mysql_column"
-  autoload :Columns, "#{File.dirname(__FILE__)}/mysql_columns"
-  autoload :Index, "#{File.dirname(__FILE__)}/mysql_index"
-  autoload :Indexes, "#{File.dirname(__FILE__)}/mysql_indexes"
-  autoload :Result, "#{File.dirname(__FILE__)}/mysql_result"
-  autoload :ResultJava, "#{File.dirname(__FILE__)}/mysql_result_java"
-  autoload :ResultMysql2, "#{File.dirname(__FILE__)}/mysql_result_mysql2"
-  autoload :ResultUnbuffered, "#{File.dirname(__FILE__)}/mysql_result_unbuffered"
-  autoload :Sqlspecs, "#{File.dirname(__FILE__)}/mysql_sqlspecs"
-
-  attr_reader :baza, :conn, :conns, :sep_table, :sep_col, :sep_val
-  attr_accessor :tables, :cols, :indexes
-
-  #Helper to enable automatic registering of database using Baza::Db.from_object
-  def self.from_object(args)
-    if args[:object].class.name == "Mysql2::Client"
-      return {
-        type: :success,
-        args: {
-          type: :mysql,
-          subtype: :mysql2,
-          conn: args[:object],
-          query_args: {
-            as: :hash,
-            symbolize_keys: true
-          }
-        }
-      }
-    elsif args[:object].class.name == "Java::ComMysqlJdbc::JDBC4Connection"
-      return {
-        type: :success,
-        args: {
-          type: :mysql,
-          subtype: :java,
-          conn: args[:object],
-          query_args: {
-            as: :hash,
-            symbolize_keys: true
-          }
-        }
-      }
-    end
-
-    return nil
-  end
-
-  def initialize(baza)
-    @baza = baza
-    @opts = @baza.opts
-    @sep_table = "`"
-    @sep_col = "`"
-    @sep_val = "'"
-
-    require "monitor"
-    @mutex = Monitor.new
-
-    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
-
-    @java_rs_data = {}
-    @subtype = @baza.opts[:subtype]
-    @subtype ||= :mysql
-    reconnect
-  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
-      case @subtype
-        when :mysql
-          @conn = Mysql.real_connect(@baza.opts[:host], @baza.opts[:user], @baza.opts[:pass], @baza.opts[:db], @port)
-        when :mysql2
-          require "rubygems"
-          require "mysql2"
-
-          args = {
-            host: @baza.opts[:host],
-            username: @baza.opts[:user],
-            password: @baza.opts[:pass],
-            database: @baza.opts[:db],
-            port: @port,
-            symbolize_keys: true,
-            cache_rows: false
-          }
-
-          #Symbolize keys should also be given here, else table-data wont be symbolized for some reason - knj.
-          @query_args = {symbolize_keys: true}
-          @query_args.merge!(@baza.opts[:query_args]) if @baza.opts[:query_args]
-
-          pos_args = [:as, :async, :cast_booleans, :database_timezone, :application_timezone, :cache_rows, :connect_flags, :cast]
-          pos_args.each do |key|
-            args[key] = @baza.opts[key] if @baza.opts.key?(key)
-          end
-
-          args[:as] = :array if @opts[:result] == "array"
-
-          tries = 0
-          begin
-            tries += 1
-            if @baza.opts[:conn]
-              @conn = @baza.opts[:conn]
-            else
-              @conn = Mysql2::Client.new(args)
-            end
-          rescue => e
-            if tries <= 3
-              if e.message == "Can't connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock' (111)"
-                sleep 1
-                tries += 1
-                retry
-              end
-            end
-
-            raise e
-          end
-        when :java
-          if @baza.opts[:conn]
-            @jdbc_loaded = true
-            @conn = @baza.opts[:conn]
-          else
-            unless @jdbc_loaded
-              require "java"
-              require "/usr/share/java/mysql-connector-java.jar" if File.exists?("/usr/share/java/mysql-connector-java.jar")
-              import "com.mysql.jdbc.Driver"
-              @jdbc_loaded = true
-            end
-
-            @conn = java.sql::DriverManager.getConnection("jdbc:mysql://#{@baza.opts[:host]}:#{@port}/#{@baza.opts[:db]}?user=#{@baza.opts[:user]}&password=#{@baza.opts[:pass]}&populateInsertRowWithDefaultValues=true&zeroDateTimeBehavior=round&characterEncoding=#{@encoding}&holdResultsOpenOverStatementClose=true")
-          end
-
-          query("SET SQL_MODE = ''")
-        else
-          raise "Unknown subtype: #{@subtype} (#{@subtype.class.name})"
-      end
-
-      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
-        case @subtype
-          when :mysql
-            return Baza::Driver::Mysql::Result.new(self, @conn.query(str))
-          when :mysql2
-            return Baza::Driver::Mysql::ResultMysql2.new(@conn.query(str, @query_args))
-          when :java
-            stmt = conn.create_statement
-
-            if str.match(/^\s*(delete|update|create|drop|insert\s+into|alter|truncate)\s+/i)
-              begin
-                stmt.execute(str)
-              ensure
-                stmt.close
-              end
-
-              return nil
-            else
-              id = nil
-
-              begin
-                res = stmt.execute_query(str)
-                ret = Baza::Driver::Mysql::ResultJava.new(@baza, @opts, res)
-                id = ret.__id__
-
-                #If ID is being reused we have to free the result.
-                self.java_mysql_resultset_killer(id) if @java_rs_data.key?(id)
-
-                #Save reference to result and statement, so we can close them when they are garbage collected.
-                @java_rs_data[id] = {res: res, stmt: stmt}
-                ObjectSpace.define_finalizer(ret, method(:java_mysql_resultset_killer))
-
-                return ret
-              rescue => e
-                res.close if res
-                stmt.close
-                @java_rs_data.delete(id) if ret && id
-
-                raise e
-              end
-            end
-          else
-            raise "Unknown subtype: '#{@subtype}'."
-        end
-      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
-      case @subtype
-        when :mysql
-          @conn.query_with_result = false
-          return Baza::Driver::Mysql::ResultUnbuffered.new(@conn, @opts, @conn.query(str))
-        when :mysql2
-          return Baza::Driver::Mysql::ResultMysql2.new(@conn.query(str, @query_args.merge(stream: true)))
-        when :java
-          if str.match(/^\s*(delete|update|create|drop|insert\s+into)\s+/i)
-            stmt = @conn.createStatement
-
-            begin
-              stmt.execute(str)
-            ensure
-              stmt.close
-            end
-
-            return nil
-          else
-            stmt = @conn.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY, java.sql.ResultSet.CONCUR_READ_ONLY)
-            stmt.setFetchSize(java.lang.Integer::MIN_VALUE)
-
-            begin
-              res = stmt.executeQuery(str)
-              ret = Baza::Driver::Mysql::ResultJava.new(@baza, @opts, res)
-
-              #Save reference to result and statement, so we can close them when they are garbage collected.
-              @java_rs_data[ret.__id__] = {res: res, stmt: stmt}
-              ObjectSpace.define_finalizer(ret, method("java_mysql_resultset_killer"))
-
-              return ret
-            rescue => e
-              res.close if res
-              stmt.close
-              raise e
-            end
-          end
-        else
-          raise "Unknown subtype: '#{@subtype}'"
-      end
-    end
-  end
-
-  #Escapes a string to be safe to use in a query.
-  def escape_alternative(string)
-    case @subtype
-      when :mysql
-        return @conn.escape_string(string.to_s)
-      when :mysql2
-        return @conn.escape(string.to_s)
-      when :java
-        return escape(string)
-      else
-        raise "Unknown subtype: '#{@subtype}'."
-    end
-  end
-
-  #An alternative to the MySQL framework's escape. This is copied from the Ruby/MySQL framework at: http://www.tmtm.org/en/ruby/mysql/
-  def escape(string)
-    return string.to_s.gsub(/([\0\n\r\032\'\"\\])/) do
-      case $1
-        when "\0" then "\\0"
-        when "\n" then "\\n"
-        when "\r" then "\\r"
-        when "\032" then "\\Z"
-        else "\\#{$1}"
-      end
-    end
-  end
-
-  #Escapes a string to be safe to use as a column in a query.
-  def esc_col(string)
-    string = string.to_s
-    raise "Invalid column-string: #{string}" if string.include?(@sep_col)
-    return string
-  end
-
-  alias :esc_table :esc_col
-  alias :esc :escape
-
-  #Returns the last inserted ID for the connection.
-  def last_id
-    case @subtype
-      when :mysql
-        @mutex.synchronize do
-          return @conn.insert_id.to_i
-        end
-      when :mysql2
-        @mutex.synchronize do
-          return @conn.last_id.to_i
-        end
-      when :java
-        data = self.query("SELECT LAST_INSERT_ID() AS id").fetch
-        return data[:id].to_i if data.key?(:id)
-        raise "Could not figure out last inserted ID."
-    end
-  end
-
-  #Closes the connection threadsafe.
-  def close
-    @mutex.synchronize do
-      @conn.close
-    end
-  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})." if ids_length != arr_hashes_length
-
-      return ids
-    else
-      return nil
-    end
-  end
-
-  #Starts a transaction, yields the database and commits at the end.
-  def transaction
-    @baza.q("START TRANSACTION")
-
-    begin
-      yield @baza
-      @baza.q("COMMIT")
-    rescue
-      @baza.q("ROLLBACK")
-      raise
-    end
-  end
-end