Add files and license

Author: kazk

.github/workflows/ci.yaml

@@ -0,0 +1,16 @@
+name: CI
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.0']
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+        bundler-cache: true
+    # - run: bundle exec rake

.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Qualified, Inc
+
+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.

README.md

@@ -0,0 +1,19 @@
+# SqlSpecHelper
+
+`spec/spec_helper.rb`
+
+```ruby
+require 'sql_spec_helper'
+
+# Add `$sql`, `DB`, `run_sql`, `compare_with`, and `Display` to main for backwards compatibility.
+$sql_spec_helper = SqlSpecHelper.new('/workspace/solution.txt')
+$sql = $sql_spec_helper.sql
+DB = $sql_spec_helper.db
+def run_sql(...)
+  $sql_spec_helper.run_sql(...)
+end
+def compare_with(...)
+  $sql_spec_helper.compare_with(...)
+end
+Display = SqlSpecHelper::Display
+```

Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "sql_spec_helper"
+
+# 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__)

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

lib/sql_spec_helper.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'sequel'
+
+require_relative 'sql_spec_helper/display'
+require_relative 'sql_spec_helper/daff_wrapper'
+require_relative 'sql_spec_helper/compare'
+
+class SqlSpecHelper
+  attr_reader :sql, :db
+
+  def initialize(solution_path)
+    @sql = File.read(solution_path)
+    @commands = sql_commands(@sql)
+    @db = connect
+  end
+
+  # `show_daff_table: true` display diff table
+  # `daff_csv_show_index: true` include index in test output
+  def compare_with(expected, limit: 100, collapsed: false, show_daff_table: true, daff_csv_show_index: false, &block)
+    sql_compare = SqlCompare.new(
+      self,
+      expected,
+      cmds: @commands,
+      limit: limit,
+      collapsed: collapsed,
+      show_daff_table: show_daff_table,
+      daff_csv_show_index: daff_csv_show_index
+    )
+    sql_compare.instance_eval(&block) if block
+
+    sql_compare.spec
+    sql_compare.actual
+  end
+
+  # The main method used when running user's code.
+  # Returns an Array of `Sequel::Adapter::Dataset` unless commands contained only one `SELECT`.
+  # Returns `nil` if no `SELECT`.
+  def run_sql(cmds: nil, limit: 100, print: true, label: 'SELECT Results', collapsed: false, &block)
+    Display.status("Running sql commands...")
+    cmds ||= @commands
+    results = Array(cmds).each_with_object([]) do |cmd, results|
+      dataset = run_cmd(cmd) || []
+      result = dataset.to_a
+      next if result.empty?
+
+      lbl = label
+      lbl += " (Top #{limit} of #{result.size})" if result.size > limit
+      lbl = "-" + lbl if collapsed
+
+      block.call(dataset, lbl) if block
+
+      Display.table(result.take(limit), label: lbl, allow_preview: true) if print
+      results.push(dataset)
+    end
+
+    if results.length > 1
+      results
+    else
+      results.first
+    end
+
+  rescue Sequel::DatabaseError => ex
+    Display.print("ERROR", ex.message.strip)
+  end
+
+  private
+
+  # Connect the database
+  def connect
+    Display.status "Connecting to database..."
+    case ENV['DATABASE_TYPE']
+    when 'sqlite'
+      Sequel.sqlite
+    when 'postgres'
+      Sequel.connect(
+        adapter: 'postgres',
+        host: ENV['PGHOST'],
+        user: ENV['PGUSER'],
+        port: ENV['PGPORT'],
+        database: ENV['DATABASE_NAME'] || ENV['PGDATABASE'],
+      )
+    when 'mssql'
+      Sequel.connect(
+        adapter: 'tinytds',
+        host: ENV['MSSQL_HOST'],
+        port: ENV['MSSQL_PORT'],
+        user: ENV['MSSQL_USER'],
+        password: ENV['MSSQL_PASS'],
+      )
+    else
+      raise "Unknown database type #{ENV['DATABASE_TYPE']}"
+    end
+  end
+
+  def sql_commands(sql)
+    split_sql_commands(clean_sql(sql))
+  end
+
+  def run_cmd(cmd)
+    select_cmd?(cmd) ? @db[cmd] : @db.run(cmd)
+  end
+
+  def clean_sql(sql)
+    sql.gsub(/(\/\*([\s\S]*?)\*\/|--.*)/, "")
+  end
+
+  def select_cmd?(cmd)
+    (cmd.strip =~ /^(SELECT|WITH)/i) == 0
+  end
+
+  def split_sql_commands(sql)
+    # first we want to seperate select statements into chunks
+    chunks = sql.split(/;[ \n\r]*$/i).select {|s| !s.empty?}.chunk {|s| select_cmd?(s)}
+    # select statements need to stay individual so that we can return individual datasets, but we can group other statements together
+    chunks.each_with_object([]) do |(select, cmds), final|
+      if select
+        final.concat(cmds)
+      else
+        final.push(cmds.join(";\n"))
+      end
+    end
+  end
+end

