mysql_framework 1.1.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e883779b80815c73bad5a4d6ca0fabe04821e47ac42244e2ec4de8f503079e5
-  data.tar.gz: 563e8190f534c2c0f86f58785a32bfd102d80067c50fff5e3841e20ed7f36fcc
+  metadata.gz: f48c69762d95976838c6779c9acfc6591e2113d9a91128f69a2621890332bee0
+  data.tar.gz: 5d9d0250828d1e93626010796f79364d2f23b22554c38f4bda313ca718faffc6
 SHA512:
-  metadata.gz: '097525d900a4c0122c705c40ce36d59d647e67f43944b98ed1c327f984a5d151f90cefd7d74af11641113f5797d3c1f3c252d614f3888c8df65fb8d65676db68'
-  data.tar.gz: 344b2bacb1f09c0789ed23d2dcf7ed0e61e389d485159bb17150055282a96fcb30cfa77d77a4c5dc286727a1834295480a2761d607a59b302a123ee8e233c7e3
+  metadata.gz: 0e477a4a454360a80a979421aad3ba7db1b7399656062dc7cd129174af1f48953fb3c56d2ad2d959fafbf009a7c1e9f9aa57d34c91c5a06aeb853d0f0e518fb8
+  data.tar.gz: 2c0980c6a0c94718d0df07d56ae1f88367ce8716d5af457b1c9c6526c29878380bbaeaffaca314dcdf4943d1366c27940675d693fdec4fe961fc183e7a6bb3ed

data/lib/mysql_framework.rb

@@ -7,6 +7,7 @@ require_relative 'mysql_framework/logger'
 require_relative 'mysql_framework/scripts'
 require_relative 'mysql_framework/sql_column'
 require_relative 'mysql_framework/sql_condition'
+require_relative 'mysql_framework/in_condition'
 require_relative 'mysql_framework/sql_query'
 require_relative 'mysql_framework/sql_table'
 require_relative 'mysql_framework/version'

data/lib/mysql_framework/connector.rb

@@ -75,10 +75,19 @@ module MysqlFramework
     end
 
     # This method is called to execute a prepared statement
+    #
+    # @note Ensure we close each statement, otherwise we can run into
+    # a 'Commands out of sync' error if multiple threads are running different
+    # queries at the same time.
     def execute(query, provided_client = nil)
       with_client(provided_client) do |client|
-        statement = client.prepare(query.sql)
-        statement.execute(*query.params)
+        begin
+          statement = client.prepare(query.sql)
+          result = statement.execute(*query.params)
+          result.to_a if result
+        ensure
+          statement.close if statement
+        end
       end
     end
 

data/lib/mysql_framework/in_condition.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MysqlFramework
+# This class is used to represent a Sql IN Condition for a column.
+  class InCondition < SqlCondition
+    # This method is called to get the condition as a string for a sql prepared statement
+    def to_s
+      params = value.map { |_| '?' }
+      "#{@column} #{@comparison} (#{params.join(', ')})"
+    end
+  end
+end

data/lib/mysql_framework/scripts/base.rb

@@ -36,7 +36,7 @@ module MysqlFramework
 
       def column_exists?(client, table_name, column_name)
         result = client.query(<<~SQL)
-          SHOW COLUMNS FROM "#{table_name}" WHERE Field="#{column_name}";
+          SHOW COLUMNS FROM #{table_name} WHERE Field="#{column_name}";
         SQL
 
         result.count == 1
@@ -44,7 +44,7 @@ module MysqlFramework
 
       def index_exists?(client, table_name, index_name)
         result = client.query(<<~SQL)
-          SHOW INDEX FROM "#{table_name}" WHERE Key_name="#{index_name}" LIMIT 1;
+          SHOW INDEX FROM #{table_name} WHERE Key_name="#{index_name}" LIMIT 1;
         SQL
 
         result.count == 1

data/lib/mysql_framework/sql_column.rb

