ruby-plsql 0.5.3 → 0.6.0

data/lib/plsql/oci_connection.rb

@@ -68,14 +68,17 @@ module PLSQL
     class Cursor #:nodoc:
       include Connection::CursorCommon
 
-      # stack of open cursors
-      @@open_cursors = []
       attr_reader :raw_cursor
 
+      # stack of open cursors per thread
+      def self.open_cursors
+        Thread.current[:plsql_oci_cursor_stack] ||= []
+      end
+
       def initialize(conn, raw_cursor)
         @connection = conn
         @raw_cursor = raw_cursor
-        @@open_cursors.push self
+        self.class.open_cursors.push self
       end
 
       def self.new_from_parse(conn, sql)
@@ -125,7 +128,7 @@ module PLSQL
 
       def close
         # close all cursors that were created after this one
-        while (open_cursor = @@open_cursors.pop) && !open_cursor.equal?(self)
+        while (open_cursor = self.class.open_cursors.pop) && !open_cursor.equal?(self)
           open_cursor.close_raw_cursor
         end
         close_raw_cursor
@@ -144,19 +147,19 @@ module PLSQL
     def plsql_to_ruby_data_type(metadata)
       data_type, data_length = metadata[:data_type], metadata[:data_length]
       case data_type
-      when "VARCHAR2", "CHAR", "NVARCHAR2", "NCHAR"
+      when "VARCHAR", "VARCHAR2", "CHAR", "NVARCHAR2", "NCHAR"
         [String, data_length || 32767]
       when "CLOB", "NCLOB"
         [OCI8::CLOB, nil]
       when "BLOB"
         [OCI8::BLOB, nil]
-      when "NUMBER", "PLS_INTEGER", "BINARY_INTEGER"
+      when "NUMBER", "NATURAL", "NATURALN", "POSITIVE", "POSITIVEN", "SIGNTYPE", "SIMPLE_INTEGER", "PLS_INTEGER", "BINARY_INTEGER"
         [OraNumber, nil]
       when "DATE"
         [DateTime, nil]
       when "TIMESTAMP", "TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITH LOCAL TIME ZONE"
         [Time, nil]
-      when "TABLE", "VARRAY", "OBJECT"
+      when "TABLE", "VARRAY", "OBJECT", "XMLTYPE"
         # create Ruby class for collection
         klass = OCI8::Object::Base.get_class_by_typename(metadata[:sql_type_name])
         unless klass
@@ -336,4 +339,4 @@ module PLSQL
 
   end
   
-end
+end

data/lib/plsql/package.rb

@@ -2,28 +2,34 @@ module PLSQL
 
   module PackageClassMethods #:nodoc:
     def find(schema, package)
-      if schema.select_first(
-            "SELECT object_name FROM all_objects
-            WHERE owner = :owner
-              AND object_name = :package
-              AND object_type = 'PACKAGE'",
-            schema.schema_name, package.to_s.upcase)
-        new(schema, package)
-      # search for synonym
-      elsif (row = schema.select_first(
-            "SELECT o.owner, o.object_name
-            FROM all_synonyms s, all_objects o
-            WHERE s.owner IN (:owner, 'PUBLIC')
-              AND s.synonym_name = :synonym_name
-              AND o.owner = s.table_owner
-              AND o.object_name = s.table_name
-              AND o.object_type = 'PACKAGE'
-            ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
-            schema.schema_name, package.to_s.upcase))
-        new(schema, row[1], row[0])
-      else
-        nil
-      end
+      package_name = package.to_s.upcase
+      find_in_schema(schema, package_name) || find_by_synonym(schema, package_name)
+    end
+
+    def find_in_schema(schema, package_name)
+      row = schema.select_first(<<-SQL, schema.schema_name, package_name)
+        SELECT object_name
+        FROM   all_objects
+        WHERE  owner = :owner
+        AND    object_name = :package
+        AND    object_type = 'PACKAGE'
+      SQL
+      new(schema, package_name) if row
+    end
+
+    def find_by_synonym(schema, package_name)
+      row = schema.select_first(<<-SQL, schema.schema_name, package_name)
+        SELECT o.object_name, o.owner
+        FROM   all_synonyms s,
+               all_objects o
+        WHERE  s.owner IN (:owner, 'PUBLIC')
+        AND    s.synonym_name = :synonym_name
+        AND    o.owner = s.table_owner
+        AND    o.object_name = s.table_name
+        AND    o.object_type = 'PACKAGE'
+        ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)
+      SQL
+      new(schema, row[0], row[1]) if row
     end
   end
 
@@ -41,29 +47,41 @@ module PLSQL
       PLSQL::Procedure.find(@schema, name, @package) ? true : false
     end
 
