yesql 0.1.5 → 0.2.1

data/lib/.rbnext/3.0/yesql/query/performer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "yesql"
+require "yesql/bindings/utils"
+require "yesql/common/adapter"
+require "yesql/bindings/transformed"
+require "yesql/query/result"
+require "yesql/query/transform_result"
+require "yesql/params/output"
+
+module ::YeSQL
+  module Query
+    class Performer
+      include ::YeSQL::Bindings::Utils
+
+      def initialize(bind_statement:, file_path:, bindings: {}, output: :rows, prepare: false)
+        @bind_statement = bind_statement
+        @file_path = file_path
+        @named_bindings = bindings.transform_keys(&:to_sym)
+        @output = ::YeSQL::Params::Output.new(output)
+        @prepare = prepare
+      end
+
+      def call ;  ::YeSQL::Query::TransformResult.new(output: output, result: query_result).call; end
+
+      private
+
+      attr_reader :bind_statement, :file_path, :named_bindings, :output, :prepare
+
+      def query_result
+        @query_result ||= ::YeSQL::Query::Result.new(binds: binds,
+                                                     bind_statement: bind_statement,
+                                                     file_path: file_path,
+                                                     prepare: prepare).call
+      end
+
+      def binds
+        ::YeSQL::Bindings::Transformed.new(statement_binds: statement_binds(extractor)).call
+      end
+
+      def extractor ;  ::YeSQL::Bindings::Extractor.new(bindings: named_bindings).call; end
+    end
+  end
+end

data/lib/.rbnext/3.0/yesql/query/result.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "yesql"
+require "forwardable"
+require "yesql/common/adapter"
+
+module ::YeSQL
+  module Query
+    class Result
+      extend ::Forwardable
+
+      include ::YeSQL::Common::Adapter
+
+      def initialize(bind_statement:, file_path:, prepare:, binds: [])
+        @binds = binds
+        @bind_statement = bind_statement
+        @file_path = file_path
+        @prepare_option = prepare
+      end
+
+      def call
+        return view_result if view?
+        return rails5_result if ::ActiveRecord::VERSION::MAJOR == 5 && mysql?
+
+        exec_query(bound, file_path, binds, prepare: prepare_option)
+      end
+
+      private
+
+      attr_reader :binds, :bind_statement, :file_path, :prepare_option
+
+      def_delegators(:bind_statement, :bound, :to_s, :view?)
+      def_delegators(:connection, :exec_query, :raw_connection)
+      def_delegators(:raw_connection, :prepare)
+
+      def view_result ;   exec_query(bound); end
+      def rails5_result ;  prepare(bound).execute(*binds); end
+      def connection ;  @connection ||= ActiveRecord::Base.connection; end
+    end
+  end
+end

data/lib/.rbnext/3.0/yesql/query/transform_result.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "yesql"
+require "yesql/common/adapter"
+require "forwardable"
+
+module ::YeSQL
+  module Query
+    class TransformResult
+      extend ::Forwardable
+
+      include ::YeSQL::Common::Adapter
+
+      def initialize(output:, result:)
+        @output = output
+        @result = result
+      end
+
+      def call
+        if rails_5? && mysql?
+          return columns if columns?
+          return rows_values if rows?
+          return array_of_symbol_hashes if hash?
+        end
+
+        return result.public_send(output.to_sym) if columns? || rows?
+
+        to_a.map(&:symbolize_keys)
+      end
+
+      private
+
+      attr_reader :output, :result
+
+      def_delegators(:result, :fields, :rows, :to_a)
+      def_delegators(:output, :columns?, :hash?, :rows?)
+
+      def array_of_symbol_hashes
+        to_a.tap { break hashed_rows(_1) if rails_5? }.map { _1&.symbolize_keys || _1 }
+      end
+
+      def columns ;  fields || result.columns; end
+      def rows_values ;  to_a.map { _1.respond_to?(:values) ? _1.values : _1 }; end
+      def hashed_rows(rows) ;  rows.map { columns.zip(_1).to_h }; end
+      def rails_5? ;  ::ActiveRecord::VERSION::MAJOR == 5; end
+    end
+  end
+end

