baza 0.0.19 → 0.0.20

data/lib/baza/model_handler_sqlhelper.rb

@@ -1,7 +1,7 @@
-require 'ostruct'
+require "ostruct"
 
 class Baza::ModelHandler
-  #This method helps build SQL from Objects-instances list-method. It should not be called directly but only through Objects.list.
+  # This method helps build SQL from Objects-instances list-method. It should not be called directly but only through Objects.list.
   def sqlhelper(list_args, args_def)
     args = args_def
 
@@ -12,7 +12,7 @@ class Baza::ModelHandler
     end
 
     if args[:table]
-      table_def = "`#{db.esc_table(args[:table])}`."
+      table_def = "`#{db.escape_table(args[:table])}`."
     else
       table_def = ""
     end
@@ -51,7 +51,7 @@ class Baza::ModelHandler
             list_args.delete("ordermode")
           end
 
-          sql_order << "#{table_def}`#{db.esc_col(list_args["orderby"])}`#{ordermode}"
+          sql_order << "#{table_def}`#{db.escape_column(list_args["orderby"])}`#{ordermode}"
           list_args.delete("orderby")
         end
       elsif list_args["orderby"].is_a?(Array)
@@ -71,26 +71,26 @@ class Baza::ModelHandler
 
             if val[0].is_a?(Array)
               if args[:joined_tables]
-                args[:joined_tables].each do |table_name, table_data|
+                args[:joined_tables].each do |table_name, _table_data|
                   next if table_name.to_s != val[0][0].to_s
                   do_joins[table_name] = true
-                  orders << "`#{db.esc_table(table_name)}`.`#{db.esc_col(val[0][1])}`#{ordermode}"
+                  orders << "`#{db.escape_table(table_name)}`.`#{db.escape_column(val[0][1])}`#{ordermode}"
                   found = true
                   break
                 end
               end
 
-              raise "Could not find joined table for ordering: '#{val[0][0]}'." if !found
+              raise "Could not find joined table for ordering: '#{val[0][0]}'." unless found
             else
               orderstr = val[0]
             end
           elsif val.is_a?(String)
             orderstr = val
             ordermode = " ASC"
-          elsif val.is_a?(Hash) and val[:type] == :sql
+          elsif val.is_a?(Hash) && val[:type] == :sql
             orders << val[:sql]
             found = true
-          elsif val.is_a?(Hash) and val[:type] == :case
+          elsif val.is_a?(Hash) && val[:type] == :case
             caseorder = " CASE"
 
             val[:case].each do |key, caseval|
@@ -99,38 +99,35 @@ class Baza::ModelHandler
               col_str = nil
 
               if col.is_a?(Array)
-                raise "No joined tables for '#{args[:table]}'." if !args[:joined_tables]
+                raise "No joined tables for '#{args[:table]}'." unless args[:joined_tables]
 
                 found = false
-                args[:joined_tables].each do |table_name, table_data|
-                  if table_name == col.first
-                    do_joins[table_name] = true
-                    col_str = "`#{db.esc_table(table_name)}`.`#{db.esc_col(col.last)}`"
-                    found = true
-                    break
-                  end
+                args[:joined_tables].each do |table_name, _table_data|
+                  next unless table_name == col.first
+                  do_joins[table_name] = true
+                  col_str = "`#{db.escape_table(table_name)}`.`#{db.escape_column(col.last)}`"
+                  found = true
+                  break
                 end
 
-                raise "No such joined table on '#{args[:table]}': '#{col.first}' (#{col.first.class.name}) with the following joined table:\n#{Php4r.print_r(args[:joined_tables], true)}" if !found
-              elsif col.is_a?(String) or col.is_a?(Symbol)
+                raise "No such joined table on '#{args[:table]}': '#{col.first}' (#{col.first.class.name}) with the following joined table:\n#{Php4r.print_r(args[:joined_tables], true)}" unless found
+              elsif col.is_a?(String) || col.is_a?(Symbol)
                 col_str = "#{table_def}`#{col}`"
                 found = true
               else
                 raise "Unknown type for case-ordering: '#{col.class.name}'."
               end
 
