terrazine 0.0.2 → 0.0.3

data/lib/terrazine/builder.rb

@@ -1,251 +1,70 @@
+require_relative 'builders/operators'
+require_relative 'builders/predicates'
+require_relative 'builders/expressions'
+require_relative 'builders/clauses'
+require_relative 'builders/params'
+
 module Terrazine
-  # build structures in to sql string
+  # builds structures in to sql string
+  # TODO: SPLIT!!! But how-_-
+  # Operators(sql_functions), Predicates, Clauses(select, from...), Expressions(columns, tables), Params...
+  # they are mixed... everything can contain everything and they must communicate with each other.
+  # And how it can be splitted?
   class Builder
-    attr_accessor :sql, :constructor
+    # https://6ftdan.com/allyourdev/2015/05/02/private-module-methods-in-ruby/
+    # TODO: all methods private except get_sql, get_partial_sql ?
 
-    def initialize(constructor)
-      @constructor = constructor
+    def initialize
       @params = []
     end
 
-    # TODO: update, delete, insert.....
+    # get complete sql structure for constructor.
+    def get_sql(structure, options)
+      # get_partial_sql structure, key: 'sql'
+      wrap_result send("build_#{options[:key] || 'sql'}", structure)
+    end
+
+    # def get_partial_sql(structure, options)
+    # wrap_result send("build_#{options[:key]}", structure)
+    # end
+
+    private
+
+    # TODO: update, delete, insert, group.....
     def build_sql(structure)
       structure = structure.is_a?(Constructor) ? structure.structure : structure
       sql = ''
-      sql += "WITH #{build_with(structure[:with])} " if structure[:with]
-      # puts "build_sql, structure: #{structure}"
-      [:union, :select, :insert, :update, :delete, :set, :from, :join, :where,
-       :group, :order, :limit, :offset].each do |i|
+      [:with, :union, :select, :insert, :update, :delete, :set, :from,
+       :join, :where, :returning, :group, :order, :limit, :offset].each do |i|
          next unless structure[i]
-         sql += send("build_#{i}".to_sym, structure[i])
+         sql += send("build_#{i}", structure[i], structure)
        end
       sql
     end
 
-    # get complete sql structure for constructor.
-    def get_sql(structure)
-      sql = build_sql structure
-      res = @params.count.positive? ? [sql, @params] : sql
-      @params = []
-      res
-    end
-
-    def build_with(structure)
-      if structure.second.is_a? Hash
-        "#{structure.first} AS (#{build_sql(structure.last)})"
+    def method_missing(name, *args)
+      /(?<type>[^_]+)_(?<action>\w+)/ =~ name
+      # arguments = [action]
+      if type && respond_to?("#{type}_missing", true)
+        send "#{type}_missing", action, *args
       else
-        structure.map { |v| build_with(v) }.join ', '
+        super
       end
     end
 
-    # def build_select_query(structure)
-    # puts "build_select_query, structure: #{structure}"
-    # sql += build_select(structure[:select], structure[:distinct]) if structure[:select]
-    # [:from, :join, :where, :order, :limit, :offset].each do |i|
-    # sql += send("build_#{i}", structure[i]) if structure[i]
-    # end
+    # TODO
+    # def construct_as(field, name)
     # end
 
