ruby-plsql 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 786698aedb4dff545a44a91fda4b7529d392b6d3afaee1e5a4447ee3be81a9d6
-  data.tar.gz: fa71bb0ec3ad558ab6805b077069401225fb1d8e949f4dc00360ecd085bae81b
+  metadata.gz: e240a454b5016fb465baaff47830601ea5f06f9a0f4ed7f2e032e2e8027c8841
+  data.tar.gz: 8209b0f8b037838e7be37578a396b8652855540abd6a0c2cbf226adfaf7a598e
 SHA512:
-  metadata.gz: f814a2f6b9b2b0784e41f861f0ed0965cb814aaf4e8687293f8285e4758810fd4979e1ef96d7f7b0a305e701f0426fb81d3be0ece725abdf1888270a91131691
-  data.tar.gz: c17b7330167301d53715b4d43441acb67697a53a0b0378ea51f65824b96215ece3730db3af01be4e7442a2c3c632dc9fc14109425cfda73cfa535997d77444ba
+  metadata.gz: af3ba3c7a782369e6e4f94afe467194f155fc961dc80e946ebbbaec07f48244169d33f1c0c387d6710752b7590f70c9cc5fb84bc21f8687b8c520d32ed09f557
+  data.tar.gz: 2fe1c1fa55a48cc547a3f34f371aba37147c4d3c8efc2c34d104b42b8e250251f6d233d65c6fedba42855774ccf559d6aed4164f341823b5c6fbbbb605acb047

data/History.txt

