sqb 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36cfacce28d143bb31c2b714cc2b4a99744a7dfd117832e0952979767bfcd7af
-  data.tar.gz: 72efb2953532af5f444b55833e3342138bfe68a94560567658e81981d38db043
+  metadata.gz: b3c57f511a3e18b3718cbbcd5e6703b52bd0b3d6e92ead8aca02a04ef46b087a
+  data.tar.gz: 2fd0e2d396c722bf2d0fcac632a8322be95ab3aa65b64ba70d86b62ca5859d98
 SHA512:
-  metadata.gz: 9bad00a3fad97d424d51d7a150ca64055885fdd730d8c925712895176ac6fa61e575433f3bc18b90f165d5a2fa2bda5b32c5e07ba463d0460d39578c9cdcaa76
-  data.tar.gz: 0b927ede58eaa630e8a665a1d5ee9e564eaaebfd96d8ed29a66a0b0606aab22fe000f75142428386084d512d6238f3450a1642ebf13bdce57bade20a449023a6
+  metadata.gz: ba298f55cf459a29818711e146c78b58911a1673c277879d013f2333e31729b733fa686af429931797aad1b1d5dfb0ea43c0b31364d4ac3c1f68f99ded75d4d9
+  data.tar.gz: 8e4c5e633e78f78689a2d60e8574bb5e86de9d0c0305ace9e4c46e64daadc9c971a3615da18fa5825e295081e2b3eabd6c61b43d9f185b18de10f98ebdfa83e0

data/lib/sqb.rb

@@ -1,7 +1,12 @@
-require 'sqb/query'
 require 'sqb/version'
 require 'sqb/safe_string'
 
+require 'sqb/query'
+require 'sqb/select'
+require 'sqb/update'
+require 'sqb/delete'
+require 'sqb/insert'
+
 module SQB
   def self.safe(string)
     SafeString.new(string)

data/lib/sqb/base.rb

@@ -0,0 +1,25 @@
+require 'sqb/error'
+require 'sqb/escaping'
+
+module SQB
+  class Base
+
+    include SQB::Escaping
+
+    attr_reader :prepared_arguments
+
+    def initialize(table_name, options = {}, &block)
+      @table_name = table_name
+      @options = options
+      @prepared_arguments = []
+      block.call(self) if block_given?
+    end
+
+    # Generate the full SQL query for this query.
+    #
+    # @return [String]
+    def to_sql
+    end
+
+  end
+end

data/lib/sqb/columns.rb

@@ -0,0 +1,38 @@
+module SQB
+  module Columns
+
+    # Add a column to the query
+    #
+    # @param column [String, Symbol, Hash] the column name (or a hash with table & column name)
+    # @option options [String] :function a function to wrap around the column
+    # @options options [String] :as the name to return this column as
+    # @return [Query] returns the query
+    def column(column, options = {})
+      @columns ||= []
+      with_table_and_column(column) do |table, column|
+        @columns << [].tap do |query|
+          if options[:function]
+            query << "#{escape_function(options[:function])}("
+          end
+          query << escape_and_join(table, column)
+          if options[:function]
+            query << ")"
+          end
+          if options[:as]
+            query << "AS"
+            query << escape(options[:as])
+          end
+        end.join(' ')
+      end
+      self
+    end
+
+    # Replace all existing columns with the given column
+    def column!(*args)
+      @columns = []
+      column(*args)
+    end
+
+
+  end
+end

data/lib/sqb/delete.rb

@@ -0,0 +1,35 @@
+require 'sqb/base'
+require 'sqb/filtering'
+require 'sqb/ordering'
+require 'sqb/limiting'
+
+module SQB
+  class Delete < Base
+
+    include SQB::Filtering
+    include SQB::Ordering
+    include SQB::Limiting
+
+    def to_sql
+      [].tap do |query|
+        query << "DELETE FROM"
+        query << escape_and_join(@options[:database_name], @table_name)
+
+        if @where && !@where.empty?
+          query << "WHERE"
+          query << @where.join(' AND ')
+        end
+
+        if @orders && !@orders.empty?
+          query << "ORDER BY"
+          query << @orders.join(', ')
+        end
+
+        if @limit
+          query << "LIMIT #{@limit.to_i}"
+        end
+      end.join(' ')
+    end
+
+  end
+end

