baza 0.0.17 → 0.0.18

data/include/drivers/mysql/mysql_result.rb

@@ -1,42 +0,0 @@
-#This class controls the results for the normal MySQL-driver.
-class Baza::Driver::Mysql::Result
-  #Constructor. This should not be called manually.
-  def initialize(driver, result)
-    @driver = driver
-    @result = result
-    @mutex = Mutex.new
-
-    if @result
-      @keys = []
-      @result.fetch_fields.each do |key|
-        @keys << key.name.to_sym
-      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
-
-    ret = {}
-    count = 0
-    @keys.each do |key|
-      ret[key] = fetched[count]
-      count += 1
-    end
-
-    return ret
-  end
-
-  #Loops over every result yielding it.
-  def each
-    while data = self.fetch
-      yield(data)
-    end
-  end
-end

data/include/drivers/mysql/mysql_result_java.rb

@@ -1,61 +0,0 @@
-#This class controls the result for the Java-MySQL-driver.
-class Baza::Driver::Mysql::ResultJava
-  #Constructor. This should not be called manually.
-  def initialize(knjdb, opts, result)
-    @baza_db = knjdb
-    @result = result
-
-    if !opts.key?(:result) || opts[:result] == "hash"
-      @as_hash = true
-    elsif opts[:result] == "array"
-      @as_hash = false
-    else
-      raise "Unknown type of result: '#{opts[:result]}'."
-    end
-  end
-
-  #Reads meta-data about the query like keys and count.
-  def read_meta
-    @result.before_first
-    meta = @result.meta_data
-    @count = meta.column_count
-
-    @keys = []
-    1.upto(@count) do |count|
-      @keys << meta.column_label(count).to_sym
-    end
-  end
-
-  def fetch
-    return false unless @result
-    self.read_meta unless @keys
-    status = @result.next
-
-    unless status
-      @result = nil
-      @keys = nil
-      @count = nil
-      return false
-    end
-
-    if @as_hash
-      ret = {}
-      1.upto(@count) do |count|
-        ret[@keys[count - 1]] = @result.object(count)
-      end
-    else
-      ret = []
-      1.upto(@count) do |count|
-        ret << @result.object(count)
-      end
-    end
-
-    return ret
-  end
-
-  def each
-    while data = self.fetch
-      yield(data)
-    end
-  end
-end

data/include/drivers/mysql/mysql_result_mysql2.rb

@@ -1,26 +0,0 @@
-#This class controls the result for the MySQL2 driver.
-class Baza::Driver::Mysql::ResultMysql2
-  #Constructor. This should not be called manually.
-  def initialize(result)
-    @result = result
-  end
-
-  #Returns a single result.
-  def fetch
-    @enum = @result.to_enum if !@enum
-
-    begin
-      return @enum.next
-    rescue StopIteration
-      return false
-    end
-  end
-
-  #Loops over every single result yielding it.
-  def each
-    @result.each do |res|
-      next unless res #This sometimes happens when streaming results...
-      yield(res)
-    end
-  end
-end

data/include/drivers/sqlite3/sqlite3.rb

