baza 0.0.38 → 0.0.39

data/lib/baza/driver/pg/table.rb

@@ -119,6 +119,49 @@ class Baza::Driver::Pg::Table < Baza::Table
     result
   end
 
+  def referenced_foreign_keys(args = {})
+    sql = "
+      SELECT
+        tc.constraint_name,
+        tc.table_name,
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name
+
+      FROM
+        information_schema.table_constraints AS tc
+
+      JOIN information_schema.key_column_usage AS kcu ON
+        tc.constraint_name = kcu.constraint_name
+
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+
+      WHERE
+        constraint_type = 'FOREIGN KEY' AND
+        ccu.table_name = '#{@db.escape(name)}'
+    "
+
+    sql << " AND tc.constraint_name = '#{@db.escape(args.fetch(:name))}'" if args[:name]
+
+    result = [] unless block_given?
+
+    @db.query(sql) do |data|
+      foreign_key = Baza::Driver::Pg::ForeignKey.new(
+        db: @db,
+        data: data
+      )
+
+      if block_given?
+        yield foreign_key
+      else
+        result << foreign_key
+      end
+    end
+
+    result
+  end
+
   def foreign_key(name)
     foreign_keys(name: name) do |foreign_key|
       return foreign_key

data/lib/baza/driver/pg/tables.rb

@@ -39,39 +39,46 @@ class Baza::Driver::Pg::Tables < Baza::Tables
     tables_list
   end
 
-  def create(table_name, data, args = nil)
+  def create(table_name, columns:, indexes: nil, return_sql: false, temp: false)
     table_name = table_name.to_s
     raise "Invalid table name: #{table_name}" if table_name.strip.empty?
-    raise "No columns was given for '#{table_name}'." if !data[:columns] || data[:columns].empty?
+    raise "No columns was given for '#{table_name}'." if !columns || columns.empty?
 
     create_table_sql = "CREATE"
-    create_table_sql << " TEMPORARY" if data[:temp]
+    create_table_sql << " TEMPORARY" if temp
     create_table_sql << " TABLE #{db.quote_table(table_name)} ("
 
     first = true
-    data.fetch(:columns).each do |col_data|
+    columns.each do |col_data|
       create_table_sql << ", " unless first
       first = false if first
       col_data.delete(:after) if col_data[:after]
       create_table_sql << db.columns.data_sql(col_data)
     end
 
+    columns.each do |col_data| # rubocop :disable Style/CombinableLoops
+      next unless col_data.key?(:foreign_key)
+
+      create_table_sql << ","
+      create_table_sql << " CONSTRAINT #{col_data.fetch(:foreign_key).fetch(:name)}" if col_data.fetch(:foreign_key)[:name]
+      create_table_sql << " FOREIGN KEY (#{col_data.fetch(:name)}) " \
+        "REFERENCES #{col_data.fetch(:foreign_key).fetch(:to).fetch(0)} (#{col_data.fetch(:foreign_key).fetch(:to).fetch(1)})"
+    end
+
     create_table_sql << ")"
 
     sqls = [create_table_sql]
 
-    if data[:indexes] && !data[:indexes].empty?
-      sqls += db.indexes.create_index(data.fetch(:indexes), table_name: table_name, return_sql: true)
+    if indexes && !indexes.empty?
+      sqls += db.indexes.create_index(indexes, table_name: table_name, return_sql: true)
     end
 
-    if !args || !args[:return_sql]
-      db.transaction do
-        sqls.each do |sql|
-          db.query(sql)
-        end
+    return sqls if return_sql
+
+    db.transaction do
+      sqls.each do |sql|
+        db.query(sql)
       end
-    else
-      sqls
     end
   end
 end

data/lib/baza/driver/sqlite3/columns.rb

@@ -7,7 +7,7 @@ class Baza::Driver::Sqlite3::Columns
     @db = args.fetch(:db)
   end
 
