terrazine 0.0.2 → 0.0.3

data/lib/terrazine/builders/operators.rb

@@ -0,0 +1,63 @@
+module Terrazine
+  class Builder
+    private
+
+    # now it doesnt use Predicates
+
+    def build_operator(structure, prefix = nil)
+      operator = structure.first.to_s.sub(/^_/, '')
+      arguments = structure.drop(1)
+      # puts operator
+      send("operator_#{operator}", arguments, prefix)
+    end
+
+    def operator_missing(name, arguments, prefix)
+      "#{name}(#{build_columns arguments, prefix})"
+    end
+
+    def operator_params(arguments, _)
+      if arguments.count > 1
+        arguments.map { |i| build_param i }
+      else
+        build_param arguments.first
+      end
+    end
+
+    # without arguments smthng like this - "COUNT(#{prefix + '.'}*)"
+    def operator_count(arguments, prefix)
+      if arguments.count > 1
+        arguments.map { |i| "COUNT(#{build_columns(i, prefix)})" }.join ', '
+      else
+        "COUNT(#{build_columns(arguments.first, prefix)})"
+      end
+    end
+
+    def operator_nullif(arguments, prefix)
+      "NULLIF(#{build_columns(arguments.first, prefix)}, #{arguments[1]})"
+    end
+
+    def operator_array(arguments, prefix)
+      if [Hash, Constructor].include?(arguments.first.class)
+        "ARRAY(#{build_sql arguments.first})"
+      else # TODO? condition and error case
+        "ARRAY[#{build_columns arguments, prefix}]"
+      end
+    end
+
+    def operator_avg(arguments, prefix)
+      "AVG(#{build_columns(arguments.first, prefix)})"
+    end
+
+    def operator_values(arguments, _)
+      values = arguments.first.first.is_a?(Array) ? arguments.first : [arguments.first]
+      values.map! { |i| "(#{build_columns i})" }
+      "(VALUES#{values.join ', '}) AS #{arguments[1]} (#{build_columns arguments.last})"
+    end
+
+    def operator_case(arguments, _)
+      else_val = "ELSE #{arguments.pop} " unless arguments.last.is_a? Array
+      conditions = arguments.map { |i| "WHEN #{i.first} THEN #{i.last}" }.join ' '
+      "CASE #{conditions} #{else_val}END"
+    end
+  end
+end

data/lib/terrazine/builders/params.rb

@@ -0,0 +1,18 @@
+module Terrazine
+  class Builder
+
+    private
+
+    def build_param(value)
+      # no need for injections check - pg gem will check it
+      @params << value
+      "$#{@params.count}"
+    end
+
+    def wrap_result(sql)
+      res = @params.count.positive? ? [sql, @params] : sql
+      @params = []
+      res
+    end
+  end
+end

data/lib/terrazine/builders/predicates.rb