data/lib/.rbnext/3.0/yesql/statement.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+require "forwardable"
+
+require "yesql/utils/read"
+require "yesql/bindings/extractor"
+require "yesql/common/adapter"
+
+module ::YeSQL
+  class Statement
+    extend ::Forwardable
+
+    include ::YeSQL::Common::Adapter
+    include ::YeSQL::Utils::Read
+    # Give access to the quote method.
+    include ::ActiveRecord::ConnectionAdapters::Quoting
+
+    def initialize(bindings = {}, file_path)
+      @bindings = bindings
+      @file_path = file_path
+    end
+
+    def bound
+      to_s.gsub(::YeSQL::BIND_REGEX) { extract_bind_values(extractor[_1[/(\w+)/].to_sym]) }
+    end
+
+    def to_s ;  @to_s ||= statement(readable: true); end
+    def view? ;  to_s =~ /^create\s.*view\s/i; end
+
+    private
+
+    attr_reader :bindings, :file_path
+
+    def extract_bind_values(match)
+      return quote(match[:value]) if view?
+
+      match[:bind][:vars]
+    end
+
+    def extractor ;  @extractor ||= ::YeSQL::Bindings::Extractor.new(bindings: bindings).call; end
+  end
+end

data/lib/.rbnext/3.0/yesql/utils/read.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ::YeSQL
+  module Utils
+    module Read
+      def statement(readable: false) ;  read_file(found_file, readable); end
+
+      private
+
+      def read_file(file, readable)
+        return File.readlines(file, chomp: true).join(" ") if readable == true
+
+        File.read(file)
+      end
+
+      def found_file ;  dir_sql_files.find { _1.include?("#{file_path}.sql") }; end
+      def dir_sql_files ;  Dir["./#{::YeSQL.config.path}/**/*.sql"]; end
+    end
+  end
+end

data/lib/yesql.rb

@@ -1,50 +1,45 @@
 # frozen_string_literal: true
 
-require 'yesql/version'
-require 'yesql/config/configuration'
-require 'yesql/query/performer'
-require 'yesql/errors/cache_expiration_error'
-require 'yesql/errors/file_path_does_not_exist_error'
-require 'yesql/errors/no_bindings_provided_error'
-require 'yesql/errors/output_argument_error'
-require 'yesql/bindings/binder'
-
-module YeSQL
+require "backports/2.0"
+require "ruby-next/language/setup"
+
+RubyNext::Language.setup_gem_load_path
+
+require "yesql/statement"
+require "yesql/version"
+require "yesql/config/configuration"
+require "yesql/query/performer"
+require "yesql/errors/file_path_does_not_exist_error"
+require "yesql/errors/no_bindings_provided_error"
+require "yesql/errors/output_argument_error"
+
+module ::YeSQL
   include ::YeSQL::Config
-  include ::YeSQL::Errors::CacheExpirationError
-  include ::YeSQL::Errors::FilePathDoesNotExistError
-  include ::YeSQL::Errors::NoBindingsProvidedError
-  include ::YeSQL::Errors::OutputArgumentError
 
-  BIND_REGEX = /(?<!:):(\w+)(?=\b)/.freeze
+  BIND_REGEX = /(?<!:):(\w+)(?=\b)/
 
-  # rubocop:disable Naming/MethodName
-  def YeSQL(file_path, bindings = {}, options = {})
+  def YeSQL(file_path, binds = {}, options = {})
     output = options[:output] || :rows
-    cache = options[:cache] || {}
 
-    validate(bindings, cache, file_path, output)
-    execute(bindings, cache, file_path, output, options)
+    validate(binds, file_path, output)
+    execute(binds, file_path, output, options[:prepare])
   end
-  # rubocop:enable Naming/MethodName
 
   private
 
-  def validate(bindings, cache, file_path, output)
-    validate_file_path_existence(file_path)
-    validate_statement_bindings(bindings, file_path)
-    validate_output_options(output)
-    validate_cache_expiration(cache[:expires_in]) unless cache.empty?
+  def validate(binds, file_path, output)
+    ::YeSQL::Errors::FilePathDoesNotExistError.new(file_path).validate_file_path_existence
+    ::YeSQL::Errors::NoBindingsProvidedError.new(binds, file_path).validate_statement_bindings
+    ::YeSQL::Errors::OutputArgumentError.new(output).validate_output_options
   end
 
-  def execute(bindings, cache, file_path, output, options)
+  def execute(binds, file_path, output, prepare)
     ::YeSQL::Query::Performer.new(
-      bindings: bindings,
-      bind_statement: ::YeSQL::Bindings::Binder.bind_statement(file_path, bindings),
-      cache: cache,
+      bindings: binds,
+      bind_statement: ::YeSQL::Statement.new(binds, file_path),
       file_path: file_path,
       output: output,
-      prepare: options[:prepare]
+      prepare: prepare
     ).call
   end
 end

data/lib/yesql/bindings/extract.rb

@@ -1,53 +1,52 @@
 # frozen_string_literal: true
 
-require 'yesql'
+require "yesql"
+require "yesql/common/adapter"
 
 module ::YeSQL
   module Bindings
     class Extract
       include ::YeSQL::Common::Adapter
 
