sql_builder 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c310ff0fcce5f5e392e9e8ec98895fe44224154c80d6681b83fb9565a9366af7
+  data.tar.gz: 79f2fc22344f7d1d4984d66f107e828d2ab386dd99c37e1b924b3a7499ee0996
+SHA512:
+  metadata.gz: f3618224985c8813acc7098aa036028d4796c4a59af20d16170af46cb6ecaabf790c1d0b93d5677ff5c0988835b1f51246c1f6b4b9851ec2e4163def2f0485dc
+  data.tar.gz: 7a56ce17bf57b650dbac08e6d9b4dcc0e2dc2c4b9c02950adcb3dd7076aba67436ae6b33829531879624dd99f4d3f704a9cab9d7a43955e1ad7de90210d7625d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/

data/.rakeTasks

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Settings><!--This file was automatically generated by Ruby plugin.
+You are allowed to: 
+1. Remove rake task
+2. Add existing rake tasks
+To add existing rake tasks automatically delete this file and reload the project.
+--><RakeGroup description="" fullCmd="" taksId="rake"><RakeTask description="Build sql_builder-0.1.0.gem into the pkg directory" fullCmd="build" taksId="build" /><RakeTask description="Remove any temporary products" fullCmd="clean" taksId="clean" /><RakeTask description="Remove any generated files" fullCmd="clobber" taksId="clobber" /><RakeTask description="Build and install sql_builder-0.1.0.gem into system gems" fullCmd="install" taksId="install" /><RakeGroup description="" fullCmd="" taksId="install"><RakeTask description="Build and install sql_builder-0.1.0.gem into system gems without network access" fullCmd="install:local" taksId="local" /></RakeGroup><RakeTask description="Create tag v0.1.0 and build and push sql_builder-0.1.0.gem to rubygems.org" fullCmd="release[remote]" taksId="release[remote]" /><RakeTask description="Run tests" fullCmd="test" taksId="test" /><RakeTask description="" fullCmd="default" taksId="default" /><RakeTask description="" fullCmd="release" taksId="release" /><RakeGroup description="" fullCmd="" taksId="release"><RakeTask description="" fullCmd="release:guard_clean" taksId="guard_clean" /><RakeTask description="" fullCmd="release:rubygem_push" taksId="rubygem_push" /><RakeTask description="" fullCmd="release:source_control_push" taksId="source_control_push" /></RakeGroup></RakeGroup></Settings>

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.6.8

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 1.17.3

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in sql_builder.gemspec
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    sql_builder (1.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.0.4)
+      activesupport (= 6.0.4)
+    activerecord (6.0.4)
+      activemodel (= 6.0.4)
+      activesupport (= 6.0.4)
+    activesupport (6.0.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    concurrent-ruby (1.1.9)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.3)
+    pg (0.21.0)
+    rake (13.0.3)
+    thread_safe (0.3.6)
+    tzinfo (1.2.9)
+      thread_safe (~> 0.1)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 5.2)
+  bundler (~> 2.1)
+  minitest (~> 5.0)
+  pg (~> 0.18)
+  rake (~> 13)
+  sql_builder!
+
+BUNDLED WITH
+   2.3.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Andy Selvig
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,156 @@
+# SqlBuilder
+
+SqlBuilder is a small, simple Ruby library that lets you compose SQL queries using a fluent, builder syntax.
+
+This is *not* an ORM and does require any schema definition or mapping. 
+You simply specify a query and SqlBuilder will generate an ad-hoc, read-only Ruby class to represent the result.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sql_builder', git: 'git@github.com:Terrier-Tech/sql_builder.git'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+SqlBuilder uses a chainable builder syntax to make constructing queries more flexible than using plain strings. 
+It also automatically handles things like applying prefixes to column names and managing aliases.
+
+```ruby
+# sql builder example
+locs = SqlBuilder.new
+  .select(%w(city state), 'loc', 'location_') # columns, table alias, prefix
+  .select(%w(first_name last_name), 'tech', 'technician_') 
+  .from('locations', 'loc') # table name, alias
+  .left_join('users', 'tech', 'tech.id = loc.primary_technician_id') # table name, alias, clause
+  .where("loc.zip = ?", '55124') # plain string clause
+  .where("tech.first_name = ?", 'Billy')
+  .exec
+
+# returns an array of POROs with attributes location_city, location_state, 
+# technician_first_name, technician_last_name
+locs.each do |loc|
+  puts "#{loc.technician_first_name} in #{loc.location_city}" 
+end
+```
+
+Attribute types will be automatically inferred from the names, including converting from cents to dollars.
+
+Since SqlBuilder stores all of the components of the query and is a plain Ruby object, it can also be composed conditionally:
+
+```ruby
+builder = SqlBuilder.new
+  .select(%w(first_name last_name), 'tech')
+  .from('users', 'tech')
+  .where('tech._state = 0')
+  .where("tech.role = ?", 'technician')
+
+if branch_id
+  builder.where("tech.branch_id = ?", branch_id)
+end
+
+techs = builder.exec
+```
+
+
+### Important Notes
+
+First, **SqlBuilder now sanitizes input!**, this utilizes ActiveRecord's(v4.2) ```sanitize_sql_array``` method to do the heavy lifting. You may opt for a more recent version of ActiveRecord in which case it will use the ```sanitize``` method.
+
+Second, SqlBuilder assumes you have ActiveRecord around in order to use `SqlBuilder#exec`.
+If this isn't the case, you can always get the raw SQL using `SqlBuilder#to_sql`. 
+
+### Joins
+
+SqlBuilder offers 4 join commands `left_join`, `inner_join`, `outer_join`, and `right_join`.  Any of these can take one of three combinations of arguments (all strings):
+
+```ruby
+# base_query
+inspection_items = SqlBuilder.new
+    .select('inspection_items.*')
+    
+# the following three examples will add the following join clause: INNER JOIN work_orders AS wo ON wo.id = inspection_items.work_order_id
+# three args can be used to add any join (parent or child)
+inspection_items.inner_join('work_orders', 'wo', 'wo.id = inspection_items.work_order_id')
+
+# two args can only be used to add a parent table join
+inspection_items.inner_join('work_orders AS wo', 'inspection_items.work_order_id')
+
+# one arg can only be used to add a parent table join
+inspection_items.inner_join('work_orders AS wo')
+
+
+# note that the 2 arg variation can be used to join a table that does not have a traditional foreign_key
+work_orders = SqlBuilder.new
+    .select('work_orders.*')
+
+work_orders.inner_join('users', 'work_orders.technician_id')
+```
+
+
+### Computed Columns
+
+You can compute additional columns on the result set. 
+Use the `compute_column` method with the name of the new column and a block that accepts each row: 
+
+```ruby
+locs.compute_column 'age' do |row|
+  Time.now - row.created_at
+end
+```
+
+Alternatively, you can use `compute_columns` to compute multiple columns at once: 
+
+```ruby
+locs.compute_columns do |row|
+  geo = row.geo.parse_geo_point
+  {latitude: geo.latitude, longitude: geo.longitude}
+end
+```
+
+### as_raw
+
+Optionally, you can call the `as_raw' method on a SqlBuilder instance to have it return hashes instead of objects as the result: 
+
+```ruby
+locs = SqlBuilder.new
+  .select(%w(city state), 'loc', 'location_')
+  .select(%w(first_name last_name), 'tech', 'technician_') 
+  .from('locations')
+  .inner_join('users', 'tech', 'tech.id = loc.primary_technician_id')
+  .where("zip = ?", '55124')
+  .as_raw
+  .exec
+
+locs.each do |loc|
+  puts "#{loc['technician_first_name']} in #{loc['location_city']}"
+end
+```
+
+NOTE: for historical reasons, `.as_raw` is enabled by default in Clypboard. Use `.as_objects` to enable the Ruby object generation.
+
+### Dialects
+
+Currently, SqlBuilder only supports PostgresQL and MS-SQL dialects.
+You can set the dialect by calling `SqlBuilder#dialect` with either `:psql` (default) or `mssql`.
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Terrier-Tech/sql_builder. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sql/builder"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sql_builder/query_result.rb