data/lib/sqb/distinct.rb

@@ -0,0 +1,10 @@
+module SQB
+  module Distinct
+
+    def distinct
+      @distinct = true
+      self
+    end
+
+  end
+end

data/lib/sqb/error.rb

@@ -10,4 +10,7 @@ module SQB
 
   class InvalidOperatorError < Error
   end
+
+  class NoValuesError < Error
+  end
 end

data/lib/sqb/escaping.rb

@@ -0,0 +1,56 @@
+module SQB
+  module Escaping
+
+    private
+
+    def escape(name)
+      if name.is_a?(SafeString)
+        name
+      else
+        "`#{name.to_s.gsub('`', '``')}`"
+      end
+    end
+
+    def escape_function(name)
+      if name.is_a?(SafeString)
+        name
+      else
+        name.to_s.gsub(/[^a-z0-9\_]/i, '').upcase
+      end
+    end
+
+    def value_escape(value)
+      if value == true
+        1
+      elsif value == false
+        0
+      elsif value.nil?
+        'NULL'
+      elsif value.is_a?(Integer)
+        value.to_i
+      else
+        @prepared_arguments << value.to_s
+        '?'
+      end
+    end
+
+    def with_table_and_column(input, &block)
+      if input.is_a?(Hash)
+        input.each { |table, column| block.call(table, column) }
+      else
+        block.call(@table_name, input)
+      end
+    end
+
+    def escape_and_join(*parts)
+      if parts.last.is_a?(SafeString)
+        # If a safe string is provided as a column name, we'll
+        # always use this even if a table name is provided too.
+        parts.last
+      else
+        parts.compact.map { |part| escape(part) }.join('.')
+      end
+    end
+
+  end
+end

data/lib/sqb/filtering.rb

@@ -0,0 +1,109 @@
+module SQB
+  module Filtering
+
+    # Add a condition to the query by providing a hash of keys and values.
+    #
+    # @param hash [Hash]
+    # @return [Query]
+    def where(hash)
+      if @where_within_or && @where_within_or.last
+        @where_within_or.last << hash
+      else
+        @where ||= []
+        @where << hash_to_sql(hash, @table_name)
+      end
+      self
+    end
+
+    # Set that all conditions added in this block should be joined using OR
+    # rather than AND.
+    def or(&block)
+      @where_within_or ||= []
+      # Start by making an array within the OR block for this calling
+      @where_within_or << []
+      # Execute the block. All queries to 'where' will be added to the last
+      # array in the chain (created above)
+      block.call
+    ensure
+      # Start work on a full array of SQL fragments for all OR queries
+      @where_within_or_sql ||= []
+      # After each OR call, store up the SQL fragment for all where queries
+      # executed within the block.
+      if w = @where_within_or.pop
+        @where_within_or_sql << w.map do |w|
+          hash_to_sql(w, @table_name)
+        end.join(' OR ')
+      end
+
+      # When there are no fragments in the chain left, add it to the main
+      # where chain for the query.
+      if @where_within_or.empty?
+        @where ||= []
+        @where << "(#{@where_within_or_sql.flatten.join(' OR ')})"
+        @where_within_or_sql = nil
+      end
+      self
+    end
+
+    private
+
+    def hash_to_sql(hash, table, joiner = ' AND ')
+      sql = hash.map do |key, value|
+        if key.is_a?(Hash)
+          table = key.first[0]
+          key = key.first[1]
+        end
+
+        key = escape_and_join(table, key)
+
+        if value.is_a?(Array)
+          escaped_values = value.map { |v| value_escape(v) }.join(', ')
+          "#{key} IN (#{escaped_values})"
+        elsif value.is_a?(Hash)
+          sql = []
+          value.each do |operator, value|
+            case operator
+            when :not_equal
+              if value.nil?
+                sql << "#{key} IS NOT NULL"
+              else
+                sql << "#{key} != #{value_escape(value)}"
+              end
+            when :equal
+              if value.nil?
+                sql << "#{key} IS NULL"
+              else
+                sql << "#{key} = #{value_escape(value)}"
+              end
+            when :less_than
+              sql << "#{key} < #{value_escape(value)}"
+            when :greater_than
+              sql << "#{key} > #{value_escape(value)}"
+            when :less_than_or_equal_to
+              sql << "#{key} <= #{value_escape(value)}"
+            when :greater_than_or_equal_to
+              sql << "#{key} >= #{value_escape(value)}"
+            when :in, :not_in
+              escaped_values = value.map { |v| value_escape(v) }.join(', ')
+              op = operator == :in ? "IN" : "NOT IN"
+              sql << "#{key} #{op} (#{escaped_values})"
+            when :like
+              sql << "#{key} LIKE #{value_escape(value)}"
+            when :not_like
+              sql << "#{key} NOT LIKE #{value_escape(value)}"
+            else
+              raise InvalidOperatorError, "Invalid operator '#{operator}'"
+            end
+          end
+          sql.empty? ? "1=0" : sql.join(joiner)
+        elsif value == nil
+          "#{key} IS NULL"
+        else
+          "#{key} = #{value_escape(value)}"
+        end
+      end.join(joiner)
+      "(#{sql})"
+    end
+
+  end
+end

