db2_query 0.2.2 → 0.3.2

data/lib/db2_query/definitions.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Db2Query
+  class Definitions
+    attr_accessor :types, :types_map
+
+    def initialize(types_map)
+      @types_map = types_map
+      describe
+      initialize_types
+    end
+
+    def describe
+      raise Db2Query::Error, "Please describe query definitions at #{self.class.name}"
+    end
+
+    def queries
+      @queries ||= {}
+    end
+
+    def query_definition(query_name, &block)
+      definition = Query.new(query_name)
+      yield definition
+      queries[query_name] = definition
+    end
+
+    def lookup(query_name)
+      queries.fetch(query_name)
+    rescue
+      raise Db2Query::QueryDefinitionError.new(name, query_name)
+    end
+
+    def lookup_query(*args)
+      query_name, sql = query_definitions(args)
+      lookup(query_name).tap do |query|
+        query.define_sql(sql)
+      end
+    end
+
+    private
+      def initialize_types
+        queries.each do |query_name, definition|
+          definition.columns.each do |column, col_def|
+            definition.types.store(column, data_type_instance(col_def))
+          end
+        end
+      end
+
+      def new_data_type(klass, options)
+        options.nil? ? klass.new : klass.new(**options)
+      rescue Exception => e
+        raise Db2Query::Error, e.message
+      end
+
+      def data_type_instance(column_definition)
+        data_type, options = column_definition
+        klass = @types_map.fetch(data_type)
+        new_data_type(klass, options)
+      rescue
+        raise Db2Query::Error, "Not supported `#{data_type}` data type"
+      end
+
+      def fetch_query_name(args)
+        placeholder = args.pop
+        placeholder.fetch(:query_name)
+      rescue
+        raise Db2Query::ImplementationError.new
+      end
+
+      def query_definitions(args)
+        case args.first
+        when Array
+          query_name = fetch_query_name(args.first)
+          [query_name, args.last]
+        else args
+        end
+      end
+  end
+end

data/lib/db2_query/error.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Db2Query
+  class Error < StandardError
+  end
+
+  class ArgumentError < StandardError
+    def initialize(given, expected)
+      @given = given
+      @expected = expected
+      super(message)
+    end
+
+    def message
+      "Wrong number of arguments (given #{@given}, expected #{@expected})"
+    end
+  end
+
+  class ColumnError < StandardError
+    def initialize(def_cols, res_cols)
+      @def_cols = def_cols
+      @res_cols = res_cols
+      super(message)
+    end
+
+    def message
+      "Wrong number of columns (query definitions #{@def_cols}, query result #{@res_cols})"
+    end
+  end
+
+  class ConnectionError < StandardError
+    def initialize(odbc_message)
+      @odbc_message = odbc_message
+      super(message)
+    end
+
+    def message
+      "Unable to activate ODBC DSN connection #{@odbc_message}"
+    end
+  end
+
+  class ExtentionError < StandardError
+  end
+
+  class ImplementationError < StandardError
+    def message
+      "Method `fetch`, `fetch_list`, and `exec_query` can only be implemented inside a lambda query"
+    end
+  end
+
+  class ListTypeError < StandardError
+  end
+
+  class MissingListError < StandardError
+  end
+
+  class QueryDefinitionError < StandardError
+    def initialize(klass, query_name = nil, column = nil)
+      @klass = klass
+      @query_name = query_name
+      @column = column
+      super(message)
+    end
+
+    def message
+      if @query_name.nil?
+        "Definitions::#{@klass}Definitions file not found."
+      elsif @column.nil?
+        "No query definition found for #{@klass}:#{@query_name}"
+      else
+        "Column `#{@column}` not found at `#{@klass} query:#{@query_name}` Query Definitions."
+      end
+    end
+  end
+
+  class QueryMethodError < StandardError
+    def message
+      "The query body needs to be callable or is a SQL statement string"
+    end
+  end
+end