@@ -1,3 +1,5 @@
+This file is no longer being updated. For the latest updates and release information, please see: https://github.com/rsim/ruby-plsql/releases
+
 == 0.8.0 2021-08-10
 * Improvements and fixes
   * Support Rails 6.1 [#193]

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.9.0

data/lib/plsql/connection.rb

@@ -3,13 +3,13 @@ module PLSQL
     attr_reader :raw_driver
     attr_reader :activerecord_class
 
-    def initialize(raw_conn, ar_class = nil) #:nodoc:
+    def initialize(raw_conn, ar_class = nil) # :nodoc:
       @raw_driver = self.class.driver_type
       @raw_connection = raw_conn
       @activerecord_class = ar_class
     end
 
-    def self.create(raw_conn, ar_class = nil) #:nodoc:
+    def self.create(raw_conn, ar_class = nil) # :nodoc:
       if ar_class && !(defined?(::ActiveRecord) && ar_class.ancestors.include?(::ActiveRecord::Base))
         raise ArgumentError, "Wrong ActiveRecord class"
       end
@@ -23,7 +23,7 @@ module PLSQL
       end
     end
 
-    def self.create_new(params) #:nodoc:
+    def self.create_new(params) # :nodoc:
       conn = case driver_type
              when :oci
                OCIConnection.create_raw(params)
@@ -36,7 +36,7 @@ module PLSQL
       conn
     end
 
-    def self.driver_type #:nodoc:
+    def self.driver_type # :nodoc:
       # MRI 1.8.6 or YARV 1.9.1 or TruffleRuby
       @driver_type ||= if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby") && defined?(OCI8)
         :oci
@@ -67,18 +67,18 @@ module PLSQL
       @raw_driver == :jdbc
     end
 
-    def logoff #:nodoc:
+    def logoff # :nodoc:
       # Rollback any uncommited transactions
       rollback
       # Common cleanup activities before logoff, should be called from particular driver method
       drop_session_ruby_temporary_tables
     end
 
-    def commit #:nodoc:
+    def commit # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def rollback #:nodoc:
+    def rollback # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
@@ -98,21 +98,21 @@ module PLSQL
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def select_first(sql, *bindvars) #:nodoc:
+    def select_first(sql, *bindvars) # :nodoc:
       cursor = cursor_from_query(sql, bindvars, prefetch_rows: 1)
       cursor.fetch
     ensure
       cursor.close rescue nil
     end
 
-    def select_hash_first(sql, *bindvars) #:nodoc:
+    def select_hash_first(sql, *bindvars) # :nodoc:
       cursor = cursor_from_query(sql, bindvars, prefetch_rows: 1)
       cursor.fetch_hash
     ensure
       cursor.close rescue nil
     end
 
-    def select_all(sql, *bindvars, &block) #:nodoc:
+    def select_all(sql, *bindvars, &block) # :nodoc:
       cursor = cursor_from_query(sql, bindvars)
       results = []
       row_count = 0
@@ -129,7 +129,7 @@ module PLSQL
       cursor.close rescue nil
     end
 
-    def select_hash_all(sql, *bindvars, &block) #:nodoc:
+    def select_hash_all(sql, *bindvars, &block) # :nodoc:
       cursor = cursor_from_query(sql, bindvars)
       results = []
       row_count = 0
@@ -146,11 +146,11 @@ module PLSQL
       cursor.close rescue nil
     end
 
-    def exec(sql, *bindvars) #:nodoc:
+    def exec(sql, *bindvars) # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def parse(sql) #:nodoc:
+    def parse(sql) # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
@@ -181,7 +181,7 @@ module PLSQL
 
     # all_synonyms view is quite slow therefore
     # this implementation is overriden in OCI connection with faster native OCI method
-    def describe_synonym(schema_name, synonym_name) #:nodoc:
+    def describe_synonym(schema_name, synonym_name) # :nodoc:
       select_first(
         "SELECT table_owner, table_name FROM all_synonyms WHERE owner = :owner AND synonym_name = :synonym_name",
         schema_name.to_s.upcase, synonym_name.to_s.upcase)

data/lib/plsql/helpers.rb

@@ -1,6 +1,6 @@
-module PLSQL #:nodoc:
-  module ArrayHelpers #:nodoc:
-    def self.to_hash(keys, values) #:nodoc:
+module PLSQL # :nodoc:
+  module ArrayHelpers # :nodoc:
+    def self.to_hash(keys, values) # :nodoc:
       (0...keys.size).inject({}) { |hash, i| hash[keys[i]] = values[i]; hash }
     end
   end

data/lib/plsql/jdbc_connection.rb

@@ -46,7 +46,7 @@ rescue LoadError, NameError
 end
 
 module PLSQL
-  class JDBCConnection < Connection  #:nodoc:
+  class JDBCConnection < Connection  # :nodoc:
     def self.create_raw(params)
       database = params[:database]
       url = if ENV["TNS_ADMIN"] && database && !params[:host] && !params[:url]
@@ -98,7 +98,7 @@ module PLSQL
       cs.close rescue nil
     end
 
-    class CallableStatement #:nodoc:
+    class CallableStatement # :nodoc:
       def initialize(conn, sql)
         @sql = sql
         @connection = conn
@@ -145,7 +145,7 @@ module PLSQL
         end
     end
 
-    class Cursor #:nodoc:
+    class Cursor # :nodoc:
       include Connection::CursorCommon
 
       attr_reader :result_set

data/lib/plsql/oci_connection.rb

@@ -24,7 +24,7 @@ if (oci8_version_ints <=> required_oci8_version) < 0
 end
 
 module PLSQL
-  class OCIConnection < Connection #:nodoc:
+  class OCIConnection < Connection # :nodoc:
     def self.create_raw(params)
       connection_string = if params[:host]
         "//#{params[:host]}:#{params[:port] || 1521}/#{params[:database]}"
@@ -64,7 +64,7 @@ module PLSQL
       true
     end
 
-    class Cursor #:nodoc:
+    class Cursor # :nodoc:
       include Connection::CursorCommon
 
       attr_reader :raw_cursor
@@ -157,7 +157,7 @@ module PLSQL
         [DateTime, nil]
       when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
         [Time, nil]
-      when "TABLE", "VARRAY", "OBJECT", "XMLTYPE"
+      when "TABLE", "VARRAY", "OBJECT", "XMLTYPE", "OPAQUE/XMLTYPE"
         # create Ruby class for collection
         klass = OCI8::Object::Base.get_class_by_typename(metadata[:sql_type_name])
         unless klass
@@ -289,7 +289,11 @@ module PLSQL
         # ActiveRecord Oracle enhanced adapter puts OCI8EnhancedAutoRecover wrapper around OCI8
         # in this case we need to pass original OCI8 connection
         else
-          raw_connection.instance_variable_get(:@connection)
+          if raw_connection.instance_variable_defined?(:@raw_connection)
+            raw_connection.instance_variable_get(:@raw_connection)
+          else
+            raw_connection.instance_variable_get(:@connection)
+          end
         end
       end
 

data/lib/plsql/package.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module PackageClassMethods #:nodoc:
+  module PackageClassMethods # :nodoc:
     def find(schema, package)
       package_name = package.to_s.upcase
       find_in_schema(schema, package_name) || find_by_synonym(schema, package_name)
@@ -32,7 +32,7 @@ module PLSQL
     end
   end
 
-  class Package #:nodoc:
+  class Package # :nodoc:
     extend PackageClassMethods
 
     def initialize(schema, package, override_schema_name = nil)
@@ -56,7 +56,7 @@ module PLSQL
     private
 
       def method_missing(method, *args, &block)
-        method = method.to_s
+        method = +method.to_s
         method.chop! if (assignment = method[/=$/])
 
         case (object = self[method])

data/lib/plsql/procedure.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module ProcedureClassMethods #:nodoc:
+  module ProcedureClassMethods # :nodoc:
     def find(schema, procedure, package = nil, override_schema_name = nil)
       if package.nil?
         if (row = schema.select_first(
@@ -53,12 +53,12 @@ module PLSQL
       end
   end
 
-  module ProcedureCommon #:nodoc:
+  module ProcedureCommon # :nodoc:
     attr_reader :arguments, :argument_list, :out_list, :return
     attr_reader :schema, :schema_name, :package, :procedure
 
     # return type string from metadata that can be used in DECLARE block or table definition
-    def self.type_to_sql(metadata) #:nodoc:
+    def self.type_to_sql(metadata) # :nodoc:
       case metadata[:data_type]
       when "NUMBER"
         precision, scale = metadata[:data_precision], metadata[:data_scale]
@@ -82,7 +82,7 @@ module PLSQL
     end
 
     # get procedure argument metadata from data dictionary
-    def get_argument_metadata #:nodoc:
+    def get_argument_metadata # :nodoc:
       if (@schema.connection.database_version <=> [18, 0, 0, 0]) >= 0
         get_argument_metadata_from_18c
       else
@@ -90,7 +90,7 @@ module PLSQL
       end
     end
 
-    def get_argument_metadata_below_18c #:nodoc:
+    def get_argument_metadata_below_18c # :nodoc:
       @arguments = {}
       @argument_list = {}
       @out_list = {}
@@ -126,6 +126,9 @@ module PLSQL
             data_type, in_out, data_length, data_precision, data_scale, char_used,
             char_length, type_owner, type_name, type_subname, defaulted = r
 
+        # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+        data_type = "PL/SQL BOOLEAN" if data_type == "BOOLEAN"
+
         @overloaded ||= !overload.nil?
         # if not overloaded then store arguments at key 0
         overload ||= 0
@@ -206,7 +209,7 @@ module PLSQL
     end
 
     # get procedure argument metadata from data dictionary
-    def get_argument_metadata_from_18c #:nodoc:
+    def get_argument_metadata_from_18c # :nodoc:
       @arguments = {}
       @argument_list = {}
       @out_list = {}
@@ -231,10 +234,13 @@ module PLSQL
         @object_id, @schema_name, @procedure
       ) do |r|
 
-        subprogram_id, object_name, overload, argument_name, position,
+        subprogram_id, _object_name, overload, argument_name, position,
           data_type, in_out, data_length, data_precision, data_scale, char_used,
           char_length, type_owner, type_name, type_package, type_object_type, defaulted = r
 
+        # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+        data_type = "PL/SQL BOOLEAN" if data_type == "BOOLEAN"
+
         @overloaded ||= !overload.nil?
         # if not overloaded then store arguments at key 0
         overload ||= 0
@@ -298,7 +304,7 @@ module PLSQL
       construct_argument_list_for_overloads
     end
 
-    def construct_argument_list_for_overloads #:nodoc:
+    def construct_argument_list_for_overloads # :nodoc:
       @overloads = @arguments.keys.sort
       @overloads.each do |overload|
         @argument_list[overload] = @arguments[overload].keys.sort { |k1, k2| @arguments[overload][k1][:position] <=> @arguments[overload][k2][:position] }
@@ -306,10 +312,10 @@ module PLSQL
       end
     end
 
-    def ensure_tmp_tables_created(overload) #:nodoc:
+    def ensure_tmp_tables_created(overload) # :nodoc:
       return if @tmp_tables_created.nil? || @tmp_tables_created[overload]
       @tmp_table_names[overload] && @tmp_table_names[overload].each do |table_name, argument_metadata|
-        sql = "CREATE GLOBAL TEMPORARY TABLE #{table_name} (\n"
+        sql = +"CREATE GLOBAL TEMPORARY TABLE #{table_name} (\n"
         element_metadata = argument_metadata[:element]
         case element_metadata[:data_type]
         when "PL/SQL RECORD"
@@ -330,7 +336,7 @@ module PLSQL
       @tmp_tables_created[overload] = true
     end
 
-    def build_sql_type_name(type_owner, type_package, type_name) #:nodoc:
+    def build_sql_type_name(type_owner, type_package, type_name) # :nodoc:
       if type_owner == nil || type_owner == "PUBLIC"
         type_owner_res = ""
       else
@@ -345,7 +351,7 @@ module PLSQL
       type_name_res && "#{type_owner_res}#{type_name_res}"
     end
 
-    def get_field_definitions(argument_metadata) #:nodoc:
+    def get_field_definitions(argument_metadata) # :nodoc:
       fields = {}
       case argument_metadata[:type_object_type]
       when "PACKAGE"
@@ -359,6 +365,9 @@ module PLSQL
 
           attr_no, attr_name, attr_type_owner, attr_type_name, attr_type_package, attr_length, attr_precision, attr_scale, attr_char_used = r
 
+          # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+          attr_type_name = "PL/SQL BOOLEAN" if attr_type_name == "BOOLEAN"
+
           fields[attr_name.downcase.to_sym] = {
             position: attr_no.to_i,
             data_type: attr_type_owner == nil ? attr_type_name : get_composite_type(attr_type_owner, attr_type_name, attr_type_package),
@@ -408,7 +417,7 @@ module PLSQL
       fields
     end
 
-    def get_element_definition(argument_metadata) #:nodoc:
+    def get_element_definition(argument_metadata) # :nodoc:
       element_metadata = {}
       if collection_type?(argument_metadata[:data_type])
         case argument_metadata[:type_object_type]
@@ -421,6 +430,9 @@ module PLSQL
 
           elem_type_owner, elem_type_name, elem_type_package, elem_length, elem_precision, elem_scale, elem_char_used, index_by = r
 
+          # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+          elem_type_name = "PL/SQL BOOLEAN" if elem_type_name == "BOOLEAN"
+
           if index_by == "VARCHAR2"
             raise ArgumentError, "Index-by Varchar-Table (associative array) #{argument_metadata[:type_name]} is not supported"
           end
@@ -458,6 +470,9 @@ module PLSQL
           )
           elem_type_owner, elem_type_name, elem_length, elem_precision, elem_scale, elem_char_used = r
 
+          # Oracle 23c reports BOOLEAN as "BOOLEAN" instead of "PL/SQL BOOLEAN"
+          elem_type_name = "PL/SQL BOOLEAN" if elem_type_name == "BOOLEAN"
+
           element_metadata = {
             position: 1,
             data_type: elem_type_owner == nil ? elem_type_name : "OBJECT",
@@ -510,21 +525,21 @@ module PLSQL
     end
 
     PLSQL_COMPOSITE_TYPES = ["PL/SQL RECORD", "PL/SQL TABLE", "TABLE", "VARRAY", "REF CURSOR"].freeze
-    def composite_type?(data_type) #:nodoc:
+    def composite_type?(data_type) # :nodoc:
       PLSQL_COMPOSITE_TYPES.include? data_type
     end
 
     PLSQL_COLLECTION_TYPES = ["PL/SQL TABLE", "TABLE", "VARRAY"].freeze
-    def collection_type?(data_type) #:nodoc:
+    def collection_type?(data_type) # :nodoc:
       PLSQL_COLLECTION_TYPES.include? data_type
     end
 
-    def overloaded? #:nodoc:
+    def overloaded? # :nodoc:
       @overloaded
     end
   end
 
-  class Procedure #:nodoc:
+  class Procedure # :nodoc:
     extend ProcedureClassMethods
     include ProcedureCommon
 

data/lib/plsql/procedure_call.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  class ProcedureCall #:nodoc:
+  class ProcedureCall # :nodoc:
     def initialize(procedure, args = [], options = {})
       @procedure = procedure
       @schema = @procedure.schema
@@ -115,7 +115,7 @@ module PLSQL
       MATCHING_TYPES = {
         integer: ["NUMBER", "NATURAL", "NATURALN", "POSITIVE", "POSITIVEN", "SIGNTYPE", "SIMPLE_INTEGER", "PLS_INTEGER", "BINARY_INTEGER"],
         decimal: ["NUMBER", "BINARY_FLOAT", "BINARY_DOUBLE"],
-        string: ["VARCHAR", "VARCHAR2", "NVARCHAR2", "CHAR", "NCHAR", "CLOB", "BLOB", "XMLTYPE"],
+        string: ["VARCHAR", "VARCHAR2", "NVARCHAR2", "CHAR", "NCHAR", "CLOB", "BLOB", "XMLTYPE", "OPAQUE/XMLTYPE"],
         date: ["DATE"],
         time: ["DATE", "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"],
         boolean: ["PL/SQL BOOLEAN"],
@@ -149,10 +149,10 @@ module PLSQL
       end
 
       def construct_sql(args)
-        @declare_sql = ""
-        @assignment_sql = ""
-        @call_sql = ""
-        @return_sql = ""
+        @declare_sql = +""
+        @assignment_sql = +""
+        @call_sql = +""
+        @return_sql = +""
         @return_vars = []
         @return_vars_metadata = {}
 
@@ -218,7 +218,7 @@ module PLSQL
         end
         add_out_variables
 
-        @sql = @declare_sql.empty? ? "" : "DECLARE\n" << @declare_sql
+        @sql = @declare_sql.empty? ? +"" : +"DECLARE\n" << @declare_sql
         @sql << "BEGIN\n" << @assignment_sql << dbms_output_enable_sql << @call_sql << @return_sql << "END;\n"
       end
 
@@ -240,8 +240,8 @@ module PLSQL
           @bind_values[argument] = value.nil? ? nil : (value ? 1 : 0)
           @bind_metadata[argument] = argument_metadata.merge(data_type: "NUMBER", data_precision: 1)
           "l_#{argument}"
-        when "UNDEFINED"
-          if argument_metadata[:type_name] == "XMLTYPE"
+        when "UNDEFINED", "XMLTYPE", "OPAQUE/XMLTYPE"
+          if argument_metadata[:type_name] == "XMLTYPE" || argument_metadata[:data_type] =~ /XMLTYPE/
             @declare_sql << "l_#{argument} XMLTYPE;\n"
             @assignment_sql << "l_#{argument} := XMLTYPE(:#{argument});\n" if not value.nil?
             @bind_values[argument] = value if not value.nil?
@@ -326,7 +326,7 @@ module PLSQL
           "l_#{argument} #{argument_metadata[:sql_type_name]};\n"
         else
           fields_metadata = argument_metadata[:fields]
-          sql = "TYPE t_#{argument} IS RECORD (\n"
+          sql = +"TYPE t_#{argument} IS RECORD (\n"
           sql << record_fields_sorted_by_position(fields_metadata).map do |field|
             metadata = fields_metadata[field]
             "#{field} #{type_to_sql(metadata)}"
@@ -341,7 +341,7 @@ module PLSQL
       end
 
       def record_assignment_sql_values_metadata(argument, argument_metadata, record_value)
-        sql = ""
+        sql = +""
         bind_values = {}
         bind_metadata = {}
         (record_value || {}).each do |key, value|
@@ -395,8 +395,8 @@ module PLSQL
             end
           end
           "l_#{argument} := " if is_return_value
-        when "UNDEFINED"
-          if argument_metadata[:type_name] == "XMLTYPE"
+        when "UNDEFINED", "XMLTYPE", "OPAQUE/XMLTYPE"
+          if argument_metadata[:type_name] == "XMLTYPE" || argument_metadata[:data_type] =~ /XMLTYPE/
             @declare_sql << "l_#{argument} XMLTYPE;\n" if is_return_value
             bind_variable = :"o_#{argument}"
             @return_vars << bind_variable
@@ -517,8 +517,8 @@ module PLSQL
         when "PL/SQL BOOLEAN"
           numeric_value = @cursor[":o_#{argument}"]
           numeric_value.nil? ? nil : numeric_value == 1
-        when "UNDEFINED"
-          if argument_metadata[:type_name] == "XMLTYPE"
+        when "UNDEFINED", "XMLTYPE", "OPAQUE/XMLTYPE"
+          if argument_metadata[:type_name] == "XMLTYPE" || argument_metadata[:data_type] =~ /XMLTYPE/
             @cursor[":o_#{argument}"]
           end
         else

data/lib/plsql/schema.rb

@@ -4,8 +4,8 @@ module PLSQL
 
     @@schemas = {}
 
-    class <<self
-      def find_or_new(connection_alias) #:nodoc:
+    class << self
+      def find_or_new(connection_alias) # :nodoc:
         connection_alias ||= :default
         if @@schemas[connection_alias]
           @@schemas[connection_alias]
@@ -15,7 +15,7 @@ module PLSQL
       end
     end
 
-    def initialize(raw_conn = nil, schema = nil, original_schema = nil) #:nodoc:
+    def initialize(raw_conn = nil, schema = nil, original_schema = nil) # :nodoc:
       self.connection = raw_conn
       @schema_name = schema ? schema.to_s.upcase : nil
       @original_schema = original_schema
@@ -25,11 +25,11 @@ module PLSQL
     # Returns connection wrapper object (this is not raw OCI8 or JDBC connection!)
     attr_reader :connection
 
-    def root_schema #:nodoc:
+    def root_schema # :nodoc:
       @original_schema || self
     end
 
-    def raw_connection=(raw_conn) #:nodoc:
+    def raw_connection=(raw_conn) # :nodoc:
       @connection = raw_conn ? Connection.create(raw_conn) : nil
       reset_instance_variables
     end
@@ -99,8 +99,12 @@ module PLSQL
         @original_schema.default_timezone
       else
         @default_timezone ||
-          # Use ActiveRecord class default_timezone when ActiveRecord connection is used
-          (@connection && (ar_class = @connection.activerecord_class) && ar_class.default_timezone) ||
+          # Use ActiveRecord default_timezone when ActiveRecord connection is used,
+          # preferring the connection's activerecord_class so a subclass override
+          # (available in AR < 8.0) is honored before falling back to the
+          # module-level accessor (AR 7.0+; the only one in AR 8.0+).
+          (@connection && (ar_class = @connection.activerecord_class) &&
+            (ar_class.respond_to?(:default_timezone) ? ar_class.default_timezone : ActiveRecord.default_timezone)) ||
           # default to local timezone
           :local
       end
@@ -117,7 +121,7 @@ module PLSQL
 
     # Same implementation as for ActiveRecord
     # DateTimes aren't aware of DST rules, so use a consistent non-DST offset when creating a DateTime with an offset in the local zone
-    def local_timezone_offset #:nodoc:
+    def local_timezone_offset # :nodoc:
       ::Time.local(2007).utc_offset.to_r / 86400
     end
 
@@ -234,7 +238,7 @@ module PLSQL
       end
 
       def _errors(object_schema_name, object_name, object_type)
-        result = ""
+        result = +""
         previous_line = 0
         select_all(
           "SELECT e.line, e.position, e.text error_text, s.text source_text

data/lib/plsql/sequence.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module SequenceClassMethods #:nodoc:
+  module SequenceClassMethods # :nodoc:
     def find(schema, sequence)
       if schema.select_first(
         "SELECT sequence_name FROM all_sequences
@@ -27,7 +27,7 @@ module PLSQL
   class Sequence
     extend SequenceClassMethods
 
-    def initialize(schema, sequence, override_schema_name = nil) #:nodoc:
+    def initialize(schema, sequence, override_schema_name = nil) # :nodoc:
       @schema = schema
       @schema_name = override_schema_name || schema.schema_name
       @sequence_name = sequence.to_s.upcase

data/lib/plsql/table.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module TableClassMethods #:nodoc:
+  module TableClassMethods # :nodoc:
     def find(schema, table)
       if schema.select_first(
         "SELECT table_name FROM all_tables
@@ -33,9 +33,9 @@ module PLSQL
   class Table
     extend TableClassMethods
 
-    attr_reader :columns, :schema_name, :table_name #:nodoc:
+    attr_reader :columns, :schema_name, :table_name # :nodoc:
 
-    def initialize(schema, table, override_schema_name = nil) #:nodoc:
+    def initialize(schema, table, override_schema_name = nil) # :nodoc:
       @schema = schema
       @schema_name = override_schema_name || schema.schema_name
       @table_name = table.to_s.upcase
@@ -87,9 +87,9 @@ module PLSQL
     def select(first_or_all, sql_params = "", *bindvars)
       case first_or_all
       when :first, :all
-        select_sql = "SELECT * "
+        select_sql = +"SELECT * "
       when :count
-        select_sql = "SELECT COUNT(*) "
+        select_sql = +"SELECT COUNT(*) "
       else
         raise ArgumentError, "Only :first, :all or :count are supported"
       end
@@ -251,7 +251,7 @@ module PLSQL
     end
 
     # wrapper class to simulate Procedure class for ProcedureClass#exec
-    class TableProcedure #:nodoc:
+    class TableProcedure # :nodoc:
       attr_reader :arguments, :argument_list, :return, :out_list, :schema
 
       def initialize(schema, table, operation)

data/lib/plsql/type.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module TypeClassMethods #:nodoc:
+  module TypeClassMethods # :nodoc:
     def find(schema, type)
       if schema.select_first(
         "SELECT type_name FROM all_types
@@ -33,9 +33,9 @@ module PLSQL
   class Type
     extend TypeClassMethods
 
-    attr_reader :typecode, :attributes, :schema_name, :type_name, :type_object_id #:nodoc:
+    attr_reader :typecode, :attributes, :schema_name, :type_name, :type_object_id # :nodoc:
 
-    def initialize(schema, type, override_schema_name = nil) #:nodoc:
+    def initialize(schema, type, override_schema_name = nil) # :nodoc:
       @schema = schema
       @schema_name = override_schema_name || schema.schema_name
       @type_name = type.to_s.upcase
@@ -107,7 +107,7 @@ module PLSQL
       end
     end
 
-    def method_missing(method, *args, &block) #:nodoc:
+    def method_missing(method, *args, &block) # :nodoc:
       if procedure = find_procedure(method)
         procedure.exec_with_options(args, {}, &block)
       else
@@ -115,7 +115,7 @@ module PLSQL
       end
     end
 
-    def find_procedure(new_or_procedure) #:nodoc:
+    def find_procedure(new_or_procedure) # :nodoc:
       @type_procedures[new_or_procedure] ||= begin
         procedure_name = new_or_procedure == :new ? @type_name : new_or_procedure
         # find defined procedure for type
@@ -134,7 +134,7 @@ module PLSQL
     end
 
     # wrapper class to simulate Procedure class for ProcedureClass#exec
-    class TypeProcedure #:nodoc:
+    class TypeProcedure # :nodoc:
       include ProcedureCommon
 
       def initialize(schema, type, procedure)
@@ -250,7 +250,7 @@ module PLSQL
     end
   end
 
-  class ObjectInstance < Hash #:nodoc:
+  class ObjectInstance < Hash # :nodoc:
     attr_accessor :plsql_type
 
     def self.create(type, attributes)