data/lib/sqb/grouping.rb

@@ -0,0 +1,17 @@
+module SQB
+  module Grouping
+
+    # Add a grouping
+    #
+    # @param column [String, Symbol, Hash]
+    # @return [Query]
+    def group_by(column)
+      @groups ||= []
+      with_table_and_column(column) do |table, column|
+        @groups << escape_and_join(table, column)
+      end
+      self
+    end
+
+  end
+end

data/lib/sqb/insert.rb

@@ -0,0 +1,43 @@
+require 'sqb/base'
+
+module SQB
+  class Insert < Base
+
+    def to_sql
+      [].tap do |query|
+        query << "INSERT INTO"
+        query << escape_and_join(@options[:database_name], @table_name)
+        if @values.nil? || @values.empty?
+          raise NoValuesError, "No values have been specified. Use `value` to add values to the query."
+        end
+        query << "(#{columns.join(', ')})"
+        query << "VALUES"
+        query << "(#{values.join(', ')})"
+      end.join(' ')
+    end
+
+    # Set a value to be inserted
+    #
+    # @param key [String]
+    # @param value [String, nil]
+    def value(hash)
+      @values ||= {}
+      hash.each do |key, value|
+        @values[key] = value
+      end
+      self
+    end
+    alias_method :values, :value
+
+    private
+
+    def columns
+      @values.keys.map { |k| escape(k) }
+    end
+
+    def values
+      @values.values.map { |v| value_escape(v) }
+    end
+
+  end
+end

data/lib/sqb/joins.rb

@@ -0,0 +1,55 @@
+module SQB
+  module Joins
+
+    # Add a join
+    #
+    # @param table_name [String, Symbol]
+    # @param foreign_key [String, Symbol]
+    # @option options [Hash] :where
+    # @option options [Array] :select
+    # @return [Query]
+    def join(table_name, foreign_key, options = {})
+      @joins ||= []
+      @joins_name_mapping ||= {}
+
+      if options[:name]
+        join_name = options[:name]
+      else
+        @joins_name_mapping[table_name] ||= 0
+        join_name= "#{table_name}_#{@joins_name_mapping[table_name]}"
+        @joins_name_mapping[table_name] += 1
+      end
+
+      @joins << [].tap do |query|
+        query << "INNER JOIN"
+        query << escape_and_join(@options[:database_name], table_name)
+        query << "AS"
+        query << escape(join_name)
+        query << "ON"
+        query << escape_and_join(@table_name, 'id')
+        query << "="
+        query << escape_and_join(join_name, foreign_key)
+      end.join(' ')
+
+      if options[:where]
+        join_where = options[:where].each_with_object({}) do |(column, value), hash|
+          hash[{join_name => column}] = value
+        end
+        where(join_where)
+      end
+
+      if columns = options[:columns]
+        for field in columns
+          column({join_name => field}, :as => "#{join_name}_#{field}")
+        end
+      end
+
+      if g = options[:group_by]
+        group_by(join_name => g.is_a?(Symbol) ? g : :id)
+      end
+
+      self
+    end
+
+  end
+end