-    def build_union(structure)
-      structure.map { |i| build_sql(i) }.join ' UNION '
-    end
-
-    def build_distinct_select(distinct)
-      case distinct
-      when Array
-        "DISTINCT ON(#{build_columns fields}) "
-      when true
-        'DISTINCT '
-      end
-    end
-
-    def build_select(structure, distinct = nil)
-      # puts "build_select, structure #{structure}"
-      "SELECT #{build_distinct_select distinct}#{build_columns structure} "
-    end
-
-    def build_tables(structure)
-      case structure
-      when Array
-        if check_alias(structure.first) # VALUES function or ...?
-          build_function(structure)
-        # if it's a array with strings/values
-        elsif structure.select { |i| i.is_a? Array }.empty? # array of table_name and alias
-          structure.join ' '
-        else # array of tables/values
-          structure.map { |i| i.is_a?(Array) ? build_tables(i) : i }.join(', ')
-        end
-      when String, Symbol
-        structure
-      else
-        raise "Undefined structure for FROM - #{structure}"
-      end
-    end
-
-    def build_from(structure)
-      "FROM #{build_tables(structure)} "
-    end
-
-    def conditions_constructor(structure, joiner = :and, level = nil)
-      case structure
-      when Array
-        key = structure.first
-        # AND, OR support
-        if key.is_a? Symbol
-          res = structure.drop(1).map { |i| conditions_constructor(i) }.join " #{key} ".upcase
-          level ? res : "(#{res})"
-        # Sub Queries support - ['rgl IN ?', {...}]
-        elsif key =~ /\?/
-          if [Hash, Constructor].include?(structure.second.class)
-            key.sub(/\?/, "(#{build_sql(structure.second)})")
-          else
-            key.sub(/\?/, build_param(structure.second))
-          end
-        else
-          res = structure.map { |i| conditions_constructor(i) }.join " #{joiner} ".upcase
-          level ? res : "(#{res})"
-        end
-      when String
-        structure
-      end
-    end
-
-    # TODO? conditions like [:eq :name :Aeonax]
-    def build_conditions(structure)
-      conditions_constructor(structure, :and, true) + ' '
-    end
-
-    # TODO: -_-
-    def build_join(structure)
-      if structure.is_a? Array
-        # TODO: hash is sux here -_- !!!!!!
-        if structure.second.is_a? Hash
-          name = build_tables structure.first # (name.is_a?(Array) ? name.join(' ') : name)
-          v = structure.second
-          "#{v[:option].to_s.upcase + ' ' if v[:option]}JOIN #{name} ON #{build_conditions v[:on]}"
-        else
-          structure.map { |i| build_join(i) }.join
-        end
-      else
-        structure =~ /join/i ? structure : "JOIN #{structure} "
-      end
-    end
-
-    def build_where(structure)
-      "WHERE #{build_conditions(structure)} "
-    end
-
-    # TODO!
-    def build_order(structure)
-      "ORDER BY #{structure} "
-    end
-
-    def build_limit(limit)
-      "LIMIT #{limit || 8} "
-    end
-
-    def build_offset(offset)
-      "OFFSET #{offset || 0} "
-    end
-
-    private
-
-    def build_param(value)
-      # no need for injections check - pg gem will check it
-      @params << value
-      "$#{@params.count}"
-    end
-
     # all functions and column aliases begins from _
     def check_alias(val)
       val.to_s =~ /^_/
     end
 
-    def iterate_hash(data)
+    def iterate_hash(data, join = true)
       iterations = []
       data.each { |k, v| iterations << yield(k, v) }
