sqlstmt 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f15173de416b124dcceb20abbd5ed52b75a02fa
-  data.tar.gz: 32cf06f1abe2899c9bd4a576f41652434a5f5c15
+  metadata.gz: e5516750b663f84d0ee52a37951a305e8c003914
+  data.tar.gz: 2c80189865a625385c7da900c8cc8fe494a3860c
 SHA512:
-  metadata.gz: 493cc16b5693113549812f69a8eae2088cbee81afbd12ca3b7f84c7fdf83364e8e2bc8fbb01fa5af205430c465aa18acf5f6cd4041f4a91889f877d221cbbd6b
-  data.tar.gz: 53df18c4c4c03a10ccb8415f66cd803e29c829528f8c49352b7176dbf7d5959c285c25fe1afd17ccaf83c98c19856fa38b305162f8cdf5f22530bd61f5f4991e
+  metadata.gz: 07d9232c1d6473704cda766e7c12436a8677f2589939201b3dd8681801f66bf6ca72fb9c2b5b9c301c2a945d3d3792d430687a82e2d4755aa94d4d0a81d5f33d
+  data.tar.gz: a08886bb3a3fdfbce82fed743ba2ec339c16d7acc33bb2b789025b24cc0bca0a58853da1ec50f6cc34f314e6c0d6ad10fdc6b839937e17f621e3fd76c47c0164

data/lib/sqlstmt/data.rb

@@ -3,62 +3,45 @@ 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
+FLAG_KEYWORDS = %i(distinct ignore replace straight_join with_rollup).freeze
+SINGLE_VALUE_KEYWORDS = %i(group_by into limit offset order_by outfile).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'
+# :name is the full name of the table
+# :alias is the alias specified for the table, or if none is specified, it's the same as :name
+#   this may be the wrong approach, but for now at least, it seems the most intuitive/useful option
+# :index is used to specify a "USE INDEX" clause
 SqlTable = Struct.new(:str, :name, :alias, :index)
 
-SqlData = Struct.new(
-  :stmt_type,
-  :tables,
-  :joins,
+# kwstr is the keyword string, like 'JOIN' or 'LEFT JOIN'
+# table is a SqlTable object, representing the table being joined to
+# on_expr is the ON expression for the join
+SqlJoin = Struct.new(:kwstr, :table, :on_expr)
 
-  # set of all table names and aliases
-  # this includes ones added by a join
-  :table_ids,
+# :table_ids is a set of all table names and aliases, including ones added by a join
+SPECIAL_DATA_FIELDS = %i(stmt_type table_ids where_behavior).freeze
+ARRAY_DATA_FIELDS = MULTI_VALUE_KEYWORDS.map {|keyword| "#{keyword}s".to_sym} + %i(tables joins set_fields set_values tables_to_delete).freeze
 
-  :wheres,
-  :where_behavior,
-  :fields,
-  :values,
-  :group_by,
-  :order_by,
-  :limit,
-  :having,
-  :into_table,
-  :tables_to_delete,
-  :distinct,
-  :straight_join,
-  :replace,
-  :ignore,
-  :outfile,
-  :with_rollup,
-  :called_get,
-) do
+# calling uniq on this in case some fields end up in multiple categories
+ALL_DATA_FIELDS = (FLAG_KEYWORDS + SINGLE_VALUE_KEYWORDS + ARRAY_DATA_FIELDS + SPECIAL_DATA_FIELDS).uniq
+
+SqlData = Struct.new(*ALL_DATA_FIELDS) do
 def initialize
-  self.tables = []
-  self.joins = []
   self.table_ids = Set.new
-  self.wheres = []
   self.where_behavior = :require
-  self.fields = []
-  self.values = []
-  self.having = []
-  self.tables_to_delete = []
-  self.ignore = ''
-  self.outfile = ''
-  self.called_get = false
+  ARRAY_DATA_FIELDS.each do |field|
+    self[field] = []
+  end
 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
+  ARRAY_DATA_FIELDS.each do |field|
+    self[field] = self[field].dup
+  end
   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
 end
 
 end

data/lib/sqlstmt/mysql/build.rb

@@ -14,8 +14,9 @@ class MysqlBuilder
   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}"
+    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}"
   end
 
   def build_stmt_update
@@ -25,10 +26,11 @@ class MysqlBuilder
 
   def build_stmt_insert
     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(',')
+    value_list = @data.set_values.join(',')
+    ignore_str = @data.ignore ? 'IGNORE ' : ''
+    start_str = "#{keyword} #{ignore_str}INTO #{@data.into} "
+    if !@data.set_fields.empty?
+      field_list = @data.set_fields.join(',')
       start_str += "(#{field_list}) "
     end
 
@@ -53,14 +55,14 @@ class MysqlBuilder
     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 ')}"
+    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}"
   end
 
   def build_set_clause
     set_exprs = []
-    @data.fields.each_with_index do |field, index|
-      set_exprs << "#{field} = #{@data.values[index]}"
+    @data.set_fields.each_with_index do |field, index|
+      set_exprs << "#{field} = #{@data.set_values[index]}"
     end
     return set_exprs.join(', ')
   end