@@ -0,0 +1,383 @@
+require_relative './query_row'
+
+# wraps the result of a SQL query into a container of objects
+# a new QueryResult will contain an array of objects implementing a
+# custom class derived from QueryRow containing convenience methods to access values
+class QueryResult
+
+  attr_reader :columns, :column_types
+
+  def initialize(raw)
+    @columns = []
+    @column_types = {}
+    if raw.empty?
+      @array = raw
+    else
+      @row_class = create_row_class raw.first
+      @array = raw.map do |raw_row|
+        @row_class.new self, raw_row
+      end
+    end
+  end
+
+  def each
+    return @array.to_enum(:each) unless block_given?
+    @array.each do |row|
+      yield row
+    end
+  end
+
+  def map
+    return @array.to_enum(:map) unless block_given?
+    @array.map do |row|
+      yield row
+    end
+  end
+
+  def select
+    return @array.to_enum(:select) unless block_given?
+    @array.select do |row|
+      yield row
+    end
+  end
+
+  def group_by
+    return @array.to_enum(:group_by) unless block_given?
+    @array.group_by do |row|
+      yield row
+    end
+  end
+
+  def index_by
+    return @array.to_enum(:index_by) unless block_given?
+    @array.index_by do |row|
+      yield row
+    end
+  end
+
+  def sort_by
+    self.to_a.sort_by
+  end
+
+  def to_a
+    @array
+  end
+
+  def count
+    @array.count
+  end
+
+  def length
+    @array.count
+  end
+
+  def first
+    @array.first
+  end
+
+  def empty?
+    @array.empty?
+  end
+
+  def column_names
+    @columns.map{|c| c[:name]}
+  end
+
+  def set_column_type(column, type)
+    unless self.column_names.index column.to_s
+      raise "No column '#{column}' in the result"
+    end
+    unless COLUMN_TYPES.index type.to_sym
+      raise "Invalid column type '#{type}', must be one of #{COLUMN_TYPES.map(&:to_s).join(', ')}"
+    end
+    @column_types[column.to_s] = type
+    define_column_method @row_class, column.to_s
+  end
+
+  def set_column_order(order)
+    new_columns = []
+    order.each do |name|
+      @columns.each do |set|
+        if set[:name] == name
+          new_columns.append set
+        end
+      end
+    end
+    @columns = new_columns
+  end
+
+  def as_json(options={})
+    @array.map do |row|
+      row.as_json options
+    end
+  end
+
+  def to_csv
+    return '' if @array.empty?
+    CSV.generate do |csv|
+      csv << column_names
+      self.each do |row|
+        csv << @columns.map{|col| row.serialize_value(col)}
+      end
+    end
+  end
+
+  # computes a new column by evaluating a block for every row
+  def compute_column(name, type=nil)
+    return unless @row_class # empty result
+    name_s = name.to_s
+    define_column_method @row_class, name_s, type
+    each do |row|
+      new_val = yield row
+      row.send "#{name}=", new_val
+    end
+  end
+
+  # computes new columns by evaluating a block for every row
+  # the block should return a hash of new column values
+  def compute_columns
+    return unless @row_class # empty result
+    columns_defined = @columns.pluck(:name).map { |key| [key.to_s, true] }.to_h
+    each do |row|
+      new_vals = yield row
+      new_vals.each_key do |name|
+        name=name.to_s
+        unless columns_defined[name]
+          define_column_method @row_class, name
+          columns_defined[name]=true
+        end
+      end
+      new_vals.each do |key, val|
+        row.send "#{key}=", val
+      end
+    end
+  end
+
+  def remove_column(name)
+    @columns.delete_if {|c| c[:name] == name.to_s}
+  end
+
+  TRUE_STRINGS = %w(1 true t)
+
+  COLUMN_TYPES = %i(raw array bool dollars time date integer float json geo string)
+
+  def define_column_method(row_class, name, type=nil)
+    name_s = name.to_s
+    type ||= @column_types[name_s] || QueryResult.column_type(name_s)
+    unless COLUMN_TYPES.index type.to_sym
+      raise "Invalid column type '#{type}', must be one of #{COLUMN_TYPES.map(&:to_s).join(', ')}"
+    end
+    @columns << {name: name_s, type: type}
+    case type
+    when :raw
+      row_class.define_method name do
+        self.instance_variable_get('@raw')[name_s]
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val
+      end
+    when :array
+      row_class.define_method name do
+        val = self.instance_variable_get('@raw')[name_s]
+        if val.is_a? String
+          # this might not be the best implementation
+          val.gsub('{', '').gsub('}', '').gsub('"', '').split(',')
+        else
+          val
+        end
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val
+      end
+    when :bool
+      row_class.define_method name do
+        raw = self.instance_variable_get('@raw')[name_s]
+        TRUE_STRINGS.include?(raw.to_s.downcase)
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = TRUE_STRINGS.include?(val.to_s.downcase)
+      end
+    when :dollars
+      row_class.define_method name do
+        self.instance_variable_get('@raw')[name_s].to_i/100.0
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = ((val || 0)*100).to_i
+      end
+    when :time
+      row_class.define_method name do
+        raw_time = self.instance_variable_get('@raw')[name_s]
+        case raw_time
+        when String
+          # always return times in the local timezone
+          if SqlBuilder.default_timezone == :local
+            time = Time.parse raw_time
+          else # assume database times are in UTC
+            time = raw_time.in_time_zone('UTC').getlocal
+          end
+          self.instance_variable_get('@raw')[name_s] = time
+          time
+        else
+          raw_time
+        end
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val
+      end
+    when :date
+      row_class.define_method name do
+        raw_date = self.instance_variable_get('@raw')[name_s]
+        case raw_date
+        when String
+          date = Date.parse(raw_date)
+          self.instance_variable_get('@raw')[name_s] = date
+          date
+        else
+          raw_date
+        end
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val
+      end
+    when :integer
+      row_class.define_method name do
+        raw = self.instance_variable_get('@raw')[name_s]
+        if raw.blank?
+          nil
+        elsif raw.is_a? Integer
+          raw
+        elsif raw =~ /^-*\d+$/
+          i = raw.to_i
+          self.instance_variable_get('@raw')[name_s] = i
+          i
+        else
+          raw
+        end
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val.to_i
+      end
+    when :float
+      row_class.define_method name do
+        self.instance_variable_get('@raw')[name_s].to_f
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val.to_f
+      end
+    when :json
+      row_class.define_method name do
+        raw = self.instance_variable_get('@raw')[name_s]
+        raw ? JSON.parse(raw) : nil
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val&.as_json
+      end
+    when :geo
+      row_class.define_method name do
+        self.instance_variable_get('@raw')[name_s]&.parse_geo_point
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val
+      end
+    else # string
+      row_class.define_method name do
+        self.instance_variable_get('@raw')[name_s]
+      end
+      row_class.define_method "#{name}=" do |val|
+        self.instance_variable_get('@raw')[name_s] = val.to_s
+      end
+    end
+  end
+
+
+  private
+
+  ARRAY_SUFFIXES = %w(_array tags ies recipients _ids)
+  BOOL_PREFIXES = %w(is_)
+  RAW_SUFFIXES = %w(_items lanes certs)
+  DOLLARS_SUFFIXES = %w(price dollars total tax _value amount balance)
+  TIME_SUFFIXES = %w(_at time)
+  DATE_SUFFIXES = %w(_date)
+  INTEGER_EXACT = %w(x y value)
+  INTEGER_SUFFIXES = %w(number count duration _i)
+  INTEGER_PREFIXES = %w(days_since days_until)
+  FLOAT_SUFFIXES = %w(_m _miles distance latitude longitude _score _f)
+  JSON_SUFFIXES = %w(object_array json_array json weather)
+  GEO_SUFFIXES = %w(geo)
+
+  def self.column_type(key)
+    key_s = key.to_s
+    if key_s == '_state'
+      return :integer
+    end
+    RAW_SUFFIXES.each do |suffix|
+      if key_s.end_with?(suffix)
+        return :raw
+      end
+    end
+    JSON_SUFFIXES.each do |suffix| # do json before arrays so we can use *object_array and *json_array
+      if key_s.end_with?(suffix)
+        return :json
+      end
+    end
+    ARRAY_SUFFIXES.each do |suffix|
+      if key_s.end_with?(suffix)
+        return :array
+      end
+    end
+    BOOL_PREFIXES.each do |suffix|
+      if key_s.start_with?(suffix)
+        return :bool
+      end
+    end
+    DOLLARS_SUFFIXES.each do |suffix|
+      if key_s.end_with?(suffix)
+        return :dollars
+      end
+    end
+    TIME_SUFFIXES.each do |suffix|
+      if key_s.end_with?(suffix)
+        return :time
+      end
+    end
+    DATE_SUFFIXES.each do |suffix|
+      if key_s.end_with?(suffix)
+        return :date
+      end
+    end
+    if INTEGER_EXACT.index(key_s)
+      return :integer
+    end
+    INTEGER_SUFFIXES.each do |suffix|
+      if key_s.end_with?(suffix)
+        return :integer
+      end
+    end
+    INTEGER_PREFIXES.each do |prefix|
+      if key_s.start_with?(prefix)
+        return :integer
+      end
+    end
+    FLOAT_SUFFIXES.each do |suffix|
+      if key_s.end_with?(suffix)
+        return :float
+      end
+    end
+    GEO_SUFFIXES.each do |suffix|
+      if key_s.end_with?(suffix)
+        return :geo
+      end
+    end
+    :string
+  end
+
+  def create_row_class(template)
+    this = self
+    Class.new QueryRow do
+      template.each do |key, value|
+        this.define_column_method self, key
+      end
+    end
+  end
+
+end

