sqlstmt 0.2.11 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5516750b663f84d0ee52a37951a305e8c003914
-  data.tar.gz: 2c80189865a625385c7da900c8cc8fe494a3860c
+  metadata.gz: 618fd088e704565e2bb73f6b7887db32cf60f7be
+  data.tar.gz: b632cba8862643ac1003cea40b7cf1b15f862900
 SHA512:
-  metadata.gz: 07d9232c1d6473704cda766e7c12436a8677f2589939201b3dd8681801f66bf6ca72fb9c2b5b9c301c2a945d3d3792d430687a82e2d4755aa94d4d0a81d5f33d
-  data.tar.gz: a08886bb3a3fdfbce82fed743ba2ec339c16d7acc33bb2b789025b24cc0bca0a58853da1ec50f6cc34f314e6c0d6ad10fdc6b839937e17f621e3fd76c47c0164
+  metadata.gz: ea60dddfea616466f657e597065ef6051cd091d7d123f06be08d12c93fc43e0f3e28d6cfebb2c0ff6358e28ddc5a234110b5fe8ac220e3c3b99789cb2733653d
+  data.tar.gz: fa8802b7ec27baee278410180119d9eae21cbc31d13cecd20e2f207eb6eaa7a7c5fd4b545a2122bfcda915de8153887de18bdce069c64a2582770f8da2e8a9b6

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Makani Mason, Kem Mason
+Copyright (c) 2007 ATPSoft
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/sqlstmt/core_to_sql.rb

@@ -4,8 +4,10 @@ require 'date'
 class String
   unless method_defined?(:to_sql)
     def to_sql
-       str = gsub('\\', '\\\\').gsub('\'', '\\\'').gsub("'", "\\'")
-      "'#{str}'"
+      str = gsub('\\') {'\\\\'}
+      str = str.gsub("'") {"\\'"}
+      str = str.gsub('"') {'\\"'}
+      return "'#{str}'"
     end
   end
 end

data/lib/sqlstmt/data.rb

@@ -4,7 +4,7 @@ module SqlStmtLib
 extend self
 
 FLAG_KEYWORDS = %i(distinct ignore replace straight_join with_rollup).freeze
-SINGLE_VALUE_KEYWORDS = %i(group_by into limit offset order_by outfile).freeze
+SINGLE_VALUE_KEYWORDS = %i(group_by into limit offset order_by outfile on_duplicate ignore_duplicate).freeze
 MULTI_VALUE_KEYWORDS = %i(get having where).freeze
 
 # :str is the full original string specifying the table, like 'frog f' or 'frog AS f' or 'frog'

data/lib/sqlstmt/mysql/build.rb

@@ -11,52 +11,99 @@ class MysqlBuilder
     return send(method_name)
   end
 
+  def combine_parts(parts)
+    parts.each do |str|
+      str.strip!
+    end
+    parts.reject! do |str|
+      str.nil? || str.empty?
+    end
+    return parts.join(' ')
+  end
+
   def build_stmt_select
-    straight_join_str = @data.straight_join ? 'STRAIGHT_JOIN ' : ''
-    distinct_str = @data.distinct ? 'DISTINCT ' : ''
-    select_str = @data.gets.join(',')
-    outfile_str = @data.outfile ? " INTO OUTFILE #{@data.outfile}" : ''
-    return "SELECT #{straight_join_str}#{distinct_str}#{select_str}#{build_from_clause}#{outfile_str}"
+    parts = []
+    parts << shared_select(@data.gets)
+    if @data.outfile
+      parts << "INTO OUTFILE #{@data.outfile}"
+    end
+    return combine_parts(parts)
   end
 
   def build_stmt_update
-    limit_clause = simple_clause('LIMIT', @data.limit)
-    return "UPDATE #{build_table_list}#{build_join_clause} SET #{build_set_clause}#{build_where_clause}#{limit_clause}"
+    parts = [
+      'UPDATE',
+      build_table_list,
+      build_join_clause,
+      'SET',
+      build_set_clause,
+      build_where_clause,
+      simple_clause('LIMIT', @data.limit),
+    ]
+    return combine_parts(parts)
   end
 
   def build_stmt_insert