lib/sql_spec_helper/compare.rb

@@ -0,0 +1,115 @@
+require 'rspec/expectations'
+
+class SqlSpecHelper
+  class SqlCompare
+    attr_reader :actual, :expected
+
+    def initialize(helper, expected, cmds: nil, limit: 100, collapsed: false, show_daff_table: true, daff_csv_show_index: false)
+      @results = helper.run_sql(cmds: cmds, label: 'Results: Actual', limit: limit, collapsed: collapsed)
+      @actual = @results.is_a?(Array) ? @results.last.to_a : @results.to_a
+      @limit = limit
+      Display.status("Running expected query...")
+      @expected = expected.to_a
+      @daff_csv_show_index = daff_csv_show_index
+
+      Display.log('Query returned no rows', 'Results: Actual') if @actual.size == 0
+      Display.table(@expected, label: 'Results: Expected', tab: true, allow_preview: true)
+      if show_daff_table && @actual.size > 0 && @expected != @actual
+        # set `index: true` to collect ordering data (row/column mapping)
+        daff_data = DaffWrapper.new(@actual, @expected, index: true).serializable
+        Display.daff_table(daff_data, label: 'Diff', tab: true, allow_preview: true)
+      end
+
+      @column_blocks ||= {}
+      @rows_blocks = []
+    end
+
+    def column(name, &block)
+      @column_blocks[name.to_sym] = block.to_proc
+      self
+    end
+
+    def rows(&block)
+      @rows_blocks << block.to_proc
+      self
+    end
+
+    def spec(&block)
+      return if @spec_called
+      @spec_called = true
+
+      _self = self
+      column_blocks = @column_blocks
+      rows_blocks = @rows_blocks
+      it_blocks = @it_blocks
+      daff_csv_show_index = @daff_csv_show_index
+
+      RSpec.describe "Query" do
+        let(:actual) { _self.actual }
+        let(:expected) { _self.expected }
+
+        describe "columns" do
+          expected.first.each do |key, value|
+            describe "column \"#{key}\"" do
+              it "should be included within results" do
+                if (actual_row = actual&.first)
+                  expect(actual_row).to have_key(key), "missing column \"#{key}\""
+                else
+                  RSpec::Expectations.fail_with("the query returned no row")
+                end
+              end
+
+              if value
+                # TODO `value.class` is type in Ruby, and can be misleading
+                it "should be a #{value.class.name} value" do
+                  if (actual_row = actual&.first)
+                    if (actual_value = actual_row[key])
+                      expect(actual_value).to be_a(value.class), "column \"#{key}\" should be #{value.class}, not #{actual_value.class}"
+                    else
+                      RSpec::Expectations.fail_with("missing column \"#{key}\"")
+                    end
+                  else
+                    RSpec::Expectations.fail_with("the query returned no row")
+                  end
+                end
+              end
+
+              self.instance_eval(&column_blocks[key]) if column_blocks[key]
+            end
+          end
+        end
+
+        describe "rows" do
+          matcher :eq_table do |expected|
+            match {|actual| actual == expected}
+            failure_message do |actual|
+              ("rows did not match expected\n" + DaffWrapper.new(actual, expected, index: daff_csv_show_index).as_csv).gsub(/\r?\n/, '<:LF:>')
+            end
+          end
+
+          it "should have #{expected.count} rows" do
+            if (count = actual&.count)
+              expect(count).to eq(expected.count), "expected #{expected.count} rows, got #{count} rows"
+            else
+              RSpec::Expectations.fail_with("the query returned no row")
+            end
+          end
+
+          rows_blocks.each do |block|
+            self.instance_eval(&block)
+          end
+
+          it "should match the expected" do
+            if actual.empty?
+              RSpec::Expectations.fail_with("the query returned no row")
+            else
+              expect(actual).to eq_table expected
+            end
+          end
+        end
+
+        self.instance_eval(&block) if block
+      end
+    end
+  end
+end