data/lib/sql_builder/query_row.rb

@@ -0,0 +1,50 @@
+# base class for objects representing a single row in a query result
+class QueryRow
+
+  attr_reader :raw
+
+  def initialize(result, raw)
+    @result = result
+    @raw = raw
+  end
+
+  def [](key)
+    @raw[key.to_s]
+  end
+
+  def []=(key, value)
+    @raw[key.to_s] = value
+  end
+
+  def inspect
+    '{' + @result.columns.map{|col| "#{col[:name]}=#{self.send(col[:name])}"}.join(', ') + '}'
+  end
+
+  def serialize_value(column)
+    value = self.send(column[:name])
+    case column[:type]
+    when :time
+      value&.to_s
+    else
+      value
+    end
+  end
+
+  def as_json(options={})
+    attrs = {}
+    @result.columns.each do |col|
+      attrs[col[:name]] = self.serialize_value col
+    end
+    attrs
+  end
+
+  def keys
+    @result.column_names
+  end
+
+  # this is needed so that we can call defined_method outside of the subclass definition
+  class << self
+    public :define_method
+  end
+
+end

data/lib/sql_builder/version.rb

@@ -0,0 +1,5 @@
+module Sql
+  module Builder
+    VERSION = "1.3.0"
+  end
+end

data/lib/sql_builder.rb

