jdbc_helpers 0.0.4-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: da31e2a345c9a088a11b6f3ebb6d7cb1615e68de
+  data.tar.gz: 9132e05e016094c28a6390d3120f060057cabd79
+SHA512:
+  metadata.gz: 1cbdbe86780d684d11152ab64e0ce1023e4ed53b9d247d69e12798a644088bf3e9a28a3e9d6dd913e86b1895e37790efccd744f9062e57723e4260dd093bf8dd
+  data.tar.gz: ace30512f1a002d7f2846031651b5e433c970c03f63900e8bb253977d19e6116717ec8f3a3f192acff3a344e26571117717bb8b29461eed26787b0241562edb1

data/lib/jdbc_helpers.rb

@@ -0,0 +1,278 @@
+require 'json'
+require 'logger'
+
+# JDBC helper classes to simplify interactions with JDBC databases.
+# note that this assumes that you have already instantiated
+# a JDBC driver into the current namespace.
+module JDBCHelpers
+  # Base class to provide helper methods that may be generally useful to the concrete classes
+  class Base
+    # Cleanses SQL statements so they can be presented in a log without security risk
+    # currently removes AWS credentials for Redshift copy/unload
+    # @param [String] stmt SQL statement to cleanse
+    # @return [String] cleansed statement
+    def cleanse_statement(stmt)
+      # filter out aws creds from redshift
+      tmp = stmt.to_s
+      return tmp.gsub(
+        /aws_access_key_id\s*=\s*.{20}\s*\;\s*|aws_secret_access_key\s*=\s*(\w|\/|^'){40,41}/i,
+        '<removed>'
+      ).gsub(/\s+/,' ')
+    end
+    
+    # Array of classes that should be casted to Strings
+    # @return [Array<Class>]
+    def convert_to_string_classes
+      [Java::JavaSql::Timestamp, Java::JavaSql::Date]
+    end
+  end
+
+  # Creates a discreet JDBC connection and makes it available via connection attribute
+  class ConnectionFactory < JDBCHelpers::Base
+    attr_accessor :connection
+    
+    # @param [String] jdbc_url
+    # @param [String] db_user
+    # @param [String] db_pass
+    # @param [Logger] logger object otherwise will default to new Logger 
+    def initialize(jdbc_url, db_user, db_pass, logger = nil)
+      @logger = logger ? logger : Logger.new(STDOUT)
+      @logger.info("connecting to #{jdbc_url} as user #{db_user}...")
+      @connection = java.sql.DriverManager.get_connection(
+        jdbc_url,
+        db_user,
+        db_pass
+      )
+      @logger.info("connection successful!") if @connection
+    end
+  end
+
+  # executes a sql statement
+  class Execute < JDBCHelpers::Base
+    # Rows affected by the SQL statement execution. Note that
+    # not all JDBC drivers/databases handle this appropriately
+    attr_accessor :rows_affected
+
+    # @param [Object] db_connect active connection against which to execute statement
+    # @param [String] statement SQL statement text
+    # @param [Logger] logger object otherwise will default to new Logger 
+    def initialize(db_connect, statement, logger = nil)
+      @logger = logger ? logger : Logger.new(STDOUT)
+      stmt = db_connect.create_statement
+      @logger.info(
+        "executing statement: #{cleanse_statement(statement)}"
+      )
+      start = Time.new.utc
+      @rows_affected = stmt.execute_update(statement)
+      @logger.info "query executed #{Time.new.utc - start} seconds"
+    end
+  end
+
+  # Executes a select query, then returns the first field from the first row
+  class SingleValueFromQuery < JDBCHelpers::Base
+    # Value of the first field from the first row. class will vary.
+    attr_accessor :result
+    
+    # @param [Object] db_connect active connection against which to execute statement
+    # @param [String] statement SQL statement text
+    # @param [Logger] logger object otherwise will default to new Logger 
+    def initialize(db_connect, statement, logger = nil)
+      @logger = logger ? logger : Logger.new(STDOUT)
+      stmt = db_connect.create_statement
+      @logger.info(
+        "executing query: #{cleanse_statement(statement)}"
+      )
+      start = Time.new.utc
+      rs = stmt.execute_query(statement)
+      @logger.info "query executed #{Time.new.utc-start} seconds"
+      rs.next
+      value = rs.getObject(1)
+      rs.close
+
+      #the below simplifies things... especially comparisons
+      #if you don't like it you can write your own damn helper!
+      value = value.to_s if convert_to_string_classes.include?(value.class)
+      @result = value
+    end
+  end
+
+  # Execute a SQL query, store the results as an array of hashes.
+  class QueryResultsToArray < JDBCHelpers::Base
+    # Contains the array of hashes returned from the select query
+    attr_accessor :results
+  
+    # @param [Object] db_connect active connection against which to execute statement
+    # @param [String] statement SQL statement text
+    # @param [Logger] logger object otherwise will default to new Logger 
+    def initialize(db_connect, statement, logger = nil)
+      @logger = logger ? logger : Logger.new(STDOUT)
+      stmt = db_connect.create_statement
+      @logger.info "executing query: #{cleanse_statement(statement)}"
+      start = Time.new.utc
+      rs = stmt.execute_query(statement)
+      @logger.info("query executed #{Time.new.utc - start} seconds")
+      @results = rs_to_array(rs)
+    end
+
+    # converts a JDBC recordset to an array of hashes, with one hash per record
+    # @param [Object] rs JDBC result set object
+    # @return [Array<Hash>] Array of Hash with a Hash for each record
+    def rs_to_array(rs)
+      # creates an array of hashes from a jdbc record set
+      arr = []
+
+      # get basic metadata for the recordset
+      meta = rs.getMetaData
+      cols = meta.getColumnCount.to_i
+
+      # loop through the records to add them into hash
+      while rs.next do
+        # r is a temporary hash for the row being processed
+        r = {}
+
+        # add each row to r
+        (1..cols).each do |c|
+          r[meta.get_column_name(c)] = rs.getObject(c)
+          if convert_to_string_classes.include?(r[meta.get_column_name(c)].class)
+            r[meta.get_column_name(c)] = r[meta.get_column_name(c)].to_s
+          end
+        end # each cols
+
+        # append hash to array
+        arr << r
+      end # while
+
+      # completed hash is returned
+      return arr
+    end
+  end
+
+  # Creates a hash of arrays of hashes from a SQL query
+  class QueryResultsToHashOfArrays < JDBCHelpers::Base
+    attr_accessor :results
+
+    # @param [Object] db_connect active connection against which to execute statement
+    # @param [String] statement SQL statement text
+    # @param [String] key_field SQL result set field containing the key to be used in the top level of hash
+    # @param [Logger] logger object otherwise will default to new Logger 
+    def initialize(db_connect, statement, key_field, logger = nil)
+      @logger = logger ? logger : Logger.new(STDOUT)
+      stmt = db_connect.create_statement
+      @logger.info "executing query in thread #{Thread.current.object_id}:\n#{cleanse_statement(statement)}"
+      start = Time.new.utc
+      rs = stmt.execute_query(statement)
+      @logger.info "query executed #{Time.new.utc - start} seconds"
+      @results=rs_to_hash(rs, key_field, true)
+    end
+
+    # converts a JDBC recordset to an array of hashes, with one hash per record
+    # creates a hash from a jdbc record set
+    # index_key_field is the field you want to use as the top level
+    # hash key... and should exist in the record set
+    # multi_val=true will create an array below each index_key_filed,
+    # false will create a hash as the child
+    # @param [Object] rs JDBC result set object
+    # @param [String] index_key_field field to use as top level hash keys
+    # @return [Hash] Hash of Arrays of Hashes for each record
+    def rs_to_hash(rs, index_key_field, multi_val)
+      # setting default hash value is necessary for appending to arrays
+      hash=Hash.new{ |h, k| h[k] = [] }
+
+      # get basic metadata for the recordset
+      meta = rs.getMetaData
+      cols = meta.getColumnCount.to_i
+
+      # loop through the records to add them into hash
+      while rs.next do
+        # if multi_val is not true... create new hash value as an empty hash if it doesn't already exist
+        hash[rs.getString(index_key_field)]={} if (!hash[rs.getString(index_key_field)] and !multi_val)
+
+        # if multi_val is true... create new hash value as an empty array if it doesn't already exist
+        hash[rs.getString(index_key_field)]=[] if (!hash[rs.getString(index_key_field)] and multi_val)
+
+        # r is a temporary hash for the row being processed
+        r=Hash.new
+
+        # add each row to r
+        (1..cols).each do |c|
+          r[meta.get_column_name(c)] = rs.getObject(c)
+          if convert_to_string_classes.include?(r[meta.get_column_name(c)].class)
+            r[meta.get_column_name(c)] = r[meta.get_column_name(c)].to_s
+          end
+        end # each cols
+
+        # set hash value to r if not multi_val
+        hash[rs.getString(index_key_field)] = r if !multi_val
+
+        # append hash to r if multi_val
+        hash[rs.getString(index_key_field)] << r if multi_val
+      end # while
+
+      # completed hash is returned
+      return hash
+    end
+  end # class
+
+  class QueryResultsToJSONFile < JDBCHelpers::Base
+    # runs a SQL query, then writes the results as JSON objects to a provided file object.
+    # by use of the formatter parameter, you can change the output to any format you desire (CSV, XML, etc)
+    # see json_formatter method for an example of a proc to perform formatting
+    # @param [Object] db_connect active connection against which to execute statement
+    # @param [String] statement SQL statement text
+    # @param [IO] file_object IO object to receive the formatted results
+    # @param [proc] formatter proc to handle the actual formatting, defaults to JSON if nil
+    # @param [Logger] logger object otherwise will default to new Logger 
+    def initialize(db_connect, statement, file_object, formatter = nil, logger = nil)
+      @logger = logger ? logger : Logger.new(STDOUT)
+      stmt = db_connect.create_statement
+      @logger.info "executing query: #{cleanse_statement(statement)}"
+      start = Time.new.utc
+      rs = stmt.execute_query(statement)
+      @logger.info "query executed initial results #{Time.new.utc - start} seconds"
+      record_count = rs_to_json_file(rs, file_object, formatter)
+      @logger.info "query export time #{Time.new.utc - start} seconds"
+      @logger.info "#{record_count} rows exported"
+    end
+
+    # outputs a JDBC result set to a formatted file
+    # formatter defaults to JSON output unless you provide your own proc
+    # @param [Object] rs JDBC result set
+    # @param [IO] file_object IO object to receive the formatted results
+    # @param [proc] formatter proc to handle the actual formatting, defaults to JSON if nil
+    def rs_to_json_file(rs, file_object, formatter)
+      # default formatter outputs json objects for each row
+      formatter = json_formatter unless formatter
+
+      # get basic metadata for the recordset
+      meta = rs.getMetaData
+      cols = meta.getColumnCount.to_i
+      
+      record_count = 0
+      # loop through the records to add them into hash
+      while rs.next do
+
+        # r is a temporary hash for the row being processed
+        r = Hash.new
+
+        # add each row to r
+        (1..cols).each do |c|
+          r[meta.get_column_name(c)] = rs.getObject(c)
+          if convert_to_string_classes.include?(r[meta.get_column_name(c)].class)
+            r[meta.get_column_name(c)] = r[meta.get_column_name(c)].to_s
+          end
+        end # each cols
+
+        # formatter handles output of r to file
+        formatter.call(file_object, r)
+        record_count += 1
+      end # while
+      return record_count
+    end
+    
+    # proc must handle two inputs, |file_object, record hash|
+    # @return [proc] returns proc to output json
+    def json_formatter
+      Proc.new { |f,h| f.puts h.to_json }
+    end
+  end # class
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: jdbc_helpers
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: java
+authors:
+- jeremy winters
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2016-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+  name: logger
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.9.0
+  name: minitest
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.9.0
+description: allows for easy conversion of query results to hashes, arrays of hashes, json files, etc.
+email: jeremy.winters@full360.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jdbc_helpers.rb
+homepage: https://www.full360.com
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.6.4
+signing_key:
+specification_version: 4
+summary: helpers for jdbc interaction
+test_files: []