@@ -46,6 +46,10 @@ module MysqlFramework
       SqlCondition.new(column: to_s, comparison: '<=', value: value)
     end
 
+    def in(*values)
+      InCondition.new(column: to_s, comparison: 'IN', value: values)
+    end
+
     # This method is called to generate an alias statement for this column.
     def as(name)
       "#{self} as `#{name}`"

data/lib/mysql_framework/sql_condition.rb

@@ -3,18 +3,54 @@
 module MysqlFramework
 # This class is used to represent a Sql Condition for a column.
   class SqlCondition
+    NIL_COMPARISONS = ['IS NULL', 'IS NOT NULL'].freeze
+
     # This method is called to get the value of this condition for prepared statements.
     attr_reader :value
 
-    def initialize(column:, comparison:, value:)
+    # Creates a new SqlCondition using the given parameters.
+    #
+    # @raise ArgumentError if comparison is 'IS NULL' and value is not nil
+    # @raise ArgumentError if comparison is 'IS NOT NULL' and value is not nil
+    # @raise ArgumentError if comparison is neither 'IS NULL' or 'IS NOT NULL' and value is nil
+    #
+    # @param column [String] - the name of the column to use in the comparison
+    # @param comparison [String] - the MySQL comparison operator to use
+    # @param value [Object] - the value to use in the comparison (default nil)
+    def initialize(column:, comparison:, value: nil)
       @column = column
       @comparison = comparison
+
+      validate(value)
       @value = value
     end
 
     # This method is called to get the condition as a string for a sql prepared statement
+    #
+    # @return [String]
     def to_s
+      return "#{@column} #{@comparison.upcase}" if nil_comparison?
+
       "#{@column} #{@comparison} ?"
     end
+
+    private
+
+    def nil_comparison?
+      NIL_COMPARISONS.include?(@comparison.upcase)
+    end
+
+    def validate(value)
+      raise ArgumentError, "Cannot set value when comparison is #{@comparison}" if invalid_null_condition?(value)
+      raise ArgumentError, "Comparison of #{@comparison} requires value to be not nil" if invalid_nil_value?(value)
+    end
+
+    def invalid_null_condition?(value)
+      nil_comparison? && value != nil
+    end
+
+    def invalid_nil_value?(value)
+      nil_comparison? == false && value.nil?
+    end
   end
 end

data/lib/mysql_framework/sql_query.rb

@@ -9,11 +9,12 @@ module MysqlFramework
     def initialize
       @sql = ''
       @params = []
+      @lock = nil
     end
 
     # This method is called to access the sql string for this query.
     def sql
-      @sql.strip
+      (@sql + @lock.to_s + @dup_query.to_s).strip
     end
 
     # This method is called to start a select query
@@ -76,19 +77,6 @@ module MysqlFramework
       self
     end
 
-    # This method is called to specify the columns to bulk upsert.
-    def bulk_upsert(columns)
-      @sql += 'ON DUPLICATE KEY UPDATE '
-
-      columns.each do |column|
-        @sql += "#{column} = VALUES(#{column}), "
-      end
-
-      @sql = @sql.chomp(', ')
-
-      self
-    end
-
     # This method is called to specify the columns to update.
     def set(values)
       @sql += ' SET '
@@ -132,11 +120,20 @@ module MysqlFramework
     end
 
     # This method is called to specify a where clause for a query.
+    #
+    # Condition values are added to @params unless the value is nil.
     def where(*conditions)
       @sql += ' WHERE' unless @sql.include?('WHERE')
       @sql += " (#{conditions.join(' AND ')}) "
 
-      conditions.each { |condition| @params << condition.value }
+      conditions.each do |condition|
+        next if condition.value.nil?
+        if condition.value.is_a?(Enumerable)
+          @params.concat(condition.value)
+        else
+          @params << condition.value
+        end
+      end
 
       self
     end