+    def [](object_name)
+      object_name = object_name.to_s.downcase
+      @package_objects[object_name] ||= [Procedure, Variable].inject(nil) do |res, object_type|
+        res || object_type.find(@schema, object_name, @package, @override_schema_name)
+      end
+    end
+
     private
-    
+
     def method_missing(method, *args, &block)
-      if assignment = (method.to_s[-1,1] == '=')
-        method = method.to_s.chop.to_sym
-      end
-      object = (@package_objects[method] ||=
-        Procedure.find(@schema, method, @package, @override_schema_name) ||
-        Variable.find(@schema, method, @package, @override_schema_name))
-      case object
-      when Procedure
-        raise ArgumentError, "Cannot assign value to package procedure '#{method.to_s.upcase}'" if assignment
-        object.exec(*args, &block)
-      when Variable
-        if assignment
-          raise ArgumentError, "Just one value can be assigned to package variable '#{method.to_s.upcase}'" unless args.size == 1 && block == nil
-          object.value = args[0]
+      method = method.to_s
+      method.chop! if (assignment = method[/=$/])
+
+      case (object = self[method])
+        when Procedure
+          if assignment
+            raise ArgumentError, "Cannot assign value to package procedure '#{method.upcase}'"
+          end
+          object.exec(*args, &block)
+        when Variable
+          if assignment
+            unless args.size == 1 && block.nil?
+              raise ArgumentError, "Just one value can be assigned " \
+                                   "to package variable '#{method.upcase}'"
+            end
+            object.value = args[0]
+          else
+            unless args.size == 0 && block.nil?
+              raise ArgumentError, "Cannot pass arguments when getting " \
+                                   "package variable '#{method.upcase}' value"
+            end
+            object.value
+          end
         else
-          raise ArgumentError, "Cannot pass arguments when getting package variable '#{method.to_s.upcase}' value" unless args.size == 0 && block == nil
-          object.value
-        end
-      else
-        raise ArgumentError, "No PL/SQL procedure or variable '#{method.to_s.upcase}' found"
+          raise ArgumentError, "No PL/SQL procedure or variable '#{method.upcase}' found"
       end
     end
 

data/lib/plsql/procedure.rb

