baza 0.0.19 → 0.0.20

data/lib/baza/drivers/sqlite3/table.rb

@@ -2,40 +2,43 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
   attr_reader :name, :type
 
   def initialize(args)
-    @db = args[:db]
-    @data = args[:data]
-    @name = @data[:name].to_sym
-    @type = @data[:type].to_sym
-    @tables = args[:tables]
+    @db = args.fetch(:db)
+    @data = args.fetch(:data)
+    @name = @data.fetch(:name)
+    @type = @data.fetch(:type).to_sym
+    @tables = args.fetch(:tables)
 
     @list = Wref::Map.new
     @indexes_list = Wref::Map.new
   end
 
   def maxlength
-    return @data[:maxlength]
+    @data.fetch(:maxlength)
   end
 
   def reload
-    @data = @db.select("sqlite_master", {type: "table", name: name}, {orderby: "name"}).fetch
+    data = @db.select("sqlite_master", {type: "table", name: name}, orderby: "name").fetch
+    raise Baza::Errors::TableNotFound unless data
+    @data = data
+    self
   end
 
   def rows_count
-    data = @db.q("SELECT COUNT(*) AS count FROM `#{name}`").fetch
-    return data[:count].to_i
+    data = @db.query("SELECT COUNT(*) AS count FROM `#{name}`").fetch
+    data.fetch(:count).to_i
   end
 
-  #Drops the table from the database.
+  # Drops the table from the database.
   def drop
     raise "Cant drop native table: '#{name}'." if native?
     @db.query("DROP TABLE `#{name}`")
     @tables.remove_from_list(self) if @tables.exists_in_list?(self)
   end
 
-  #Returns true if the table is safe to drop.
+  # Returns true if the table is safe to drop.
   def native?
     return true if name.to_s == "sqlite_sequence"
-    return false
+    false
   end
 
   def optimize
@@ -43,7 +46,7 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
   end
 
   def rename(newname)
-    newname = newname.to_sym
+    newname = newname.to_s
 
     @tables.remove_from_list(self)
     newtable = clone(newname)
@@ -53,37 +56,42 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
     @name = newname
     @tables.add_to_list(self)
 
-    #Rename table on all columns and indexes.
-    @list.each do |name, column|
+    # Rename table on all columns and indexes.
+    @list.each do |_name, column|
       column.args[:table_name] = newname
     end
 
-    @indexes_list.each do |name, index|
+    @indexes_list.each do |_name, index|
       index.args[:table_name] = newname
     end
   end
 
+  # Drops the table and creates it again
   def truncate
-    @db.query("DELETE FROM `#{name}` WHERE 1=1")
-    return nil
+    table_data = data
+    drop
+    @db.tables.create(table_data.delete(:name), table_data)
+    self
   end
 
   def table
-    return @db.tables[@table_name]
+    @db.tables[@table_name]
   end
 
   def column(name)
-    list = self.columns
-    return list[name] if list[name]
-    raise Errno::ENOENT, "Column not found: #{name}."
+    columns do |column|
+      return column if column.name == name.to_s
+    end
+
+    raise Baza::Errors::ColumnNotFound, "Column not found: #{name}"
   end
 
   def columns
     @db.cols
-    ret = {}
+    ret = []
 
-    @db.q("PRAGMA table_info(`#{@db.esc_table(name)}`)") do |d_cols|
-      column_name = d_cols[:name].to_sym
+    @db.query("PRAGMA table_info(`#{@db.escape_table(name)}`)") do |d_cols|
+      column_name = d_cols.fetch(:name)
       obj = @list.get(column_name)
 
       unless obj
@@ -98,7 +106,7 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
       if block_given?
         yield obj
       else
-        ret[column_name] = obj
+        ret << obj
       end
     end
 
@@ -111,28 +119,28 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
 
   def create_columns(col_arr)
     col_arr.each do |col_data|
-      #if col_data.key?("after")
+      # if col_data.key?("after")
       #  self.create_column_programmatic(col_data)
-      #else
-        @db.query("ALTER TABLE `#{self.name}` ADD COLUMN #{@db.cols.data_sql(col_data)};")
-      #end
+      # else
+      @db.query("ALTER TABLE `#{name}` ADD COLUMN #{@db.cols.data_sql(col_data)};")
+      # end
     end
   end
 
   def create_column_programmatic(col_data)
     temp_name = "temptable_#{Time.now.to_f.to_s.hash}"