data/lib/sqb/limiting.rb

@@ -0,0 +1,14 @@
+module SQB
+  module Limiting
+
+    # Limit the number of records return
+    #
+    # @param number [Integer]
+    # @return [Query]
+    def limit(number)
+      @limit = number&.to_i
+      self
+    end
+
+  end
+end

data/lib/sqb/offsetting.rb

@@ -0,0 +1,14 @@
+module SQB
+  module Offsetting
+
+    # Set the offset
+    #
+    # @param number [Integer]
+    # @return [Query]
+    def offset(number)
+      @offset = number&.to_i
+      self
+    end
+
+  end
+end

data/lib/sqb/ordering.rb

@@ -0,0 +1,39 @@
+module SQB
+  module Ordering
+
+    VALID_ORDERS = ['ASC', 'DESC']
+
+    # Add an order column
+    #
+    # @param column [String, Symbol, Hash]
+    # @param direction [String] 'ASC' or 'DESC' (default 'ASC')
+    # @return [Query]
+    def order(column, direction = nil)
+      direction = direction ? direction.to_s.upcase : 'ASC'
+
+      unless VALID_ORDERS.include?(direction)
+        raise InvalidOrderDirectionError, "Invalid order direction #{direction}"
+      end
+
+      @orders ||= []
+
+      with_table_and_column(column) do |table, column|
+        @orders << [escape_and_join(table, column), direction].join(' ')
+      end
+
+      self
+    end
+
+    # Add an order replacing all previous ones
+    def order!(*args)
+      @orders = []
+      order(*args)
+    end
+
+    # Remove all ordering for this query
+    def no_order!
+      @orders = []
+    end
+
+  end
+end

data/lib/sqb/query.rb

@@ -1,375 +1,6 @@
-require 'sqb/error'
+require 'sqb/select'
 
 module SQB