-              raise "'colstr' was not set." if !col_str
+              raise "'colstr' was not set." unless col_str
               caseorder << " WHEN #{col_str} = '#{db.esc(isval)}' THEN '#{db.esc(caseval)}'"
             end
 
-            if val[:else]
-              caseorder << " ELSE '#{db.esc(val[:else])}'"
-            end
+            caseorder << " ELSE '#{db.esc(val[:else])}'" if val[:else]
 
             caseorder << " END"
             orders << caseorder
           elsif val.is_a?(Hash)
-            raise "No joined tables." if !args.key?(:joined_tables)
+            raise "No joined tables." unless args.key?(:joined_tables)
 
             if val[:mode] == "asc"
               ordermode = " ASC"
@@ -143,25 +140,24 @@ class Baza::ModelHandler
                 if table_data[:parent_table]
                   table_name_real = table_name
                 elsif table_data[:datarow]
-                  table_name_real = self.datarow_from_datarow_argument(table_data[:datarow]).classname
+                  table_name_real = datarow_from_datarow_argument(table_data[:datarow]).classname
                 else
                   table_name_real = @args[:module].const_get(table_name).classname
                 end
 
-                if table_name.to_s == val[:table].to_s
-                  do_joins[table_name] = true
-
-                  if val[:sql]
-                    orders << val[:sql]
-                  elsif val[:col]
-                    orders << "`#{db.esc_table(table_name_real)}`.`#{db.esc_col(val[:col])}`#{ordermode}"
-                  else
-                    raise "Couldnt figure out how to order based on keys: '#{val.keys.sort}'."
-                  end
+                next unless table_name.to_s == val[:table].to_s
+                do_joins[table_name] = true
 
-                  found = true
-                  break
+                if val[:sql]
+                  orders << val[:sql]
+                elsif val[:col]
+                  orders << "`#{db.escape_table(table_name_real)}`.`#{db.escape_column(val[:col])}`#{ordermode}"
+                else
+                  raise "Couldnt figure out how to order based on keys: '#{val.keys.sort}'."
                 end
+
+                found = true
+                break
               end
             end
           else
@@ -170,11 +166,9 @@ class Baza::ModelHandler
 
           found = true if args[:cols].key?(orderstr)
 
-          if !found
-            raise "Column not found for ordering: #{orderstr}."
-          end
+          raise "Column not found for ordering: #{orderstr}." unless found
 
-          orders << "#{table_def}`#{db.esc_col(orderstr)}`#{ordermode}" if orderstr
+          orders << "#{table_def}`#{db.escape_column(orderstr)}`#{ordermode}" if orderstr
         end
 
         sql_order << orders.join(", ")
@@ -189,9 +183,9 @@ class Baza::ModelHandler
 
       if realkey.is_a?(Array)
         if !args[:joins_skip]
-          datarow_obj = self.datarow_obj_from_args(args_def, list_args, realkey[0])
+          datarow_obj = datarow_obj_from_args(args_def, list_args, realkey[0])
           args = datarow_obj.columns_sqlhelper_args
-          raise "Couldnt get arguments from SQLHelper." if !args
+          raise "Couldnt get arguments from SQLHelper." unless args
         else
           datarow_obj = @args[:module].const_get(realkey[0])
           args = args_def
@@ -200,7 +194,7 @@ class Baza::ModelHandler
         table_sym = realkey[0].to_sym
         do_joins[table_sym] = true
         list_table_name_real = table_sym
-        table = "`#{db.esc_table(list_table_name_real)}`."
+        table = "`#{db.escape_table(list_table_name_real)}`."
         key = realkey[1]
       else
         table = table_def
@@ -208,38 +202,38 @@ class Baza::ModelHandler
         key = realkey
       end
 
-      if args.key?(:cols_bools) and args[:cols_bools].index(key) != nil
+      if args.key?(:cols_bools) && !args[:cols_bools].index(key).nil?
         val_s = val.to_s
 
