mysql_framework 1.1.2 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dea6c1520ad570dfaf0070efd3df024dbd8d8ba9bc745970ebc59a82ad38418
-  data.tar.gz: 7f2e6a694727e104584c5304673841cf06231b3efc538fb1a0bce23f69772293
+  metadata.gz: 76573ef7ddc9a996d4bc02f28fad318ca94692eab6df1f7f592229d67f5df3ab
+  data.tar.gz: fcbf52818c3cf42d451b15d95fe9609a467ff78402ce31cd43cfae74b5d89b9f
 SHA512:
-  metadata.gz: 6adf70afb9966e920ef972c187679847ea08d1638b3be8b5473bb031d5be41bc607a9143d313aafd106ff748f295b7679437f597f28a88b4e68afa6e1bcb9068
-  data.tar.gz: '0057569f653959047e9c12feac892e9e0fc51f3fa99085bcd153f26374b4057e7dbdf45f6515d5254798064992065056e7d981369c7700986073390fc88a94e3'
+  metadata.gz: 7a8011fafcfaab143dc3e74ddd4d00b5f256ef8051e4139df564e96959a79d9b6f8128704303d93e803c7fe8e4482757105152bfc1a60ad8628c2706155e5169
+  data.tar.gz: a08b82318c591fe884d5276e1eb1447a8a3460b2f3901a74b29b90a4bafaa44e483bedaf5908696f28756fd265b49c80fe7841316df2826fff0f18363763c6dd

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

@@ -59,10 +59,9 @@ module MysqlFramework
 
     # This method is called to check a client back in to the connection when no longer needed.
     def check_in(client)
-      return client.close unless connection_pool_enabled?
-
-      client = new_client if client.closed?
+      return client&.close unless connection_pool_enabled?
 
+      client = new_client if client.nil? || client.closed?
       @connection_pool.push(client)
     end
 
@@ -75,10 +74,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/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.2'
+  VERSION = '2.1.1'
 end

data/spec/lib/mysql_framework/connector_spec.rb

@@ -232,6 +232,24 @@ describe MysqlFramework::Connector do
         subject.check_in(client)
       end
     end
+
+    context 'when client is nil' do
+      let(:client) { nil }
+
+      context 'when connection pooling is enabled' do
+        it 'does not raise an error' do
+          expect { subject.check_in(client) }.not_to raise_error
+        end
+      end
+
+      context 'when connection pooling is disabled' do
+        let(:connection_pooling_enabled) { 'false' }
+
+        it 'does not raise an error' do
+          expect { subject.check_in(client) }.not_to raise_error
+        end
+      end
+    end
   end
 
   describe '#with_client' do
@@ -272,6 +290,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.2
+  version: 2.1.1
 platform: ruby
 authors:
 - Sage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-09 00:00:00.000000000 Z
+date: 2021-03-08 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.