data/lib/db2_query/field_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module FieldType
+    DEFAULT_FIELD_TYPES = {
+      binary: Db2Query::Type::Binary,
+      boolean:  Db2Query::Type::Boolean,
+      string: Db2Query::Type::String,
+      varchar: Db2Query::Type::String,
+      longvarchar: Db2Query::Type::String,
+      decimal: Db2Query::Type::Decimal,
+      integer: Db2Query::Type::Integer,
+      date: Db2Query::Type::Date,
+      time: Db2Query::Type::Time,
+      timestamp: Db2Query::Type::Timestamp
+    }
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      mattr_reader :field_types_map
+      @@field_types_map = nil
+
+      def set_field_types(types = DEFAULT_FIELD_TYPES)
+        @@field_types_map = types
+      end
+    end
+  end
+end

data/lib/db2_query/helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module Helper
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def sql_with_list(sql, list)
+        if sql.scan(/\@list+/).length == 0
+          raise Db2Query::MissingListError, "Missing @list pointer at SQL"
+        elsif !list.is_a?(Array)
+          raise Db2Query::ListTypeError, "The arguments should be an array of list"
+        end
+        sql.gsub("@list", "'#{list.join("', '")}'")
+      end
+
+      def sql_with_extention(sql, extention)
+        if sql.scan(/\@extention+/).length == 0
+          raise Db2Query::ExtentionError, "Missing @extention pointer at SQL"
+        end
+        sql.gsub("@extention", extention.strip)
+      end
+
+      private
+        def sql_query_methods
+          self.instance_methods.grep(/_sql/)
+        end
+
+        def sql_query_symbol(method_name)
+          "#{method_name}_sql".to_sym
+        end
+
+        def sql_query_method?(method_name)
+          sql_query_name = sql_query_symbol(method_name)
+          sql_query_methods.include?(sql_query_name)
+        end
+
+        def validate_sql(sql)
+          raise Db2Query::Error, "SQL have to be in string format" unless sql.is_a?(String)
+        end
+
+        def fetch_error_message
+          "`fetch`, `fetch_list` and `fetch_extention` methods applied for SQL `select` statement only."
+        end
+    end
+  end
+end

data/lib/db2_query/logger.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module Logger
+    def translate_exception_class(e, sql, binds)
+      message = "#{e.class.name}: #{e.message}"
+
+      exception = translate_exception(
+        e, message: message, sql: sql, binds: binds
+      )
+      exception.set_backtrace e.backtrace
+      exception
+    end
+
+    def log(sql, binds = [], args = [], &block)
+      instrument(
+        "sql.active_record",
+        sql:               sql,
+        name:              "SQL",
+        binds:             binds,
+        type_casted_binds: args,
+        statement_name:    nil,
+        connection_id:     object_id,
+        connection:        self) do
+        synchronize do
+          yield
+        end
+      rescue => e
+        raise translate_exception_class(e, sql, binds)
+      end
+    end
+
+    def translate_exception(exception, message:, sql:, binds:)
+      case exception
+      when RuntimeError
+        exception
+      else
+        StatementInvalid.new(message, sql: sql, binds: binds)
+      end
+    end
+
+    class StatementInvalid < ActiveRecord::ActiveRecordError
+      def initialize(message = nil, sql: nil, binds: nil)
+        super(message || $!.try(:message))
+        @sql = sql
+        @binds = binds
+      end
+
+      attr_reader :sql, :binds
+    end
+  end
+end