@@ -218,5 +215,53 @@ module MysqlFramework
 
       self
     end
+
+    # This method allows you to add a pessimistic lock to the record.
+    # The default lock is `FOR UPDATE`
+    # If you require any custom lock, e.g. FOR SHARE, just pass that in as the condition
+    # query.lock('FOR SHARE')
+    def lock(condition = nil)
+      raise 'This must be a SELECT query' unless @sql.start_with?('SELECT')
+
+      @lock = ' ' + (condition || 'FOR UPDATE')
+      self
+    end
+
+    # For insert queries if you need to handle that a primary key already exists and automatically do an update instead.
+    # If you do not pass in a hash specifying a column name and custom value for it.
+    # @param update_values [Hash] key is a column name.  A nil value will make the query update
+    # the column with the value specified in the insert.  Otherwise any value will be interpreted
+    # literally via mysql.
+    # @return SqlQuery
+    # e.g.
+    # query.insert('users')
+    # .into('id', first_name', 'login_count')
+    # .values(1, 'Bob', 1)
+    # .on_duplicate(
+    #   {
+    #     first_name: nil,
+    #     login_count: 'login_count + 5'
+    #   }
+    # )
+    # This would first create a record like => `1, 'Bob', 1`.
+    # The second time it would update it with => `'Bob', 6`  (Note the 1 is not used in the update)
+    def on_duplicate(update_values = {})
+      raise 'This must be an INSERT query' unless @sql.start_with?('INSERT')
+
+      duplicates = []
+      update_values.each do |column, col_value|
+        if col_value.nil?
+          # value comes from what the INSERT intended
+          updated_value = "#{column} = VALUES (#{column})"
+        else
+          # custom value specified by col_value
+          updated_value = "#{column} = #{col_value}"
+        end
+        duplicates << updated_value
+      end
+      @dup_query = " ON DUPLICATE KEY UPDATE #{duplicates.join(', ')}"
+
+      self
+    end
   end
 end

data/lib/mysql_framework/sql_table.rb

@@ -5,11 +5,13 @@ module MysqlFramework
   class SqlTable
     def initialize(name)
       @name = name
+      @column_objects = {}
     end
 
     # This method is called to get a sql column for this table
     def [](column)
-      SqlColumn.new(table: @name, column: column)
+      return @column_objects[column.to_sym] if @column_objects[column.to_sym]
+      @column_objects[column.to_sym] = SqlColumn.new(table: @name, column: column)
     end
 
     def to_s

data/lib/mysql_framework/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MysqlFramework
-  VERSION = '1.1.1'
+  VERSION = '2.1.0'
 end

data/spec/lib/mysql_framework/connector_spec.rb

@@ -272,6 +272,33 @@ describe MysqlFramework::Connector do
       expect(results.length).to eq(1)
       expect(results[0][:id]).to eq(guid)
     end
+
+    it 'does not raise a commands out of sync error' do
+      threads = []
+      threads << Thread.new do
+        350.times do
+          update_query = MysqlFramework::SqlQuery.new.update('gems')
+                                                 .set(updated_at: Time.now)
+          expect { subject.execute(update_query) }.not_to raise_error
+        end
+      end
+
+      threads << Thread.new do
+        350.times do
+          select_query = MysqlFramework::SqlQuery.new.select('*').from('demo')
+          expect { subject.execute(select_query) }.not_to raise_error
+        end
+      end
+
+      threads << Thread.new do
+        350.times do
+          select_query = MysqlFramework::SqlQuery.new.select('*').from('test')
+          expect { subject.execute(select_query) }.not_to raise_error
+        end
+      end
+
+      threads.each(&:join)
+    end
   end
 
   describe '#query' do

data/spec/lib/mysql_framework/sql_column_spec.rb

@@ -63,6 +63,14 @@ describe MysqlFramework::SqlColumn do
     end
   end
 