-    cloned_tabled = self.clone(temp_name)
-    cols_cur = self.columns
-    @db.query("DROP TABLE `#{self.name}`")
+    cloned_tabled = clone(temp_name)
+    cols_cur = columns
+    @db.query("DROP TABLE `#{name}`")
 
-    sql = "CREATE TABLE `#{self.name}` ("
+    sql = "CREATE TABLE `#{name}` ("
     first = true
     cols_cur.each do |name, col|
-      sql << ", " if !first
+      sql << ", " unless first
       first = false if first
       sql << @db.cols.data_sql(col.data)
 
-      if col_data[:after] and col_data[:after] == name
+      if col_data[:after] && col_data[:after] == name
         sql << ", #{@db.cols.data_sql(col_data)}"
       end
     end
@@ -141,15 +149,13 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
 
     sql = "INSERT INTO `#{self.name}` SELECT "
     first = true
-    cols_cur.each do |name, col|
-      sql << ", " if !first
+    cols_cur.each do |name, _col|
+      sql << ", " unless first
       first = false if first
 
       sql << "`#{name}`"
 
-      if col_data[:after] and col_data[:after] == name
-        sql << ", ''"
-      end
+      sql << ", ''" if col_data[:after] && col_data[:after] == name
     end
     sql << " FROM `#{temp_name}`"
     @db.query(sql)
@@ -161,23 +167,26 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
 
     sql = "CREATE TABLE `#{newname}` ("
     first = true
-    columns.each do |name, col|
+    columns.each do |col|
       sql << ", " unless first
       first = false if first
       sql << @db.cols.data_sql(col.data)
     end
-
     sql << ");"
+
     @db.query(sql)
     @db.query("INSERT INTO `#{newname}` SELECT * FROM `#{name}`")
 
     indexes_to_create = []
     new_table = @db.tables[newname.to_sym]