-      iterations.join ', '
-    end
-
-    def build_as(field, name)
-      "#{field} AS #{name.to_s.sub(/^_/, '')}" # update ruby for delete_prefix? =)
-    end
-
-    def build_columns(structure, prefix = nil)
-      case structure
-      when Array
-        # SQL function - in format: "_#{fn}"
-        if check_alias(structure.first)
-          build_function structure, prefix
-        else
-          structure.map { |i| build_columns i, prefix }.join ', '
-        end
-      when Hash
-        # sub_query
-        if structure[:select]
-          "(#{build_sql(structure)})"
-        # colum OR table alias
-        else
-          iterate_hash(structure) do |k, v|
-            if check_alias(k)
-              build_as(build_columns(v, prefix), k)
-            else
-              build_columns(v, k.to_s)
-            end
-          end
-        end
-      when Symbol, String
-        structure = structure.to_s
-        if prefix && structure !~ /, |\./
-          "#{prefix}.#{structure}"
-        else
-          structure
-        end
-      when Constructor
-        "(#{build_sql structure.structure})"
-      when true # choose everything -_-
-        build_columns('*', prefix)
-      else # TODO: values from value passing here... -_-
-        structure
-        # raise "Undefined class: #{structure.class} of #{structure}" # TODO: ERRORS class
-      end
-    end
-
-    # TODO!!!!!!! Relocate in class FunctionsBuilder? and send function name in it.
-    def build_function(structure, prefix = nil)
-      function = structure.first.to_s.sub(/^_/, '')
-      arguments = structure.drop(1)
-      case function.to_sym
-      when :param
-        build_param arguments.first
-      when :count # TODO? alias support on this lvl
-        if arguments.count > 1
-          arguments.map { |i| "COUNT(#{build_columns(i, prefix)})" }.join ','
-        else
-          "COUNT(#{build_columns(arguments.first, prefix)})"
-        end
-      when :nullif
-        # TODO? querry for value
-        "NULLIF(#{build_columns(arguments.first, prefix)}, #{arguments[1]})"
-      when :array # TODO? build_columns support
-        if [Hash, Constructor].include?(arguments.first.class)
-          "ARRAY(#{build_sql arguments.first})"
-        else # TODO? condition and error case
-          "ARRAY[#{arguments.join ', '}]"
-        end
-      when :avg
-        "AVG(#{build_columns(arguments.first, prefix)})"
-      when :values
-        "(VALUES(#{build_columns arguments.first, prefix})) AS #{structure[2]} (#{build_columns arguments.last})"
-      when :case
-        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"
-      when :coalesce
-        "COALESCE(#{build_columns(arguments, prefix)})"
-      else
-        raise "Unknown function #{function}" # TODO: errors-_-
-      end
+      join ? iterations.join(', ') : iterations
     end
   end
 end

data/lib/terrazine/builders/clauses.rb

@@ -0,0 +1,145 @@
+module Terrazine
+  class Builder
+    # it use Predicate, expressions
+
+    private
+
+    # TODO: :with_recursive
+    def build_with(structure, _)
+      "WITH #{construct_with(structure)} "
+    end
+
+    def build_union(structure, _)
+      structure.map { |i| build_sql(i) }.join ' UNION '
+    end
+
+    def build_select(structure, common_structure)
+      distinct = construct_distinct common_structure[:distinct]
+      "SELECT #{distinct}#{build_columns structure} "
+    end
+
+    def build_from(structure, _)
+      "FROM #{build_tables(structure)} "
+    end
+
+    # TODO: -_-
+    def build_join(structure, _)
+      if structure.is_a? Array
+        # TODO: hash is sux here -_- !!!!!!
+        if structure.second.is_a? Hash
+          name = build_tables structure.first # (name.is_a?(Array) ? name.join(' ') : name)
+          v = structure.second
+          "#{v[:option].to_s.upcase + ' ' if v[:option]}JOIN #{name} ON #{build_predicates v[:on]} "
+        else
+          structure.map { |i| build_join(i, nil) }.join
+        end
+      else
+        structure =~ /join/i ? structure : "JOIN #{structure} "
+      end
+    end
+
+    # TODO!
+    def build_update(structure, _)
+      "UPDATE #{construct_update structure} "
+    end
+
+    def build_returning(structure, _)
+      "RETURNING #{build_columns structure}"
+    end
+
+    def build_where(structure, _)
+      "WHERE #{build_predicates(structure)} "
+    end
+
+    # TODO!
+    def build_order(structure, _)
+      "ORDER BY #{construct_order structure} "
+    end
+
+    def build_limit(limit, _)
+      "LIMIT #{limit || 8} "
+    end
+
+    def build_offset(offset, _)
+      "OFFSET #{offset || 0} "
+    end
+
+    def construct_with(structure)
+      case structure
+      when Array
+        if structure.second.is_a? Hash
+          "#{structure.first} AS (#{build_sql(structure.last)})"
+        else
+          structure.map { |v| construct_with(v) }.join ', '
+        end
+      when Hash
+        iterate_hash(structure) { |k, v| "#{k} AS (#{build_sql v})" }
+      else
+        raise
+      end
+    end
+
+    def construct_distinct(structure)
+      return unless structure
+      if structure == true
+        'DISTINCT '
+      else
+        "DISTINCT ON(#{build_columns structure}) "
+      end
+    end
+
+    def construct_update(structure)
+      case structure
+      when Array
+        table = build_tables structure.first
+        "#{table} SET #{construct_set structure.last}"
+      when String
+        structure
+      else
+        raise "Undefined structure for `UPDATE`: #{structure}"
+      end
+    end
+
+    # TODO: (..., ...) = (..., ...)
+    def construct_set(structure)
+      case structure
+      when Hash
+        iterate_hash(structure) { |k, v| "#{build_columns k} = #{build_columns v}" }
+      when String
+        structure
+      else
+        raise "Undefined structure for `UPDATE`: #{structure}"
+      end
+    end
+
+    # { name: :asc, email: [:desc, :last] }
+    # [:name, :email, { phone: :last }]
+    def construct_order(structure)
+      case structure
+      when Array # function or values for order
+        if check_alias structure.first
+          build_operator structure
+        else
+          structure.map { |i| construct_order i }.join ', '
+        end
+      when Hash
+        iterate_hash(structure) { |k, v| "#{construct_order k} #{construct_order_options v}" }
+      else
+        structure
+      end
+    end
+
+    def construct_order_options(option)
+      case option
+      when Array
+        option.sort.map { |i| construct_order_options i }.join ' '
+      when :last, :first
+        "nulls #{option}".upcase
+      when :asc, :desc
+        option.to_s.upcase
+      else
+        "USING#{option}"
+      end
+    end
+  end
+end