-    keyword = @data.replace ? 'REPLACE' : 'INSERT'
-    value_list = @data.set_values.join(',')
-    ignore_str = @data.ignore ? 'IGNORE ' : ''
-    start_str = "#{keyword} #{ignore_str}INTO #{@data.into} "
+    parts = []
+    if @data.replace
+      parts << 'REPLACE'
+    else
+      parts << 'INSERT'
+    end
+    if @data.ignore
+      parts << 'IGNORE'
+    end
+    parts << "INTO #{@data.into}"
     if !@data.set_fields.empty?
       field_list = @data.set_fields.join(',')
-      start_str += "(#{field_list}) "
+      parts << "(#{field_list})"
     end
-
-    distinct_str = @data.distinct ? 'DISTINCT ' : ''
-    return "#{start_str}SELECT #{distinct_str}#{value_list}#{build_from_clause}"
+    parts << shared_select(@data.set_values)
+    if @data.on_duplicate
+      parts << "ON DUPLICATE KEY UPDATE #{@data.on_duplicate}"
+    elsif @data.ignore_duplicate
+      parts << "ON DUPLICATE KEY UPDATE #{@data.ignore_duplicate} = #{@data.ignore_duplicate}"
+    end
+    return combine_parts(parts)
   end
 
   def build_stmt_delete
-    if @data.tables_to_delete.empty?
-      table_clause = ''
-    else
-      table_clause = ' ' + @data.tables_to_delete.join(',')
+    parts = ['DELETE']
+    if !@data.tables_to_delete.empty?
+      parts << @data.tables_to_delete.join(',')
     end
-    return "DELETE#{table_clause}#{build_from_clause}"
+    parts << build_from_clause
+    return combine_parts(parts)
+  end
+
+  def shared_select(fields)
+    parts = ['SELECT']
+    if @data.straight_join
+      parts << 'STRAIGHT_JOIN'
+    end
+    if @data.distinct
+      parts << 'DISTINCT'
+    end
+    parts << fields.join(',')
+    parts << build_from_clause
+    return combine_parts(parts)
   end
 
   def build_from_clause
-    join_clause = build_join_clause
-    group_clause = simple_clause('GROUP BY', @data.group_by)
+    parts = ['FROM']
+    parts << build_table_list
+    parts << build_join_clause
+    parts << build_where_clause
+    parts << simple_clause('GROUP BY', @data.group_by)
     if @data.with_rollup
-      group_clause += ' WITH ROLLUP'
+      parts << 'WITH ROLLUP'
+    end
+    if !@data.havings.empty?
+      parts << "HAVING #{@data.havings.join(' AND ')}"
     end
-    order_clause = simple_clause('ORDER BY', @data.order_by)
-    limit_clause = simple_clause('LIMIT', @data.limit)
-    having_clause = @data.havings.empty? ? '' : " HAVING #{@data.havings.join(' AND ')}"
-    return " FROM #{build_table_list}#{join_clause}#{build_where_clause}#{group_clause}#{having_clause}#{order_clause}#{limit_clause}"
+    parts << simple_clause('ORDER BY', @data.order_by)
+    parts << simple_clause('LIMIT', @data.limit)
+    return combine_parts(parts)
   end
 
   def build_set_clause
@@ -87,14 +134,7 @@ class MysqlBuilder
   end
 
   def build_join_clause
-    if @data.joins.empty?
-      return ''
-    else
-      # we call uniq here to be tolerant of a table being joined to multiple times in an identical fashion
-      # where the intention is not actually to include the table multiple times
-      # but I'm thinking we may want to reconsider, or at least warn when this happens so the source bug can be fixed
-      return ' ' + @data.joins.map {|join| join_to_str(join)}.uniq.join(' ')
-    end
+    return ' ' + @data.joins.map {|join| join_to_str(join)}.uniq.join(' ')
   end
 
   def build_where_clause

data/lib/sqlstmt/sqlstmt.rb

@@ -47,7 +47,7 @@ class SqlStmt
   end
 
   def type(stmt_type)
-    if @data.stmt_type
+    if @data.stmt_type && @data.stmt_type != stmt_type
       raise SqlStmtError, "statement type already set to #{@data.stmt_type}"
     end
     @data.stmt_type = stmt_type