-  class Query
-
-    attr_reader :prepared_arguments
-
-    VALID_ORDERS = ['ASC', 'DESC']
-
-    def initialize(table_name, options = {}, &escape_block)
-      @table_name = table_name
-      @columns = []
-      @joins = []
-      @joins_name_mapping = {}
-      @where = []
-      @orders = []
-      @groups = []
-      @limit = nil
-      @offset = nil
-      @distinct = false
-      @where_within_or = []
-      @options = options
-      @prepared_arguments = []
-
-      if @options[:prepared] == false && escape_block.nil?
-        raise EscapeBlockMissingError, "An escape block must be provided if prepared statements are disabled."
-      else
-        @escape_block = escape_block
-      end
-    end
-
-    # Generate the full SQL query for this query.
-    #
-    # @return [String]
-    def to_sql
-      [].tap do |query|
-        query << "SELECT"
-        query << "DISTINCT" if @distinct
-        if @columns.empty?
-          query << escape_and_join(@table_name, '*')
-        else
-          query << @columns.join(', ')
-        end
-        query << "FROM"
-        query << escape_and_join(@options[:database_name], @table_name)
-
-        unless @joins.empty?
-          query << @joins.join(' ')
-        end
-
-        unless @where.empty?
-          query << "WHERE"
-          query << @where.join(' AND ')
-        end
-
-        unless @groups.empty?
-          query << "GROUP BY"
-          query << @groups.join(', ')
-        end
-
-        unless @orders.empty?
-          query << "ORDER BY"
-          query << @orders.join(', ')
-        end
-
-        if @limit
-          query << "LIMIT #{@limit.to_i}"
-        end
-
-        if @offset
-          query << "OFFSET #{@offset.to_i}"
-        end
-      end.join(' ')
-    end
-
-    # Add a column to the query
-    #
-    # @param column [String, Symbol, Hash] the column name (or a hash with table & column name)
-    # @option options [String] :function a function to wrap around the column
-    # @options options [String] :as the name to return this column as
-    # @return [Query] returns the query
-    def column(column, options = {})
-      with_table_and_column(column) do |table, column|
-        @columns << [].tap do |query|
-          if options[:function]
-            query << "#{escape_function(options[:function])}("
-          end
-          query << escape_and_join(table, column)
-          if options[:function]
-            query << ")"
-          end
-          if options[:as]
-            query << "AS"
-            query << escape(options[:as])
-          end
-        end.join(' ')
-      end
-      self
-    end
-
-    # Replace all existing columns with the given column
-    def column!(*args)
-      @columns = []
-      column(*args)
-    end
-
-    # Add a condition to the query by providing a hash of keys and values.
-    #
-    # @param hash [Hash]
-    # @return [Query]
-    def where(hash)
-      if @where_within_or.last
-        @where_within_or.last << hash
-      else
-        @where << hash_to_sql(hash, @table_name)
-      end
-      self
-    end
-
-    # Set that all conditions added in this block should be joined using OR
-    # rather than AND.
-    def or(&block)
-      # Start by making an array within the OR block for this calling
-      @where_within_or << []
-      # Execute the block. All queries to 'where' will be added to the last
-      # array in the chain (created above)
-      block.call
-    ensure
-      # Start work on a full array of SQL fragments for all OR queries
-      @where_within_or_sql ||= []
-      # After each OR call, store up the SQL fragment for all where queries
-      # executed within the block.
-      if w = @where_within_or.pop
-        @where_within_or_sql << w.map do |w|
-          hash_to_sql(w, @table_name)
-        end.join(' OR ')
-      end
-
-      # When there are no fragments in the chain left, add it to the main
-      # where chain for the query.
-      if @where_within_or.empty?
-        @where << "(#{@where_within_or_sql.flatten.join(' OR ')})"
-        @where_within_or_sql = nil
-      end
-      self
-    end
-
-    # Limit the number of records return
-    #
-    # @param number [Integer]
-    # @return [Query]
-    def limit(number)
-      @limit = number&.to_i
-      self
-    end
-
-    # Set the offset
-    #
-    # @param number [Integer]
-    # @return [Query]
-    def offset(number)
-      @offset = number&.to_i
-      self
-    end
-
-    # Add an order column
-    #
-    # @param column [String, Symbol, Hash]
-    # @param direction [String] 'ASC' or 'DESC' (default 'ASC')
-    # @return [Query]
-    def order(column, direction = nil)
-      direction = direction ? direction.to_s.upcase : 'ASC'
-
-      unless VALID_ORDERS.include?(direction)
-        raise InvalidOrderDirectionError, "Invalid order direction #{direction}"
-      end
-
-      with_table_and_column(column) do |table, column|
-        @orders << [escape_and_join(table, column), direction].join(' ')
-      end
-
-      self
-    end
-
-    # Add an order replacing all previous ones
-    def order!(*args)
-      @orders = []
-      order(*args)
-    end
-
-    # Remove all ordering for this query
-    def no_order!
-      @orders = []
-    end
-
-    # Add a grouping
-    #
-    # @param column [String, Symbol, Hash]
-    # @return [Query]
-    def group_by(column)
-      with_table_and_column(column) do |table, column|
-        @groups << escape_and_join(table, column)
-      end
-      self
-    end
-
-    # Add a join
-    #
-    # @param table_name [String, Symbol]
-    # @param foreign_key [String, Symbol]
-    # @option options [Hash] :where
-    # @option options [Array] :select
-    # @return [Query]
-    def join(table_name, foreign_key, options = {})
-
-      if options[:name]
-        join_name = options[:name]
-      else
-        @joins_name_mapping[table_name] ||= 0
-        join_name= "#{table_name}_#{@joins_name_mapping[table_name]}"
-        @joins_name_mapping[table_name] += 1
-      end
-
-      @joins << [].tap do |query|
-        query << "INNER JOIN"
-        query << escape_and_join(@options[:database_name], table_name)
-        query << "AS"
-        query << escape(join_name)
-        query << "ON"
-        query << escape_and_join(@table_name, 'id')
-        query << "="
-        query << escape_and_join(join_name, foreign_key)
-      end.join(' ')
-
-      if options[:where]
-        join_where = options[:where].each_with_object({}) do |(column, value), hash|
-          hash[{join_name => column}] = value
-        end
-        where(join_where)
-      end
-
-      if columns = options[:columns]
-        for field in columns
-          column({join_name => field}, :as => "#{join_name}_#{field}")
-        end
-      end
-
-      if g = options[:group_by]
-        group_by(join_name => g.is_a?(Symbol) ? g : :id)
-      end
-
-      self
-    end
-
-    def distinct
-      @distinct = true
-      self
-    end
-
-    private
-
-    def hash_to_sql(hash, table, joiner = ' AND ')
-      sql = hash.map do |key, value|
-        if key.is_a?(Hash)
-          table = key.first[0]
-          key = key.first[1]
-        end
-
-        key = escape_and_join(table, key)
-
-        if value.is_a?(Array)
-          escaped_values = value.map { |v| value_escape(v) }.join(', ')
-          "#{key} IN (#{escaped_values})"
-        elsif value.is_a?(Hash)
-          sql = []
-          value.each do |operator, value|
-            case operator
-            when :not_equal
-              if value.nil?
-                sql << "#{key} IS NOT NULL"
-              else
-                sql << "#{key} != #{value_escape(value)}"
-              end
-            when :equal
-              if value.nil?
-                sql << "#{key} IS NULL"
-              else
-                sql << "#{key} = #{value_escape(value)}"
-              end
-            when :less_than
-              sql << "#{key} < #{value_escape(value)}"
-            when :greater_than
-              sql << "#{key} > #{value_escape(value)}"
-            when :less_than_or_equal_to
-              sql << "#{key} <= #{value_escape(value)}"
-            when :greater_than_or_equal_to
-              sql << "#{key} >= #{value_escape(value)}"
-            when :in, :not_in
-              escaped_values = value.map { |v| value_escape(v) }.join(', ')
-              op = operator == :in ? "IN" : "NOT IN"
-              sql << "#{key} #{op} (#{escaped_values})"
-            when :like
-              sql << "#{key} LIKE #{value_escape(value)}"
-            when :not_like
-              sql << "#{key} NOT LIKE #{value_escape(value)}"
-            else
-              raise InvalidOperatorError, "Invalid operator '#{operator}'"
-            end
-          end
-          sql.empty? ? "1=0" : sql.join(joiner)
-        elsif value == nil
-          "#{key} IS NULL"
-        else
-          "#{key} = #{value_escape(value)}"
-        end
-      end.join(joiner)
-      "(#{sql})"
-    end
-
-    def escape(name)
-      if name.is_a?(SafeString)
-        name
-      else
-        "`#{name.to_s.gsub('`', '``')}`"
-      end
-    end
-
-    def escape_function(name)
-      if name.is_a?(SafeString)
-        name
-      else
-        name.to_s.gsub(/[^a-z0-9\_]/i, '').upcase
-      end
-    end
-
-    def value_escape(value)
-      if value == true
-        1
-      elsif value == false
-        0
-      elsif value.nil?
-        'NULL'
-      elsif value.is_a?(Integer)
-        value.to_i
-      else
-        if @options[:prepared] == false
-          escaped_value = @escape_block ? @escape_block.call(value.to_s) : value.to_s
-          "'" + escaped_value + "'"
-        else
-          @prepared_arguments << value.to_s
-          '?'
-        end
-      end
-    end
-
-    def with_table_and_column(input, &block)
-      if input.is_a?(Hash)
-        input.each { |table, column| block.call(table, column) }
-      else
-        block.call(@table_name, input)
-      end
-    end
-
-    def escape_and_join(*parts)
-      if parts.last.is_a?(SafeString)
-        # If a safe string is provided as a column name, we'll
-        # always use this even if a table name is provided too.
-        parts.last
-      else
-        parts.compact.map { |part| escape(part) }.join('.')
-      end
-    end
-
+  class Query < Select
   end
 end

