db2_query 0.3.1 → 0.3.2

data/lib/db2_query/db_statements.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module DbStatements
+    def query(sql)
+      pool do |client|
+        stmt = client.run(sql)
+        stmt.to_a
+      ensure
+        stmt.drop unless stmt.nil?
+      end
+    end
+
+    def query_rows(sql)
+      query(sql)
+    end
+
+    def query_value(sql)
+      rows = query(sql)
+      row = rows.first
+      row && row.first
+    end
+
+    def query_values(sql)
+      query(sql).map(&:first)
+    end
+
+    def execute(sql, args = [])
+      pool do |client|
+        client.do(sql, *args)
+      end
+    end
+
+    def raw_query(sql, args = [])
+      pool do |client|
+        stmt = client.run(sql, *args)
+        raw_result(stmt)
+      end
+    end
+
+    def exec_query(query, args = [])
+      sql, binds, args = query.exec_query_arguments(args)
+      log(sql, binds, args) do
+        pool do |client|
+          stmt = client.run(sql, *args)
+          columns = stmt.columns.values.map { |col| col.name.downcase }
+          rows = stmt.to_a
+          Db2Query::Result.new(columns, rows, query)
+        ensure
+          stmt.drop unless stmt.nil?
+        end
+      end
+    end
+
+    def reset_id_sequence!(table_name)
+      next_val = max_id(table_name) + 1
+      execute <<-SQL
+        ALTER TABLE #{table_name}
+        ALTER COLUMN ID
+        RESTART WITH #{next_val}
+        SET INCREMENT BY 1
+        SET NO CYCLE
+        SET CACHE 500
+        SET NO ORDER;
+      SQL
+    end
+
+    private
+      def max_id(table_name)
+        query_value("SELECT COALESCE(MAX (ID),0) FROM #{table_name}")
+      end
+
+      def raw_result(stmt)
+        columns = stmt.columns.values.map { |col| col.name.downcase }
+        stmt.to_a.map do |row|
+          index, hash = [0, {}]
+          while index < columns.length
+            hash[columns[index].to_sym] = row[index]
+            index += 1
+          end
+          hash
+        end
+      ensure
+        stmt.drop unless stmt.nil?
+      end
+  end
+end

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

@@ -4,13 +4,78 @@ module Db2Query
   class Error < StandardError
   end
 
-  class StatementInvalid < ActiveRecord::ActiveRecordError
-    def initialize(message = nil, sql: nil, binds: nil)
-      super(message || $!.try(:message))
-      @sql = sql
-      @binds = binds
+  class ArgumentError < StandardError
+    def initialize(given, expected)
+      @given = given
+      @expected = expected
+      super(message)
     end
 
-    attr_reader :sql, :binds
+    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

@@ -12,17 +12,17 @@ module Db2Query
       exception
     end
 
-    def log(sql, name = "SQL", binds = [], args = [], &block)
-      @instrumenter.instrument(
+    def log(sql, binds = [], args = [], &block)
+      instrument(
         "sql.active_record",
         sql:               sql,
-        name:              name,
+        name:              "SQL",
         binds:             binds,
         type_casted_binds: args,
         statement_name:    nil,
         connection_id:     object_id,
         connection:        self) do
-        @lock.synchronize do
+        synchronize do
           yield
         end
       rescue => e
@@ -38,5 +38,15 @@ module Db2Query
         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