@@ -0,0 +1,160 @@
+module Terrazine
+  class Builder
+    # TODO: :between, :!=, :>, :<, :>=, :<=
+    # Done: :eq, :not, :or, :and, :like, :ilike, :reg_#{type}, :in
+
+    # now it doesn't use Operators
+    # uses Expressions
+
+    private
+
+    # TODO? conditions like [:eq :name :Aeonax]
+    def build_predicates(structure)
+      construct_condition(structure, true)
+    end
+
+    # [:or, { u__name: 'Aeonax', u__role: 'liar'}, # same as [[:eq, :u__name, 'Aeonax'], ...]
+    #       [:not, [:in, :id, [1, 2, 531]]]]
+    def construct_condition(structure, first_level = nil)
+      case structure
+      when Array
+        key = structure.first
+        return construct_condition(key) if structure.size < 2
+        if key.is_a? Symbol
+          parentizer send("condition_#{key}", structure.drop(1)), first_level, key
+        elsif key.is_a?(String) && key =~ /\?/
+          if [Hash, Constructor].include?(structure.second.class)
+            key.sub(/\?/, "(#{build_sql(structure.second)})")
+          else
+            key.sub(/\?/, build_param(structure.second))
+          end
+        else
+          parentizer condition_and(structure), first_level, :and
+        end
+      when Hash
+        res = condition_eq structure
+        first_level ? condition_and(res) : res
+      when Symbol
+        condition_column(structure)
+      when String
+        structure
+      else
+        raise "Unknow structure #{structure} class #{structure.class} for condition"
+      end
+    end
+
+    # common
+
+    def condition_column(structure)
+      structure.to_s.sub(/__/, '.')
+    end
+
+    def construct_condition_value(structure)
+      case structure
+      when Symbol
+        condition_column(structure)
+      when TrueClass, FalseClass
+        structure.to_s.upcase
+      when nil
+        'NULL'
+      else
+        build_param structure
+      end
+    end
+
+    def parentizer(sql, first_level, key)
+      if first_level || ![:or, :and].include?(key)
+        sql
+      else
+        "(#{sql})"
+      end
+    end
+
+    #### Condition builders
+
+    # supporting eq if there is no array inside
+    def condition_not(structure)
+      value = if structure.count == 1
+                construct_condition structure.flatten(1)
+              else
+                condition_eq structure
+              end
+      "NOT #{value}"
+    end
+
+    def conditions_joiner(structure, joiner)
+      structure.map { |i| construct_condition i }.flatten.join(" #{joiner} ".upcase)
+    end
+
+    def condition_and(structure)
+      conditions_joiner structure, 'and'
+    end
+
+    def condition_or(structure)
+      conditions_joiner structure, 'or'
+    end
+
+    def condition_in(structure)
+      values = case structure.second
+               when Hash, Constructor
+                 build_sql structure.second
+               else
+                 build_param structure.second
+               end
+      "#{construct_condition_value structure.first} IN (#{values})"
+    end
+
+    def conditions_construct_eq(column, value)
+      return condition_in([column, value]) if value.is_a? Array
+      "#{construct_condition_value column} = #{construct_condition_value value}"
+    end
+
+    def condition_is(structure)
+      "#{construct_condition_value structure.first} IS #{construct_condition_value structure.second}"
+    end
+
+    def condition_eq(structure)
+      case structure
+      when Array
+        conditions_construct_eq structure.first, structure.second
+      when Hash
+        iterate_hash(structure, false) { |k, v| conditions_construct_eq k, v }
+      else
+        raise "Undefinded structure: #{structure} for equality condition builder"
+      end
+    end
+
+    def condition_between(structure)
+      "BETWEEN #{construct_condition structure}"
+    end
+
+    def condition_pattern(structure, pattern)
+      "#{construct_condition_value structure.first} #{pattern.upcase} " \
+      "#{construct_condition_value structure.second}"
+    end
+
+    def condition_like(structure)
+      condition_pattern structure, :like
+    end
+
+    def condition_ilike(structure)
+      condition_pattern structure, :ilike
+    end
+
+    def condition_reg(structure)
+      condition_pattern structure, '~'
+    end
+
+    def condition_reg_i(structure)
+      condition_pattern structure, '~*'
+    end
+
+    def condition_reg_f(structure)
+      condition_pattern structure, '!~'
+    end
+
+    def condition_reg_fi(structure)
+      condition_pattern structure, '!~*'
+    end
+  end
+end

data/lib/terrazine/config.rb

@@ -8,7 +8,9 @@ module Terrazine
 
       def connection(conn = nil)
         @@connection ||= conn
-        conn || @@connection
+        c = conn || @@connection
+        # Proc because of closing PG::Connection by rails on production -_-
+        c.is_a?(Proc) ? c.call : c
       end
 
       def connection!(conn = nil)

data/lib/terrazine/constructor.rb

@@ -3,12 +3,10 @@ module Terrazine
     attr_reader :structure, :params
     def initialize(structure = {})
       @structure = structure
-      # @params = []
-      @builder = Builder.new(self)
     end
 
     # TODO? join hash inside array?
-    # TODO!! join values of existing keys
+    # TODO!! join values of existing keys on hashes merge
     def structure_constructor(structure, modifier)
       return modifier unless structure
 
@@ -28,51 +26,18 @@ module Terrazine
       end
     end
 
