Add pipeline example

Author: tomeroth

examples/interpreter/collector.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require File.expand_path('../../interpreter', __FILE__)
+
+class Interpreter
+  class Collector
+    def call(param_builder)
+      {
+        where: [Interpreter.new(ast: param_builder.filters.to_ast).to_sql],
+        order: param_builder.order.first.to_a.join(' '),
+        from: param_builder.from.first,
+        limit: param_builder.limit,
+        offset: param_builder.offset,
+        search_query: param_builder.search_query
+      }
+    end
+  end
+end

examples/interpreter/to_sql/expression_factory.rb

@@ -32,7 +32,7 @@ def visit_course_category_ids(value, _left, right)
         <<~SQL
           EXISTS(
             SELECT TRUE FROM category_courses
-            WHERE category_courses.category_id #{determine_values(value, right)})
+            WHERE category_courses.category_id #{determine_values(value, right)}
             AND courses.id = category_courses.course_id
           )
         SQL

examples/sql_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class SqlBuilder
+  attr_reader :sql_struct_parts, :model_name
+
+  def initialize(sql_struct_parts:, model_name:)
+    @sql_struct_parts = sql_struct_parts
+    @model_name = model_name
+  end
+
+  def preloads
+    ssp.preloads
+  end
+
+  def sql_query
+    <<~SQL
+      SELECT #{select} FROM #{from} #{ssp.joins.join(' ')}
+      WHERE #{ssp.where.join(' AND ')}
+      ORDER BY #{ssp.order}
+      LIMIT #{ssp.limit}
+      OFFSET #{ssp.offset}
+    SQL
+  end
+
+  def count_query
+    <<~SQL
+      SELECT #{count_select} FROM #{from} #{ssp.joins.join(' ')}
+      WHERE #{ssp.where.join(' AND ')}
+    SQL
+  end
+
+  def count_select
+    "COUNT(#{select})"
+  end
+
+  def select
+    return '*' if ssp.select.empty?
+    ssp.select
+  end
+
+  def from
+    return model_name if ssp.from.empty?
+    ssp.from
+  end
+
+  def to_s
+    to_sql.to_s
+  end
+
+  alias ssp sql_struct_parts
+end

examples/sql_struct_parts.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class SqlStructParts
+  PARTS = %w[select from joins where search_query order limit offset preload].freeze
+
+  attr_reader :deps
+
+  def initialize(**opts)
+    @deps = opts[:deps] || {}
+  end
+
+  def with(deps)
+    self.class.new(deps: initialize_dependencies(deps))
+  end
+
+  PARTS.each do |sql_part|
+    define_method sql_part do
+      @deps[sql_part.to_sym] || []
+    end
+  end
+
+  # @api private
+  def initialize_dependencies(deps)
+    params = {}
+    params = initialize_arrays(params, deps)
+    params = initialize_constants(params, deps)
+    params
+  end
+
+  # @api private
+  def initialize_arrays(params, deps)
+    params[:select] = select.to_a | deps[:select].to_a
+    params[:from] = deps[:from].to_s
+    params[:joins] = joins.to_a | deps[:joins].to_a
+    params[:where] = where | deps[:where].to_a
+    params
+  end
+
+  # @api private
+  def initialize_constants(params, deps)
+    params[:search_query] = deps[:search_query].to_s
+    params[:order] = deps[:order].to_s
+    params[:limit] = deps[:limit].to_i
+    params[:offset] = deps[:offset].to_i
+    params[:preload] = preload | deps[:preload].to_a
+    params
+  end
+
+  alias << with
+end

examples/user_pipeline.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'filterly'
+require_relative 'interpreter/collector'
+require_relative 'user_query_pipeline'
+
+class UserPipeline
+  attr_reader :params, :param_builder
+
+  def initialize(params:, param_builder: ::Filterly::Pipeline::ParamBuilder.new)
+    @params = params
+    @param_builder = param_builder
+  end
+
+  def call
+    build_params
+
+    count, query = UserQueryPipeline.new(params: interpret_to_sql).call
+    puts '---------- SQL COUNT query -----------'
+    puts
+    puts count
+    puts
+    puts
+    puts '---------- SQL main query ------------'
+    puts query
+    puts
+  end
+
+  # @api private
+  def build_params
+    param_builder << filters
+    param_builder << some_other_filters
+  end
+
+  # @api private
+  def interpret_to_sql
+    Interpreter::Collector.new.call(param_builder)
+  end
+
+  # @api private
+  def filters
+    params.to_h
+  end
+
+  def some_other_filters
+    {
+      filters: {
+        course_ids: [12, 34, 54]
+      },
+      select: ['courses.new_column as new_one'],
+      params: { search_query: 'adam' }
+    }
+  end
+end
+
+UserPipeline.new(
+  params: {
+    filters: {
+      category_ids: [12, 34, 54],
+      course_annual_id: 23,
+      course_semester_id: 123
+    },
+    from: 'courses',
+    order: { 'courses.id': 'asc' },
+    params: {
+      limit: 10,
+      offset: 0,
+      not_supported: 'omitted'
+    }
+  }
+).call

examples/user_query_pipeline.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'sql_struct_parts'
+require_relative 'sql_builder'
+
+class UserQueryPipeline
+  attr_reader :sql_struct_parts
+
+  def initialize(sql_struct_parts:)
+    @sql_struct_parts = sql_struct_parts
+  end
+
+  def self.new(params:)
+    super(sql_struct_parts: SqlStructParts.new(deps: params))
+  end
+
+  def call
+    sql_struct_parts << something_special
+
+    sql_builder = SqlBuilder.new(sql_struct_parts: sql_struct_parts, model_name: 'users')
+
+    [sql_builder.count_query, sql_builder.sql_query]
+  end
+
+  def something_special
+    {
+      where: ["user.ethnicity IN('celts', 'slavic')"]
+    }
+  end
+end

