baza 0.0.20 → 0.0.21

data/lib/baza/row.rb

@@ -13,24 +13,24 @@ class Baza::Row
       @args[key.to_sym] = value
     end
 
-    @args[:objects] = $objects if !@args[:objects] && $objects && $objects.is_a?(Baza::ModelHandler)
     @args[:col_id] ||= :id
     raise "No table given." unless @args[:table]
 
     if @args[:data] && (@args[:data].is_a?(Integer) || @args[:data].is_a?(Fixnum) || @args[:data].is_a?(String))
       @data = {@args[:col_id].to_sym => @args[:data].to_s}
       reload
-    elsif @args[:data] && @args[:data].is_a?(Hash)
+    elsif @args[:data] && @args.fetch(:data).is_a?(Hash)
       @data = {}
-      @args[:data].each do |key, value|
-        @data[key.to_sym] = value
+      @args.fetch(:data).each do |key, value|
+        key = key.to_sym unless key.is_a?(Fixnum)
+        @data[key] = value
       end
     elsif @args[:id]
       @data = {}
       @data[@args[:col_id].to_sym] = @args[:id]
       reload
     else
-      raise ArgumentError.new("Invalid data: #{@args[:data]} (#{@args[:data].class})")
+      raise ArgumentError, "Invalid data: #{@args[:data]} (#{@args[:data].class})"
     end
   end
 
@@ -43,7 +43,7 @@ class Baza::Row
     false
   end
 
-  alias_method :objects, :ob
+  alias objects ob
 
   def reload
     last_id = id
@@ -59,14 +59,14 @@ class Baza::Row
   end
 
   def update(newdata)
-    db.update(@args[:table], newdata, @args[:col_id] => id)
+    db.update(@args.fetch(:table), newdata, @args.fetch(:col_id) => id)
     reload
 
     ob.call("object" => self, "signal" => "update") if ob
   end
 
   def delete
-    db.delete(@args[:table], @args[:col_id] => id)
+    db.delete(@args.fetch(:table), @args.fetch(:col_id) => id)
     destroy
   end
 
@@ -100,7 +100,7 @@ class Baza::Row
   end
 
   def id
-    @data[@args[:col_id]]
+    @data.fetch(@args.fetch(:col_id))
   end
 
   def to_param
@@ -108,18 +108,18 @@ class Baza::Row
   end
 
   def title
-    return @data[@args[:col_title].to_sym] if @args[:col_title]
+    return @data[@args.fetch(:col_title).to_sym] if @args[:col_title]
 
     if @data.key?(:title)
-      return @data[:title]
+      return @data.fetch(:title)
     elsif @data.key?(:name)
-      return @data[:name]
+      return @data.fetch(:name)
     end
 
     raise "'col_title' has not been set for the class: '#{self.class}'."
   end
 
-  alias_method :name, :title
+  alias name title
 
   def each(*args, &blk)
     @data.each(*args, &blk)
@@ -138,10 +138,10 @@ class Baza::Row
   end
 
   def method_missing(func_name, *args)
-    if match = func_name.to_s.match(/^(\S+)\?$/) && @data.key?(match[1].to_sym)
-      if @data[match[1].to_sym] == "1" || @data[match[1].to_sym] == "yes"
+    if (match = func_name.to_s.match(/^(\S+)\?$/)) && @data.key?(match[1].to_sym)
+      if @data.fetch(match[1].to_sym) == "1" || @data.fetch(match[1].to_sym) == "yes"
         return true
-      elsif @data[match[1].to_sym] == "0" || @data[match[1].to_sym] == "no"
+      elsif @data.fetch(match[1].to_sym) == "0" || @data.fetch(match[1].to_sym) == "no"
         return false
       end
     end

data/lib/baza/sql_queries.rb

@@ -0,0 +1,3 @@
+class Baza::SqlQueries
+  AutoAutoloader.autoload_sub_classes(self, __FILE__)
+end

data/lib/baza/sql_queries/generic_insert.rb

@@ -0,0 +1,81 @@
+class Baza::SqlQueries::GenericInsert
+  def initialize(args)
+    @db = args.fetch(:db)
+    @table_name = args.fetch(:table_name)
+    @data = args.fetch(:data)
+    @buffer = args[:buffer]
+    @return_sql = args[:return_sql]
+    @return_id = args[:return_id]
+  end
+
+  def execute
+    if @return_sql
+      to_sql
+    elsif @buffer
+      @buffer.query(to_sql)
+    else
+      @db.query(to_sql)
+      @db.last_id if @return_id
+    end
+  end
+
+  def to_sql
+    sql = "INSERT INTO #{@db.sep_table}#{@db.escape_table(@table_name)}#{@db.sep_table}"
+
+    if !@data || @data.empty?
+      sql << " #{sql_default_values}"
+    else
+      sql << " #{sql_columns} VALUES #{sql_values}"
+    end
+
+    sql
+  end
+
+private
+
+  def sql_default_values
+    if @db.opts.fetch(:type).to_s.include?("mysql")
+      "VALUES ()" # This is the correct syntax for inserting a blank row in MySQL.
+    elsif @db.opts.fetch(:type).to_s.include?("sqlite3")
+      "DEFAULT VALUES"
+    else
+      raise "Unknown database-type: '#{@db.opts.fetch(:type)}'."
+    end
+  end
+
+  def sql_columns
+    sql = "("
+
+    first = true
+    @data.each_key do |key|
+      if first
+        first = false
+      else
+        sql << ", "
+      end
+
+      sql << "#{@db.sep_col}#{@db.escape_column(key)}#{@db.sep_col}"
+    end
+
+    sql << ")"
+    sql
+  end
+
+  def sql_values
+    sql = "("
+
+    first = true
+    @data.each_value do |value|
+      if first
+        first = false
+      else
+        sql << ", "
+      end
+
+      sql << @db.sqlval(value)
+    end
+
+    sql << ")"
+    sql
+  end
+end

data/lib/baza/sql_queries/generic_update.rb

@@ -0,0 +1,31 @@
+class Baza::SqlQueries::GenericUpdate
+  def initialize(args)
+    @db = args.fetch(:db)
+    @table_name = args.fetch(:table_name)
+    @data = args.fetch(:data)
+    @terms = args.fetch(:terms)
+    @buffer = args[:buffer]
+  end
+
+  def execute
+    if @buffer
+      @buffer.query(to_sql)
+    else
+      @db.query(to_sql)
+    end
+  end
+
+  def to_sql
+    sql = "UPDATE #{@db.sep_col}#{@db.escape_table(@table_name)}#{@db.sep_col} SET "
+
+    first = true
+    @data.each do |key, value|
+      sql << ", " unless first
+      first = false if first
+      sql << "#{@db.sep_col}#{@db.escape_column(key)}#{@db.sep_col} = #{@db.sqlval(value)}"
+    end
+
+    sql << " WHERE #{@db.sql_make_where(@terms)}" if @terms && !@terms.empty?
+    sql
+  end
+end

data/lib/baza/sql_queries/mysql_upsert.rb

@@ -0,0 +1,52 @@
+class Baza::SqlQueries::MysqlUpsert
+  def initialize(args)
+    @db = args.fetch(:db)
+    @table_name = args.fetch(:table_name)
+    @updates = args.fetch(:updates)
+    @terms = args.fetch(:terms)
+  end
+
+  def execute
+    procedure_name = "baza_upsert_#{SecureRandom.hex(5)}"
+
+    sql = "CREATE PROCEDURE `#{@db.escape_table(procedure_name)}` () BEGIN\n"
+    sql << "\tIF EXISTS(#{select_query}) THEN\n"
+    sql << "\t\t#{update_sql};\n"
+    sql << "\tELSE\n"
+    sql << "\t\t#{insert_sql};\n"
+    sql << "\tEND IF;\n"
+    sql << "END;\n"
+
+    @db.query(sql)
+
+    begin
+      @db.query("CALL `#{@db.escape_table(procedure_name)}`")
+    ensure
+      @db.query("DROP PROCEDURE `#{@db.escape_table(procedure_name)}`")
+    end
+  end
+
+private
+
+  def select_query
+    sql = ""
+    sql << "SELECT * FROM #{@db.sep_table}#{@db.escape_table(@table_name)}#{@db.sep_table} WHERE"
+
+    first = true
+    @terms.each do |column, value|
+      sql << " AND" unless first
+      first = false if first
+      sql << " #{@db.sep_col}#{@db.escape_column(column)}#{@db.sep_col} = #{@db.sqlval(value)}"
+    end
+
+    sql
+  end
+
+  def update_sql
+    @db.update(@table_name, @updates, @terms, return_sql: true)
+  end
+
+  def insert_sql
+    @db.insert(@table_name, @updates.merge(@terms), return_sql: true)
+  end
+end

data/lib/baza/sql_queries/mysql_upsert_duplicate_key.rb

@@ -0,0 +1,57 @@
+class Baza::SqlQueries::MysqlUpsertDuplicateKey
+  def initialize(args)
+    @db = args.fetch(:db)
+    @table_name = args.fetch(:table_name)
+    @updates = StringCases.stringify_keys(args.fetch(:updates))
+    @terms = StringCases.stringify_keys(args.fetch(:terms))
+    @buffer = args[:buffer]
+    @return_id = args[:return_id]
+  end
+
+  def to_sql
+    sql = insert_sql
+    sql << " ON DUPLICATE KEY UPDATE"
+
+    first = true
+
+    if @return_id
+      sql << " #{@db.sep_col}#{@db.escape_column(primary_key_column_name)}#{@db.sep_col} = LAST_INSERT_ID(#{@db.sep_col}#{@db.escape_column(primary_key_column_name)}#{@db.sep_col})"
+      first = false
+    end
+
+    @updates.each do |key, value|
+      sql << "," unless first
+      first = false if first
+      sql << " #{@db.sep_col}#{@db.escape_column(key)}#{@db.sep_col} = #{@db.sqlval(value)}"
+    end
+
+    sql
+  end
+
+  def execute
+    if @buffer
+      @buffer.query(to_sql)
+    else
+      @db.query(to_sql)
+      return @db.query(last_insert_sql).fetch.fetch(:id).to_i if @return_id
+    end
+  end
+
+private
+
+  def insert_sql
+    @db.insert(@table_name, @updates.merge(@terms), return_sql: true)
+  end
+
+  def table
+    @table ||= @db.tables[@table_name.to_s]
+  end
+
+  def primary_key_column_name
+    @primary_key_column_name ||= table.columns(primarykey: true).first.name
+  end
+
+  def last_insert_sql
+    "SELECT LAST_INSERT_ID() AS `id` FROM #{@db.sep_table}#{@db.escape_table(@table_name)}#{@db.sep_table}"
+  end
+end

data/lib/baza/sql_queries/non_atomic_upsert.rb

@@ -0,0 +1,25 @@
+class Baza::SqlQueries::NonAtomicUpsert
+  def initialize(args)
+    @db = args.fetch(:db)
+    @table_name = args.fetch(:table_name)
+    @updates = args.fetch(:updates)
+    @terms = args.fetch(:terms)
+    @buffer = args[:buffer]
+  end
+
+  def execute
+    row = @db.single(@table_name, @terms)
+
+    if @buffer
+      obj = @buffer
+    else
+      obj = @db
+    end
+
+    if row
+      obj.update(@table_name, @updates, @terms)
+    else
+      obj.insert(@table_name, @terms.merge(@updates))
+    end
+  end
+end

data/lib/baza/sql_queries/postgres_upsert_duplicate_key.rb

@@ -0,0 +1,118 @@
+class Baza::SqlQueries::PostgresUpsertDuplicateKey
+  def initialize(args)
+    @db = args.fetch(:db)
+    @table_name = args.fetch(:table_name)
+    @updates = StringCases.stringify_keys(args.fetch(:updates))
+    @terms = StringCases.stringify_keys(args.fetch(:terms))
+    @return_id = args[:return_id]
+  end
+
+  def execute
+    if @db.commands.version.to_f >= 9.5
+      @db.query(on_conflict_sql)
+    elsif @terms.empty?
+      return insert_and_register_conflict
+    else
+      @db.query(begin_update_exception_sql)
+    end
+
+    @db.last_id if @return_id
+  end
+
+private
+
+  def insert_and_register_conflict
+    @db.query(insert_sql)
+    @db.last_id if @return_id
+  rescue => e
+    if (match = e.message.match(/Key \((.+)\)=\((.+)\) already exists/))
+      column_name = match[1]
+      conflicting_value = match[2]
+
+      @terms = {column_name => conflicting_value}
+      @db.query(begin_update_exception_sql)
+
+      if @return_id
+        primary_column = table.columns.find(&:primarykey?).name.to_sym
+        data = @db.single(@table_name, column_name => conflicting_value)
+        return data.fetch(primary_column).to_i
+      end
+    else
+      raise e
+    end
+  end
+
+  def begin_update_exception_sql
+    sql = "do $$\n"
+    sql << "BEGIN\n"
+    sql << "\t#{insert_sql};\n"
+    sql << "EXCEPTION WHEN unique_violation THEN\n"
+    sql << "\t#{update_sql};\n"
+    sql << "END $$;"
+
+    sql
+  end
+
+  def on_conflict_sql
+    "#{insert_sql} ON CONFLICT DO UPDATE #{update_set_sql}"
+  end
+
+  def insert_sql
+    sql = "INSERT INTO #{@db.sep_table}#{@db.escape_table(@table_name)}#{@db.sep_table} ("
+
+    combined_data = @updates.merge(@terms)
+
+    first = true
+    combined_data.each_key do |column_name|
+      sql << ", " unless first
+      first = false if first
+      sql << "#{@db.sep_col}#{@db.escape_column(column_name)}#{@db.sep_col}"
+    end
+
+    sql << ") VALUES ("
+
+    first = true
+    combined_data.each_value do |value|
+      sql << ", " unless first
+      first = false if first
+      sql << @db.sqlval(value).to_s
+    end
+
+    sql << ")"
+    sql
+  end
+
+  def update_sql
+    "UPDATE #{@db.sep_table}#{@db.escape_table(@table_name)}#{@db.sep_table} #{update_set_sql} #{update_where_sql}"
+  end
+
+  def update_set_sql
+    sql = "SET "
+
+    first = true
+    @updates.each do |key, value|
+      sql << ", " unless first
+      first = false if first
+      sql << "#{@db.sep_col}#{@db.escape_column(key)}#{@db.sep_col} = #{@db.sqlval(value)}"
+    end
+
+    sql
+  end
+
+  def update_where_sql
+    sql = "WHERE "
+
+    first = true
+    @terms.each do |key, value|
+      sql << " AND " unless first
+      first = false if first
+      sql << "#{@db.sep_col}#{@db.escape_column(key)}#{@db.sep_col} = #{@db.sqlval(value)}"
+    end
+
+    sql
+  end
+
+  def table
+    @table ||= @db.tables[@table_name.to_s]
+  end
+end