-    indexes.each do |name, index|
-      index_name = name.to_s
+    indexes.each do |index|
+      index_name = index.name.gsub(/\A#{Regexp.escape(name)}_/, "")
 
       if @db.opts[:index_append_table_name] && match = index_name.match(/\A(.+?)__(.+)\Z/)
         index_name = match[2]
+      else
+        # Two indexes with the same name can't exist, and we are cloning, so we need to change the name
+        index_name = "#{newname}_#{index_name}"
       end
 
       create_data = index.data
@@ -197,29 +206,28 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
 
   def copy(args = {})
     temp_name = "temptable_#{Time.now.to_f.to_s.hash}"
-    cloned_tabled = self.clone(temp_name)
-    cols_cur = self.columns
-    @db.query("DROP TABLE `#{self.name}`")
+    cloned_tabled = clone(temp_name)
+    cols_cur = columns
+    @db.query("DROP TABLE `#{name}`")
 
-    sql = "CREATE TABLE `#{self.name}` ("
+    sql = "CREATE TABLE `#{name}` ("
     first = true
-    cols_cur.each do |name, col|
-      next if args[:drops] && args[:drops].to_s.include?(name.to_s)
+    cols_cur.each do |col|
+      next if args[:drops] && args[:drops].to_s.include?(col.name)
 
-      sql << ", " if !first
+      sql << ", " unless first
       first = false if first
 
-      if args.key?(:alter_columns) && args[:alter_columns][name.to_sym]
-        sql << @db.cols.data_sql(args[:alter_columns][name.to_sym])
+      if args.key?(:alter_columns) && args[:alter_columns][col.name]
+        sql << @db.cols.data_sql(args[:alter_columns][col.name])
       else
         sql << @db.cols.data_sql(col.data)
       end
 
-      if args[:new]
-        args[:new].each do |col_data|
-          if col_data[:after] && col_data[:after] == name
-            sql << ", #{@db.cols.data_sql(col_data)}"
-          end
+      next unless args[:new]
+      args[:new].each do |col_data|
+        if col_data[:after] && col_data[:after] == col.name
+          sql << ", #{@db.cols.data_sql(col_data)}"
         end
       end
     end
@@ -227,22 +235,19 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
     sql << ");"
     @db.query(sql)
 
-    sql = "INSERT INTO `#{self.name}` SELECT "
+    sql = "INSERT INTO `#{name}` SELECT "
     first = true
-    cols_cur.each do |name, col|
-      next if args[:drops] && args[:drops].to_s.include?(name.to_s)
+    cols_cur.each do |col|
+      next if args[:drops] && args[:drops].to_s.include?(col.name)
 
-      sql << ", " if !first
+      sql << ", " unless first
       first = false if first
 
-      sql << "`#{name}`"
+      sql << "`#{col.name}`"
 
-      if args[:news]
-        args[:news].each do |col_data|
-          if col_data[:after] && col_data[:after] == name.to_s
-            sql << ", ''"
-          end
-        end
+      next unless args[:news]
+      args[:news].each do |col_data|
+        sql << ", ''" if col_data[:after] && col_data[:after] == col.name
       end
     end
 
@@ -252,36 +257,33 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
   end
 
   def index(index_name)
-    index_name = index_name.to_sym
+    index_name = index_name.to_s
 
-    if index = @indexes_list[index_name]
+    if (index = @indexes_list[index_name])
       return index
     end
 
     if @db.opts[:index_append_table_name]
       tryname = "#{name}__#{index_name}"
 
-      if index = @indexes_list[tryname]
+      if (index = @indexes_list[tryname])
         return index
       end
     end
 
-    indexes do |index|
-      if index.name.to_s == "#{name}__#{index_name}"
-        return index
-      end
-
-      return index if index.name.to_s == index_name.to_s
+    indexes do |index_i|
+      return index_i if index_i.name == "#{name}__#{index_name}"
+      return index_i if index_i.name == index_name
     end
 
-    raise Errno::ENOENT, "Index not found: #{index_name}."
+    raise Baza::Errors::IndexNotFound, "Index not found: #{index_name}."
   end
 
   def indexes
     @db.indexes
-    ret = {} unless block_given?
+    ret = [] unless block_given?
 
-    @db.q("PRAGMA index_list(`#{@db.esc_table(name)}`)") do |d_indexes|
+    @db.query("PRAGMA index_list(`#{@db.escape_table(name)}`)") do |d_indexes|
       next if d_indexes[:Key_name] == "PRIMARY"
       obj = @indexes_list.get(d_indexes[:name])
 
@@ -304,7 +306,7 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
       if block_given?
         yield(obj)
       else
-        ret[d_indexes[:name].to_sym] = obj
+        ret << obj
       end
     end
 
@@ -316,31 +318,28 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
   end
 
   def create_indexes(index_arr, args = nil)
-    if args && args[:return_sql]
-      ret = []
-    end
+    ret = [] if args && args[:return_sql]
 
     index_arr.each do |index_data|
-      if index_data.is_a?(String) or index_data.is_a?(Symbol)
+      if index_data.is_a?(String) || index_data.is_a?(Symbol)
         index_data = {name: index_data, columns: [index_data]}
       end
 
       raise "No name was given in data: '#{index_data}'." if !index_data.key?(:name) || index_data[:name].to_s.strip.empty?
       raise "No columns was given on index #{index_data[:name]}." if !index_data[:columns] || index_data[:columns].empty?
 
-      name = index_data[:name]
-      name = "#{self.name}__#{name}" if @db.opts[:index_append_table_name]
+      index_name = index_data.fetch(:name).to_s
+      index_name = "#{name}__#{index_name}" if @db.opts[:index_append_table_name] && !index_name.start_with?("#{name}__")
 
       sql = "CREATE"
       sql << " UNIQUE" if index_data[:unique]
-      sql << " INDEX '#{@db.esc_col(name)}' ON `#{@db.esc_table(self.name)}` ("
+      sql << " INDEX '#{@db.escape_column(index_name)}' ON `#{@db.escape_table(name)}` ("
 
       first = true
-      index_data[:columns].each do |col_name|
-        sql << ", " if !first
+      index_data.fetch(:columns).each do |col_name|
+        sql << ", " unless first
         first = false if first
-
-        sql << "`#{@db.esc_col(col_name)}`"
+        sql << "`#{@db.escape_column(col_name)}`"
       end
 
       sql << ")"
@@ -366,15 +365,15 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
       indexes: []
     }
 