-        if val_s == "1" or val_s == "true"
+        if val_s == "1" || val_s == "true"
           realval = "1"
-        elsif val_s == "0" or val_s == "false"
+        elsif val_s == "0" || val_s == "false"
           realval = "0"
         else
           raise "Could not make real value out of class: #{val.class.name} => #{val}."
         end
 
-        sql_where << " AND #{table}`#{db.esc_col(key)}` = '#{db.esc(realval)}'"
+        sql_where << " AND #{table}`#{db.escape_column(key)}` = '#{db.esc(realval)}'"
         found = true
       elsif args[:cols].key?(key.to_s)
         if val.is_a?(Array)
-          if val.empty? and db.opts[:type].to_s == "mysql"
+          if val.empty? && db.opts[:type].to_s == "mysql"
             sql_where << " AND false"
           else
-            escape_sql = val.map { |v| "'#{db.escape(v)}'" }.join(',')
-            sql_where << " AND #{table}`#{db.esc_col(key)}` IN (#{escape_sql})"
+            escape_sql = val.map { |v| "'#{db.escape(v)}'" }.join(",")
+            sql_where << " AND #{table}`#{db.escape_column(key)}` IN (#{escape_sql})"
           end
-        elsif val.is_a?(Hash) and val[:type].to_sym == :col
-          raise "No table was given for join: '#{val}', key: '#{key}' on table #{table}." if !val.key?(:table)
+        elsif val.is_a?(Hash) && val[:type].to_sym == :col
+          raise "No table was given for join: '#{val}', key: '#{key}' on table #{table}." unless val.key?(:table)
           do_joins[val[:table].to_sym] = true
-          sql_where << " AND #{table}`#{db.esc_col(key)}` = `#{db.esc_table(val[:table])}`.`#{db.esc_col(val[:name])}`"
-        elsif val.is_a?(Hash) and val[:type] == :sqlval and val[:val] == :null
-          sql_where << " AND #{table}`#{db.esc_col(key)}` IS NULL"
+          sql_where << " AND #{table}`#{db.escape_column(key)}` = `#{db.escape_table(val[:table])}`.`#{db.escape_column(val[:name])}`"
+        elsif val.is_a?(Hash) && val[:type] == :sqlval && val[:val] == :null
+          sql_where << " AND #{table}`#{db.escape_column(key)}` IS NULL"
         elsif val.is_a?(Proc)
-          call_args = OpenStruct.new(:ob => self, :db => db)
-          sql_where << " AND #{table}`#{db.esc_col(key)}` = '#{db.esc(val.call(call_args))}'"
+          call_args = OpenStruct.new(ob: self, db: db)
+          sql_where << " AND #{table}`#{db.escape_column(key)}` = '#{db.esc(val.call(call_args))}'"
         else
-          sql_where << " AND #{table}`#{db.esc_col(key)}` = '#{db.esc(val)}'"
+          sql_where << " AND #{table}`#{db.escape_column(key)}` = '#{db.esc(val)}'"
         end
 
         found = true
@@ -253,61 +247,61 @@ class Baza::ModelHandler
         limit_from = 0
         limit_to = val.to_i
         found = true
-      elsif args.key?(:cols_dbrows) and args[:cols_dbrows].index("#{key.to_s}_id") != nil
+      elsif args.key?(:cols_dbrows) && !args[:cols_dbrows].index("#{key}_id").nil?
         if val == false
-          sql_where << " AND #{table}`#{db.esc_col(key.to_s + "_id")}` = '0'"
+          sql_where << " AND #{table}`#{db.escape_column(key.to_s + "_id")}` = '0'"
         elsif val.is_a?(Array)
           if val.empty?
             sql_where << " AND false"
           else
-            sql_where << " AND #{table}`#{db.esc_col("#{key}_id")}` IN (#{Knj::ArrayExt.join(:arr => val, :sep => ",", :surr => "'", :callback => proc{|obj| obj.id.sql})})"
+            sql_where << " AND #{table}`#{db.escape_column("#{key}_id")}` IN (#{Knj::ArrayExt.join(arr: val, sep: ",", surr: "'", callback: proc { |obj| obj.id.sql })})"
           end
         else
