sqlstmt 0.2.9 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a699b087738e5ba85981e2b914a3b9538ef09d3b
-  data.tar.gz: d684bc830ce3a0750954c336890de5ebd594a87e
+  metadata.gz: 0f15173de416b124dcceb20abbd5ed52b75a02fa
+  data.tar.gz: 32cf06f1abe2899c9bd4a576f41652434a5f5c15
 SHA512:
-  metadata.gz: 715b1603957d23a2e6f13d89e55fe45a9a46eaf8fcb5687b8ed84ae837098982e621fc042d9704784ddd28641d0d6a3fc1401f788612df8e080d8616fd9f25ed
-  data.tar.gz: 2e1dd28397d42d82ecb81396f156e4d2325f118167084d831de17d35f21376e8b4360f9dc9715323c1733dd0ce6f060f597e5c9743b060fc26fc3ecd3523737a
+  metadata.gz: 493cc16b5693113549812f69a8eae2088cbee81afbd12ca3b7f84c7fdf83364e8e2bc8fbb01fa5af205430c465aa18acf5f6cd4041f4a91889f877d221cbbd6b
+  data.tar.gz: 53df18c4c4c03a10ccb8415f66cd803e29c829528f8c49352b7176dbf7d5959c285c25fe1afd17ccaf83c98c19856fa38b305162f8cdf5f22530bd61f5f4991e

data/lib/sqlstmt/data.rb

@@ -1,12 +1,21 @@
+require 'set'
+
 module SqlStmtLib
 extend self
 