data/lib/sqb/safe_string.rb

@@ -1,5 +1,4 @@
 module SQB
   class SafeString < String
-
   end
 end

data/lib/sqb/select.rb

@@ -0,0 +1,66 @@
+require 'sqb/base'
+require 'sqb/distinct'
+require 'sqb/columns'
+require 'sqb/filtering'
+require 'sqb/joins'
+require 'sqb/ordering'
+require 'sqb/grouping'
+require 'sqb/limiting'
+require 'sqb/offsetting'
+
+module SQB
+  class Select < Base
+
+    include SQB::Distinct
+    include SQB::Columns
+    include SQB::Filtering
+    include SQB::Joins
+    include SQB::Ordering
+    include SQB::Grouping
+    include SQB::Limiting
+    include SQB::Offsetting
+
+    def to_sql
+      [].tap do |query|
+        query << "SELECT"
+        query << "DISTINCT" if @distinct
+        if @columns.nil? || @columns.empty?
+          query << escape_and_join(@table_name, '*')
+        else
+          query << @columns.join(', ')
+        end
+
+        query << "FROM"
+        query << escape_and_join(@options[:database_name], @table_name)
+
+        if @joins && !@joins.empty?
+          query << @joins.join(' ')
+        end
+
+        if @where && !@where.empty?
+          query << "WHERE"
+          query << @where.join(' AND ')
+        end
+
+        if @groups && !@groups.empty?
+          query << "GROUP BY"
+          query << @groups.join(', ')
+        end
+
+        if @orders && !@orders.empty?
+          query << "ORDER BY"
+          query << @orders.join(', ')
+        end
+
+        if @limit
+          query << "LIMIT #{@limit.to_i}"
+        end
+
+        if @offset
+          query << "OFFSET #{@offset.to_i}"
+        end
+      end.join(' ')
+    end
+
+  end
+end