-  DATA_SQL_ALLOWED_KEYS = [:name, :type, :maxlength, :autoincr, :primarykey, :null, :default, :default_func, :renames, :after, :renames].freeze
+  DATA_SQL_ALLOWED_KEYS = [:foreign_key, :name, :type, :maxlength, :autoincr, :primarykey, :null, :default, :default_func, :renames, :after, :renames].freeze
   # Returns SQL for a knjdb-compatible hash.
   def data_sql(data)
     data.each_key do |key|

data/lib/baza/driver/sqlite3/foreign_key.rb

@@ -0,0 +1,14 @@
+class Baza::Driver::Sqlite3::ForeignKey < Baza::ForeignKey
+  def initialize(db:, data:)
+    @db = db
+    @column_name = data.fetch(:from)
+    @name = data.fetch(:id)
+    @table_name = data.fetch(:table)
+    @referenced_table_name = data.fetch(:referenced_table)
+    @referenced_column_name = data.fetch(:to)
+  end
+
+  def drop
+    raise "stub"
+  end
+end

data/lib/baza/driver/sqlite3/foreign_keys.rb

@@ -0,0 +1,11 @@
+class Baza::Driver::Sqlite3::ForeignKeys
+  attr_reader :db
+
+  def initialize(db:)
+    @db = db
+  end
+
+  def create(from:, to:, name: nil) # rubocop:disable Lint/UnusedMethodArgument
+    raise "Only support doing create table in SQLite"
+  end
+end

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

@@ -1,4 +1,4 @@
-class Baza::Driver::Sqlite3::Table < Baza::Table
+class Baza::Driver::Sqlite3::Table < Baza::Table # rubocop:disable Metrics/ClassLength
   attr_reader :name, :type
 
   def initialize(args)
@@ -12,6 +12,41 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
     @indexes_list = Wref::Map.new
   end
 
+  def foreign_keys
+    db.query("PRAGMA foreign_key_list('#{name}')").map do |foreign_key_data|
+      data = foreign_key_data.clone
+      data[:referenced_table] = data.fetch(:table)
+      data[:table] = name
+
+      Baza::Driver::Sqlite3::ForeignKey.new(db: db, data: data)
+    end
+  end
+
+  def referenced_foreign_keys
+    sql = "
+      SELECT
+        sqlite_master.name,
+        pragma_join.*
+
+      FROM
+        sqlite_master
+
+      JOIN pragma_foreign_key_list(sqlite_master.name) pragma_join ON
+        pragma_join.\"table\" != sqlite_master.name
+
+      WHERE sqlite_master.type = 'table'
+      ORDER BY sqlite_master.name
+    "
+
+    db.query(sql).map do |foreign_key_data|
+      data = foreign_key_data.clone
+      data[:referenced_table] = data.fetch(:table)
+      data[:table] = data.fetch(:name)
+
+      Baza::Driver::Sqlite3::ForeignKey.new(db: db, data: data)
+    end
+  end
+
   def maxlength
     @data.fetch(:maxlength)
   end
@@ -57,20 +92,20 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
     @tables.add_to_list(self)
 
     # Rename table on all columns and indexes.
-    @list.each do |_name, column|
+    @list.each_value do |column|
       column.args[:table_name] = newname
     end
 
-    @indexes_list.each do |_name, index|
+    @indexes_list.each_value do |index|
       index.args[:table_name] = newname
     end
   end
 
   # Drops the table and creates it again
   def truncate
-    table_data = data
+    table_data = data.clone
     drop
-    @db.tables.create(table_data.delete(:name), table_data)
+    @db.tables.create(table_data.delete(:name), **table_data)
     self
   end
 
@@ -149,7 +184,7 @@ class Baza::Driver::Sqlite3::Table < Baza::Table
 
     sql = "INSERT INTO `#{self.name}` SELECT "
     first = true
-    cols_cur.each do |name, _col|
+    cols_cur.each_key do |name|
       sql << ", " unless first
       first = false if first
 

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