-    # just string
-    ### select "name, email"
-
-    # array of strings or symbols
-    ### select [*selectable_fields]
-
-    # hash with column aliases
-    ### select _field_alias: :field
-    ### => 'SELECT field AS field_alias '
-
-    # array of fields and aliases - order doesnt matter
-    ### select [{ _user_id: :id, _user_name: :name }, :password]
-    ### => 'SELECT id AS user_id, name AS user_name, password '
-
-    # functions - array with first value - function name with underscore as symbol
-    ### select [:_nullif, :row, :value]
-
-    # table alias/name
-    ### select t_a: [{ _user_id: :id }, :field_2, [:_nullif, :row, :value]]
-    ### => 'SELECT t_a.id AS user_id, t_a.password, NULLIF(t_a.row, value) '
-
-    # any nesting and sub queries as new SQLConstructor or hash structure
-    ### select u: [{ _some_count: [:_count, [:_nullif, :row, :value]] },
-    ###            :name, :email],
-    ###        _u_count: (another_constructor || another_structure)
-    ### => 'SELECT COUNT(NULLIF(u,row, value)) AS some_count, u.name, u.email, (SELECT ...) AS u_count '
-
-    # construct it
-    ### constructor = SQLConstructor.new from: [:users, :u],
-    ###                                  join [[:mrgl, :m], { on: 'm.user_id = u.id'}]
-    ### constructor.select :name
-    ### constructor.select [{u: :id, _some_count: [:_count, another_constructor]}] if smthng
-    ### constructor.select [{r: :rgl}, :zgl] if another_smthng
-    ### constructor.build_sql
-    ### => 'SELECT name, u.id, COUNT(SELECT ...) AS some_count, r.rgl, zgl FROM ...'
     def select(structure)
       @structure[:select] = structure_constructor(@structure[:select], structure)
       self
     end
 
-    # distinct_select select_structure
-    # distinct_select select_structure, distinct_field
-    # distinct_select select_structure, [*distinct_fields]
-    def distinct_select(structure, fields = nil)
-      @structure[:distinct] = fields || true
+    def distinct(fields = true)
+      @structure[:distinct] = fields
+      self
+    end
+
+    def distinct_select(structure, fields = true)
+      @structure[:distinct] = fields
       select structure
       self
     end
@@ -87,34 +52,11 @@ module Terrazine
     end
 
     # TODO: join constructor AND better syntax
-    # join 'users u ON u.id = m.user_id'
-    # join ['users u ON u.id = m.user_id',
-    #       'skills s ON u.id = s.user_id']
-    # join [[:user, :u], { on: 'rgl = 123' }]
-    # join [[[:user, :u], { option: :full, on: [:or, 'mrgl = 2', 'rgl = 22'] }],
-    #       [:master, { on: ['z = 12', 'mrgl = 12'] }]]
     def join(structure)
       @structure[:join] = structure
-      # puts @structure[:join]
       self
     end
 
-    # conditions 'mrgl = 12'
-    # conditions ['z = 12', 'mrgl = 12']
-    # conditions ['NOT z = 13', [:or, 'mrgl = 2', 'rgl = 22']]
-    # conditions [:or, ['NOT z = 13', [:or, 'mrgl = 2', 'rgl = 22']],
-    #                  [:or, 'rgl = 12', 'zgl = fuck']]
-    # conditions [['NOT z = 13',
-    #             [:or, 'mrgl = 2', 'rgl = 22']],
-    #             [:or, 'rgl = 12', 'zgl = fuck']]
-    # => 'NOT z = 13 AND (mrgl = 2 OR rgl = 22) AND (rgl = 12 OR zgl = fuck)'
-    # conditions ['NOT z = 13', [:or, 'mrgl = 2',
-    #                                 ['rgl IN ?', {select: true, from: :users}]]]
-
-    # constructor.where ['u.categories_cache ~ ?',
-    #                           { select: :path, from: :categories,
-    #                             where: ['id = ?', s_params[:category_id]] }]
-    # constructor.where('m.cashless IS TRUE')
     def where(structure)
       w = @structure[:where]
       if w.is_a?(Array) && w.first.is_a?(Array)
@@ -127,22 +69,34 @@ module Terrazine
       self
     end
 
-    # TODO: with -_-
-    # with [:alias_name, { select: true, from: :users}]
-    # with [[:alias_name, { select: true, from: :users}],
-    #       [:alias_name_2, { select: {u: [:name, :email]},
-    #                         from: :rgl}]]
+    # TODO: with constructor -_-
+    def with(structure)
+      @structure[:with] = structure
+      self
+    end
 
+    # TODO: order constructor -_-
+    def order(structure)
+      @structure[:order] = structure
+      self
+    end
+
+    # TODO: default per used here and in builder...-_-
     def limit(per)
       @structure[:limit] = (per || 8).to_i
       self
     end
 
+    # same as limit =(
+    def offset(offset)
+      @structure[:offset] = offset || 0
+    end
+
     # TODO: serve - return count of all rows
     # params - hash with keys :per, :page
     def paginate(params)
       limit params[:per]