-          sql_where << " AND #{table}`#{db.esc_col(key.to_s + "_id")}` = '#{db.esc(val.id)}'"
+          sql_where << " AND #{table}`#{db.escape_column(key.to_s + "_id")}` = '#{db.esc(val.id)}'"
         end
 
         found = true
-      elsif match = key.match(/^([A-z_\d]+)_(search|has)$/) and args[:cols].key?(match[1]) != nil
+      elsif match = key.match(/^([A-z_\d]+)_(search|has)$/) && !args[:cols].key?(match[1]).nil?
         if match[2] == "search"
           Knj::Strings.searchstring(val).each do |str|
-            sql_where << " AND #{table}`#{db.esc_col(match[1])}` LIKE '%#{db.esc(str)}%'"
+            sql_where << " AND #{table}`#{db.escape_column(match[1])}` LIKE '%#{db.esc(str)}%'"
           end
         elsif match[2] == "has"
           if val
-            sql_where << " AND #{table}`#{db.esc_col(match[1])}` != ''"
+            sql_where << " AND #{table}`#{db.escape_column(match[1])}` != ''"
           else
-            sql_where << " AND #{table}`#{db.esc_col(match[1])}` = ''"
+            sql_where << " AND #{table}`#{db.escape_column(match[1])}` = ''"
           end
         end
 
         found = true
-      elsif match = key.match(/^([A-z_\d]+)_(not|lower)$/) and args[:cols].key?(match[1])
+      elsif match = key.match(/^([A-z_\d]+)_(not|lower)$/) && args[:cols].key?(match[1])
         if match[2] == "not"
           if val.is_a?(Array)
             if val.empty?
-              #ignore.
+              # ignore.
             else
               escape_sql = Knj::ArrayExt.join(
-                :arr => val,
-                :callback => proc{|value|
+                arr: val,
+                callback: proc do|value|
                   db.escape(value)
-                },
-                :sep => ",",
-                :surr => "'"
+                end,
+                sep: ",",
+                surr: "'"
               )
-              sql_where << " AND #{table}`#{db.esc_col(match[1])}` NOT IN (#{escape_sql})"
+              sql_where << " AND #{table}`#{db.escape_column(match[1])}` NOT IN (#{escape_sql})"
             end
           else
-            sql_where << " AND #{table}`#{db.esc_col(match[1])}` != '#{db.esc(val)}'"
+            sql_where << " AND #{table}`#{db.escape_column(match[1])}` != '#{db.esc(val)}'"
           end
         elsif match[2] == "lower"
-          sql_where << " AND LOWER(#{table}`#{db.esc_col(match[1])}`) = LOWER('#{db.esc(val)}')"
+          sql_where << " AND LOWER(#{table}`#{db.escape_column(match[1])}`) = LOWER('#{db.esc(val)}')"
         else
           raise "Unknown mode: '#{match[2]}'."
         end
 
         found = true
-      elsif args.key?(:cols_date) and match = key.match(/^(.+)_(day|week|month|year|from|to|below|above)(|_(not))$/) and args[:cols_date].index(match[1]) != nil
+      elsif args.key?(:cols_date) && (match = key.match(/^(.+)_(day|week|month|year|from|to|below|above)(|_(not))$/)) && !args[:cols_date].index(match[1]).nil?
         not_v = match[4]
         val = Datet.in(val) if val.is_a?(Time)
 
@@ -316,65 +310,65 @@ class Baza::ModelHandler
             sql_where << " AND ("
             first = true
 
-            val.each do |realval|
+            val.each do |dayval|
               if first
                 first = false
               else
                 sql_where << " OR "
               end
 
-              sql_where << "#{db.sqlspecs.strftime("%d %m %Y", "#{table}`#{db.esc_col(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%d %m %Y", "'#{db.esc(realval.dbstr)}'")}"
+              sql_where << "#{db.sqlspecs.strftime("%d %m %Y", "#{table}`#{db.escape_column(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%d %m %Y", "'#{db.esc(dayval.dbstr)}'")}"
             end
 
             sql_where << ")"
           else
