db2_query 0.2.3 → 0.3.3

data/lib/db2_query/helper.rb

@@ -0,0 +1,50 @@
+# 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_extension(sql, extension)
+        if sql.scan(/\@extension+/).length == 0
+          raise Db2Query::ExtensionError, "Missing @extension pointer at SQL"
+        end
+        sql.gsub("@extension", extension.strip)
+      end
+      alias sql_with_extention sql_with_extension
+
+      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_extension` 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,128 @@
+# frozen_string_literal: true
+
+module Db2Query
+  class Query
+    attr_reader :query_name, :sql, :columns, :keys, :types, :argument_types
+
+    include SqlStatement
+
+    def initialize(query_name = nil)
+      @columns = {}
+      @query_name = query_name
+      @sql_statement = nil
+      @argument_types = {}
+      @types = {}
+    end
+
+    def define_sql(sql)
+      @keys ||= sql_arguments(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 argument_type(key)
+      argument_types.fetch(key) || data_type(key)
+    rescue
+      raise Db2Query::Error, "No argument #{key} type found at query: #{query_name}"
+    end
+
+    def argument_keys
+      keys.map do |key|
+        arg_key = "#{key}".split(".").last
+        arg_key.to_sym unless arg_key.nil?  
+      end
+    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)
+      argument_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 sql_arguments(raw_sql)
+        raw_sql.scan(/\$\S+/).map { |arg| arg.gsub!(/[$=,)]/, "").to_sym }
+      end
+
+      def serialized_arg(arg, key)
+        query_name.nil? ? arg : argument_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 validated_args(args)
+        arguments = args.first.is_a?(Hash) ? args.first : args
+        given, expected = [arguments.length, keys.length]
+        raise Db2Query::ArgumentError.new(given, expected) unless given == expected
+        sorted_args(arguments)
+      end
+  end
+end

data/lib/db2_query/railtie.rb

@@ -1,20 +1,15 @@
 # frozen_string_literal: true
 
-require "db2_query"
-require "rails"
-
-module DB2Query
-  class Railtie < Rails::Railtie
+module Db2Query
+  class Railtie < ::Rails::Railtie
     railtie_name :db2_query
 
     rake_tasks do
-      path = File.expand_path(__dir__)
-      Dir.glob("#{path}/tasks/*.rake").each { |f| load f }
+      Dir.glob("#{Db2Query.root}/db2_query/tasks/*.rake").each { |f| load f }
     end
 
-    initializer "db2_query.database_initialization" do
-      DB2Query::Base.configurations = DB2Query.config
-      DB2Query::Base.establish_connection :primary
+    config.app_generators do
+      require "#{Db2Query.root}/rails/generators/query/query_generator.rb"
     end
   end
 end

data/lib/db2_query/result.rb

@@ -1,69 +1,89 @@
 # frozen_string_literal: true
 
-module DB2Query
+module Db2Query
   class Result < ActiveRecord::Result
-    attr_reader :formatters
+    attr_reader :definition
 
-    def initialize(columns, rows, formatters = {}, column_types = {})
-      @formatters = formatters
-      super(columns, rows, column_types)
+    alias query definition
+
+    delegate :data_type, :validate_result_columns, to: :definition
+
+    def initialize(columns, rows, definition)
+      @definition = definition
+      validate_result_columns(columns)
+      super(columns, rows, {})
+    end
+
+    def record
+      records.first
     end
 
     def records
-      @records ||= rows.map do |row|
-        Record.new(row, columns, formatters)
-      end
+      @records ||= rows.map { |row| new_record(row) }
     end
 
     def to_h
       rows.map do |row|
-        columns.zip(row).each_with_object({}) { |cr, h| h[cr[0].to_sym] = cr[1] }
+        index, hash = [0, {}]
+        while index < columns.length
+          attr_name = columns[index].to_sym
+          hash[attr_name] = data_type(attr_name).deserialize(row[index])
+          index += 1
+        end
+        hash
       end
     end
 
     def inspect
       entries = records.take(11).map!(&:inspect)
-
       entries[10] = "..." if entries.size == 11
-
-      "#<#{self.class.name} @records=[#{entries.join(', ')}]>"
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
     end
 
     class Record
-      attr_reader :formatters
+      attr_reader :definition
 
-      def initialize(row, columns, formatters)
-        @formatters = formatters
-        columns.zip(row) do |col, val|
-          column, value = format(col, val)
-          singleton_class.class_eval { attr_accessor "#{column}" }
-          send("#{column}=", value)
-        end
+      delegate :data_type, to: :definition
+
+      def initialize(row, columns, definition)
+        @definition = definition
+        add_attributes(columns, row)
       end
 
       def inspect
         inspection = if defined?(instance_variables) && instance_variables
-          instance_variables.reject { |var| var == :@formatters }.map do |attr|
-            value = instance_variable_get(attr)
-            "#{attr[1..-1]}: #{(value.kind_of? String) ? %Q{"#{value}"} : value}"
+          instance_variables.reject { |var| var == :@definition }.map do |attribute|
+            "#{attribute[1..-1]}: #{instance_variable_get(attribute)}"
           end.compact.join(", ")
         else
           "not initialized"
         end
-
         "#<Record #{inspection}>"
       end
 
       private
-        def format(col, val)
-          column = col.downcase
-          format_name = formatters[column.to_sym]
-          unless format_name.nil?
-            formatter = DB2Query::Formatter.lookup(format_name)
-            val = formatter.format(val)
+        def add_attributes(columns, row)
+          index = 0
+          while index < columns.length
+            column, value = [columns[index], row[index]]
+            class_eval { attr_accessor "#{column}" }
+            send("#{column}=", data_type(column).deserialize(value))
+            index += 1
           end
-          [column, val]
         end
     end
+
+    private
+      def new_record(row)
+        Record.new(row, columns, definition)
+      end
+
+      def method_missing(method_name, *args, &block)
+        if record.respond_to?(method_name)
+          record.send(method_name)
+        else
+          super
+        end
+      end
   end
 end

data/lib/db2_query/sql_statement.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module SqlStatement
+    def delete_sql?
+      sql.match?(/delete/i)
+    end
+
+    def insert_sql?
+      sql.match?(/insert/i)
+    end
+
+    def iud_sql?
+      sql.match?(/insert into|update|delete/i)
+    end
+
+    def db2_spec_sql
+      iud_sql? ? iud_spec_sql : sql
+    end
+
+    def table_name
+      insert_sql? ? sql.split("INTO ").last.split(" ").first : nil
+    end
+
+    private
+      def new_keys(raw_sql)
+        raw_sql.scan(/\$\S+/).map { |key| key.gsub!(/[$=,)]/, "").to_sym }
+      end
+
+      def iud_spec_sql
+        "SELECT * FROM #{delete_sql? ? "OLD" : "NEW"} TABLE (#{sql})"
+      end
+  end
+end

data/lib/db2_query/tasks/database.rake

@@ -1,54 +1,10 @@
 # frozen_string_literal: true
 
-DB2_QUERY_DATABASE_TEMPLATE ||= <<-EOF
-# frozen_string_literal: true
-# Database configuration example
-development:
-  primary:
-    dsn: iseries
-    uid: <%= ENV["ISERIES_UID"] %>
-    pwd: <%= ENV["ISERIES_PWD"] %>
-  secondary:
-    conn_string:
-      driver: DB2
-      database: ARUNIT2
-      dbalias: ARUNIT2
-      hostname: LOCALHOST
-      currentschema: LIBTEST
-      port: "0"
-      protocol: IPC
-      uid: <%= ENV["DB2EC_UID"] %>
-      pwd: <%= ENV["DB2EC_PWD"] %>
-test:
-  primary:
-    dsn: iseries
-    uid: <%= ENV["ISERIES_UID"] %>
-    pwd: <%= ENV["ISERIES_PWD"] %>
-  secondary:
-    conn_string:
-      driver: DB2
-      database: ARUNIT2
-      dbalias: ARUNIT2
-      hostname: LOCALHOST
-      currentschema: LIBTEST
-      port: "0"
-      protocol: IPC
-      uid: <%= ENV["DB2EC_UID"] %>
-      pwd: <%= ENV["DB2EC_PWD"] %>
-EOF
+require "db2_query/tasks"
 
 namespace :db2query do
   desc "Create Database configuration file"
   task :database do
-    database_path = "#{Rails.root}/config/db2query_database.yml"
-    if File.exist?(database_path)
-      raise ArgumentError, "File exists."
-    else
-      puts "  Creating database config file ..."
-      File.open(database_path, "w") do |file|
-        file.puts DB2_QUERY_DATABASE_TEMPLATE
-      end
-      puts "  File '#{database_path}' created."
-    end
+    Db2Query::DatabaseTask.generate_file
   end
 end

data/lib/db2_query/tasks/init.rake

@@ -3,7 +3,7 @@
 namespace :db2query do
   desc "Create Initializer and Database configuration file"
   task :init do
-    Rake::Task["db2query:initializer"].invoke
     Rake::Task["db2query:database"].invoke
+    Rake::Task["db2query:initializer"].invoke
   end
 end

data/lib/db2_query/tasks/initializer.rake

@@ -1,42 +1,10 @@
 # frozen_string_literal: true
 
-DB2_QUERY_INITIALIZER_TEMPLATE ||= <<-EOF
-# frozen_string_literal: true
-
-require "db2_query"
-require "db2_query/formatter"
-
-DB2Query::Base.initiation do |base|
-  base.configurations = base.parent.config
-  base.establish_connection ENV['RAILS_ENV'].to_sym
-end
-
-# Example
-
-class FirstNameFormatter < DB2Query::AbstractFormatter
-  def format(value)
-    "Dr." + value
-  end
-end
-
-DB2Query::Formatter.registration do |format|
-  format.register(:first_name_formatter, FirstNameFormatter)
-end
-EOF
+require "db2_query/tasks"
 
 namespace :db2query do
   desc "Create Initializer file"
   task :initializer do
-    # Create initializer file
-    initializer_path = "#{Rails.root}/config/initializers/db2query.rb"
-    if File.exist?(initializer_path)
-      raise ArgumentError, "File exists."
-    else
-      puts "  Creating initializer file ..."
-      File.open(initializer_path, "w") do |file|
-        file.puts DB2_QUERY_INITIALIZER_TEMPLATE
-      end
-      puts "  File '#{initializer_path}' created."
-    end
+    Db2Query::InitializerTask.generate_file
   end
 end

data/lib/db2_query/tasks/templates/database.rb.tt

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+development:
+  dsn: TODO
+  idle: 5
+  pool: 5
+  timeout: 5
+
+test:
+  dsn: TODO
+  idle: 5
+  pool: 5
+  timeout: 5
+
+production:
+  dsn: TODO
+  idle: 5
+  pool: 5
+  timeout: 5

data/lib/db2_query/tasks/templates/initializer.rb.tt

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "db2_query"
+
+Db2Query::Base.initiation do |base|
+  base.set_field_types
+  base.establish_connection
+end

data/lib/db2_query/tasks.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Db2Query
+  class Tasks < Thor::Group
+    include Thor::Actions
+
+    class << self
+      alias generate_file start
+    end
+  end
+
+  class DatabaseTask < Tasks
+    source_root File.expand_path("../tasks/templates", __FILE__)
+
+    def create_database_config_file
+      template "database.rb", File.join("config/db2query.yml")
+    end
+  end
+
+  class InitializerTask < Tasks
+    source_root File.expand_path("../tasks/templates", __FILE__)
+
+    def create_initializer_file
+      template "initializer.rb", File.join("config/initializers/db2query.rb")
+    end
+  end
+end

data/lib/db2_query/type/binary.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module Type
+    class Binary
+      def type
+        :binary
+      end
+
+      def serialize(value)
+        value.unpack1("H*")
+      end
+
+      def deserialize(value)
+        [value].pack("H*")
+      end
+    end
+  end
+end

data/lib/db2_query/type/boolean.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module Type
+    class Boolean < Value
+      TRUE_VALUES = [
+        true, 1, "1", "t", "T",
+        "true", "TRUE", "on", "ON",
+        :"1", :t, :T, :true, :TRUE, :on, :ON
+      ].freeze
+
+      DEFAULT = { true: true, false: false }
+
+      def initialize(options = DEFAULT)
+        super(options)
+      end
+
+      def name
+        :boolean
+      end
+
+      def serialize(value)
+        case value
+        when *TRUE_VALUES
+          1
+        else
+          0
+        end
+      end
+
+      def deserialize(value)
+        case value
+        when 1
+          options[:true]
+        else
+          options[:false]
+        end
+      end
+    end
+  end
+end

data/lib/db2_query/type/date.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Db2Query
+  module Type
+    class Date < Value
+      def type
+        :string
+      end
+
+      YMD_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+      DMY_DATE = /\A(\d\d)-(\d\d)-(\d{4})\z/
+
+      def serialize(value)
+        if value.is_a?(::String)
+          value = value.tr("/", "-")
+          case value
+          when YMD_DATE, DMY_DATE
+            quote(::Date.parse(value))
+          else
+            nil
+          end
+        elsif value.is_a?(::Date)
+          quote(value.strftime("%F"))
+        else
+          nil
+        end
+      end
+
+      def deserialize(value)
+        ::Date.parse(value.to_s)
+      end
+    end
+  end
+end