-    columns.each do |name, column|
+    columns do |column|
       ret[:columns] << column.data
     end
 
-    indexes.each do |name, index|
-      ret[:indexes] << index.data if name != "PRIMARY"
+    indexes do |index|
+      ret[:indexes] << index.data unless index.name == "PRIMARY"
     end
 
-    return ret
+    ret
   end
 
   def insert(data)
@@ -391,8 +390,8 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
 
 private
 
-  def parse_columns_from_sql sql
+  def parse_columns_from_sql(sql)
     columns_sql = sql.match(/\((.+?)\)\Z/)[1]
-    return columns_sql.split(",").map{ |column| column[1, column.length - 2] }
+    columns_sql.split(",").map { |column| column.match(/`(.+)`/)[1] }
   end
 end

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

@@ -1,3 +1,5 @@
+require "monitor"
+
 class Baza::Driver::Sqlite3::Tables
   attr_reader :db, :driver
 
@@ -5,33 +7,36 @@ class Baza::Driver::Sqlite3::Tables
     @args = args
     @db = @args[:db]
 
-    @list_mutex = Mutex.new
+    @list_mutex = Monitor.new
     @list = Wref::Map.new
   end
 
   def [](table_name)
-    table_name = table_name.to_sym
+    table_name = table_name.to_s
 
     if ret = @list.get(table_name)
       return ret
     end
 
-    self.list do |table_obj|
-      return table_obj if table_obj.name == table_name
+    list(name: table_name) do |table|
+      return table if table.name == table_name
     end
 
-    raise Errno::ENOENT, "Table was not found: #{table_name}."
+    raise Baza::Errors::TableNotFound, "Table was not found: #{table_name}."
   end
 
-  def list
-    ret = {} unless block_given?
+  def list(args = {})
+    ret = [] unless block_given?
 
     @list_mutex.synchronize do
-      q_tables = @db.select("sqlite_master", {"type" => "table"}, {orderby: "name"}) do |d_tables|
-        next if d_tables[:name] == "sqlite_sequence"
+      tables_args = {type: "table"}
+      tables_args[:name] = args.fetch(:name) if args[:name]
+
+      q_tables = @db.select("sqlite_master", tables_args, orderby: "name") do |d_tables|
+        table_name = d_tables.fetch(:name)
+        next if table_name == "sqlite_sequence"
 
-        tname = d_tables[:name].to_sym
-        obj = @list.get(tname)
+        obj = @list.get(table_name)
 
         unless obj
           obj = Baza::Driver::Sqlite3::Table.new(
@@ -39,25 +44,25 @@ class Baza::Driver::Sqlite3::Tables
             data: d_tables,
             tables: self
           )
-          @list[tname] = obj
+          @list[table_name] = obj
         end
 
         if block_given?
-          yield(obj)
+          yield obj
         else
-          ret[tname] = obj
+          ret << obj
         end
       end
     end
 
     if block_given?
-      return nil
+      nil
     else
-      return ret
+      ret
     end
   end
 
-  def exists_in_list? table
+  def exists_in_list?(table)
     @list.key?(table.name)
   end
 
@@ -73,15 +78,17 @@ class Baza::Driver::Sqlite3::Tables
 
   CREATE_ALLOWED_KEYS = [:indexes, :columns]
   def create(name, data, args = nil)
-    data.each do |key, val|
+    data.each_key do |key|
       raise "Invalid key: '#{key}' (#{key.class.name})." unless CREATE_ALLOWED_KEYS.include?(key)
     end
 
+    raise "No columns given" if data.fetch(:columns).empty?
+
     sql = "CREATE TABLE `#{name}` ("
 
     first = true
-    data[:columns].each do |col_data|
-      sql << ", " if !first
+    data.fetch(:columns).each do |col_data|
+      sql << ", " unless first
       first = false if first
       sql << @db.cols.data_sql(col_data)
     end
@@ -94,13 +101,13 @@ class Baza::Driver::Sqlite3::Tables
       @db.query(sql)
     end
 
-    if data.key?(:indexes) && data[:indexes]
+    if data[:indexes]
       table_obj = self[name]
 
       if args && args[:return_sql]