@@ -0,0 +1,329 @@
+require "sql_builder/version"
+require "sql_builder/query_result"
+require "active_record"
+
+# Monkey Patch
+module ActiveRecord
+  class Base
+    class << self
+      public :sanitize_sql_array
+    end
+  end
+end
+
+# provides a builder interface for creating SQL queries
+class SqlBuilder
+  DEFAULT_LIMIT = 10000
+
+  # attributes that are arrays and should be included in serialization
+  ARRAY_ATTRS = %w[selects clauses distincts froms joins order_bys group_bys havings withs]
+
+  attr_accessor(*ARRAY_ATTRS)
+
+  # attributes that are scalars and should be included in serialization
+  SCALAR_ATTRS = %w[the_limit make_objects row_offset fetch_next the_dialect]
+  attr_accessor(*SCALAR_ATTRS)
+
+  @@default_make_objects = true
+
+  def self.default_make_objects=(val)
+    @@default_make_objects = val
+  end
+
+  class << self
+    # This should mimic the behavior of ActiveRecord::Base.default_timezone
+    # i.e. it's either :utc (default) or :local
+    attr_accessor :default_timezone
+
+    @default_timezone = :utc
+  end
+
+  def initialize
+    ARRAY_ATTRS.each do |attr|
+      self.send "#{attr}=", []
+    end
+
+    @make_objects = @@default_make_objects
+    @the_limit = DEFAULT_LIMIT
+    @limit_warning = true
+    @row_offset = nil
+    @fetch_next = nil
+    @the_dialect = :psql
+  end
+
+
+  ## Dialects
+
+  DIALECTS = %i(psql mssql)
+
+  def dialect(new_dialect=nil)
+    if new_dialect.nil?
+      return @the_dialect # make this method act like a getter as well
+    end
+    new_dialect = new_dialect.to_sym
+    unless DIALECTS.index new_dialect
+      raise "Invalid dialect #{new_dialect}, must be one of: #{DIALECTS.join(', ')}"
+    end
+    @the_dialect = new_dialect
+    self
+  end
+
+  def from(table, as=nil)
+    if as
+      @froms << "#{table} AS #{as}"
+    else
+      @froms << table
+    end
+    self
+  end
+
+  def select(columns, table=nil, prefix=nil)
+    columns = [columns] unless columns.is_a? Array
+    table_part = table ? "#{table}." : ''
+    columns.each do |c|
+      statement = "#{table_part}#{c}"
+      if prefix
+        statement += " #{prefix}#{c}"
+      end
+      @selects << statement
+    end
+    self
+  end
+
+  def with(w)
+    @withs << w
+    self
+  end
+
+  def get_join_mode_vars(arg1, arg2, arg3)
+    # 1 and 2 arg options can only join parent tables
+    if arg2.nil? && arg3.nil?
+      # 'work_orders AS wo'
+      table = arg1.split(' ').first
+      as = arg1.split(' ').last
+
+      if self.froms.blank?
+        raise 'must declare a from statement to use 1 argument join'
+      end
+      child_table = self.froms.first.split(' ').last
+      foreign_key = "#{table.singularize}_id"
+      clause = "#{child_table}.#{foreign_key} = #{as}.id"
+    elsif arg3.nil?
+      # 'work_orders AS wo', 'inspection_items.work_order_id'
+      table = arg1.split(' ').first
+      as = arg1.split(' ').last
+      clause = "#{as}.id = #{arg2}"
+    else
+      table = arg1
+      as = arg2
+      clause = arg3
+    end
+    [table, as, clause]
+  end
+
+
+  def left_join(arg1, arg2=nil, arg3=nil)
+    table, as, clause = get_join_mode_vars arg1, arg2, arg3
+    @joins << "LEFT JOIN #{table} AS #{as} ON #{clause}"
+    self
+  end
+
+  def inner_join(arg1, arg2=nil, arg3=nil)
+    table, as, clause = get_join_mode_vars arg1, arg2, arg3
+    @joins << "INNER JOIN #{table} AS #{as} ON #{clause}"
+    self
+  end
+
+  def outer_join(arg1, arg2=nil, arg3=nil)
+    table, as, clause = get_join_mode_vars arg1, arg2, arg3
+    @joins << "LEFT OUTER JOIN #{table} AS #{as} ON #{clause}"
+    self
+  end
+
+  def right_join(arg1, arg2=nil, arg3=nil)
+    table, as, clause = get_join_mode_vars arg1, arg2, arg3
+    @joins << "RIGHT JOIN #{table} AS #{as} ON #{clause}"
+    self
+  end
+
+  def parse_where(clause)
+    clause.each_with_index do |entry, i|
+      if entry.is_a?(Array)
+        template = clause[0].split('?')
+        template = template.map.with_index {|phrase, index| index==i-1 ? phrase : phrase+'?' }
+        template.insert(i, '('+('?'*entry.length).split('').join(',')+')')
+        clause[0] = template.join('')
+        clause.delete_at(i)
+        clause.insert(i, *entry)
+      end
+    end
+  end
+
+  # Adds a where clause without any sanitization or substitution
+  # This is essentially for clauses containing a `?`
+  def where_raw(clause)
+    @clauses << clause
+    self
+  end
+
+  def where(*clause)
+    @clauses << sanitize(parse_where(clause))
+    self
+  end
+
+  def having(clause)
+    @havings << clause
+    self
+  end
+
+  def group_by(expression)
+    @group_bys << expression
+    self
+  end
+
+  def order_by(expression)
+    @order_bys << expression
+    self
+  end
+
+  def limit(limit, limit_warning=false)
+    @limit_warning = limit_warning
+    @the_limit = limit
+    self
+  end
+
+  def offset(offset)
+    @row_offset = offset
+    self
+  end
+
+  def fetch(fetch)
+    @fetch_next = fetch
+    self
+  end
+
+  def distinct(distinct, table=nil)
+    distinct = [distinct] unless distinct.is_a? Array
+    table_part = table ? "#{table}." : ''
+    distinct.each do |d|
+      statement = "#{table_part}#{d}"
+      @distincts << statement
+    end
+    self
+  end
+
+  def to_sql
+    _distinct = ''
+    if @distincts and @distincts.count > 0
+      if @the_dialect == :mssql
+        _distinct += 'DISTINCT ('
+        _distinct += @distincts.join(', ')
+        _distinct += ')'
+      else
+        _distinct += 'DISTINCT ON ('
+        _distinct += @distincts.join(', ')
+        _distinct += ')'
+      end
+    end
+
+    withs_s = @withs.map do |w|
+      "WITH #{w}"
+    end.join(' ')
+
+    top_s = if @the_limit && @the_dialect == :mssql
+      "TOP #{@the_limit}"
+    else
+      ''
+    end
+
+    froms_s = @froms.empty? ? '' : "FROM #{@froms.join(', ')}"
+
+    s = "#{withs_s} SELECT #{top_s} #{_distinct} #{@selects.join(', ')} #{froms_s} #{@joins.join(' ')}"
+    if @clauses.length > 0
+      clauses_s = @clauses.map{|c| "(#{c})"}.join(' AND ')
+      s += "  WHERE #{clauses_s}"
+    end
+    if @group_bys.length > 0
+      s += " GROUP BY #{@group_bys.join(', ')}"
+    end
+    if @havings.length > 0
+      s += " HAVING #{@havings.join(' AND ')}"
+    end
+    if @order_bys.length > 0
+      s += " ORDER BY #{@order_bys.join(', ')}"
+    end
+    if @the_limit && @the_dialect != :mssql
+      s += " LIMIT #{@the_limit}"
+    end
+    if @row_offset && @the_dialect == :mssql
+      s += " OFFSET #{@row_offset} ROWS"
+    elsif @row_offset
+      s += " OFFSET #{@row_offset}"
+    end
+    if @fetch_next && @the_dialect == :mssql
+      s += " FETCH NEXT #{@fetch_next} ROWS ONLY"
+    elsif @fetch_next
+      s += " FETCH FIRST #{@fetch_next} ROWS ONLY"
+    end
+    s
+  end
+
+  def sanitize(query)
+    query.each_with_index do |entry, i| #need to escape %
+      if entry.is_a?(String)
+        query[i] = entry.gsub('%', '%%')
+      end
+    end
+    if ActiveRecord::Base.respond_to? :sanitize_sql
+      ActiveRecord::Base.sanitize_sql query
+    else
+      ActiveRecord::Base.sanitize_sql_array query
+    end
+  end
+
+  def check_result_limit!(query)
+    if query.count == @the_limit and @limit_warning
+      raise "Query result has exactly #{@the_limit} results, which is the same as the limit"
+    end
+    query
+  end
+
+  def exec
+    results = ActiveRecord::Base.connection.execute(self.to_sql).to_a
+    if @make_objects
+      check_result_limit!(QueryResult.new results)
+    else
+      check_result_limit!(results)
+    end
+  end
+
+  def dup
+    other = SqlBuilder.new
+    (ARRAY_ATTRS + SCALAR_ATTRS).each do |attr|
+      other.send "#{attr}=", self.send(attr).dup
+    end
+    other.make_objects = @make_objects
+    other.the_limit = @the_limit
+    other
+  end
+
+  def as_raw
+    @make_objects = false
+    self
+  end
+
+  def as_objects
+    @make_objects = true
+    self
+  end
+
+  def self.from_raw(raw)
+    builder = SqlBuilder.new
+    (ARRAY_ATTRS + SCALAR_ATTRS).each do |attr|
+      if raw[attr]
+        builder.send "#{attr}=", raw[attr]
+      end
+    end
+    builder
+  end
+end

data/sql_builder.gemspec

@@ -0,0 +1,31 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "sql_builder/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "sql_builder"
+  spec.version       = Sql::Builder::VERSION
+  spec.authors       = ["Andy Selvig"]
+  spec.email         = ["ajselvig@gmail.com"]
+
+  spec.summary       = "Small Ruby library for building ad-hoc SQL queries."
+  spec.description   = "Use builder pattern to create ad-hoc SQL queries that aren't tied to models but return read-only plain Ruby objects."
+  spec.homepage      = "https://github.com/Terrier-Tech/sql_builder"
+  spec.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rake", "~> 13"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "activerecord", ">=5.2"
+  spec.add_development_dependency "pg", "~> 0.18"
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: sql_builder
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Andy Selvig
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+description: Use builder pattern to create ad-hoc SQL queries that aren't tied to
+  models but return read-only plain Ruby objects.
+email:
+- ajselvig@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rakeTasks"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/sql_builder.rb
+- lib/sql_builder/query_result.rb
+- lib/sql_builder/query_row.rb
+- lib/sql_builder/version.rb
+- sql_builder.gemspec
+homepage: https://github.com/Terrier-Tech/sql_builder
+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: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Small Ruby library for building ad-hoc SQL queries.
+test_files: []