sqlstmt 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89688ddfe350e862894b961b9370652590cbb4b5
-  data.tar.gz: 5cded7053ef7a68944cedcca3636cfd7ae6a141d
+  metadata.gz: a699b087738e5ba85981e2b914a3b9538ef09d3b
+  data.tar.gz: d684bc830ce3a0750954c336890de5ebd594a87e
 SHA512:
-  metadata.gz: acfc44e647935793b752b39675e14b45b6b7a47d3eaabcf442d470b47eaecd062d0b7af85360a163ae370e8b6eb2b587c9267625af4ad44914ba0259bd662cbf
-  data.tar.gz: c15c9d5fd1df7ba29b9eac9d76d86fe9ba913dc1a16233a86de32bd9939249ca289d4761cea00fb7b95f4b60b1c50a9e88f9eb93d550427e4fab85ac30e63b1e
+  metadata.gz: 715b1603957d23a2e6f13d89e55fe45a9a46eaf8fcb5687b8ed84ae837098982e621fc042d9704784ddd28641d0d6a3fc1401f788612df8e080d8616fd9f25ed
+  data.tar.gz: 2e1dd28397d42d82ecb81396f156e4d2325f118167084d831de17d35f21376e8b4360f9dc9715323c1733dd0ce6f060f597e5c9743b060fc26fc3ecd3523737a

data/lib/sqlstmt/build.rb

@@ -0,0 +1,10 @@
+require 'sqlstmt/mysql/check'
+require 'sqlstmt/mysql/build'
+
+class SqlStmt
+  def to_s
+    SqlStmtLib::MysqlChecker.new(@data).run
+    return SqlStmtLib::MysqlBuilder.new(@data).build_stmt
+  end
+  alias_method :to_sql, :to_s
+end

data/lib/sqlstmt/data.rb

@@ -0,0 +1,58 @@
+module SqlStmtLib
+extend self
+
+SqlTable = Struct.new(:str, :name, :alias, :index)
+
+SqlData = Struct.new(
+  :stmt_type,
+  :tables,
+  :joins,
+  :wheres,
+  :where_behavior,
+  :fields,
+  :values,
+  :group_by,
+  :order_by,
+  :limit,
+  :having,
+  :into_table,
+  :rows,
+  :tables_to_delete,
+  :distinct,
+  :straight_join,
+  :replace,
+  :ignore,
+  :outfile,
+  :with_rollup,
+  :called_get,
+) do
+def initialize
+  self.tables = []
+  self.joins = []
+  self.wheres = []
+  self.where_behavior = :require
+  self.fields = []
+  self.values = []
+  self.having = []
+  self.rows = []
+  self.tables_to_delete = []
+  self.ignore = ''
+  self.outfile = ''
+  self.called_get = false
+end
+
+def initialize_copy(orig)
+  # without this call to super, any field that we aren't dup'ing here won't be copied
+  super
+  self.tables = orig.tables.dup
+  self.joins = orig.joins.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
+
+end

data/lib/sqlstmt/mysql/build.rb