+# in the case where only one identifier is specified, :name and :alias are both set to that value
+# this may be the wrong approach, but for now at least, it seems the most intuitive/useful option
 SqlTable = Struct.new(:str, :name, :alias, :index)
 
 SqlData = Struct.new(
   :stmt_type,
   :tables,
   :joins,
+
+  # set of all table names and aliases
+  # this includes ones added by a join
+  :table_ids,
+
   :wheres,
   :where_behavior,
   :fields,
@@ -16,7 +25,6 @@ SqlData = Struct.new(
   :limit,
   :having,
   :into_table,
-  :rows,
   :tables_to_delete,
   :distinct,
   :straight_join,
@@ -29,12 +37,12 @@ SqlData = Struct.new(
 def initialize
   self.tables = []
   self.joins = []
+  self.table_ids = Set.new
   self.wheres = []
   self.where_behavior = :require
   self.fields = []
   self.values = []
   self.having = []
-  self.rows = []
   self.tables_to_delete = []
   self.ignore = ''
   self.outfile = ''
@@ -46,11 +54,11 @@ def initialize_copy(orig)
   super
   self.tables = orig.tables.dup
   self.joins = orig.joins.dup
+  self.table_ids = orig.table_ids.dup
   self.wheres = orig.wheres.dup
   self.fields = orig.fields.dup
   self.values = orig.values.dup
   self.having = orig.having.dup
-  self.rows = orig.rows.dup
 end
 
 end

data/lib/sqlstmt/mysql/build.rb

@@ -24,10 +24,6 @@ class MysqlBuilder
   end
 
   def build_stmt_insert
-    if !@data.fields.empty? && !@data.rows.empty?
-      raise "unable to use INSERT SELECT and INSERT VALUES together, may only call :set or :add_row, but not both"
-    end
-
     keyword = @data.replace ? 'REPLACE' : 'INSERT'
     value_list = @data.values.join(',')
     start_str = "#{keyword} #{@data.ignore}INTO #{@data.into_table} "
@@ -36,13 +32,8 @@ class MysqlBuilder
       start_str += "(#{field_list}) "
     end
 
-    if @data.rows.empty?
-      distinct_str = @data.distinct ? 'DISTINCT ' : ''
-      return "#{start_str}SELECT #{distinct_str}#{value_list}#{build_from_clause}"
-    else
-      raise "DISTINCT not supported when inserting values" if @data.distinct
-      return "#{start_str}VALUES (#{value_list})"
-    end
+    distinct_str = @data.distinct ? 'DISTINCT ' : ''
+    return "#{start_str}SELECT #{distinct_str}#{value_list}#{build_from_clause}"
   end
 
   def build_stmt_delete
@@ -89,11 +80,19 @@ class MysqlBuilder
     return value ? " #{keywords} #{value}" : ''
   end
 
+  def join_to_str(join_ary)
+    kwstr, tbl, on_expr = join_ary
+    return [kwstr, tbl.str, on_expr].join(' ')
+  end
+
   def build_join_clause
     if @data.joins.empty?
       return ''
     else
-      return ' ' + @data.joins.map {|ary| ary.join(' ')}.uniq.join(' ')
+      # 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 {|ary| join_to_str(ary)}.uniq.join(' ')
     end
   end
 

data/lib/sqlstmt/mysql/check.rb

@@ -9,40 +9,55 @@ class MysqlChecker
   end
 
   def run
+    check_basics
+    check_where
+    check_statement_type_specific
+  end
+
+  def check_basics
     if !@data.stmt_type
-      raise SqlStmtError, "unable to build sql - must call :select, :update, :insert or :delete to specify statement type"
+      raise SqlStmtError, "must call :select, :update, :insert or :delete"
     end
     if @data.tables.empty?
-      raise SqlStmtError, "unable to build sql - must call :table"
+      raise SqlStmtError, "must call :table"
     end
+  end
 
+  def check_where
     if (@data.where_behavior == :require) && @data.wheres.empty?
-      raise SqlStmtError, "unable to build sql - must call :where, :no_where, or :optional_where"
+      raise SqlStmtError, "must call :where, :no_where, or :optional_where"
     elsif (@data.where_behavior == :exclude) && !@data.wheres.empty?
-      raise SqlStmtError, "unable to build sql - :where and :no_where must not both be called, consider :optional_where instead"
+      raise SqlStmtError, ":where and :no_where must not both be called, consider :optional_where instead"
     end
+  end
 
-    if @data.stmt_type == 'select'
-      raise SqlStmtError, "unable to build sql - must call :get" if @data.fields.empty?
-      raise SqlStmtError, "unable to build sql - must not call :set" if !@data.values.empty?
-    else
-      raise SqlStmtError, "unable to build sql - must not call :get" if @data.called_get
-    end
+  def check_statement_type_specific
+    method_name = "check_stmt_#{@data.stmt_type}"
+    send(method_name)
 
-    if ['update','insert'].include?(@data.stmt_type)
-      raise SqlStmtError, "unable to build sql - must call :set or :setq" if @data.values.empty?
-      raise SqlStmtError, "unable to build sql - must not call :get" if @data.called_get
+    if @data.stmt_type != 'select'
+      raise SqlStmtError, "must not call :get on #{@data.stmt_type} statement" if @data.called_get
     end
+  end
 
-    if @data.stmt_type == 'insert'
-      raise SqlStmtError, "unable to build sql - must call :into" if @data.into_table.nil?
-    end
+  def check_stmt_select
+    raise SqlStmtError, "must call :get on select statement" if @data.fields.empty?
+    raise SqlStmtError, "must not call :set on select statement" if !@data.values.empty?
+  end
+
+  def check_stmt_update
+    raise SqlStmtError, "must call :set on update statement" if @data.values.empty?
+  end
+
+  def check_stmt_insert
+    raise SqlStmtError, "must call :set on insert statement" if @data.values.empty?
+    raise SqlStmtError, "must call :into on insert statement" if @data.into_table.nil?
+  end
 
-    if @data.stmt_type == 'delete'
-      raise SqlStmtError, "unable to build sql - must not call :get or :set" if !@data.fields.empty?
-      if @data.tables_to_delete.empty? && ((@data.tables.size + @data.joins.size) > 1)
-        raise SqlStmtError, "unable to build sql - must specify tables to delete when including multiple tables"
-      end
+  def check_stmt_delete
+    raise SqlStmtError, "must not call :set on delete statement" if !@data.values.empty?
+    if @data.tables_to_delete.empty? && ((@data.tables.size + @data.joins.size) > 1)
+      raise SqlStmtError, "must specify tables to delete when including multiple tables"
     end
   end
 end

data/lib/sqlstmt/sqlstmt.rb

@@ -12,7 +12,7 @@ require 'sqlstmt/error'
 # also, looking to the future of supporting other dialects of SQL, I think the same will be true there
 # meaning, we don't the choice of SQL dialect to be allowed at any time
 
-# unless there is something better to return, all methods return self so they can be chained together
+# unless there is something better to return, methods return self so they can be chained together
 class SqlStmt
   attr_reader :data
 
@@ -24,60 +24,61 @@ class SqlStmt
     @data = @data.dup
   end
 
-  ###### temporary transition methods
-  def fields
-    return @data.fields
-  end
-
-  def tables
-    return @data.tables
-  end
-
-  def joins
-    return @data.joins
-  end
-
-  def wheres
-    return @data.wheres
-  end
-
   ###### pick statement type
 
   def select
-    return set_statement_type('select')
+    return type('select')
   end
 
   def update
-    return set_statement_type('update')
+    return type('update')
   end
 
   def insert
-    return set_statement_type('insert')
+    return type('insert')
   end
 
   def delete(*tables)
-    set_statement_type('delete')
+    type('delete')
     @data.tables_to_delete = tables
     return self
   end
 
-  ###### common operations
+  def type(stmt_type)
+    if @data.stmt_type
+      raise SqlStmtError, "statement type already set to #{@data.stmt_type}"
+    end
+    @data.stmt_type = stmt_type
+    return self
+  end
+
+  ###### tables & joins
 
-  def table(table_str, use_index = nil)
-    parts = table_str.split(' ')
-    table_obj = SqlStmtLib::SqlTable.new(table_str, parts[0], parts[1], use_index)
-    @data.tables << table_obj
+  def table(ref, use_index = nil)
+    @data.tables << include_table(ref, use_index)
     return self
   end
 
   def join(table, *exprs)
-    return add_join('JOIN', table, exprs)
+    return any_join('JOIN', table, exprs)
   end
 
   def left_join(table, *exprs)
-    return add_join('LEFT JOIN', table, exprs)
+    return any_join('LEFT JOIN', table, exprs)
+  end
+
+  def any_join(kwstr, ref, exprs)
+    tbl = include_table(ref)
+    @data.joins << [kwstr, tbl, "ON #{exprs.join(' AND ')}"]
+    return self
+  end
+
+  def includes_table?(table_to_find)
+    return @data.table_ids.include?(table_to_find)
   end
 
+  ###### where
+
   def where(*expr)
     @data.wheres.concat(expr)
     return self
@@ -93,6 +94,8 @@ class SqlStmt
     return self
   end
 
+  ###### fields & values
+
   def get(*exprs)
     @data.fields.concat(exprs)
     @data.called_get = true
@@ -100,7 +103,7 @@ class SqlStmt
   end
 
   def set(field, value)
-    raise "trying to include field #{field} again" if @data.fields.include?(field)
+    raise SqlStmtError, "trying to include field #{field} again" if @data.fields.include?(field)
     # this is to support the special case of INSERT INTO table SELECT * FROM ...
     # where * specified with no matching insert field list specified
     if field
@@ -115,6 +118,8 @@ class SqlStmt
     return set(field, value.to_sql)
   end
 
+  ###### to be sorted
+
   def group_by(expr)
     @data.group_by = expr
     return self
@@ -146,13 +151,6 @@ class SqlStmt
     return self
   end
 
-  # used with INSERT VALUES statements only
-  def add_row(row)
-    @data.rows << row
-  end
-
-  ###### less commonly used methods
-
   def distinct
     @data.distinct = true
     return self
@@ -178,32 +176,20 @@ class SqlStmt
     return self
   end
 
-  ###### methods to analyze what the statement contains
-  def includes_table?(table_to_find)
-    retval = @data.tables.find { |table| (table.name == table_to_find) || (table.alias == table_to_find) }
-    retval ||= @data.joins.find { |_, table, _| table_names_match?(table, table_to_find) }
-    return retval
-  end
-
 private
-  def set_statement_type(stmt_type)
-    if @data.stmt_type
-      raise "statement type already set to #{@data.stmt_type}"
+  # this is used for method calls to :table and :any_join
+  def include_table(ref, use_index = nil)
+    parts = ref.split(' ')
+    if parts.size == 3
+      parts.delete_at(1)
     end
-    @data.stmt_type = stmt_type
-    return self
-  end
-
-  def add_join(keyword, table, exprs)
-    @data.joins << [keyword, table, "ON #{exprs.join(' AND ')}"]
-    return self
-  end
+    @data.table_ids.merge(parts)
 
-  def table_names_match?(fullstr, tofind)
-    if tofind.index(' ') || !fullstr.index(' ')
-      return fullstr == tofind
+    if parts.size == 2
+      tbl_name, tbl_alias = parts
+    else
+      tbl_name = tbl_alias = parts.first
     end
-    orig_name, _, tblas = fullstr.partition(' ')
-    return (orig_name == tofind) || (tblas == tofind)
+    return SqlStmtLib::SqlTable.new(ref, tbl_name, tbl_alias, use_index)
   end
 end

data/test/helper.rb

@@ -1,2 +1,7 @@
+require 'simplecov'
+SimpleCov.command_name 'Unit Tests'
+SimpleCov.add_filter "/test/"
+SimpleCov.start
+
 require 'minitest/autorun'
 require 'sqlstmt'

data/test/select_test.rb

@@ -2,10 +2,18 @@ require_relative 'helper'
 
 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_tables
@@ -16,6 +24,7 @@ class TestSelect < Minitest::Test
 
   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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlstmt
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.10
 platform: ruby
 authors:
 - Makani Mason
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-02 00:00:00.000000000 Z
+date: 2018-08-03 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