+  describe '#in' do
+    it 'returns a SqlCondition for the comparison' do
+      condition = subject.in('a', 'b', 'c')
+      expect(condition).to be_a(MysqlFramework::InCondition)
+      expect(condition.to_s).to eq('`gems`.`version` IN (?, ?, ?)')
+    end
+  end
+
   describe '#as' do
     it 'returns the column specified as another name' do
       expect(subject.as('v')).to eq('`gems`.`version` as `v`')

data/spec/lib/mysql_framework/sql_condition_spec.rb

@@ -8,4 +8,82 @@ describe MysqlFramework::SqlCondition do
       expect(subject.to_s).to eq('version = ?')
     end
   end
+
+  context 'when comparison is neither IS NULL or IS NOT NULL' do
+    context 'when value is nil' do
+      subject { described_class.new(column: 'version', comparison: '=', value: nil) }
+
+      it 'does raises an ArgumentError' do
+        expect { subject }.to raise_error(ArgumentError, "Comparison of = requires value to be not nil")
+      end
+    end
+  end
+
+  context 'when comparison is IS NULL' do
+    subject { described_class.new(column: 'version', comparison: 'IS NULL') }
+
+    it 'has a nil value by default' do
+      expect(subject.value).to be_nil
+    end
+
+    context 'when a value is passed to the constructor' do
+      subject { described_class.new(column: 'version', comparison: 'IS NULL', value: 'foo') }
+
+      describe '#new' do
+        it 'raises an ArgumentError if value is set' do
+          expect { subject }.to raise_error(ArgumentError, 'Cannot set value when comparison is IS NULL')
+        end
+      end
+    end
+
+    describe '#to_s' do
+      it 'does not include a value placeholder' do
+        expect(subject.to_s).to eq('version IS NULL')
+      end
+    end
+  end
+
+  context 'when comparison is lowercase is null' do
+    subject { described_class.new(column: 'version', comparison: 'is null') }
+
+    describe '#to_s' do
+      it 'ignores case' do
+        expect(subject.to_s).to eq 'version IS NULL'
+      end
+    end
+  end
+
+  context 'when comparison is IS NOT NULL' do
+    subject { described_class.new(column: 'version', comparison: 'IS NOT NULL') }
+
+    it 'has a nil value by default' do
+      expect(subject.value).to be_nil
+    end
+
+    context 'when a value is passed to the constructor' do
+      subject { described_class.new(column: 'version', comparison: 'IS NOT NULL', value: 'foo') }
+
+      describe '#new' do
+        it 'raises an ArgumentError if value is set' do
+          expect { subject }.to raise_error(ArgumentError, 'Cannot set value when comparison is IS NOT NULL')
+        end
+      end
+    end
+
+    describe '#to_s' do
+      it 'does not include a value placeholder' do
+        expect(subject.to_s).to eq('version IS NOT NULL')
+      end
+    end
+  end
+
+  context 'when comparison is lowercase is not null' do
+    subject { described_class.new(column: 'version', comparison: 'is not null') }
+
+    describe '#to_s' do
+      it 'ignores case' do
+        expect(subject.to_s).to eq 'version IS NOT NULL'
+      end
+    end
+  end
 end

data/spec/lib/mysql_framework/sql_query_spec.rb

@@ -50,6 +50,19 @@ describe MysqlFramework::SqlQuery do
       expect(subject.params).to eq(['9876'])
     end
 
+    context 'when a select query contains conditions with nil values' do
+      it 'does not store them as parameters' do
+        subject.select('*')
+          .from(gems, 40)
+          .where(
+            MysqlFramework::SqlCondition.new(column: 'id', comparison: '=', value: 9876),
+            MysqlFramework::SqlCondition.new(column: 'foo', comparison: 'IS NOT NULL'),
+          )
+        expect(subject.sql).to eq('SELECT * FROM `gems` PARTITION (p40) WHERE (id = ? AND foo IS NOT NULL)')
+        expect(subject.params.size).to eq 1
+      end
+    end
+
     it 'builds a joined select query as expected' do
       subject.select('*')
         .from(gems, 40)
