db2_query 0.2.2 → 0.3.2

data/lib/db2_query/railtie.rb

@@ -3,18 +3,16 @@
 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.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/tasks/database.rake

@@ -1,58 +1,10 @@
 # frozen_string_literal: true
 
-DB2_QUERY_DATABASE_TEMPLATE ||= <<-EOF
-# frozen_string_literal: true
-# Database configuration example
-development:
-  primary:
-    adapter: db2_query
-    dsn: iseries
-    uid: <%= ENV["ISERIES_UID"] %>
-    pwd: <%= ENV["ISERIES_PWD"] %>
-  secondary:
-    adapter: db2_query
-    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:
-    adapter: db2_query
-    dsn: iseries
-    uid: <%= ENV["ISERIES_UID"] %>
-    pwd: <%= ENV["ISERIES_PWD"] %>
-  secondary:
-    adapter: db2_query
-    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/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