spec/examples/interpreter_spec.rb

@@ -128,7 +128,7 @@
           (course_id='23' OR (course_id='7' OR course_id='56')) AND annual='2017-2018'
           AND EXISTS(
             SELECT TRUE FROM category_courses
-            WHERE category_courses.category_id IN('67','32','34'))
+            WHERE category_courses.category_id IN('67','32','34')
             AND courses.id = category_courses.course_id
           )
         SQL

spec/examples/sql_builder_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'examples/sql_builder'
+require 'examples/sql_struct_parts'
+
+RSpec.describe SqlBuilder do
+  subject do
+    described_class.new(sql_struct_parts: sql_struct, model_name: 'users')
+  end
+
+  let(:sql_struct) do
+    SqlStructParts.new(
+      deps: {
+        select: 'users.*',
+        from: '(SELECT users WHERE id IN(1,2,3)) as users',
+        where: ['(users.name = "Pszemek" OR users.age > 24)', 'users.status = "adult"'],
+        joins: ['LEFT JOIN courses c ON(c.id=users.course_id)'],
+        limit: 10,
+        order: 'users.id ASC',
+        offset: 5,
+        preload: %i[courses addresses]
+      }
+    )
+  end
+
+  let(:sql_struct_no_from_or_select) do
+    SqlStructParts.new(
+      deps: {
+        select: [],
+        from: nil,
+        where: ['users.name = "Pszemek" AND users.age > 24'],
+        joins: ['LEFT JOIN courses c ON(c.id=users.course_id)'],
+        limit: 10,
+        order: 'users.id ASC',
+        offset: 5,
+        preload: %i[courses addresses]
+      }
+    )
+  end
+
+  describe '#sql_query' do
+    it 'returns sql query' do
+      expect(subject.sql_query.tr("\n", ' ')).to eql(
+        <<~SQL.tr("\n", ' ')
+          SELECT users.* FROM (SELECT users WHERE id IN(1,2,3)) as users
+          LEFT JOIN courses c ON(c.id=users.course_id)
+          WHERE (users.name = "Pszemek" OR users.age > 24) AND users.status = "adult"
+          ORDER BY users.id ASC
+          LIMIT 10
+          OFFSET 5
+        SQL
+      )
+    end
+
+    it 'uses model_name when from is upsent' do
+      result = described_class.new(
+        sql_struct_parts: sql_struct_no_from_or_select,
+        model_name: 'users'
+      ).sql_query
+
+      expect(result.tr("\n", ' ')).to eql(
+        <<~SQL.tr("\n", ' ')
+          SELECT * FROM users
+          LEFT JOIN courses c ON(c.id=users.course_id)
+          WHERE users.name = "Pszemek" AND users.age > 24
+          ORDER BY users.id ASC
+          LIMIT 10
+          OFFSET 5
+        SQL
+      )
+    end
+  end
+
+  describe '#count_query' do
+    it 'returns sql count query' do
+      expect(subject.count_query.tr("\n", ' ')).to eql(
+        <<~SQL.tr("\n", ' ')
+          SELECT COUNT(users.*) FROM (SELECT users WHERE id IN(1,2,3)) as users
+          LEFT JOIN courses c ON(c.id=users.course_id)
+          WHERE (users.name = "Pszemek" OR users.age > 24) AND users.status = "adult"
+        SQL
+      )
+    end
+  end
+end

spec/examples/sql_struct_parts_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './examples/sql_struct_parts'
+
+RSpec.describe SqlStructParts do
+  subject do
+    described_class.new(deps: deps)
+  end
+
+  let(:deps) do
+    {
+      select: ['users.*'],
+      where: ['user.id IN(1,2,3)'],
+      limit: 20,
+      joins: ['LEFT JOIN courses c ON(c.id=b.lk)']
+    }
+  end
+
+  describe '#new' do
+    it 'creates deps with default values' do
+      expect(subject.deps).to eql(
+        select: ['users.*'],
+        limit: 20,
+        where: ['user.id IN(1,2,3)'],
+        joins: ['LEFT JOIN courses c ON(c.id=b.lk)']
+      )
+    end
+  end
+
+  describe '#with' do
+    it 'merges new params with the old ones' do
+      result = subject
+        .with(
+          limit: 10,
+          offset: 0,
+          joins: ['INNER JOIN addresses a ON(a.id=b.address_id)']
+        )
+        .with(from: 'users', select: ['id, surname'], where: ['user.age > 45'])
+
+      expect(result.deps).to eql(
+        from: 'users',
+        joins: [
+          'LEFT JOIN courses c ON(c.id=b.lk)',
+          'INNER JOIN addresses a ON(a.id=b.address_id)'
+        ],
+        limit: 0,
+        offset: 0,
+        order: '',
+        preload: [],
+        search_query: '',
+        select: ['users.*', 'id, surname'],
+        where: ['user.id IN(1,2,3)', 'user.age > 45']
+      )
+    end
+  end
+
+  describe '#initialize_dependencies' do
+    it 'allows to call attributes by methods' do
+      result = subject.with(limit: 11)
+
+      expect(result.limit).to eql(11)
+      expect(result.where).to eql(['user.id IN(1,2,3)'])
+    end
+  end
+end