@@ -0,0 +1,105 @@
+module SqlStmtLib
+extend self
+
+class MysqlBuilder
+  def initialize(data)
+    @data = data
+  end
+
+  def build_stmt
+    method_name = "build_stmt_#{@data.stmt_type}"
+    return send(method_name)
+  end
+
+  def build_stmt_select
+    straight_join_str = @data.straight_join ? 'STRAIGHT_JOIN ' : ''
+    distinct_str = @data.distinct ? 'DISTINCT ' : ''
+    select_str = @data.fields.join(',')
+    return "SELECT #{straight_join_str}#{distinct_str}#{select_str}#{build_from_clause}#{@data.outfile}"
+  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}"
+  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} "
+    if !@data.fields.empty?
+      field_list = @data.fields.join(',')
+      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
+  end
+
+  def build_stmt_delete
+    if @data.tables_to_delete.empty?
+      table_clause = ''
+    else
+      table_clause = ' ' + @data.tables_to_delete.join(',')
+    end
+    return "DELETE#{table_clause}#{build_from_clause}"
+  end
+
+  def build_from_clause
+    join_clause = build_join_clause
+    group_clause = simple_clause('GROUP BY', @data.group_by)
+    if @data.with_rollup
+      group_clause += ' WITH ROLLUP'
+    end
+    order_clause = simple_clause('ORDER BY', @data.order_by)
+    limit_clause = simple_clause('LIMIT', @data.limit)
+    having_clause = @data.having.empty? ? '' : " HAVING #{@data.having.join(' AND ')}"
+    return " FROM #{build_table_list}#{join_clause}#{build_where_clause}#{group_clause}#{having_clause}#{order_clause}#{limit_clause}"
+  end
+
+  def build_set_clause
+    set_exprs = []
+    @data.fields.each_with_index do |field, index|
+      set_exprs << "#{field} = #{@data.values[index]}"
+    end
+    return set_exprs.join(', ')
+  end
+
+  def table_to_str(table)
+    if table.index
+      return "#{table.str} USE INDEX (#{table.index})"
+    end
+    return table.str
+  end
+
+  def build_table_list
+    return @data.tables.map {|table| table_to_str(table) }.join(',')
+  end
+
+  def simple_clause(keywords, value)
+    return value ? " #{keywords} #{value}" : ''
+  end
+
+  def build_join_clause
+    if @data.joins.empty?
+      return ''
+    else
+      return ' ' + @data.joins.map {|ary| ary.join(' ')}.uniq.join(' ')
+    end
+  end
+
+  def build_where_clause
+    return @data.wheres.empty? ? '' : " WHERE #{@data.wheres.join(' AND ')}"
+  end
+end
+
+end

data/lib/sqlstmt/mysql/check.rb

@@ -0,0 +1,50 @@
+require 'sqlstmt/error'
+
+module SqlStmtLib
+extend self
+
+class MysqlChecker
+  def initialize(data)
+    @data = data
+  end
+
+  def run
+    if !@data.stmt_type
+      raise SqlStmtError, "unable to build sql - must call :select, :update, :insert or :delete to specify statement type"
+    end
+    if @data.tables.empty?
+      raise SqlStmtError, "unable to build sql - must call :table"
+    end
+
+    if (@data.where_behavior == :require) && @data.wheres.empty?
+      raise SqlStmtError, "unable to build sql - 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"
+    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
+
+    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
+    end
+
+    if @data.stmt_type == 'insert'
+      raise SqlStmtError, "unable to build sql - must call :into" 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
+    end
+  end
+end
+
+end

data/lib/sqlstmt/sqlstmt.rb

@@ -1,70 +1,63 @@
+require 'sqlstmt/data'
 require 'sqlstmt/error'
-require 'sqlstmt/to_sql'
 
+# in looking at the implementation, it could be asked:
+# why are there not individual classes for each statement type?
+# and indeed, it does seem a natural fit, and the first version was built that way
+# however, this meant that the statement type had to be determined at object creation time
+# and for some cases this was a limitation and in general went against the purposes of this library
+# namely, to build the statement gradually and in no particular order, even the statement type
+# for example, we might build a statement and add a where clause to it
+# and some step later on would determine the statement type
+# 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
 class SqlStmt
-  attr_reader :fields, :tables, :joins, :wheres
-  Table = Struct.new(:str, :name, :alias, :index)
+  attr_reader :data
 
   def initialize
-    @stmt_type = nil
-    @tables = []
-    @joins = []
-    @wheres = []
-    @where_behavior = :require
-    @fields = []
-    @values = []
-    @group_by = nil
-    @order_by = nil
-    @limit = nil
-    @having = []
-    @into_table = nil
-    @rows = []
-    @tables_to_delete = []
-    @distinct = nil
-    @straight_join = nil
-    @replace = nil
-    @ignore = ''
-    @outfile = ''
-    @with_rollup = nil
-    # track this explicitly to guarantee get is not used with non-select statements
-    @called_get = false
-  end
-
-  def initialize_copy(orig)
-    super
-    @tables = @tables.dup
-    @joins = @joins.dup
-    @wheres = @wheres.dup
-    @fields = @fields.dup
-    @values = @values.dup
-    @having = @having.dup
-    @rows = @rows.dup
+    @data = SqlStmtLib::SqlData.new
+  end
+
+  def initialize_copy(_orig)
+    @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
-    ensure_no_statement_type
-    @stmt_type = 'select'
-    return self
+    return set_statement_type('select')
   end
 
   def update