-        ret += table_obj.create_indexes(data[:indexes], return_sql: true)
+        ret += table_obj.create_indexes(data.fetch(:indexes), return_sql: true)
       else
-        table_obj.create_indexes(data[:indexes])
+        table_obj.create_indexes(data.fetch(:indexes))
       end
     end
 

data/lib/baza/drivers/sqlite3/unbuffered_result.rb

@@ -1,8 +1,8 @@
 class Baza::Driver::Sqlite3::UnbufferedResult
-  def initialize(driver, statement)
+  def initialize(_driver, statement)
     @statement = statement
     @statement.execute
-    @columns = statement.columns.map { |column| column.to_sym }
+    @columns = statement.columns.map(&:to_sym)
   end
 
   def fetch

data/lib/baza/drivers/sqlite3.rb

@@ -1,7 +1,9 @@
-#This class handels SQLite3-specific behaviour.
+# This class handels SQLite3-specific behaviour.
 class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
   path = "#{File.dirname(__FILE__)}/sqlite3"
 
+  autoload :Database, "#{path}/database"
+  autoload :Databases, "#{path}/databases"
   autoload :Table, "#{path}/table"
   autoload :Tables, "#{path}/tables"
   autoload :Column, "#{path}/column"
@@ -14,7 +16,14 @@ class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
 
   attr_reader :mutex_statement_reader
 
-  #Helper to enable automatic registering of database using Baza::Db.from_object
+  def self.args
+    [{
+      label: "Path",
+      name: "path"
+    }]
+  end
+
+  # 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 {
@@ -27,7 +36,7 @@ class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
     end
   end
 
-  #Constructor. This should not be called manually.
+  # Constructor. This should not be called manually.
   def initialize(baza_db)
     super
 
@@ -38,14 +47,14 @@ class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
       @conn = @baza.opts[:conn]
     else
       raise "No path was given." unless @path
-      require 'sqlite3' unless ::Object.const_defined?(:SQLite3)
+      require "sqlite3" unless ::Object.const_defined?(:SQLite3)
 
       @conn = ::SQLite3::Database.open(@path)
       @conn.type_translation = false # Type translation is always done in the C ext for SQLite3
     end
   end
 
-  #Executes a query against the driver.
+  # Executes a query against the driver.
   def query(sql)
     @mutex_statement_reader.synchronize do
       return Baza::Driver::Sqlite3::Result.new(self, @conn.prepare(sql))
@@ -53,29 +62,33 @@ class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
   end
 
   def query_ubuf(sql)
-    return Baza::Driver::Sqlite3::UnbufferedResult.new(self, @conn.prepare(sql))
+    Baza::Driver::Sqlite3::UnbufferedResult.new(self, @conn.prepare(sql))
   end
 
-  #Escapes a string to be safe to used in a 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(/'/, "''")
+    # 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
+    string.to_s.gsub(/'/, "''")
   end
 
-  #Returns the last inserted ID.
+  # 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
+    query("SELECT last_insert_rowid() AS id").fetch[:id].to_i
   end
 
-  #Closes the connection to the database.
+  # Closes the connection to the database.
   def close
     @mutex_statement_reader.synchronize { @conn.close }
   end
 
-  #Starts a transaction, yields the database and commits.
+  # Starts a transaction, yields the database and commits.
   def transaction
     @conn.transaction { yield @baza }
   end
+
+  def supports_multiple_databases?
+    false
+  end
 end

data/lib/baza/drivers/sqlite3_java/database.rb

@@ -0,0 +1,2 @@
+class Baza::Driver::Sqlite3java::Database < Baza::Database
+end

data/lib/baza/drivers/sqlite3_java/unbuffered_result.rb

@@ -1,5 +1,5 @@
 class Baza::Driver::Sqlite3Java::UnbufferedResult < Baza::ResultBase
-  def initialize(driver, result_set)
+  def initialize(_driver, result_set)
     @result_set = result_set
 
     if @result_set
@@ -22,7 +22,7 @@ class Baza::Driver::Sqlite3Java::UnbufferedResult < Baza::ResultBase
       hash[@columns[count]] = @result_set.string(count + 1)
     end
 
-    return hash
+    hash
   end
 
   def each