-      @structure[:offset] = ((params[:page]&.to_i || 1) - 1) * @structure[:limit]
+      offset((params.fetch(:page, 1).to_i - 1) * @structure[:limit])
       self
     end
 
@@ -156,8 +110,8 @@ module Terrazine
     # constructor.build_sql
     # => 'SELECT .... FROM ...'
     # => ['SELECT .... FROM .... WHERE id = $1', [22]]
-    def build_sql
-      @builder.get_sql @structure
+    def build_sql(options = {})
+      Builder.new.get_sql @structure, options
     end
   end
 end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Terrazine
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/spec/constructor_spec.rb

@@ -1,6 +1,7 @@
 require_relative 'spec_helper'
 
 # TODO.... -_-
+# May be store structures with string representation? Because tests sux right now=(
 describe Terrazine::Constructor do
   before :each do
     @constructor = Terrazine.new_constructor
@@ -13,7 +14,26 @@ describe Terrazine::Constructor do
     expect(@constructor.class).to eql Terrazine::Constructor
   end
 
-  context '`select`' do
+  context '`WITH`' do
+    it 'build array like syntax' do
+      @constructor.with [:name, { select: true }]
+      expect(@constructor.build_sql).to eq 'WITH name AS (SELECT * ) '
+    end
+
+    it 'build nested array like syntax' do
+      @constructor.with [[:name, { select: true }],
+                         [:another_name, { select: :mrgl }]]
+      expect(@constructor.build_sql).to eq 'WITH name AS (SELECT * ), another_name AS (SELECT mrgl ) '
+    end
+
+    it 'build hash like syntax' do
+      @constructor.with name: { select: true },
+                        another_name: { select: :mrgl }
+      expect(@constructor.build_sql).to eq 'WITH name AS (SELECT * ), another_name AS (SELECT mrgl ) '
+    end
+  end
+
+  context '`SELECT`' do
     it 'build simple structure' do
       @constructor.select(:name)
       @constructor.select('phone')
@@ -32,22 +52,37 @@ describe Terrazine::Constructor do
       @constructor.select select: [:_count, [:_nullif, :connected, true]],
                           from: [:calls, :c],
                           where: 'u.id = c.user_id'
-      expect(@constructor.build_sql).to eq 'SELECT (SELECT COUNT(NULLIF(connected, true)) FROM calls c WHERE u.id = c.user_id  ) '
+      expect(@constructor.build_sql).to eq 'SELECT (SELECT COUNT(NULLIF(connected, true)) FROM calls c WHERE u.id = c.user_id ) '
     end
 
     it 'build big structures' do
       @permanent_c.select _calls_count: { select: [:_count, [:_nullif, :connected, true]],
                                           from: [:calls, :c],
-                                          where: 'u.id = c.user_id' },
+                                          where: { u__id: :c__user_id } },
                           u: [:name, :phone, { _master: [:_nullif, :role, "'master'"] },
                               'u.abilities, u.id', 'birthdate']
       @permanent_c.select o: :client_name
       @permanent_c.select :secure_id
-      expect(@permanent_c.build_sql).to eq "SELECT (SELECT COUNT(NULLIF(connected, true)) FROM calls c WHERE u.id = c.user_id  ) AS calls_count, u.name, u.phone, NULLIF(u.role, 'master') AS master, u.abilities, u.id, u.birthdate, o.client_name, secure_id "
+      expect(@permanent_c.build_sql).to eq "SELECT (SELECT COUNT(NULLIF(connected, true)) FROM calls c WHERE u.id = c.user_id ) AS calls_count, u.name, u.phone, NULLIF(u.role, 'master') AS master, u.abilities, u.id, u.birthdate, o.client_name, secure_id "
+    end
+
+    it 'build DISTINCT' do
+      @constructor.distinct_select([:id, :name, :phone])
+      expect(@constructor.build_sql).to eq 'SELECT DISTINCT id, name, phone '
+    end
+
+    it 'build DISTINCT ON field' do
+      @constructor.distinct_select([:id, :name, :phone], :id)
+      expect(@constructor.build_sql).to eq 'SELECT DISTINCT ON(id) id, name, phone '
+    end
+
+    it 'build DISTINCT ON array of field' do
+      @constructor.distinct_select([:id, :name, :phone], [:id, :phone])
+      expect(@constructor.build_sql).to eq 'SELECT DISTINCT ON(id, phone) id, name, phone '
     end
   end
 
