mysql_framework 1.1.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c803b7020c3d65742c29d1e354945c61cf1c097fccd13e6ec25861410ea2d5af
-  data.tar.gz: b0a3ca6bf7946c34cce87aa797ffb6d91a5bf65e42cdb0092d990fc6f42f327d
+  metadata.gz: 3694d868584973bdad19a924b7b50961e2c5fcca8ea45e7222605b5145152c24
+  data.tar.gz: d92fe8d7004501fab5e05cd0277f04287bafd3a2352439a1ec4fa5d2cedefe10
 SHA512:
-  metadata.gz: 576b1afe0fc7469168de50cb94a705efe00e565f7057fc72e3a41a44bd7a8cdff9187fcd1d0ec22298e56c4c5452eaa3eb3b62c858225d16eef6e77512fe915d
-  data.tar.gz: c90070d20e9cf952dc0d395833f35dfa4d330756023242d0d997ccd3216ad9a1eca23f535cba65efcb4e7e665d851b9e6237ecfe882ab09473b53d922f6e9978
+  metadata.gz: a7c05de40f9bcecbbef52444d78a3d07cde007aa7122da4eebc94d411deee65e9805c42bf2f4ead59150668346108348eca7cb04e264aa36882e925a20bd8c60
+  data.tar.gz: abbc47dbbd4a95b3c3e1956089308b7e4f052185698cd36e00d0f887594e17e5491a5ee28e00988cabc24831b76e8a1c5e2ccc2d4fd0dc7517a4ac1bb8bf2598

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/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.0'
+  VERSION = '2.0.1'
 end

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,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mysql_framework
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Sage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-20 00:00:00.000000000 Z
+date: 2020-06-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -103,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
@@ -150,7 +137,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubyforge_project: 
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: A lightweight framework to provide managers for working with MySQL.