@@ -80,9 +82,8 @@ 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(' ')
+  def join_to_str(join)
+    return [join.kwstr, join.table.str, join.on_expr].join(' ')
   end
 
   def build_join_clause
@@ -92,7 +93,7 @@ class MysqlBuilder
       # 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(' ')
+      return ' ' + @data.joins.map {|join| join_to_str(join)}.uniq.join(' ')
     end
   end
 

data/lib/sqlstmt/mysql/check.rb

@@ -36,26 +36,26 @@ class MysqlChecker
     send(method_name)
 
     if @data.stmt_type != 'select'
-      raise SqlStmtError, "must not call :get on #{@data.stmt_type} statement" if @data.called_get
+      raise SqlStmtError, "must not call :get on #{@data.stmt_type} statement" if !@data.gets.empty?
     end
   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?
+    raise SqlStmtError, "must call :get on select statement" if @data.gets.empty?
+    raise SqlStmtError, "must not call :set on select statement" if !@data.set_values.empty?
   end
 
   def check_stmt_update
-    raise SqlStmtError, "must call :set on update statement" if @data.values.empty?
+    raise SqlStmtError, "must call :set on update statement" if @data.set_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?
+    raise SqlStmtError, "must call :set on insert statement" if @data.set_values.empty?
+    raise SqlStmtError, "must call :into on insert statement" if @data.into.nil?
   end
 
   def check_stmt_delete
-    raise SqlStmtError, "must not call :set on delete statement" if !@data.values.empty?
+    raise SqlStmtError, "must not call :set on delete statement" if !@data.set_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

data/lib/sqlstmt/sqlstmt.rb

@@ -10,7 +10,7 @@ require 'sqlstmt/error'
 # 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
+# meaning, we allow the choice of SQL dialect to be made at any time
 
 # unless there is something better to return, methods return self so they can be chained together
 class SqlStmt
@@ -21,6 +21,8 @@ class SqlStmt
   end
 
   def initialize_copy(_orig)
+    # I don't really know why this is necessary, but it seems to be
+    super
     @data = @data.dup
   end
 
@@ -69,7 +71,7 @@ class SqlStmt
 
   def any_join(kwstr, ref, exprs)
     tbl = include_table(ref)
-    @data.joins << [kwstr, tbl, "ON #{exprs.join(' AND ')}"]
+    @data.joins << SqlStmtLib::SqlJoin.new(kwstr, tbl, "ON #{exprs.join(' AND ')}")
     return self
   end
 
@@ -79,11 +81,6 @@ class SqlStmt
 
   ###### where
 
-  def where(*expr)
-    @data.wheres.concat(expr)
-    return self
-  end
-
   def no_where
     @data.where_behavior = :exclude
     return self
@@ -96,21 +93,19 @@ class SqlStmt
 
   ###### fields & values
 
-  def get(*exprs)
-    @data.fields.concat(exprs)
-    @data.called_get = true
-    return self
-  end
-
+  # nil can be passed in for the field, in which case it won't be added
+  # this is only for the special case of INSERT INTO table SELECT b.* FROM blah b WHERE ...
+  # where there are no specific fields listed
   def set(field, value)
-    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 @data.set_fields.include?(field)
+      raise SqlStmtError, "trying to set field #{field} again"
+    end
+
     if field
-      @data.fields << field
+      @data.set_fields << field
     end
     value = value.is_a?(String) ? value : value.to_sql
-    @data.values << value
+    @data.set_values << value
     return self
   end
 
@@ -118,62 +113,27 @@ class SqlStmt
     return set(field, value.to_sql)
   end
 
-  ###### to be sorted
-
-  def group_by(expr)
-    @data.group_by = expr
-    return self
-  end
-
-  def order_by(expr)
-    @data.order_by = expr
-    return self
-  end
-
-  def limit(clause)
-    @data.limit = clause
-    return self
-  end
-
-  def having(*expr)
-    @data.having.concat(expr)
-    return self
-  end
-
-  def with_rollup
-    @data.with_rollup = true
-    return self
-  end
-
-  # used with INSERT statements only
-  def into(into_table)
-    @data.into_table = into_table
-    return self
-  end
-
-  def distinct
-    @data.distinct = true
-    return self
-  end
+  ###### these are simple wrappers around various keywords
 
-  def straight_join
-    @data.straight_join = true
-    return self
-  end
-
-  def replace
-    @data.replace = true
-    return self
+  SqlStmtLib::FLAG_KEYWORDS.each do |keyword|
+    define_method(keyword) do
+      @data[keyword] = true
+      return self
+    end
   end
 
-  def ignore
-    @data.ignore = 'IGNORE '
-    return self
+  SqlStmtLib::SINGLE_VALUE_KEYWORDS.each do |keyword|
+    define_method(keyword) do |value|
+      @data[keyword] = value
+      return self
+    end
   end
 
-  def outfile(str)
-    @data.outfile = " INTO OUTFILE #{str}"
-    return self
+  SqlStmtLib::MULTI_VALUE_KEYWORDS.each do |keyword|
+    define_method(keyword) do |*values|
+      @data["#{keyword}s"].concat(values)
+      return self
+    end
   end
 
 private

metadata

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