-  context '`from`' do
+  context '`FROM`' do
     it 'build simple data structures' do
       @constructor.from :users
       expect(@constructor.build_sql).to eq 'FROM users '
@@ -55,19 +90,25 @@ describe Terrazine::Constructor do
       expect(@permanent_c.build_sql).to match 'o.client_name, secure_id FROM users u $'
     end
 
-    it 'build values' do
-      @constructor.from [:_values, [:_param, 'mrgl'], :r, ['type']]
+    it 'build VALUES' do
+      @constructor.from [:_values, [:_params, 'mrgl'], :r, ['type']]
       expect(@constructor.build_sql).to eq ['FROM (VALUES($1)) AS r (type) ', ['mrgl']]
     end
 
-    it 'build values and tables' do
+    it 'build VALUES and tables' do
       @constructor.from [[:mrgl, :m], [:_values, [1, 2], :rgl, [:zgl, :gl]]]
       expect(@constructor.build_sql).to eq 'FROM mrgl m, (VALUES(1, 2)) AS rgl (zgl, gl) '
     end
+
+    it 'build VALUES with many rows' do
+      @constructor.from [:_values, [[:_params, 'mrgl'], [:_params, 'rgl']], :r, ['type']]
+      expect(@constructor.build_sql).to eq ['FROM (VALUES($1), ($2)) AS r (type) ',
+                                            ['mrgl', 'rgl']]
+    end
   end
 
-  context '`join`' do
-    it 'build simple join' do
+  context '`JOIN`' do
+    it 'build simple structure' do
       @constructor.join 'users u ON u.id = m.user_id'
       expect(@constructor.build_sql).to eq 'JOIN users u ON u.id = m.user_id '
       @constructor.join ['users u ON u.id = m.user_id',
@@ -84,7 +125,56 @@ describe Terrazine::Constructor do
     end
   end
 
-  context '`conditions`' do
-    
+  context '`ORDER`' do
+    it 'build string structre' do
+      @constructor.order 'name ASC'
+      expect(@constructor.build_sql).to eq 'ORDER BY name ASC '
+    end
+
+    it 'build array structure' do
+      @constructor.order [:name, :email]
+      expect(@constructor.build_sql).to eq 'ORDER BY name, email '
+    end
+
+    it 'build hash structure' do
+      @constructor.order name: :asc, phone: [:first, :desc]
+      expect(@constructor.build_sql).to eq 'ORDER BY name ASC, phone DESC NULLS FIRST '
+    end
+
+    it 'build complicated structure' do
+      @constructor.order [:role, { name: :asc, phone: [:last, :desc], amount: '<' }]
+      expect(@constructor.build_sql).to eq 'ORDER BY role, name ASC, phone DESC NULLS LAST, amount USING< '
+    end
+  end
+
+  context '`WHERE`' do
+    it 'build simple structure' do
+      @constructor.where [[:not, 'z = 13'],
+                          [:or, 'mrgl = 2', 'rgl = 22'],
+                          [:or, 'rgl = 12', 'zgl = lol']]
+      expect(@constructor.build_sql).to eq 'WHERE NOT z = 13 AND (mrgl = 2 OR rgl = 22) AND (rgl = 12 OR zgl = lol) '
+    end
+
+    it 'build intemidate structure' do
+      @constructor.where [{ role: 'manager', id: [0, 1, 153] },
+                          [:not, [:like, :u__name, 'Aeonax']]]
+      expect(@constructor.build_sql).to eq ['WHERE role = $1 AND id IN ($2) AND NOT u.name LIKE $3 ', ['manager', [0, 1, 153], 'Aeonax']]
+    end
+  end
+
+  context 'Operators' do
+    it 'build missing operator' do
+      sql = Terrazine.build_sql([:_to_json,
+                                 [:_array_agg,
+                                  { select: [:id, :title,
+                                             { _copies_in_stock:
+                                                 { select: [:_count, :id],
+                                                   from: [:book_copies, :b_c],
+                                                   where: ['b_c.shop_id = s.id',
+                                                           'b_c.book_id = b.id',
+                                                           'NOT b_c.sold = TRUE'] } }] }]],
+                                key: 'operator')
+      expect(sql).to eq 'to_json(array_agg((SELECT id, title, (SELECT COUNT(id) FROM book_copies b_c WHERE b_c.shop_id = s.id AND b_c.book_id = b.id AND NOT b_c.sold = TRUE ) AS copies_in_stock )))'
+    end
   end
 end