@@ -139,16 +152,6 @@ describe MysqlFramework::SqlQuery do
     end
   end
 
-  describe '#bulk_upsert' do
-    it 'sets the sql for the upsert statement' do
-      columns = %w(column_1 column_2)
-
-      subject.bulk_upsert(columns)
-
-      expect(subject.sql).to eq('ON DUPLICATE KEY UPDATE column_1 = VALUES(column_1), column_2 = VALUES(column_2)')
-    end
-  end
-
   describe '#set' do
     it 'sets the sql for the set statement' do
       subject.set(name: 'mysql_framework', author: 'sage', created_at: '2016-06-28 10:00:00')
@@ -223,6 +226,13 @@ describe MysqlFramework::SqlQuery do
         expect(subject.sql).to eq('WHERE (`gems`.`author` = ? AND `gems`.`created_at` > ?) AND (`gems`.`name` = ?)')
       end
     end
+
+    context 'when the condition includes an array of parameters' do
+      it 'concats the parameter collections' do
+        subject.and.where(gems[:name].in('a','b'))
+        expect(subject.sql).to eq('WHERE (`gems`.`author` = ? AND `gems`.`created_at` > ?) AND (`gems`.`name` IN (?, ?))')
+      end
+    end
   end
 
   describe '#and' do
@@ -330,4 +340,69 @@ describe MysqlFramework::SqlQuery do
       end
     end
   end
+
+  describe '#lock' do
+    it 'appends `FOR_UPDATE` to the query' do
+      subject.select('*').from(gems).lock
+      expect(subject.sql).to end_with('FOR UPDATE')
+    end
+  end
+
+  describe '#on_duplicate' do
+    let(:query) do
+      subject.insert(gems)
+        .into(
+          gems[:id],
+          gems[:name],
+          gems[:author]
+        )
+        .values(
+          1,
+          'mysql_framework',
+          'Bob Hope'
+        )
+    end
+
+    context 'when no custom values are specified' do
+      it 'updates with the value from the INSERT clause' do
+        query.on_duplicate(
+          {
+            gems[:name] => nil,
+            gems[:author] => nil
+          }
+        )
+
+        expect(query.sql)
+          .to end_with 'ON DUPLICATE KEY UPDATE `gems`.`name` = VALUES (`gems`.`name`), `gems`.`author` = VALUES (`gems`.`author`)'
+      end
+    end
+
+    context 'when a custom value is specified' do
+      it 'updates the value based on the custom value' do
+        query.on_duplicate(
+          {
+            gems[:name] => '"mysql_alternative"',
+            gems[:author] => '"Michael Caine"'
+          }
+        )
+
+        expect(query.sql)
+          .to end_with 'ON DUPLICATE KEY UPDATE `gems`.`name` = "mysql_alternative", `gems`.`author` = "Michael Caine"'
+      end
+    end
+
+    context 'when column names are specified instead of SqlColumn objects' do
+      it 'updates the value based on the custom column key names' do
+        query.on_duplicate(
+          {
+            name: '"mysql_alternative"',
+            author: '"Michael Caine"'
+          }
+        )
+
+        expect(query.sql)
+          .to end_with 'ON DUPLICATE KEY UPDATE name = "mysql_alternative", author = "Michael Caine"'
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mysql_framework
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Sage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-09 00:00:00.000000000 Z
+date: 2020-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -89,6 +89,7 @@ extra_rdoc_files: []
 files:
 - lib/mysql_framework.rb
 - lib/mysql_framework/connector.rb
+- lib/mysql_framework/in_condition.rb
 - lib/mysql_framework/logger.rb
 - lib/mysql_framework/scripts.rb
 - lib/mysql_framework/scripts/base.rb
@@ -136,8 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: A lightweight framework to provide managers for working with MySQL.