@@ -79,13 +79,24 @@ class SqlStmt
     return @data.table_ids.include?(table_to_find)
   end
 
-  ###### where
+  ###### where - because the lack of a where clause can be so impactful,
+  ###### the default behavior is to require one, but this behavior can be customized using the 3 methods below
+  ###### note that each of these override the other calls, so whichever is one called last will take effect
 
+  # if no where clauses have been added, the statement will fail to build
+  # this is the default value, but in case it got changed, we can reset it back
+  def require_where
+    @data.where_behavior = :require
+    return self
+  end
+
+  # if any where clauses have been added, the statement will fail to build
   def no_where
     @data.where_behavior = :exclude
     return self
   end
 
+  # this disables a where clause requirement
   def optional_where
     @data.where_behavior = :optional
     return self

data/test/insert_select_test.rb

@@ -16,6 +16,12 @@ class TestInsertSelect < Minitest::Test
     assert_equal('INSERT INTO target SELECT * FROM source', SqlStmt.new.insert.into('target').table('source').set(nil, '*').no_where.to_s)
   end
 
+  def test_ignore_duplicate
+    sqlt = SqlStmt.new.insert.into('target').table('source').set(nil, '*').no_where
+    assert_equal('INSERT INTO target SELECT * FROM source ON DUPLICATE KEY UPDATE idkey = idkey', sqlt.dup.ignore_duplicate('idkey').to_s)
+    assert_equal('INSERT INTO target SELECT * FROM source ON DUPLICATE KEY UPDATE idkey = idkey + 1', sqlt.dup.on_duplicate('idkey = idkey + 1').to_s)
+  end
+
   def test_dup
     shared_builder = SqlStmt.new.insert.into('target')
     first_builder = shared_builder

data/test/select_test.rb

@@ -1,64 +1,96 @@
 require_relative 'helper'
 
+# adding this extra line so lines can match up perfectly for now with the swift implementation
 class TestSelect < Minitest::Test
-  def test_includes_table
-    sqlb = SqlStmt.new.select.table('target')
-    assert(sqlb.includes_table?('target'))
-    assert_equal(['target'], sqlb.data.table_ids.to_a)
-
-    sqlb = SqlStmt.new.select.table('target t')
-    assert(sqlb.includes_table?('target'))
-    assert(sqlb.includes_table?('t'))
-    assert(!sqlb.includes_table?('blah'))
-
-    sqlb = SqlStmt.new.select.table('target AS t')
-    assert(sqlb.includes_table?('target'))
-    assert(sqlb.includes_table?('t'))
-  end
+  def test_gradually
+    sqlt = SqlStmt.new
 
-  def test_tables
-    assert_equal('SELECT blah FROM target', SqlStmt.new.select.table('target').no_where.get('blah').to_sql)
-    assert_equal('SELECT t.blah FROM target t', SqlStmt.new.select.table('target t').no_where.get('t.blah').to_sql)
-    assert_equal('SELECT t.blah FROM target t USE INDEX (blee)', SqlStmt.new.select.table('target t', 'blee').no_where.get('t.blah').to_sql)
-  end
+    # keep these chained together, so we have at least one test of the return value of all the method calls
+    # in ruby this isn't particular tricky or unique, but still it's good to test
+    sqlt.select.type('select')
+    assert_raises(SqlStmtError) { sqlt.update() }
 
-  def test_minimum_requirements
-    assert_raises(SqlStmtError) { SqlStmt.new.select.table('target').to_s }
-    assert_raises(SqlStmtError) { SqlStmt.new.type('select').table('target').to_s }
-    assert_raises(SqlStmtError) { SqlStmt.new.select.table('target').no_where.to_s }
-    assert_raises(SqlStmtError) { SqlStmt.new.select.table('target').optional_where.to_s }
-    assert_equal('SELECT blah FROM target', SqlStmt.new.select.table('target').optional_where.get('blah').to_sql)
-  end
+    sqlt.table('target')
+    assert_equal(['target'], sqlt.data.table_ids.to_a())
+    assert_raises(SqlStmtError) { sqlt.to_s() }
+
+    sqlt.get('blah')
+    assert_raises(SqlStmtError) { sqlt.to_s() }
+
+    sqlt.no_where()
+    assert_equal('SELECT blah FROM target', sqlt.to_sql())
 