-            sql_where << " AND #{db.sqlspecs.strftime("%d %m %Y", "#{table}`#{db.esc_col(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%d %m %Y", "'#{db.esc(val.dbstr)}'")}"
+            sql_where << " AND #{db.sqlspecs.strftime("%d %m %Y", "#{table}`#{db.escape_column(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%d %m %Y", "'#{db.esc(val.dbstr)}'")}"
           end
         elsif match[2] == "week"
-          sql_where << " AND #{db.sqlspecs.strftime("%W %Y", "#{table}`#{db.esc_col(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%W %Y", "'#{db.esc(val.dbstr)}'")}"
+          sql_where << " AND #{db.sqlspecs.strftime("%W %Y", "#{table}`#{db.escape_column(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%W %Y", "'#{db.esc(val.dbstr)}'")}"
         elsif match[2] == "month"
-          sql_where << " AND #{db.sqlspecs.strftime("%m %Y", "#{table}`#{db.esc_col(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%m %Y", "'#{db.esc(val.dbstr)}'")}"
+          sql_where << " AND #{db.sqlspecs.strftime("%m %Y", "#{table}`#{db.escape_column(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%m %Y", "'#{db.esc(val.dbstr)}'")}"
         elsif match[2] == "year"
-          sql_where << " AND #{db.sqlspecs.strftime("%Y", "#{table}`#{db.esc_col(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%Y", "'#{db.esc(val.dbstr)}'")}"
-        elsif match[2] == "from" or match[2] == "above"
-          sql_where << " AND #{table}`#{db.esc_col(match[1])}` >= '#{db.esc(val.dbstr)}'"
-        elsif match[2] == "to" or match[2] == "below"
-          sql_where << " AND #{table}`#{db.esc_col(match[1])}` <= '#{db.esc(val.dbstr)}'"
+          sql_where << " AND #{db.sqlspecs.strftime("%Y", "#{table}`#{db.escape_column(match[1])}`")} #{self.not(not_v, "!")}= #{db.sqlspecs.strftime("%Y", "'#{db.esc(val.dbstr)}'")}"
+        elsif match[2] == "from" || match[2] == "above"
+          sql_where << " AND #{table}`#{db.escape_column(match[1])}` >= '#{db.esc(val.dbstr)}'"
+        elsif match[2] == "to" || match[2] == "below"
+          sql_where << " AND #{table}`#{db.escape_column(match[1])}` <= '#{db.esc(val.dbstr)}'"
         else
           raise "Unknown date-key: #{match[2]}."
         end
 
         found = true
-      elsif args.key?(:cols_num) and match = key.match(/^(.+)_(from|to|above|below|numeric)$/) and args[:cols_num].index(match[1]) != nil
+      elsif args.key?(:cols_num) && match = key.match(/^(.+)_(from|to|above|below|numeric)$/) && !args[:cols_num].index(match[1]).nil?
         if match[2] == "from"
-          sql_where << " AND #{table}`#{db.esc_col(match[1])}` >= '#{db.esc(val)}'"
+          sql_where << " AND #{table}`#{db.escape_column(match[1])}` >= '#{db.esc(val)}'"
         elsif match[2] == "to"
-          sql_where << " AND #{table}`#{db.esc_col(match[1])}` <= '#{db.esc(val)}'"
+          sql_where << " AND #{table}`#{db.escape_column(match[1])}` <= '#{db.esc(val)}'"
         elsif match[2] == "above"
-          sql_where << " AND #{table}`#{db.esc_col(match[1])}` > '#{db.esc(val)}'"
+          sql_where << " AND #{table}`#{db.escape_column(match[1])}` > '#{db.esc(val)}'"
         elsif match[2] == "below"