data/lib/terrazine/builders/expressions.rb

@@ -0,0 +1,72 @@
+module Terrazine
+  class Builder
+
+    # doesn't use Predicates
+    # use Operators, Expressions
+
+    private
+
+    # TODO: split
+    def build_tables(structure)
+      case structure
+      when Array
+        if check_alias(structure.first) # VALUES function or ...?
+          build_operator(structure)
+        # if it's a array with strings/values || array of tables/values
+        else
+          joiner = structure.select { |i| i.is_a? Array }.empty? ? ' ' : ', '
+          structure.map { |i| build_tables i }.join joiner
+        end
+      when Hash
+        "(#{build_sql structure})"
+      when String, Symbol
+        structure
+      else
+        raise "Undefined structure for FROM - #{structure}"
+      end
+    end
+
+    # TODO: split
+    def build_columns(structure, prefix = nil)
+      case structure
+      when Array
+        # SQL function - in format: "_#{fn}"
+        if check_alias(structure.first)
+          build_operator structure, prefix
+        else
+          structure.map { |i| build_columns i, prefix }.join ', '
+        end
+      when Hash
+        # sub_query
+        if structure[:select]
+          "(#{build_sql(structure)})"
+        # colum OR table alias
+        else
+          iterate_hash(structure) do |k, v|
+            if check_alias(k)
+              # update ruby for delete_prefix? =)
+              "#{build_columns(v, prefix)} AS #{k.to_s.sub(/^_/, '')}"
+              # construct_as(build_columns(v, prefix), k)
+            else
+              build_columns(v, k.to_s)
+            end
+          end
+        end
+      when Symbol, String, Integer
+        structure = structure.to_s
+        if prefix && structure !~ /, |\.|\(/
+          "#{prefix}.#{structure}"
+        else
+          structure
+        end
+      when Constructor
+        "(#{build_sql structure.structure})"
+      when true # choose everything -_-
+        build_columns('*', prefix)
+      else # TODO: values from value passing here... -_-
+        structure
+        # raise "Undefined class: #{structure.class} of #{structure}" # TODO: ERRORS class
+      end
+    end
+  end
+end