@@ -75,42 +75,43 @@ class Baza::Driver::Sqlite3::Tables < Baza::Tables
     @list[table.name] = table
   end
 
-  CREATE_ALLOWED_KEYS = [:indexes, :columns].freeze
-  def create(name, data, args = nil)
-    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?
+  def create(name, columns:, indexes: nil, return_sql: false)
+    raise "No columns given" if !columns || columns.empty?
 
     sql = "CREATE TABLE `#{name}` ("
 
     first = true
-    data.fetch(:columns).each do |col_data|
+    columns.each do |col_data|
       sql << ", " unless first
       first = false if first
       sql << @db.columns.data_sql(col_data)
     end
 
+    columns.each do |col_data| # rubocop:disable Style/CombinableLoops
+      next unless col_data.key?(:foreign_key)
+
+      sql << ", FOREIGN KEY (#{col_data.fetch(:name)}) REFERENCES #{col_data.fetch(:foreign_key).fetch(:to).fetch(0)}(#{col_data.fetch(:foreign_key).fetch(:to).fetch(1)})"
+    end
+
     sql << ")"
 
-    if args && args[:return_sql]
+    if return_sql
       ret = [sql]
     else
       @db.query(sql)
     end
 
-    if data[:indexes]
+    if indexes
       table_obj = self[name]
 
-      if args && args[:return_sql]
-        ret += table_obj.create_indexes(data.fetch(:indexes), return_sql: true)
+      if return_sql
+        ret += table_obj.create_indexes(indexes, return_sql: true)
       else
-        table_obj.create_indexes(data.fetch(:indexes))
+        table_obj.create_indexes(indexes)
       end
     end
 
-    if args && args[:return_sql]
+    if return_sql
       return ret
     else
       return nil

data/lib/baza/driver/sqlite3.rb

@@ -69,7 +69,7 @@ class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
   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