-  def test_stuff
-    assert_equal('SELECT blah FROM source', SqlStmt.new.select.table('source').get('blah').no_where.to_s)
-    assert_equal('SELECT DISTINCT blah FROM source', SqlStmt.new.select.table('source').get('blah').no_where.distinct.to_s)
-    assert_equal('SELECT blah FROM source WHERE source_id = 1', SqlStmt.new.select.table('source').get('blah').where('source_id = 1').to_s)
-    assert_equal('SELECT blah FROM source s', SqlStmt.new.select.table('source s').get('blah').no_where.to_s)
-    assert_equal('SELECT blah FROM source s JOIN other o ON s.blah_id = o.blah_id', SqlStmt.new.select.table('source s').join('other o', 's.blah_id = o.blah_id').get('blah').no_where.to_s)
-    assert_equal('SELECT blah FROM source s LEFT JOIN other o ON s.blah_id = o.blah_id', SqlStmt.new.select.table('source s').left_join('other o', 's.blah_id = o.blah_id').get('blah').no_where.to_s)
-    assert_equal('SELECT blah,blee FROM source', SqlStmt.new.select.table('source').get('blah','blee').no_where.to_s)
-    assert_equal('SELECT blah FROM source HAVING blee > 0', SqlStmt.new.select.table('source').get('blah').no_where.having('blee > 0').to_s)
+    sqlt.require_where()
+    assert_raises(SqlStmtError) { sqlt.to_s }
+
+    sqlt.optional_where()
+    assert_equal('SELECT blah FROM target', sqlt.to_sql())
+
+    sqlt.where('frog = 1')
+    assert_equal('SELECT blah FROM target WHERE frog = 1', sqlt.to_sql())
+
+    sqlt.join('other o', 'target.id = o.id')
+    assert_equal(['target', 'other', 'o'], sqlt.data.table_ids.to_a)
+    assert_equal('SELECT blah FROM target JOIN other o ON target.id = o.id WHERE frog = 1', sqlt.to_sql())
   end
 
-  def test_group_by
-    sqlb = SqlStmt.new.select.table('source').get('blah').no_where.group_by('blah')
-    assert_equal('SELECT blah FROM source GROUP BY blah', sqlb.to_s)
-    sqlb.with_rollup
-    assert_equal('SELECT blah FROM source GROUP BY blah WITH ROLLUP', sqlb.to_s)
+  def test_simple_with_small_variations
+    tmpl = SqlStmt.new
+    tmpl.select().table('target t').get('blah').no_where()
+    assert_equal(['target', 't'], tmpl.data.table_ids.to_a())
+
+    sqlt = tmpl.dup()
+    sqlt.distinct
+    assert_equal('SELECT DISTINCT blah FROM target t', sqlt.to_sql())
+
+    sqlt = tmpl.dup()
+    sqlt.join('other o', 't.blah_id = o.blah_id', 't.blee_id = o.blee_id')
+    assert_equal('SELECT blah FROM target t JOIN other o ON t.blah_id = o.blah_id AND t.blee_id = o.blee_id', sqlt.to_sql())
+
+    sqlt = tmpl.dup()
+    sqlt.left_join('other o', 't.blah_id = o.blah_id')
+    assert_equal('SELECT blah FROM target t LEFT JOIN other o ON t.blah_id = o.blah_id', sqlt.to_sql())
+
+    sqlt = tmpl.dup()
+    sqlt.get('blee', 'bloo')
+    assert_equal('SELECT blah,blee,bloo FROM target t', sqlt.to_sql())
+
+    sqlt = tmpl.dup()
+    sqlt.having('blah > 0')
+    assert_equal('SELECT blah FROM target t HAVING blah > 0', sqlt.to_sql())
+
+    sqlt = tmpl.dup()
+    sqlt.group_by('blah')
+    assert_equal('SELECT blah FROM target t GROUP BY blah', sqlt.to_sql())
+    sqlt.with_rollup
+    assert_equal('SELECT blah FROM target t GROUP BY blah WITH ROLLUP', sqlt.to_sql())
   end
 