-      def initialize(indexed_bindings, hash, index, value)
-        @indexed_bindings = indexed_bindings
+      def initialize(hash, indexed_bindings, index, value)
         @hash = hash
         @index = index
+        @indexed_bindings = indexed_bindings
         @value = value
       end
 
       def bind_vals
         return [nil, value] unless array?
 
-        value.map { |bind| [nil, bind] }
+        value.map { [nil, _1] }
       end
 
       def bind_vars
         if mysql?
-          return '?' unless array?
+          return "?" unless array?
 
-          Array.new(value.size, '?').join(', ')
+          Array.new(size, "?").join(", ")
         elsif pg?
           return "$#{last_val}" unless array?
 
-          value.map.with_index(bind_index) { |_, i| "$#{i}" }.join(', ')
+          value.map.with_index(bind_index) { "$#{_2}" }.join(", ")
         end
       end
 
-      def last_val
-        prev_last_val + current_val_size
-      end
-
       def prev
         return if first?
 
         indexed_bindings[index - 2].first
       end
 
+      def last_val = prev_last_val + current_val_size
+
       private
 
       attr_reader :hash, :index, :indexed_bindings, :value
 
       def current_val_size
-        return value.size if array?
+        return size if array?
 
         1
       end
@@ -58,19 +57,15 @@ module ::YeSQL
         hash[prev][:last_val]
       end
 
-      def first?
-        index == 1
-      end
-
-      def array?
-        value.is_a?(Array)
-      end
-
       def bind_index
         return 1 if first?
 
         prev_last_val + 1
       end
+
+      def size = value.size
+      def first? = index == 1
+      def array? = value.is_a?(Array)
     end
   end
 end

data/lib/yesql/bindings/extractor.rb

@@ -1,38 +1,38 @@
 # frozen_string_literal: true
 
-require 'yesql/bindings/extract'
+require "yesql/bindings/extract"
 
-module YeSQL
+module ::YeSQL
   module Bindings
     class Extractor
-      def initialize(bindings:)
+      def initialize(bindings: {})
         @bindings = bindings
-        @indexed_bindings = (bindings || {}).to_a
+        @indexed_bindings = bindings.to_a
       end
 
-      # rubocop:disable Metrics/MethodLength
       def call
-        bindings.each_with_object({}).with_index(1) do |((key, value), hash), index|
-          hash[key] =
-            ::YeSQL::Bindings::Extract.new(indexed_bindings, hash, index, value).tap do |extract|
-              break {
-                bind: {
-                  vals: extract.bind_vals,
-                  vars: extract.bind_vars
-                },
-                last_val: extract.last_val,
-                match: key,
-                prev: extract.prev,
-                value: value
-              }
-            end
-        end
+        bindings
+          .each_with_object({})
+          .with_index(1) do |((key, value), hash), index|
+            hash[key] = binding_extracts(hash, indexed_bindings, index, key, value)
+          end
       end
-      # rubocop:enable Metrics/MethodLength
 
       private
 
       attr_reader :bindings, :indexed_bindings
+
+      def binding_extracts(hash, indexed_bindings, index, key, value)
+        ::YeSQL::Bindings::Extract.new(hash, indexed_bindings, index, value).tap do
+          break {
+            bind: { vals: _1.bind_vals, vars: _1.bind_vars },
+            last_val: _1.last_val,
+            match: key,
+            prev: _1.prev,
+            value: value
+          }
+        end
+      end
     end
   end
 end

data/lib/yesql/bindings/transformed.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "yesql"
+require "yesql/common/adapter"
+
+module ::YeSQL
+  module Bindings
+    class Transformed
+      include ::YeSQL::Common::Adapter
+
+      def initialize(statement_binds:)
+        @statement_binds = statement_binds
+      end
+
+      def call
+        return mysql_rails5_binds if rails5? && mysql?
+        return mysql_binds if !rails5? && mysql?
+
+        pg_binds
+      end
+
+      private
+
+      attr_reader :statement_binds
+
+      def rails5? = ::ActiveRecord::VERSION::MAJOR == 5
+
+      def mysql_rails5_binds
+        statement_binds
+          .flat_map(&:first)
+          .each_slice(2)
+          .flat_map do
+            next [_1, _2].compact.map(&:last) if _1.is_a?(Array)
+
+            _2
+          end
+      end
+
+      def mysql_binds
+        statement_binds
+          .map(&:first)
+          .flatten
+          .each_slice(2)
+          .to_a
+      end
+
+      def pg_binds
+        statement_binds
+          .sort_by { _2.to_s.tr("$", "").to_i }
+          .uniq
+          .map(&:first)
+          .flatten
+          .each_slice(2)
+          .to_a
+      end
+    end
+  end
+end