@@ -1,159 +0,0 @@
-#This class handels SQLite3-specific behaviour.
-class Baza::Driver::Sqlite3
-  autoload :Table, "#{File.dirname(__FILE__)}/sqlite3_table"
-  autoload :Tables, "#{File.dirname(__FILE__)}/sqlite3_tables"
-  autoload :Column, "#{File.dirname(__FILE__)}/sqlite3_column"
-  autoload :Columns, "#{File.dirname(__FILE__)}/sqlite3_columns"
-  autoload :Index, "#{File.dirname(__FILE__)}/sqlite3_index"
-  autoload :Indexes, "#{File.dirname(__FILE__)}/sqlite3_indexes"
-  autoload :Result, "#{File.dirname(__FILE__)}/sqlite3_result"
-  autoload :ResultJava, "#{File.dirname(__FILE__)}/sqlite3_result_java"
-  autoload :Sqlspecs, "#{File.dirname(__FILE__)}/sqlite3_sqlspecs"
-
-  attr_reader :baza, :conn, :sep_table, :sep_col, :sep_val, :symbolize
-  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 == "SQLite3::Database"
-      return {
-        type: :success,
-        args: {
-          type: :sqlite3,
-          conn: args[:object]
-        }
-      }
-    elsif args[:object].class.name == "Java::OrgSqlite::SQLiteConnection"
-      return {
-        type: :success,
-        args: {
-          type: :sqlite3,
-          conn: args[:object]
-        }
-      }
-    end
-
-    return nil
-  end
-
-  #Constructor. This should not be called manually.
-  def initialize(baza_db)
-    @sep_table = "`"
-    @sep_col = "`"
-    @sep_val = "'"
-
-    @baza = baza_db
-    @path = @baza.opts[:path] if @baza.opts[:path]
-    @baza.opts[:subtype] ||= :java if RUBY_ENGINE == "jruby"
-    @subtype = @baza.opts[:subtype]
-
-    if @baza.opts[:conn]
-      @conn = @baza.opts[:conn]
-      @stat = @conn.createStatement if @subtype == :java
-    else
-      raise "No path was given." unless @path
-
-      if @subtype == :java
-        if @baza.opts[:sqlite_driver]
-          require @baza.opts[:sqlite_driver]
-        else
-          require "jdbc/sqlite3"
-          ::Jdbc::SQLite3.load_driver
-        end
-
-        require "java"
-        import "org.sqlite.JDBC"
-        @conn = java.sql.DriverManager::getConnection("jdbc:sqlite:#{@baza.opts[:path]}")
-        @stat = @conn.createStatement
-      elsif @subtype == :rhodes
-        @conn = ::SQLite3::Database.new(@path, @path)
-      else
-        @conn = ::SQLite3::Database.open(@path)
-        @conn.results_as_hash = true
-        @conn.type_translation = false
-      end
-    end
-  end
-
-  #Executes a query against the driver.
-  def query(string)
-    if @subtype == :rhodes
-      return Baza::Driver::Sqlite3::Result.new(self, @conn.execute(string, string))
-    elsif @subtype == :java
-      begin
-        return Baza::Driver::Sqlite3::ResultJava.new(self, @stat.executeQuery(string))
-      rescue java.sql.SQLException => e
-        if e.message.to_s.index("query does not return ResultSet") != nil
-          return Baza::Driver::Sqlite3::ResultJava.new(self, nil)
-        else
-          raise e
-        end
-      end
-    else
-      return Baza::Driver::Sqlite3::Result.new(self, @conn.execute(string))
-    end
-  end
-
-  #SQLite3 driver doesnt support unbuffered queries??
-  alias query_ubuf query
-
-  #Escapes a string to be safe to used in a query.
-  def escape(string)
-    #This code is taken directly from the documentation so we dont have to rely on the SQLite3::Database class. This way it can also be used with JRuby and IronRuby...
-    #http://sqlite-ruby.rubyforge.org/classes/SQLite/Database.html
-    return string.to_s.gsub(/'/, "''")
-  end
-
-  #Escapes a string to be used as a column.
-  def esc_col(string)
-    string = string.to_s
-    raise "Invalid column-string: #{string}" if string.index(@sep_col) != nil
-    return string
-  end
-
-  alias :esc_table :esc_col
-  alias :esc :escape
-
-  #Returns the last inserted ID.
-  def last_id
-    return @conn.last_insert_row_id if @conn.respond_to?(:last_insert_row_id)
-    return query("SELECT last_insert_rowid() AS id").fetch[:id].to_i
-  end
-
-  #Closes the connection to the database.
-  def close
-    @conn.close
-  end
-
-  #Starts a transaction, yields the database and commits.
-  def transaction
-    if @subtype == :java
-      query("BEGIN TRANSACTION")
-
-      begin
-        yield(@baza)
-        query("COMMIT")
-      rescue => e
-        query("ROLLBACK")
-      end
-    else
-      @conn.transaction do
-        yield(@baza)
-      end
-    end
-  end
-
-  def insert_multi(tablename, arr_hashes, args = nil)
-    sql = [] if args && args[:return_sql]
-
-    @baza.transaction do
-      arr_hashes.each do |hash|
-        res = @baza.insert(tablename, hash, args)
-        sql << res if args && args[:return_sql]
-      end
-    end
-
-    return sql if args && args[:return_sql]
-    return nil
-  end
-end

data/include/drivers/sqlite3/sqlite3_result.rb

@@ -1,35 +0,0 @@
-#This class handels the result when running MRI (or others).
-class Baza::Driver::Sqlite3::Result
-  #Constructor. This should not be called manually.
-  def initialize(driver, result_array)
-    @result_array = result_array
-    @index = 0
-  end
-
-  #Returns a single result.
-  def fetch
-    result_hash = @result_array[@index]
-    return false unless result_hash
-    @index += 1
-
-    ret = {}
-    result_hash.each do |key, val|
-      if (Float(key) rescue false)
-        #do nothing.
-      elsif !key.is_a?(Symbol)
-        ret[key.to_sym] = val
-      else
-        ret[key] = val
-      end
-    end
-
-    return ret
-  end
-
-  #Loops over every result yielding them.
-  def each
-    while data = self.fetch
-      yield(data)
-    end
-  end
-end

data/include/drivers/sqlite3/sqlite3_result_java.rb

@@ -1,39 +0,0 @@
-#This class handels results when running in JRuby.
-class Baza::Driver::Sqlite3::ResultJava
-  def initialize(driver, rs)
-    @index = 0
-    retkeys = driver.baza.opts[:return_keys]
-
-    if rs
-      metadata = rs.getMetaData
-      columns_count = metadata.getColumnCount
-
-      @rows = []
-      while rs.next
-        row_data = {}
-        for i in (1..columns_count)
-          col_name = metadata.getColumnName(i).to_sym
-          row_data[col_name] = rs.getString(i)
-        end
-
-        @rows << row_data
-      end
-    end
-  end
-
-  #Returns a single result.
-  def fetch
-    return false unless @rows
-    ret = @rows[@index]
-    return false unless ret
-    @index += 1
-    return ret
-  end
-
-  #Loops over every result and yields them.
-  def each
-    while data = fetch
-      yield data
-    end
-  end
-end

data/spec/include/cloner_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe Baza::Cloner do
-  it 'can clone drivers' do
-    require 'info_active_record'
-    conn = Baza::InfoActiveRecord.connection
-    baza_db = Baza::Cloner.from_active_record_connection(conn[:conn])
-    expect(baza_db.query('SELECT 1 AS test').fetch[:test]).to eq 1
-  end
-end

data/spec/include/drivers/active_record_spec.rb

@@ -1,8 +0,0 @@
-require "spec_helper"
-
-describe Baza::Driver::ActiveRecord do
-  it_behaves_like "a baza driver"
-  it_should_behave_like "a baza tables driver"
-  it_should_behave_like "a baza columns driver"
-  it_should_behave_like "a baza indexes driver"
-end

data/spec/info_active_record.rb

@@ -1,49 +0,0 @@
-class Baza::InfoActiveRecord
-  attr_reader :db
-
-  def self.connection
-    require "active_record"
-
-    if RUBY_ENGINE == "jruby"
-      require "/usr/share/java/mysql-connector-java.jar" if File.exists?("/usr/share/java/mysql-connector-java.jar")
-      @conn_pool ||= ::ActiveRecord::Base.establish_connection(
-        adapter: "mysql",
-        host: "localhost",
-        database: "baza-test",
-        username: "baza-test",
-        password: "BBH7djRUKzL5nmG3"
-      )
-      @conn ||= @conn_pool.connection
-    else
-      @conn_pool ||= ::ActiveRecord::Base.establish_connection(
-        adapter: "mysql2",
-        host: "localhost",
-        database: "baza-test",
-        username: "baza-test",
-        password: "BBH7djRUKzL5nmG3"
-      )
-      @conn ||= @conn_pool.connection
-    end
-
-    return {pool: @conn_pool, conn: @conn}
-  end
-
-  def initialize
-    data = Baza::InfoActiveRecord.connection
-
-    @db = Baza::Db.new(
-      type: :active_record,
-      conn: data[:conn]
-    )
-  end
-
-  def before
-    @db.tables.list.each do |name, table|
-      table.drop
-    end
-  end
-
-  def after
-    @db.close
-  end
-end

data/spec/info_active_record_shippable.rb

@@ -1,47 +0,0 @@
-class Baza::InfoActiveRecord
-  attr_reader :db
-
-  def self.connection
-    require "active_record"
-
-    if RUBY_ENGINE == "jruby"
-      require "/usr/share/java/mysql-connector-java.jar" if File.exists?("/usr/share/java/mysql-connector-java.jar")
-      @conn_pool ||= ::ActiveRecord::Base.establish_connection(
-        adapter: "mysql",
-        host: "localhost",
-        database: "baza",
-        username: "shippa"
-      )
-      @conn ||= @conn_pool.connection
-    else
-      @conn_pool ||= ::ActiveRecord::Base.establish_connection(
-        adapter: "mysql2",
-        host: "localhost",
-        database: "baza",
-        username: "shippa"
-      )
-      @conn ||= @conn_pool.connection
-    end
-
-    return {pool: @conn_pool, conn: @conn}
-  end
-
-  def initialize
-    data = Baza::InfoActiveRecord.connection
-
-    @db = Baza::Db.new(
-      type: :active_record,
-      conn: data[:conn]
-    )
-  end
-
-  def before
-    @db.tables.list.each do |name, table|
-      table.drop
-    end
-  end
-
-  def after
-    @db.close
-  end
-end