-  def test_duplicate_joins
-    sqlb = SqlStmt.new.select.table('source s').get('frog').no_where
-    4.times { sqlb.join('other o', 's.blah_id = o.blah_id') }
-    assert_equal('SELECT frog FROM source s JOIN other o ON s.blah_id = o.blah_id', sqlb.to_s)
+  def test_tables
+    sqlt = SqlStmt.new.select().table('target t', 'blee').no_where.get('t.blah')
+    assert_equal('SELECT t.blah FROM target t USE INDEX (blee)', sqlt.to_sql())
+
+    sqlt = SqlStmt.new.select().table('target')
+    assert(sqlt.includes_table?('target'))
+    assert(!sqlt.includes_table?('blah'))
+
+    sqlt = SqlStmt.new.select().table('target t')
+    assert(sqlt.includes_table?('target'))
+    assert(sqlt.includes_table?('t'))
+
+    sqlt = SqlStmt.new.select().table('target AS t')
+    assert(sqlt.includes_table?('target'))
+    assert(sqlt.includes_table?('t'))
+
+    sqlt.join('other o', 't.blah_id = o.blah_id')
+    assert(sqlt.includes_table?('other'))
+    assert(sqlt.includes_table?('o'))
   end
 
-  def test_join_with_multiple_conditions
-    %i(join left_join).each do |method|
-      sqlb = SqlStmt.new.select.table('source s').get('frog').no_where.send(method, 'other o', 'z.blee_id = o.blee_id', 'z.other_field = o.other_field')
-      method_sql = method.to_s.upcase.sub('_', ' ')
-      assert_equal("SELECT frog FROM source s #{method_sql} other o ON z.blee_id = o.blee_id AND z.other_field = o.other_field", sqlb.to_s)
-    end
+  def test_duplicate_joins
+    sqlt = SqlStmt.new.select().table('source s').get('frog').no_where
+    4.times { sqlt.join('other o', 's.blah_id = o.blah_id') }
+    assert_equal('SELECT frog FROM source s JOIN other o ON s.blah_id = o.blah_id', sqlt.to_s)
+    assert_equal('other o', sqlt.data.joins.first.table.str)
   end
 end

data/test/to_sql_test.rb

@@ -1,15 +1,23 @@
 require_relative 'helper'
 
 class Test_to_sql < Minitest::Test
-  def test_stuff
-    assert_equal("'blah'", 'blah'.to_sql)
+  def test_to_sql
     assert_equal('NULL', nil.to_sql)
+
+    assert_equal("'blah'", 'blah'.to_sql)
+    assert_equal("'b\\\\lah'", "b\\lah".to_sql())
+    assert_equal("'b\\'lah'", "b'lah".to_sql())
+    assert_equal("'b\\\"lah'", "b\"lah".to_sql())
+
     assert_equal('3', 3.to_sql)
-    assert_equal("'2008-09-24'", Date.new(2008,9,24).to_sql)
-    assert_equal("'2008-09-24 09:30:04'", DateTime.new(2008,9,24,9,30,4).to_sql)
+    assert_equal('10.0', BigDecimal.new('10').to_sql)
+
     assert_equal('1', true.to_sql)
     assert_equal('0', false.to_sql)
-    assert_equal('10.0', BigDecimal.new('10').to_sql)
+
+    assert_equal("'2008-09-24'", Date.new(2008,9,24).to_sql)
+    assert_equal("'2008-09-24 09:30:04'", DateTime.new(2008,9,24,9,30,4).to_sql)
+
     assert_equal("('a','b','c')", ['a', 'b', 'c'].to_sql)
   end
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqlstmt
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.12
 platform: ruby
 authors:
-- Makani Mason
-- Kem Mason
+- ATPSoft
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
+date: 2019-09-10 00:00:00.000000000 Z
 dependencies: []
 description: Build SQL statements using method calls instead of strings. This is not
   an ORM. It has only been used and tested with MySQL so far but the intention is
@@ -57,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: build SQL statements using method calls instead of strings