data/lib/sqb/update.rb

@@ -0,0 +1,52 @@
+require 'sqb/base'
+require 'sqb/filtering'
+require 'sqb/limiting'
+
+module SQB
+  class Update < Base
+
+    include SQB::Filtering
+    include SQB::Limiting
+
+    def to_sql
+      [].tap do |query|
+        query << "UPDATE"
+        query << escape_and_join(@options[:database_name], @table_name)
+        query << "SET"
+        if @sets && !@sets.empty?
+          query << @sets.map do |key, value|
+            "#{escape_and_join(@table_name, key)} = #{value_escape(value)}"
+          end.join(', ')
+        else
+          raise NoValuesError, "No values have been updated. Use `set` to set the values to update."
+        end
+
+        if @where && !@where.empty?
+          query << "WHERE"
+          query << @where.join(' AND ')
+        end
+
+        if @limit
+          query << "LIMIT #{@limit.to_i}"
+        end
+
+        if @offset
+          query << "OFFSET #{@offset.to_i}"
+        end
+      end.join(' ')
+    end
+
+    # Set a value to be updated
+    #
+    # @param key [String]
+    # @param value [String, nil]
+    def set(hash)
+      @sets ||= {}
+      hash.each do |key, value|
+        @sets[key] = value
+      end
+      self
+    end
+
+  end
+end

data/lib/sqb/version.rb

@@ -1,3 +1,3 @@
 module SQB
-  VERSION = '1.0.2'
+  VERSION = '1.0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqb
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-27 00:00:00.000000000 Z
+date: 2018-02-28 00:00:00.000000000 Z
 dependencies: []
 description: A friendly SQL builder for MySQL.
 email:
@@ -18,9 +18,23 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/sqb.rb
+- lib/sqb/base.rb
+- lib/sqb/columns.rb
+- lib/sqb/delete.rb
+- lib/sqb/distinct.rb
 - lib/sqb/error.rb
+- lib/sqb/escaping.rb
+- lib/sqb/filtering.rb
+- lib/sqb/grouping.rb
+- lib/sqb/insert.rb
+- lib/sqb/joins.rb
+- lib/sqb/limiting.rb
+- lib/sqb/offsetting.rb
+- lib/sqb/ordering.rb
 - lib/sqb/query.rb
 - lib/sqb/safe_string.rb
+- lib/sqb/select.rb
+- lib/sqb/update.rb
 - lib/sqb/version.rb
 homepage: https://github.com/adamcooke/sqb
 licenses: