db2_query 0.3.1 → 0.3.2

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

data/lib/db2_query/railtie.rb

@@ -8,8 +8,11 @@ module Db2Query
     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
+
+    config.app_generators do
+      require "#{Db2Query.root}/rails/generators/query/query_generator.rb"
     end
   end
 end

data/lib/db2_query/result.rb

@@ -2,76 +2,88 @@
 
 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)
-    end
+    alias query definition
+
+    delegate :data_type, :validate_result_columns, to: :definition
 
-    def includes_column?(name)
-      @columns.include? name
+    def initialize(columns, rows, definition)
+      @definition = definition
+      validate_result_columns(columns)
+      super(columns, rows, {})
     end
 
     def record
-      @record ||= Record.new(rows[0], columns, formatters)
+      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} [#{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,41 +1,10 @@
 # frozen_string_literal: true
 
-require "db2_query"
-
-DB2_QUERY_DATABASE_TEMPLATE ||= <<-EOF
-# 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
-EOF
+require "db2_query/tasks"
 
 namespace :db2query do
   desc "Create Database configuration file"
   task :database do
-    database_path = "#{Rails.root}/config/db2query.yml"
-    if File.exist?(database_path)
-      raise Db2Query::Error, "Db2Query database config file exists, please check first"
-    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,41 +1,10 @@
 # frozen_string_literal: true
 
-require "db2_query"
-
-DB2_QUERY_INITIALIZER_TEMPLATE ||= <<-EOF
-# frozen_string_literal: true
-require "db2_query"
-require "db2_query/formatter"
-
-Db2Query::Base.initiation do |base|
-  base.establish_connection
-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 Db2Query::Error, "Db2Query initializer file exists, please check first"
-    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