data/lib/db2_query/query.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Db2Query
+  class Query
+    attr_reader :columns, :keys, :query_name, :sql, :types
+
+    include SqlStatement
+
+    def initialize(query_name = nil)
+      @columns = {}
+      @query_name = query_name
+      @sql_statement = nil
+      @types = {}
+    end
+
+    def define_sql(sql)
+      @keys ||= new_keys(sql)
+      @sql ||= sql.tr("$", "")
+    end
+
+    def map_column(name, args)
+      @columns[name] = args
+    end
+
+    def method_missing(method_name, *args, &block)
+      map_column(method_name, args)
+    end
+
+    def data_type(key)
+      column = column_from_key(key)
+      types.fetch(column.to_sym)
+    rescue
+      raise Db2Query::Error, "No column #{column} found at query: #{query_name} definitions"
+    end
+
+    def length
+      columns.length
+    end
+
+    def raw_query_args(args)
+      case args
+      when Array, Hash
+        validated_args(args)
+      else
+        args
+      end
+    end
+
+    def define_args(args)
+      class_eval { attr_accessor "args" }
+      send("args=", raw_query_args(args))
+    end
+
+    def sorted_args(args)
+      keys.map.with_index do |key, index|
+        serialized_arg(args.is_a?(Hash) ? args[key] : args[index], key)
+      end
+    end
+
+    def column_id
+      columns.fetch(:id, nil)
+    end
+
+    def validate_result_columns(result_columns)
+      res_cols, def_cols = [result_columns.length, length]
+      if res_cols != def_cols
+        raise Db2Query::ColumnError.new(def_cols, res_cols)
+      end
+    end
+
+    def exec_query_arguments(args)
+      [db2_spec_sql, binds(args), validated_args(args)]
+    end
+
+    def validate_select_query
+      if iud_sql?
+        raise Db2Query::Error, "Fetch queries are used for select statement query only."
+      end
+    end
+
+    class Bind < Struct.new(:name, :value)
+    end
+
+    private
+      def new_keys(raw_sql)
+        raw_sql.scan(/\$\S+/).map { |key| key.gsub!(/[$=,)]/, "").to_sym }
+      end
+
+      def serialized_arg(arg, key)
+        query_name.nil? ? arg : data_type(key).serialize(arg)
+      end
+
+      def column_from_key(key)
+        "#{key}".split(".").last.downcase
+      end
+
+      def new_bind(key, arg)
+        [Bind.new(column_from_key(key), arg), arg]
+      end
+
+      def binds(args)
+        keys.map.with_index do |key, index|
+          new_bind(key, args.first.is_a?(Hash)? args.first[key] : args[index])
+        end
+      end
+
+      def validate_arguments(given, expected)
+        raise Db2Query::ArgumentError.new(given, expected) unless given == expected
+      end
+
+      def validated_args(args)
+        args = args.first.is_a?(Hash) ? args.first : args
+        validate_arguments(args.length, keys.length)
+        sorted_args(args)
+      end
+  end
+end

data/lib/db2_query/quoting.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module Quoting
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def quoted_true
+        "TRUE"
+      end
+
+      def unquoted_true
+        1
+      end
+
+      def quoted_false
+        "FALSE"
+      end
+
+      def unquoted_false
+        0
+      end
+
+      def quoted_binary(value)
+        "x'#{value.hex}'"
+      end
+
+      def quoted_time(value)
+        value = value.change(year: 2000, month: 1, day: 1)
+        quoted_date(value).sub(/\A\d\d\d\d-\d\d-\d\d /, "")
+      end
+
+      def quoted_date(value)
+        if value.acts_like?(:time)
+          if ActiveRecord::Base.default_timezone == :utc
+            value = value.getutc if !value.utc?
+          else
+            value = value.getlocal
+          end
+        end
+
+        result = value.to_s(:db)
+        if value.respond_to?(:usec) && value.usec > 0
+          result << "." << sprintf("%06d", value.usec)
+        else
+          result
+        end
+      end
+
+      private
+        def _quote(value)
+          case value
+          when String, Symbol, ActiveSupport::Multibyte::Chars
+            "'#{quote_string(value.to_s)}'"
+          when true
+            quoted_true
+          when false
+            quoted_false
+          when nil
+            "NULL"
+          when BigDecimal
+            value.to_s("F")
+          when Numeric, ActiveSupport::Duration
+            value.to_s
+          when Db2Query::Type::Binary::Data
+            quoted_binary(value)
+          when ActiveRecord::Type::Time::Value
+            "'#{quoted_time(value)}'"
+          when Date, Time
+            "'#{quoted_date(value)}'"
+          when Class
+            "'#{value}'"
+          else raise TypeError, "can't quote #{value.class.name}"
+          end
+        end
+
+        def _type_cast(value)
+          case value
+          when Symbol, ActiveSupport::Multibyte::Chars
+            value.to_s
+          when Db2Query::Type::Binary::Data
+            value.hex
+          when true
+            unquoted_true
+          when false
+            unquoted_false
+          when BigDecimal
+            value.to_s("F")
+          when nil, Numeric, String
+            value
+          when ActiveRecord::Type::Time::Value
+            quoted_time(value)
+          when Date, Time
+            quoted_date(value)
+          else raise TypeError, "can't cast #{value.class.name}"
+          end
+        end
+    end
+  end
+end