-    string.to_s.gsub(/'/, "''")
+    string.to_s.gsub("'", "''")
   end
 
   # Closes the connection to the database.

data/lib/baza/driver/sqlite3_java.rb

@@ -50,7 +50,7 @@ class Baza::Driver::Sqlite3Java < Baza::JdbcDriver
   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
-    string.to_s.gsub(/'/, "''")
+    string.to_s.gsub("'", "''")
   end
 
   def transaction

data/lib/baza/driver/sqlite3_rhodes.rb

@@ -45,7 +45,7 @@ class Baza::Driver::Sqlite3Rhodes < Baza::BaseSqlDriver
   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
-    string.to_s.gsub(/'/, "''")
+    string.to_s.gsub("'", "''")
   end
 
   # Closes the connection to the database.

data/lib/baza/dump.rb

@@ -67,11 +67,12 @@ class Baza::Dump
 
   # Dumps the given table into the given IO.
   def dump_table(io, table_obj)
-    create_data = table_obj.data
+    create_data = table_obj.data.clone
     create_data.delete(:name)
+    create_data[:return_sql] = true
 
     # Get SQL for creating table and add it to IO.
-    sqls = @export_db.tables.create(table_obj.name, create_data, return_sql: true)
+    sqls = @export_db.tables.create(table_obj.name, **create_data)
     sqls.each do |sql|
       io.write("#{sql};\n")
     end

data/lib/baza/foreign_key.rb

@@ -1,7 +1,7 @@
 class Baza::ForeignKey
   include Baza::DatabaseModelFunctionality
 
-  attr_reader :column_name, :db, :name, :table_name
+  attr_reader :column_name, :db, :name, :table_name, :referenced_column_name, :referenced_table_name
 
   def column
     @_column ||= table.column(column_name)

data/lib/baza/jdbc_driver.rb

@@ -49,7 +49,7 @@ private
   def query_with_statement(sql, preload_results)
     @mutex.synchronize do
       begin
-        if sql =~ /^\s*(delete|update|create|drop|insert\s+into|alter|truncate)\s+/i
+        if sql.match?(/^\s*(delete|update|create|drop|insert\s+into|alter|truncate)\s+/i)
           return query_no_result_set(sql)
         else
           stmt = yield

data/lib/baza/mysql_base_driver.rb

@@ -62,7 +62,7 @@ class Baza::MysqlBaseDriver < Baza::BaseSqlDriver
           sql << @db.quote_value(val)
         end
       else
-        hash.each do |_key, val|
+        hash.each_value do |val|
           if first_key
             first_key = false
           else

data/lib/baza/query_buffer.rb

@@ -2,6 +2,8 @@
 class Baza::QueryBuffer
   attr_reader :thread_async
 
+  QUERIES_FLUSH_SIZE = 12 * 1024 * 1024
+
   INITIALIZE_ARGS_ALLOWED = [:db, :debug, :flush_async].freeze
   # Constructor. Takes arguments to be used and a block.
   def initialize(args)
@@ -10,6 +12,7 @@ class Baza::QueryBuffer
     @queries = []
     @inserts = {}
     @queries_count = 0
+    @queries_size = 0
     @debug = @args[:debug]
     @lock = Mutex.new
 
@@ -44,9 +47,10 @@ class Baza::QueryBuffer
       STDOUT.print "Adding to buffer: #{str}\n" if @debug
       @queries << str
       @queries_count += 1
+      @queries_size += str.bytesize
     end
 
-    flush if @queries_count >= 1000
+    flush if @queries_count >= 1000 || @queries_size >= QUERIES_FLUSH_SIZE
     nil
   end
 
@@ -84,6 +88,27 @@ class Baza::QueryBuffer
     nil
   end
 
+  def insert_with_multi(table, data, sort: false)
+    data_key = ""
+
+    if sort
+      data = data.sort_by { |element| element[0].to_s }
+      data = Hash[data]
+    end
+
+    data.each do |key, value|
+      data_key << "#{key}---"
+      @queries_size += value.is_a?(String) ? value.bytesize * 1.5 : 8
+    end
+
+    @inserts[table] ||= {}
+    @inserts[table][data_key] ||= []
+    @inserts[table][data_key] << data
+
+    @queries_count += 1
+    flush if @queries_count >= 1000 || @queries_size >= QUERIES_FLUSH_SIZE
+  end
+
   # Flushes all queries out in a transaction. This will automatically be called for every 1000 queries.
   def flush
     if @args[:flush_async]
@@ -127,20 +152,25 @@ private
             @queries.shift(1000).each do |str|
               STDOUT.print "Executing via buffer: #{str}\n" if @debug
               db.q(str)
+
+              @queries_count -= 1
             end
           end
         end
       end
 
-      @inserts.each do |table, datas_arr|
-        until datas_arr.empty?
-          datas_chunk_arr = datas_arr.shift(1000)
-          @db.insert_multi(table, datas_chunk_arr)
+      @inserts.each do |table, datas|
+        datas.each_value do |datas_arr|
+          until datas_arr.empty?
+            datas_chunk_arr = datas_arr.shift(1000)
+            @db.insert_multi(table, datas_chunk_arr)
+            @queries_count -= datas_chunk_arr.length
+          end
         end
       end
 
       @inserts.clear
-      @queries_count = 0
+      @queries_size = 0
     end
 
     nil

data/lib/baza/result_base.rb

@@ -15,11 +15,8 @@ class Baza::ResultBase
   end
 
   def to_a
-    array = []
-    each do |row_data|
-      array << row_data
+    map do |row_data|
+      row_data
     end
-
-    array
   end
 end

data/lib/baza/tables.rb

@@ -1,5 +1,5 @@
 class Baza::Tables
   def exists?(name)
-    list.any? { |table| table.name.to_s == name.to_s }
+    list(name: name).any? { |table| table.name.to_s == name.to_s }
   end
 end