-    ensure_no_statement_type
-    @stmt_type = 'update'
-    return self
+    return set_statement_type('update')
   end
 
   def insert
-    ensure_no_statement_type
-    @stmt_type = 'insert'
-    return self
+    return set_statement_type('insert')
   end
 
   def delete(*tables)
-    ensure_no_statement_type
-    @stmt_type = 'delete'
-    @tables_to_delete = tables
+    set_statement_type('delete')
+    @data.tables_to_delete = tables
     return self
   end
 
@@ -72,8 +65,8 @@ class SqlStmt
 
   def table(table_str, use_index = nil)
     parts = table_str.split(' ')
-    table_obj = Table.new(table_str, parts[0], parts[1], use_index)
-    @tables << table_obj
+    table_obj = SqlStmtLib::SqlTable.new(table_str, parts[0], parts[1], use_index)
+    @data.tables << table_obj
     return self
   end
 
@@ -86,35 +79,35 @@ class SqlStmt
   end
 
   def where(*expr)
-    @wheres.concat(expr)
+    @data.wheres.concat(expr)
     return self
   end
 
   def no_where
-    @where_behavior = :exclude
+    @data.where_behavior = :exclude
     return self
   end
 
   def optional_where
-    @where_behavior = :optional
+    @data.where_behavior = :optional
     return self
   end
 
   def get(*exprs)
-    @fields.concat(exprs)
-    @called_get = true
+    @data.fields.concat(exprs)
+    @data.called_get = true
     return self
   end
 
   def set(field, value)
-    raise "trying to include field #{field} again" if @fields.include?(field)
+    raise "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
-      @fields << field
+      @data.fields << field
     end
     value = value.is_a?(String) ? value : value.to_sql
-    @values << value
+    @data.values << value
     return self
   end
 
@@ -123,90 +116,86 @@ class SqlStmt
   end
 
   def group_by(expr)
-    @group_by = expr
+    @data.group_by = expr
     return self
   end
 
   def order_by(expr)
-    @order_by = expr
+    @data.order_by = expr
     return self
   end
 
   def limit(clause)
-    @limit = clause
+    @data.limit = clause
     return self
   end
 
   def having(*expr)
-    @having.concat(expr)
+    @data.having.concat(expr)
     return self
   end
 
   def with_rollup
-    @with_rollup = true
+    @data.with_rollup = true
     return self
   end
 
   # used with INSERT statements only
   def into(into_table)
-    @into_table = into_table
+    @data.into_table = into_table
     return self
   end
 
   # used with INSERT VALUES statements only
   def add_row(row)
-    @rows << row
+    @data.rows << row
   end
 
-  def to_s
-    verify_minimum_requirements
-    return build_stmt
-  end
-  alias_method :to_sql, :to_s
-
   ###### less commonly used methods
 
   def distinct
-    @distinct = true
+    @data.distinct = true
     return self
   end
 
   def straight_join
-    @straight_join = true
+    @data.straight_join = true
     return self
   end
 
   def replace
-    @replace = true
+    @data.replace = true
     return self
   end
 
   def ignore
-    @ignore = 'IGNORE '
+    @data.ignore = 'IGNORE '
     return self
   end
 
   def outfile(str)
-    @outfile = " INTO OUTFILE #{str}"
+    @data.outfile = " INTO OUTFILE #{str}"
     return self
   end
 
   ###### methods to analyze what the statement contains
   def includes_table?(table_to_find)
