sqb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 44f58ba5485e199e6364aa99556e1a7b2ea8bb5520ff6f5059bff7dcc96df8c2
+  data.tar.gz: 8ae30d22f80255a79f13e0a372c65e62666202ec1c85f8a270a1bba75da96c99
+SHA512:
+  metadata.gz: 2d4bfa140701dfa6de3528106148c238e9be0e025ed11a1c857b9c795e54734491a3d582f8aed3ab2b73c0aec14c00e4044aca92aa9b180d5f721388fd9bacb8
+  data.tar.gz: 13405cee8bf220248ae53c9d6eb8aac63d142cbb7a9b9f8f33cccbed95b89857d0f31312b858ed57aebc5eeca7b03bbeca3d75abc02a266430f3730503b8276b

data/lib/sqb/error.rb

@@ -0,0 +1,4 @@
+module SQB
+  class Error < StandardError
+  end
+end

data/lib/sqb/query.rb

@@ -0,0 +1,346 @@
+require 'sqb/error'
+
+module SQB
+  class Query
+
+    VALID_ORDERS = ['ASC', 'DESC']
+
+    def initialize(table_name, &escape_block)
+      @table_name = table_name
+      @columns = []
+      @joins = []
+      @joins_name_mapping = {}
+      @where = []
+      @orders = []
+      @groups = []
+      @limit = nil
+      @offset = nil
+      @distinct = false
+      @where_within_or = []
+      @escape_block = escape_block
+    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 << column_tuple(@table_name, '*')
+        else
+          query << @columns.join(', ')
+        end
+        query << "FROM"
+        query << escape(@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 << column_tuple(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
+    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 Error, "Invalid order direction #{direction}"
+      end
+
+      with_table_and_column(column) do |table, column|
+        @orders << [column_tuple(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 << column_tuple(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(table_name)
+        query << "AS"
+        query << escape(join_name)
+        query << "ON"
+        query << column_tuple(@table_name, 'id')
+        query << "="
+        query << column_tuple(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 = column_tuple(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})"
+            else
+              raise Error, "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)
+      "`#{name.to_s.gsub('`', '``')}`"
+    end
+
+    def escape_function(name)
+      name.to_s.gsub(/[^a-z0-9\_]/i, '').upcase
+    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 value.to_s.length == 0
+          'NULL'
+        else
+          escaped_value = @escape_block ? @escape_block.call(value.to_s) : value.to_s
+          "'" + escaped_value + "'"
+        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.to_sym)
+      end
+    end
+
+    def column_tuple(table, column)
+      [escape(table), escape(column)].join('.')
+    end
+
+  end
+end

data/lib/sqb/version.rb

@@ -0,0 +1,3 @@
+module SQB
+  VERSION = '1.0.0'
+end

data/lib/sqb.rb

@@ -0,0 +1,2 @@
+require 'sqb/query'
+require 'sqb/version'

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: sqb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-26 00:00:00.000000000 Z
+dependencies: []
+description: A friendly SQL builder for MySQL.
+email:
+- me@adamcooke.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sqb.rb
+- lib/sqb/error.rb
+- lib/sqb/query.rb
+- lib/sqb/version.rb
+homepage: https://github.com/adamcooke/sqb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.4
+signing_key: 
+specification_version: 4
+summary: This gem provides a friendly DSL for constructing MySQL queries.
+test_files: []