-          sql_where << " AND #{table}`#{db.esc_col(match[1])}` < '#{db.esc(val)}'"
+          sql_where << " AND #{table}`#{db.escape_column(match[1])}` < '#{db.esc(val)}'"
         else
           raise "Unknown method of treating cols-num-argument: #{match[2]}."
         end
 
         found = true
-      elsif match = key.match(/^(.+)_lookup$/) and args[:cols].key?("#{match[1]}_id") and args[:cols].key?("#{match[1]}_class")
-        sql_where << " AND #{table}`#{db.esc_col("#{match[1]}_class")}` = '#{db.esc(val.table)}'"
-        sql_where << " AND #{table}`#{db.esc_col("#{match[1]}_id")}` = '#{db.esc(val.id)}'"
+      elsif match = key.match(/^(.+)_lookup$/) && args[:cols].key?("#{match[1]}_id") && args[:cols].key?("#{match[1]}_class")
+        sql_where << " AND #{table}`#{db.escape_column("#{match[1]}_class")}` = '#{db.esc(val.table)}'"
+        sql_where << " AND #{table}`#{db.escape_column("#{match[1]}_id")}` = '#{db.esc(val.id)}'"
         found = true
       elsif realkey == "groupby"
         found = true
 
         if val.is_a?(Array)
           val.each do |col_name|
-            raise "Column '#{val}' not found on table '#{table}'." if !args[:cols].key?(col_name)
+            raise "Column '#{val}' not found on table '#{table}'." unless args[:cols].key?(col_name)
             sql_groupby << ", " if sql_groupby.length > 0
-            sql_groupby << "#{table}`#{db.esc_col(col_name)}`"
+            sql_groupby << "#{table}`#{db.escape_column(col_name)}`"
           end
         elsif val.is_a?(String)
           sql_groupby << ", " if sql_groupby.length > 0
-          sql_groupby << "#{table}`#{db.esc_col(val)}`"
+          sql_groupby << "#{table}`#{db.escape_column(val)}`"
         else
           raise "Unknown class given for 'groupby': '#{val.class.name}'."
         end
@@ -385,11 +379,11 @@ class Baza::ModelHandler
 
     args = args_def
 
-    if !args[:joins_skip]
-      raise "No joins defined on '#{args[:table]}' for: '#{args[:table]}'." if !do_joins.empty? and !args[:joined_tables]
+    unless args[:joins_skip]
+      raise "No joins defined on '#{args[:table]}' for: '#{args[:table]}'." if !do_joins.empty? && !args[:joined_tables]
 
-      do_joins.each do |table_name, temp_val|
-        raise "No join defined on table '#{args[:table]}' for table '#{table_name}'." if !args[:joined_tables].key?(table_name)
+      do_joins.each do |table_name, _temp_val|
+        raise "No join defined on table '#{args[:table]}' for table '#{table_name}'." unless args[:joined_tables].key?(table_name)
         table_data = args[:joined_tables][table_name]
 
         if table_data.key?(:parent_table)
@@ -410,62 +404,60 @@ class Baza::ModelHandler
         class_name = args[:table].to_sym
 
         if table_data[:datarow]
-          datarow = self.datarow_from_datarow_argument(table_data[:datarow])
+          datarow = datarow_from_datarow_argument(table_data[:datarow])
         else
-          self.requireclass(class_name) if @objects.key?(class_name)
+          requireclass(class_name) if @objects.key?(class_name)
           datarow = @args[:module].const_get(class_name)
         end
 
-        if !datarow.columns_sqlhelper_args
+        unless datarow.columns_sqlhelper_args
           ob.requireclass(datarow.table.to_sym)
-          raise "No SQL-helper-args on class '#{datarow.table}' ???" if !datarow.columns_sqlhelper_args
+          raise "No SQL-helper-args on class '#{datarow.table}' ???" unless datarow.columns_sqlhelper_args
         end
 
         newargs = datarow.columns_sqlhelper_args.clone
         newargs[:table] = join_table_name_real
         newargs[:joins_skip] = true
 
-        #Clone the where-arguments and run them against another sqlhelper to sub-join.
+        # Clone the where-arguments and run them against another sqlhelper to sub-join.
         join_args = table_data[:where].clone
-        ret = self.sqlhelper(join_args, newargs)
+        ret = sqlhelper(join_args, newargs)
         sql_joins << ret[:sql_where]
 
-        #If any of the join-arguments are left, then we should throw an error.
-        join_args.each do |key, val|
+        # If any of the join-arguments are left, then we should throw an error.
+        join_args.each_key do |key|
           raise "Invalid key '#{key}' when trying to join table '#{table_name}' on table '#{args_def[:table]}'."
         end
       end
     end
 
-    #If limit arguments has been given then add them.
-    if limit_from and limit_to
-      sql_limit = " LIMIT #{limit_from}, #{limit_to}"
-    end
+    # If limit arguments has been given then add them.
+    sql_limit = " LIMIT #{limit_from}, #{limit_to}" if limit_from && limit_to
 
     sql_groupby = nil if sql_groupby.empty?
 
-    return {
-      :sql_joins => sql_joins,
-      :sql_where => sql_where,
-      :sql_limit => sql_limit,
-      :sql_order => sql_order,
-      :sql_groupby => sql_groupby
+    {
+      sql_joins: sql_joins,
+      sql_where: sql_where,
+      sql_limit: sql_limit,
+      sql_order: sql_order,
+      sql_groupby: sql_groupby
     }
   end
 
-  #Used by sqlhelper-method to look up datarow-classes and automatically load them if they arent loaded already.
-  def datarow_obj_from_args(args, list_args, class_name)
+  # Used by sqlhelper-method to look up datarow-classes and automatically load them if they arent loaded already.
+  def datarow_obj_from_args(args, _list_args, class_name)
     class_name = class_name.to_sym
 
-    if !args.key?(:joined_tables)
+    unless args.key?(:joined_tables)
       raise "No joined tables on '#{args[:table]}' to find datarow for: '#{class_name}'."
     end
 
     args[:joined_tables].each do |table_name, table_data|
       next if table_name.to_sym != class_name
-      return self.datarow_from_datarow_argument(table_data[:datarow]) if table_data[:datarow]
+      return datarow_from_datarow_argument(table_data[:datarow]) if table_data[:datarow]
 
-      self.requireclass(class_name) if @objects.key?(class_name)
+      requireclass(class_name) if @objects.key?(class_name)
       return @args[:module].const_get(class_name)
     end
 
@@ -479,16 +471,14 @@ class Baza::ModelHandler
       const = datarow_argument
     end
 
-    self.load_class(datarow_argument.to_s.split("::").last) if !const.initialized? #Make sure the class is initialized.
+    load_class(datarow_argument.to_s.split("::").last) unless const.initialized? # Make sure the class is initialized.
 
-    return const
+    const
   end
 
   def not(not_v, val)
-    if not_v == "not" or not_v == "not_"
-      return val
-    end
+    return val if not_v == "not" || not_v == "not_"
 
-    return ""
+    ""
   end
 end

data/lib/baza/mysql_base_driver.rb

@@ -0,0 +1,112 @@
+class Baza::MysqlBaseDriver < Baza::BaseSqlDriver
+  def self.args
+    [{
+      label: "Host",
+      name: "host"
+    }, {
+      label: "Port",
+      name: "port"
+    }, {
+      label: "Username",
+      name: "user"
+    }, {
+      label: "Password",
+      name: "pass"
+    }, {
+      label: "Database",
+      name: "db"
+    }, {
+      label: "Encoding",
+      name: "encoding"
+    }]
+  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 << "`#{escape_column(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]
+
+    query(sql)
+
+    if args && args[:return_id]
+      first_id = 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})." unless ids_length == arr_hashes_length
+
+      return ids
+    else
+      return nil
+    end
+  end
+
+  def transaction
+    @baza.q("START TRANSACTION")
+
+    begin
+      yield @baza
+      @baza.q("COMMIT")
+    rescue
+      @baza.q("ROLLBACK")
+      raise
+    end
+  end
+end