-    retval = @tables.find { |table| (table.name == table_to_find) || (table.alias == table_to_find) }
-    retval ||= @joins.find { |_, table, _| table_names_match?(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 ensure_no_statement_type
-    if @stmt_type
-      raise "statement type already set to #{@stmt_type}"
+  def set_statement_type(stmt_type)
+    if @data.stmt_type
+      raise "statement type already set to #{@data.stmt_type}"
     end
+    @data.stmt_type = stmt_type
+    return self
   end
 
   def add_join(keyword, table, exprs)
-    @joins << [keyword, table, "ON #{exprs.join(' AND ')}"]
+    @data.joins << [keyword, table, "ON #{exprs.join(' AND ')}"]
     return self
   end
 
@@ -217,139 +206,4 @@ private
     orig_name, _, tblas = fullstr.partition(' ')
     return (orig_name == tofind) || (tblas == tofind)
   end
-
-  ###### the remainder of the methods are for verifying and building the completed statement string
-
-  def verify_minimum_requirements
-    if !@stmt_type
-      raise SqlStmtError, "unable to build sql - must call :select, :update, :insert or :delete to specify statement type"
-    end
-    if @tables.empty?
-      raise SqlStmtError, "unable to build sql - must call :table"
-    end
-
-    if (@where_behavior == :require) && @wheres.empty?
-      raise SqlStmtError, "unable to build sql - must call :where, :no_where, or :optional_where"
-    elsif (@where_behavior == :exclude) && !@wheres.empty?
-      raise SqlStmtError, "unable to build sql - :where and :no_where must not both be called, consider :optional_where instead"
-    end
-
-    if @stmt_type == 'select'
-      raise SqlStmtError, "unable to build sql - must call :get" if @fields.empty?
-      raise SqlStmtError, "unable to build sql - must not call :set" if !@values.empty?
-    else
-      raise SqlStmtError, "unable to build sql - must not call :get" if @called_get
-    end
-
-    if ['update','insert'].include?(@stmt_type)
-      raise SqlStmtError, "unable to build sql - must call :set or :setq" if @values.empty?
-      raise SqlStmtError, "unable to build sql - must not call :get" if @called_get
-    end
-
-    if @stmt_type == 'insert'
-      raise SqlStmtError, "unable to build sql - must call :into" if @into_table.nil?
-    end
-
-    if @stmt_type == 'delete'
-      raise SqlStmtError, "unable to build sql - must not call :get or :set" if !@fields.empty?
-      if @tables_to_delete.empty? && ((@tables.size + @joins.size) > 1)
-        raise SqlStmtError, "unable to build sql - must specify tables to delete when including multiple tables"
-      end
-    end
-  end
-
-  def build_stmt
-    method_name = "build_stmt_#{@stmt_type}"
-    return send(method_name)
-  end
-
-  def build_stmt_select
-    straight_join_str = @straight_join ? 'STRAIGHT_JOIN ' : ''
-    distinct_str = @distinct ? 'DISTINCT ' : ''
-    select_str = @fields.join(',')
-    return "SELECT #{straight_join_str}#{distinct_str}#{select_str}#{build_from_clause}#{@outfile}"
-  end
-
-  def build_stmt_update
-    limit_clause = simple_clause('LIMIT', @limit)
-    return "UPDATE #{build_table_list}#{build_join_clause} SET #{build_set_clause}#{build_where_clause}#{limit_clause}"
-  end
-
-  def build_stmt_insert
-    if !@fields.empty? && !@rows.empty?
-      raise "unable to use INSERT SELECT and INSERT VALUES together, may only call :set or :add_row, but not both"
-    end
-
-    keyword = @replace ? 'REPLACE' : 'INSERT'
-    value_list = @values.join(',')
-    start_str = "#{keyword} #{@ignore}INTO #{@into_table} "
-    if !@fields.empty?
-      field_list = @fields.join(',')
-      start_str += "(#{field_list}) "
-    end
-
-    if @rows.empty?
-      distinct_str = @distinct ? 'DISTINCT ' : ''
-      return "#{start_str}SELECT #{distinct_str}#{value_list}#{build_from_clause}"
-    else
-      raise "DISTINCT not supported when inserting values" if @distinct
-      return "#{start_str}VALUES (#{value_list})"
-    end
-  end
-
-  def build_stmt_delete
-    if @tables_to_delete.empty?
-      table_clause = ''
-    else
-      table_clause = ' ' + @tables_to_delete.join(',')
-    end
-    return "DELETE#{table_clause}#{build_from_clause}"
-  end
-
-  def build_from_clause
-    join_clause = build_join_clause
-    group_clause = simple_clause('GROUP BY', @group_by)
-    if @with_rollup
-      group_clause += ' WITH ROLLUP'
-    end
-    order_clause = simple_clause('ORDER BY', @order_by)
-    limit_clause = simple_clause('LIMIT', @limit)
-    having_clause = @having.empty? ? '' : " HAVING #{@having.join(' AND ')}"
-    return " FROM #{build_table_list}#{join_clause}#{build_where_clause}#{group_clause}#{having_clause}#{order_clause}#{limit_clause}"
-  end
-
-  def build_set_clause
-    set_exprs = []
-    @fields.each_with_index do |field, index|
-      set_exprs << "#{field} = #{@values[index]}"
-    end
-    return set_exprs.join(', ')
-  end
-
-  def table_to_str(table)
-    if table.index
-      return "#{table.str} USE INDEX (#{table.index})"
-    end
-    return table.str
-  end
-
-  def build_table_list
-    return @tables.map {|table| table_to_str(table) }.join(',')
-  end
-
-  def simple_clause(keywords, value)
-    return value ? " #{keywords} #{value}" : ''
-  end
-
-  def build_join_clause
-    if @joins.empty?
-      return ''
-    else
-      return ' ' + @joins.map {|ary| ary.join(' ')}.uniq.join(' ')
-    end
-  end
-
-  def build_where_clause
-    return @wheres.empty? ? '' : " WHERE #{@wheres.join(' AND ')}"
-  end
 end

data/lib/sqlstmt.rb

@@ -1 +1,3 @@
+require 'sqlstmt/core_to_sql'
 require 'sqlstmt/sqlstmt'
+require 'sqlstmt/build'

data/test/data_test.rb

@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+require 'sqlstmt/data'
+
+class TestData < Minitest::Test
+  def test_deep_copy_of_arrays
+    orig = SqlStmtLib::SqlData.new
+    orig.tables << 1
+    assert_equal([1], orig.tables)
+
+    copy = orig.dup
+    assert_equal([1], copy.tables)
+
+    copy.tables << 2
+    assert_equal([1, 2], copy.tables)
+    assert_equal([1], orig.tables)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlstmt
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Makani Mason
@@ -9,10 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-18 00:00:00.000000000 Z
+date: 2018-08-02 00:00:00.000000000 Z
 dependencies: []
-description: build SQL statements in a modular fashion, one piece at a time; only
-  used/tested with MySQL so far
+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
+  to make it SQL agnostic.
 email:
 - devinfo@atpsoft.com
 executables: []
@@ -22,9 +23,14 @@ extra_rdoc_files:
 files:
 - MIT-LICENSE
 - lib/sqlstmt.rb
+- lib/sqlstmt/build.rb
+- lib/sqlstmt/core_to_sql.rb
+- lib/sqlstmt/data.rb
 - lib/sqlstmt/error.rb
+- lib/sqlstmt/mysql/build.rb
+- lib/sqlstmt/mysql/check.rb
 - lib/sqlstmt/sqlstmt.rb
-- lib/sqlstmt/to_sql.rb
+- test/data_test.rb
 - test/delete_test.rb
 - test/helper.rb
 - test/insert_select_test.rb
@@ -51,11 +57,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
-summary: build SQL statements in a modular fashion, one piece at a time
+summary: build SQL statements using method calls instead of strings
 test_files:
+- test/data_test.rb
 - test/delete_test.rb
 - test/helper.rb
 - test/insert_select_test.rb