@@ -64,7 +64,7 @@ module PLSQL
       when 'NUMBER'
         precision, scale = metadata[:data_precision], metadata[:data_scale]
         "NUMBER#{precision ? "(#{precision}#{scale ? ",#{scale}": ""})" : ""}"
-      when 'VARCHAR2', 'CHAR'
+      when 'VARCHAR', 'VARCHAR2', 'CHAR'
         length = case metadata[:char_used]
         when 'C' then "#{metadata[:char_length]} CHAR"
         when 'B' then "#{metadata[:data_length]} BYTE"
@@ -75,7 +75,7 @@ module PLSQL
       when 'NVARCHAR2', 'NCHAR'
         length = metadata[:char_length]
         "#{metadata[:data_type]}#{length && "(#{length})"}"
-      when 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'OBJECT'
+      when 'PL/SQL TABLE', 'TABLE', 'VARRAY', 'OBJECT', 'XMLTYPE'
         metadata[:sql_type_name]
       else
         metadata[:data_type]
@@ -100,11 +100,13 @@ module PLSQL
 
       # subprogram_id column is available just from version 10g
       subprogram_id_column = (@schema.connection.database_version <=> [10, 2, 0, 2]) >= 0 ? 'subprogram_id' : 'NULL'
+      # defaulted is available just from version 11g
+      defaulted_column = (@schema.connection.database_version <=> [11, 0, 0, 0]) >= 0 ? 'defaulted' : 'NULL'
 
       @schema.select_all(
         "SELECT #{subprogram_id_column}, object_name, TO_NUMBER(overload), argument_name, position, data_level,
               data_type, in_out, data_length, data_precision, data_scale, char_used,
-              char_length, type_owner, type_name, type_subname
+              char_length, type_owner, type_name, type_subname, #{defaulted_column}
         FROM all_arguments
         WHERE object_id = :object_id
         AND owner = :owner
@@ -115,7 +117,7 @@ module PLSQL
 
         subprogram_id, object_name, overload, argument_name, position, data_level,
             data_type, in_out, data_length, data_precision, data_scale, char_used,
-            char_length, type_owner, type_name, type_subname = r
+            char_length, type_owner, type_name, type_subname, defaulted = r
 
         @overloaded ||= !overload.nil?
         # if not overloaded then store arguments at key 0
@@ -155,7 +157,8 @@ module PLSQL
           :type_owner => type_owner,
           :type_name => type_name,
           :type_subname => type_subname,
-          :sql_type_name => sql_type_name
+          :sql_type_name => sql_type_name,
+          :defaulted => defaulted
         }
         if tmp_table_name
           @tmp_table_names[overload] << [(argument_metadata[:tmp_table_name] = tmp_table_name), argument_metadata]

data/lib/plsql/procedure_call.rb

@@ -109,9 +109,9 @@ module PLSQL
     end
 
     MATCHING_TYPES = {
-      :integer => ['NUMBER', 'PLS_INTEGER', 'BINARY_INTEGER'],
+      :integer => ['NUMBER', 'NATURAL', 'NATURALN', 'POSITIVE', 'POSITIVEN', 'SIGNTYPE', 'SIMPLE_INTEGER', 'PLS_INTEGER', 'BINARY_INTEGER'],
       :decimal => ['NUMBER', 'BINARY_FLOAT', 'BINARY_DOUBLE'],
-      :string => ['VARCHAR2', 'NVARCHAR2', 'CHAR', 'NCHAR', 'CLOB', 'BLOB'],
+      :string => ['VARCHAR', 'VARCHAR2', 'NVARCHAR2', 'CHAR', 'NCHAR', 'CLOB', 'BLOB', 'XMLTYPE'],
       :date => ['DATE'],
       :time => ['DATE', 'TIMESTAMP', 'TIMESTAMP WITH TIME ZONE', 'TIMESTAMP WITH LOCAL TIME ZONE'],
       :boolean => ['PL/SQL BOOLEAN'],
@@ -236,6 +236,14 @@ 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'
+          @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?
+          @bind_metadata[argument] = argument_metadata.merge(:data_type => "CLOB")
+          "l_#{argument}"
+        end
       else
         # TABLE or PL/SQL TABLE type defined inside package
         if argument_metadata[:tmp_table_name]
@@ -337,9 +345,16 @@ module PLSQL
         metadata = argument_metadata[:fields][field]
         raise ArgumentError, "Wrong field name #{key.inspect} passed to PL/SQL record argument #{argument.inspect}" unless metadata
         bind_variable = :"#{argument}_f#{metadata[:position]}"
-        sql << "l_#{argument}.#{field} := :#{bind_variable};\n"
-        bind_values[bind_variable] = value
-        bind_metadata[bind_variable] = metadata
+        case metadata[:data_type]
+        when 'PL/SQL BOOLEAN'
+          sql << "l_#{argument}.#{field} := (:#{bind_variable} = 1);\n"
+          bind_values[bind_variable] = value.nil? ? nil : (value ? 1 : 0)
+          bind_metadata[bind_variable] = metadata.merge(:data_type => "NUMBER", :data_precision => 1)
+        else
+          sql << "l_#{argument}.#{field} := :#{bind_variable};\n"
+          bind_values[bind_variable] = value
+          bind_metadata[bind_variable] = metadata
+        end
       end
       [sql, bind_values, bind_metadata]
     end
@@ -362,11 +377,29 @@ module PLSQL
           # should use different output bind variable as JDBC does not support
           # if output bind variable appears in several places
           bind_variable = :"#{argument}_o#{metadata[:position]}"
-          @return_vars << bind_variable
-          @return_vars_metadata[bind_variable] = metadata
-          @return_sql << ":#{bind_variable} := l_#{argument}.#{field};\n"
+          case metadata[:data_type]
+          when 'PL/SQL BOOLEAN'
+            @return_vars << bind_variable
+            @return_vars_metadata[bind_variable] = metadata.merge(:data_type => "NUMBER", :data_precision => 1)
+            arg_field = "l_#{argument}.#{field}"
+            @return_sql << ":#{bind_variable} := " << "CASE WHEN #{arg_field} = true THEN 1 " <<
+                                                      "WHEN #{arg_field} = false THEN 0 ELSE NULL END;\n"
+          else
+            @return_vars << bind_variable
+            @return_vars_metadata[bind_variable] = metadata
+            @return_sql << ":#{bind_variable} := l_#{argument}.#{field};\n"
+          end
         end
         "l_#{argument} := " if is_return_value
+      when 'UNDEFINED'
+        if argument_metadata[:type_name] == 'XMLTYPE'
+          @declare_sql << "l_#{argument} XMLTYPE;\n" if is_return_value
+          bind_variable = :"o_#{argument}"
+          @return_vars << bind_variable
+          @return_vars_metadata[bind_variable] = argument_metadata.merge(:data_type => "CLOB")
+          @return_sql << ":#{bind_variable} := CASE WHEN l_#{argument} IS NOT NULL THEN l_#{argument}.getclobval() END;\n"
+          "l_#{argument} := " if is_return_value
+        end
       when 'PL/SQL BOOLEAN'
         @declare_sql << "l_#{argument} BOOLEAN;\n" if is_return_value
         @declare_sql << "o_#{argument} NUMBER(1);\n"
@@ -468,12 +501,22 @@ module PLSQL
       when 'PL/SQL RECORD'
         return_value = {}
         argument_metadata[:fields].each do |field, metadata|
-          return_value[field] = @cursor[":#{argument}_o#{metadata[:position]}"]
+          field_value = @cursor[":#{argument}_o#{metadata[:position]}"]
+          case metadata[:data_type]
+          when 'PL/SQL BOOLEAN'
+            return_value[field] = field_value.nil? ? nil : field_value == 1
+          else
+            return_value[field] = field_value
+          end
         end
         return_value
       when 'PL/SQL BOOLEAN'
         numeric_value = @cursor[":o_#{argument}"]
         numeric_value.nil? ? nil : numeric_value == 1
+      when 'UNDEFINED'
+        if argument_metadata[:type_name] == 'XMLTYPE'
+          @cursor[":o_#{argument}"]
+        end
       else
         if argument_metadata[:tmp_table_name]
           is_index_by_table = argument_metadata[:data_type] == 'PL/SQL TABLE'

data/lib/plsql/schema.rb

@@ -90,7 +90,7 @@ module PLSQL
     # Current Oracle schema name
     def schema_name
       return nil unless connection
-      @schema_name ||= select_first("SELECT SYS_CONTEXT('userenv','session_user') FROM dual")[0]
+      @schema_name ||= select_first("SELECT SYS_CONTEXT('userenv','current_schema') FROM dual")[0]
     end
 
     # Default timezone to which database values will be converted - :utc or :local

data/lib/plsql/variable.rb

@@ -47,11 +47,12 @@ module PLSQL
 
     def metadata(type_string)
       case type_string
-      when /^(VARCHAR2|CHAR|NVARCHAR2|NCHAR)(\((\d+)[\s\w]*\))?$/
+      when /^(VARCHAR|VARCHAR2|CHAR|NVARCHAR2|NCHAR)(\((\d+)[\s\w]*\))?$/
         {:data_type => $1, :data_length => $3.to_i, :in_out => 'IN/OUT'}
       when /^(CLOB|NCLOB|BLOB)$/,
-          /^(NUMBER)(\(.*\))?$/, /^(PLS_INTEGER|BINARY_INTEGER)$/,
-          /^(DATE|TIMESTAMP|TIMESTAMP WITH TIME ZONE|TIMESTAMP WITH LOCAL TIME ZONE)$/
+          /^(NUMBER)(\(.*\))?$/, /^(NATURAL|NATURALN|POSITIVE|POSITIVEN|SIGNTYPE|SIMPLE_INTEGER|PLS_INTEGER|BINARY_INTEGER)$/,
+          /^(DATE|TIMESTAMP|TIMESTAMP WITH TIME ZONE|TIMESTAMP WITH LOCAL TIME ZONE)$/,
+          /^(XMLTYPE)$/
         {:data_type => $1, :in_out => 'IN/OUT'}
       when /^INTEGER$/
         {:data_type => 'NUMBER', :in_out => 'IN/OUT'}
@@ -143,4 +144,4 @@ module PLSQL
 
   end
 
-end
+end

data/ruby-plsql.gemspec

@@ -2,22 +2,29 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: ruby-plsql 0.5.3 ruby lib
+# stub: ruby-plsql 0.6.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "ruby-plsql"
-  s.version = "0.5.3"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Raimonds Simanovskis"]
-  s.date = "2015-05-07"
+  s.date = "2016-03-13"
   s.description = "ruby-plsql gem provides simple Ruby API for calling Oracle PL/SQL procedures.\nIt could be used both for accessing Oracle PL/SQL API procedures in legacy applications\nas well as it could be used to create PL/SQL unit tests using Ruby testing libraries.\n"
   s.email = "raimonds.simanovskis@gmail.com"
   s.extra_rdoc_files = [
     "README.md"
   ]
   s.files = [
+    ".travis.yml",
+    ".travis/oracle/LICENSE",
+    ".travis/oracle/README.md",
+    ".travis/oracle/download.js",
+    ".travis/oracle/download.sh",
+    ".travis/oracle/install.sh",
+    ".travis/setup_accounts.sh",
     "Gemfile",
     "History.txt",
     "License.txt",
@@ -57,11 +64,14 @@ Gem::Specification.new do |s|
     "spec/plsql/view_spec.rb",
     "spec/spec.opts",
     "spec/spec_helper.rb",
+    "spec/support/create_arunit_user.sql",
+    "spec/support/custom_config.rb.sample",
     "spec/support/file_check_script.sh",
-    "spec/support/test_db.rb"
+    "spec/support/test_db.rb",
+    "spec/support/unlock_and_setup_hr_user.sql"
   ]
   s.homepage = "http://github.com/rsim/ruby-plsql"
-  s.rubygems_version = "2.4.6"
+  s.rubygems_version = "2.5.1"
   s.summary = "Ruby API for calling Oracle PL/SQL procedures."
 
   if s.respond_to? :specification_version then
@@ -70,25 +80,28 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<jeweler>, ["~> 2.0.1"])
       s.add_development_dependency(%q<rspec>, ["~> 3.1"])
+      s.add_development_dependency(%q<rspec_junit_formatter>, [">= 0"])
       s.add_development_dependency(%q<activerecord>, ["< 4.3.0", ">= 3.2.3"])
-      s.add_development_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.6.0", ">= 1.4.1"])
+      s.add_development_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.7.0", ">= 1.4.1"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
-      s.add_development_dependency(%q<ruby-oci8>, ["~> 2.1.2"])
+      s.add_development_dependency(%q<ruby-oci8>, ["~> 2.1"])
     else
       s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
       s.add_dependency(%q<rspec>, ["~> 3.1"])
+      s.add_dependency(%q<rspec_junit_formatter>, [">= 0"])
       s.add_dependency(%q<activerecord>, ["< 4.3.0", ">= 3.2.3"])
-      s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.6.0", ">= 1.4.1"])
+      s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.7.0", ">= 1.4.1"])
       s.add_dependency(%q<simplecov>, [">= 0"])
-      s.add_dependency(%q<ruby-oci8>, ["~> 2.1.2"])
+      s.add_dependency(%q<ruby-oci8>, ["~> 2.1"])
     end
   else
     s.add_dependency(%q<jeweler>, ["~> 2.0.1"])
     s.add_dependency(%q<rspec>, ["~> 3.1"])
+    s.add_dependency(%q<rspec_junit_formatter>, [">= 0"])
     s.add_dependency(%q<activerecord>, ["< 4.3.0", ">= 3.2.3"])
-    s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.6.0", ">= 1.4.1"])
+    s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, ["< 1.7.0", ">= 1.4.1"])
     s.add_dependency(%q<simplecov>, [">= 0"])
-    s.add_dependency(%q<ruby-oci8>, ["~> 2.1.2"])
+    s.add_dependency(%q<ruby-oci8>, ["~> 2.1"])
   end
 end
 

data/spec/plsql/connection_spec.rb

@@ -7,7 +7,6 @@ describe "Connection" do
   before(:all) do
     @raw_conn = get_connection
     @conn = PLSQL::Connection.create( @raw_conn )
-    @conn.set_time_zone
   end
 
   after(:all) do
@@ -25,7 +24,6 @@ describe "Connection" do
 
     before(:each) do
       @conn1 = PLSQL::Connection.create( @raw_conn1 )
-      @conn1.set_time_zone
     end
 
     it "should create connection" do
@@ -53,6 +51,11 @@ describe "Connection" do
   # Ruby 1.8 and 1.9
   unless defined?(JRuby)
     describe "OCI data type conversions" do
+      it "should translate PL/SQL VARCHAR to Ruby String" do
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR", :data_length => 100)).to eq [String, 100]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR", :data_length => nil)).to eq [String, 32767]
+      end
+
       it "should translate PL/SQL VARCHAR2 to Ruby String" do
         expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => 100)).to eq [String, 100]
         expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => nil)).to eq [String, 32767]
@@ -124,6 +127,10 @@ describe "Connection" do
   else
 
     describe "JDBC data type conversions" do
+      it "should translate PL/SQL VARCHAR to Ruby String" do
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR", :data_length => 100)).to eq [String, 100]
+        expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR", :data_length => nil)).to eq [String, 32767]
+      end
       it "should translate PL/SQL VARCHAR2 to Ruby String" do
         expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => 100)).to eq [String, 100]
         expect(@conn.plsql_to_ruby_data_type(:data_type => "VARCHAR2", :data_length => nil)).to eq [String, 32767]
@@ -468,7 +475,6 @@ describe "Connection" do
     def reconnect_connection
       @raw_conn = get_connection
       @conn = PLSQL::Connection.create( @raw_conn )
-      @conn.set_time_zone
     end
 
     it "should drop current session ruby temporary tables" do