ruby-plsql 0.4.1 → 0.4.2

data/spec/plsql/table_spec.rb

@@ -6,10 +6,11 @@ describe "Table" do
     plsql.connection.autocommit = false
     plsql.execute <<-SQL
       CREATE TABLE test_employees (
-        employee_id   NUMBER(15),
+        employee_id   NUMBER(15) NOT NULL,
         first_name    VARCHAR2(50),
         last_name     VARCHAR2(50),
         hire_date     DATE,
+        created_at    TIMESTAMP,
         status        VARCHAR2(1) DEFAULT 'N'
       )
     SQL
@@ -32,10 +33,10 @@ describe "Table" do
     SQL
     plsql.execute <<-SQL
       CREATE TABLE test_employees2 (
-        employee_id   NUMBER(15),
+        employee_id   NUMBER(15) NOT NULL,
         first_name    VARCHAR2(50),
         last_name     VARCHAR2(50),
-        hire_date     DATE,
+        hire_date     DATE DEFAULT SYSDATE,
         address       t_address,
         phones        t_phones
       )
@@ -46,14 +47,15 @@ describe "Table" do
         :first_name => "First #{i}",
         :last_name => "Last #{i}",
         :hire_date => Time.local(2000,01,i),
+        :created_at => Time.local(2000,01,i,9,15,30,i),
         :status => 'A'
       }
     end
-    @employees_all_fields = [:employee_id, :first_name, :last_name, :hire_date, :status]
+    @employees_all_fields = [:employee_id, :first_name, :last_name, :hire_date, :created_at, :status]
     @employees_all_values = @employees.map{|e| @employees_all_fields.map{|f| e[f]}}
     @employees_some_fields = [:employee_id, :first_name, :last_name]
     @employees_some_values = @employees.map{|e| @employees_some_fields.map{|f| e[f]}}
-    @employee_default_values = {:hire_date => nil, :status => 'N'}
+    @employee_default_values = {:hire_date => nil, :created_at => nil, :status => 'N'}
 
     @employees2 = (1..10).map do |i|
       {
@@ -131,38 +133,52 @@ describe "Table" do
   describe "columns" do
 
     it "should get column names for table" do
-      plsql.test_employees.column_names.should == [:employee_id, :first_name, :last_name, :hire_date, :status]
+      plsql.test_employees.column_names.should == @employees_all_fields
     end
 
     it "should get columns metadata for table" do
       plsql.test_employees.columns.should == {
-        :employee_id =>
-          {:position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :first_name =>
-          {:position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B", :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :last_name =>
-          {:position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B", :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :hire_date => 
-          {:position=>4, :data_type=>"DATE", :data_length=>7, :data_precision=>nil, :data_scale=>nil, :char_used=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :status =>
-          {:position=>5, :data_type=>"VARCHAR2", :data_length=>1, :data_precision=>nil, :data_scale=>nil, :char_used=>"B", :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil}
+        :employee_id => {
+          :position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil,
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => false, :data_default => nil},
+        :first_name => {
+          :position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :last_name => {
+          :position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :hire_date => {
+          :position=>4, :data_type=>"DATE", :data_length=>7, :data_precision=>nil, :data_scale=>nil, :char_used=>nil,
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :created_at => {
+          :position=>5, :data_type=>"TIMESTAMP", :data_length=>11, :data_precision=>nil, :data_scale=>6, :char_used=>nil,
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :status => {
+          :position=>6, :data_type=>"VARCHAR2", :data_length=>1, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => "'N'"}
       }
     end
 
     it "should get columns metadata for table with object columns" do
       plsql.test_employees2.columns.should == {
-        :employee_id =>
-          {:position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :first_name =>
-          {:position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B", :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :last_name =>
-          {:position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B", :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :hire_date => 
-          {:position=>4, :data_type=>"DATE", :data_length=>7, :data_precision=>nil, :data_scale=>nil, :char_used=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :address => 
-          {:position=>5, :data_type=>"OBJECT", :data_length=>nil, :data_precision=>nil, :data_scale=>nil, :char_used=>nil, :type_owner=>"HR", :type_name=>"T_ADDRESS", :sql_type_name=>"HR.T_ADDRESS"},
-        :phones => 
-          {:position=>6, :data_type=>"TABLE", :data_length=>nil, :data_precision=>nil, :data_scale=>nil, :char_used=>nil, :type_owner=>"HR", :type_name=>"T_PHONES", :sql_type_name=>"HR.T_PHONES"}
+        :employee_id => {
+          :position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil,
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => false, :data_default => nil},
+        :first_name => {
+          :position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :last_name => {
+          :position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :hire_date => {
+          :position=>4, :data_type=>"DATE", :data_length=>7, :data_precision=>nil, :data_scale=>nil, :char_used=>nil,
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => "SYSDATE"},
+        :address => {
+          :position=>5, :data_type=>"OBJECT", :data_length=>nil, :data_precision=>nil, :data_scale=>nil,
+          :char_used=>nil, :type_owner=>"HR", :type_name=>"T_ADDRESS", :sql_type_name=>"HR.T_ADDRESS", :nullable => true, :data_default => nil},
+        :phones => {
+          :position=>6, :data_type=>"TABLE", :data_length=>nil, :data_precision=>nil, :data_scale=>nil, :char_used=>nil,
+          :type_owner=>"HR", :type_name=>"T_PHONES", :sql_type_name=>"HR.T_PHONES", :nullable => true, :data_default => nil}
       }
     end
 
@@ -256,6 +272,10 @@ describe "Table" do
       plsql.test_employees.first(:employee_id => @employees.first[:employee_id]).should == @employees.first
     end
 
+    it "should select records in table using WHERE condition and ORBER BY sorting" do
+      plsql.test_employees.all(:employee_id => @employees.first[:employee_id], :order_by => :employee_id).should == [@employees.first]
+    end
+
     it "should select record in table using :column => nil condition" do
       employee = @employees.last
       employee[:employee_id] = employee[:employee_id] + 1

data/spec/plsql/type_spec.rb

@@ -5,12 +5,67 @@ describe "Type" do
     plsql.connection = get_connection
     plsql.execute "DROP TYPE t_employee" rescue nil
     plsql.execute "DROP TYPE t_phones" rescue nil
+    plsql.execute "DROP TYPE t_phone" rescue nil
     plsql.execute <<-SQL
       CREATE OR REPLACE TYPE t_address AS OBJECT (
         street    VARCHAR2(50),
         city      VARCHAR2(50),
-        country   VARCHAR2(50)
-      )
+        country   VARCHAR2(50),
+        CONSTRUCTOR FUNCTION t_address(p_full_address VARCHAR2)
+          RETURN SELF AS RESULT,
+        MEMBER FUNCTION display_address(p_separator VARCHAR2 DEFAULT ',') RETURN VARCHAR2,
+        MEMBER FUNCTION display_address(p_uppercase BOOLEAN, p_separator VARCHAR2 DEFAULT ',') RETURN VARCHAR2,
+        MEMBER PROCEDURE set_country(p_country VARCHAR2),
+        MEMBER PROCEDURE set_country2(p_country VARCHAR2, x_display_address OUT VARCHAR2),
+        STATIC FUNCTION create_address(p_full_address VARCHAR2) RETURN t_address
+      );
+    SQL
+    plsql.execute <<-SQL
+      CREATE OR REPLACE TYPE BODY t_address AS
+        CONSTRUCTOR FUNCTION t_address(p_full_address VARCHAR2)
+          RETURN SELF AS RESULT
+        AS
+          l_comma1_pos INTEGER;
+          l_comma2_pos INTEGER;
+        BEGIN
+          l_comma1_pos := INSTR(p_full_address, ',', 1, 1);
+          l_comma2_pos := INSTR(p_full_address, ',', 1, 2);
+          SELF.street := TRIM(SUBSTR(p_full_address, 1, l_comma1_pos - 1));
+          SELF.city := TRIM(SUBSTR(p_full_address, l_comma1_pos+1, l_comma2_pos - l_comma1_pos - 1));
+          SELF.country := TRIM(SUBSTR(p_full_address, l_comma2_pos+1));
+          RETURN;
+        END;
+        MEMBER FUNCTION display_address(p_separator VARCHAR2) RETURN VARCHAR2 IS
+          l_separator VARCHAR2(10) := p_separator;
+        BEGIN
+          IF SUBSTR(l_separator,-1) != ' ' THEN
+            l_separator := l_separator || ' ';
+          END IF;
+          RETURN SELF.street || l_separator || SELF.city || l_separator || SELF.country;
+        END;
+        MEMBER FUNCTION display_address(p_uppercase BOOLEAN, p_separator VARCHAR2) RETURN VARCHAR2 IS
+          l_separator VARCHAR2(10) := p_separator;
+        BEGIN
+          IF p_uppercase THEN
+            RETURN UPPER(SELF.display_address(p_separator));
+          ELSE
+            RETURN SELF.display_address(p_separator);
+          END IF;
+        END;
+        MEMBER PROCEDURE set_country(p_country VARCHAR2) IS
+        BEGIN
+          SELF.country := p_country;
+        END;
+        MEMBER PROCEDURE set_country2(p_country VARCHAR2, x_display_address OUT VARCHAR2) IS
+        BEGIN
+          SELF.country := p_country;
+          x_display_address := SELF.display_address();
+        END;
+        STATIC FUNCTION create_address(p_full_address VARCHAR2) RETURN t_address IS
+        BEGIN
+          RETURN t_address(p_full_address);
+        END;
+      END;
     SQL
     plsql.execute <<-SQL
       CREATE OR REPLACE TYPE t_phone AS OBJECT (
@@ -130,4 +185,120 @@ describe "Type" do
 
   end
 
+  describe "object instance" do
+    before(:all) do
+      @phone_attributes = {:type => 'mobile', :phone_number => '123456'}
+      @address_attributes = {:street => 'Street', :city => 'City', :country => 'Country'}
+      @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
+    end
+
+    it "should get new object instance using named parameters" do
+      plsql.t_phone(@phone_attributes).should == @phone_attributes
+    end
+
+    it "should be an ObjectInstance" do
+      plsql.t_phone(@phone_attributes).should be_a(PLSQL::ObjectInstance)
+    end
+
+    it "should get new object instance using sequential parameters" do
+      plsql.t_phone(@phone_attributes[:type], @phone_attributes[:phone_number]).should == @phone_attributes
+    end
+
+    it "should get new object instance using custom constructor" do
+      plsql.t_address(@full_address).should == @address_attributes
+      plsql.t_address(:p_full_address => @full_address).should == @address_attributes
+    end
+
+    it "should get new object instance using default constructor when custom constructor exists" do
+      plsql.t_address(@address_attributes).should == @address_attributes
+      plsql.t_address(@address_attributes[:street], @address_attributes[:city], @address_attributes[:country]).should == @address_attributes
+    end
+
+    it "should get new empty collection of objects instance" do
+      plsql.t_phones.new.should == []
+      plsql.t_phones([]).should == []
+    end
+
+    it "should get new collection of objects instances" do
+      phone = plsql.t_phone(@phone_attributes)
+      plsql.t_phones([phone, phone]).should == [phone, phone]
+      plsql.t_phones(phone, phone).should == [phone, phone]
+      plsql.t_phones(@phone_attributes, @phone_attributes).should == [phone, phone]
+    end
+
+  end
+
+  describe "member procedures" do
+    before(:all) do
+      @address_attributes = {:street => 'Street', :city => 'City', :country => 'Country'}
+      @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
+    end
+
+    it "should call object instance member function without parameters" do
+      plsql.t_address(@address_attributes).display_address.should == @full_address
+    end
+
+    it "should call object instance member function with parameters" do
+      plsql.t_address(@address_attributes).display_address(',').should == @full_address
+    end
+
+    it "should call object instance member function with named parameters" do
+      plsql.t_address(@address_attributes).display_address(:p_separator => ',').should == @full_address
+    end
+
+    it "should call object overloaded instance member function" do
+      plsql.t_address(@address_attributes).display_address(true).should == @full_address.upcase
+      plsql.t_address(@address_attributes).display_address(true, ',').should == @full_address.upcase
+    end
+
+    it "should call object instance member function with explicit first SELF parameter" do
+      plsql.t_address.display_address(@address_attributes, ',').should == @full_address
+    end
+
+    it "should call object instance member function with explicit named SELF parameter" do
+      plsql.t_address.display_address(:self => @address_attributes, :p_separator => ',').should == @full_address
+    end
+
+    it "should call object instance member procedure" do
+      other_country = "Other"
+      plsql.t_address(@address_attributes).set_country(other_country).should == @address_attributes.merge(:country => other_country)
+    end
+
+    it "should call object instance member procedure with output parameters" do
+      other_country = "Other"
+      plsql.t_address(@address_attributes).set_country2(other_country).should == 
+        [@address_attributes.merge(:country => other_country),
+        {:x_display_address => "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{other_country}"}]
+    end
+
+    it "should raise error if invalid member procedure is called" do
+      lambda do
+        plsql.t_address(@address_attributes).invalid_procedure
+      end.should raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "static procedures" do
+    before(:all) do
+      @address_attributes = {:street => 'Street', :city => 'City', :country => 'Country'}
+      @full_address = "#{@address_attributes[:street]}, #{@address_attributes[:city]}, #{@address_attributes[:country]}"
+    end
+
+    it "should call object type static function" do
+      plsql.t_address.create_address(@full_address).should == @address_attributes
+    end
+
+    it "should call object type static function with named parameters" do
+      plsql.t_address.create_address(:p_full_address => @full_address).should == @address_attributes
+    end
+
+    it "should raise error if invalid static procedure is called" do
+      lambda do
+        plsql.t_address.invalid_procedure
+      end.should raise_error(ArgumentError)
+    end
+
+  end
+
 end

data/spec/plsql/variable_spec.rb

@@ -21,6 +21,8 @@ describe "Package variables /" do
           varchar2_default varchar2(50) := 'default' ;
           varchar2_default2 varchar2(50) DEFAULT 'default';
           varchar2_default3 varchar2(50) NOT NULL := 'default';
+          varchar2_3_char VARCHAR2(3 CHAR);
+          varchar2_3_byte VARCHAR2(3 BYTE);
           char_variable char(10) ;
           nvarchar2_variable NVARCHAR2(50);
           nchar_variable NCHAR(10);
@@ -53,6 +55,19 @@ describe "Package variables /" do
       plsql.test_package.varchar2_default3.should == 'default'
     end
 
+    it "should set and get VARCHAR2(n CHAR) variable" do
+      plsql.test_package.varchar2_3_char = 'āčē'
+      plsql.test_package.varchar2_3_char.should == 'āčē'
+      lambda { plsql.test_package.varchar2_3_char = 'aceg' }.should raise_error(/buffer too small/)
+    end
+
+    it "should set and get VARCHAR2(n BYTE) variable" do
+      plsql.test_package.varchar2_3_byte = 'ace'
+      plsql.test_package.varchar2_3_byte.should == 'ace'
+      lambda { plsql.test_package.varchar2_3_byte = 'āce' }.should raise_error(/buffer too small/)
+      lambda { plsql.test_package.varchar2_3_byte = 'aceg' }.should raise_error(/buffer too small/)
+    end
+
     it "should set and get CHAR variable" do
       plsql.test_package.char_variable = 'abc'
       plsql.test_package.char_variable.should == 'abc' + ' '*7
@@ -356,6 +371,7 @@ describe "Package variables /" do
       plsql.execute <<-SQL
         CREATE OR REPLACE PACKAGE test_package IS
           g_employee    t_employee;
+          g_employee2   hr.t_employee;
           g_phones      t_phones;
         END;
       SQL
@@ -379,6 +395,11 @@ describe "Package variables /" do
       plsql.test_package.g_employee.should == @employee
     end
 
+    it "should set and get object type variable when schema prefix is used with type" do
+      plsql.hr.test_package.g_employee2 = @employee
+      plsql.hr.test_package.g_employee2.should == @employee
+    end
+
     it "should set and get collection type variable" do
       plsql.test_package.g_phones = @phones
       plsql.test_package.g_phones.should == @phones

data/spec/plsql/view_spec.rb

@@ -6,7 +6,7 @@ describe "View" do
     plsql.connection.autocommit = false
     plsql.execute <<-SQL
       CREATE TABLE test_employees (
-        employee_id   NUMBER(15),
+        employee_id   NUMBER(15) NOT NULL,
         first_name    VARCHAR2(50),
         last_name     VARCHAR2(50),
         hire_date     DATE,
@@ -97,16 +97,21 @@ describe "View" do
 
     it "should get columns metadata for view" do
       plsql.test_employees_v.columns.should == {
-        :employee_id =>
-          {:position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :first_name =>
-          {:position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B", :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :last_name =>
-          {:position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B", :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :hire_date => 
-          {:position=>4, :data_type=>"DATE", :data_length=>7, :data_precision=>nil, :data_scale=>nil, :char_used=>nil, :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil},
-        :status =>
-          {:position=>5, :data_type=>"VARCHAR2", :data_length=>1, :data_precision=>nil, :data_scale=>nil, :char_used=>"B", :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil}
+        :employee_id => {
+          :position=>1, :data_type=>"NUMBER", :data_length=>22, :data_precision=>15, :data_scale=>0, :char_used=>nil,
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => false, :data_default => nil},
+        :first_name => {
+          :position=>2, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :last_name => {
+          :position=>3, :data_type=>"VARCHAR2", :data_length=>50, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :hire_date => {
+          :position=>4, :data_type=>"DATE", :data_length=>7, :data_precision=>nil, :data_scale=>nil, :char_used=>nil,
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil},
+        :status => {
+          :position=>5, :data_type=>"VARCHAR2", :data_length=>1, :data_precision=>nil, :data_scale=>nil, :char_used=>"B",
+          :type_owner=>nil, :type_name=>nil, :sql_type_name=>nil, :nullable => true, :data_default => nil}
       }
     end
 

data/spec/spec_helper.rb

@@ -2,18 +2,22 @@ require "rubygems"
 gem "rspec"
 require "spec"
 
-gem "activerecord"
-require "active_record"
-gem "activerecord-oracle_enhanced-adapter"
+unless ENV['NO_ACTIVERECORD']
+  # avoid loading activerecord 3.0 beta
+  gem "activerecord", "= 2.3.5"
+  require "active_record"
+  gem "activerecord-oracle_enhanced-adapter", "= 1.2.4"
+else
+  puts "Without ActiveRecord"
+end
 
 if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
-  # gem "ruby-oci8", "=2.0.2"
   gem "ruby-oci8", ">=2.0.3"
 end
 
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 
-require "ruby_plsql"
+require "ruby-plsql"
 
 DATABASE_NAME = ENV['DATABASE_NAME'] || 'orcl'
 DATABASE_HOST = ENV['DATABASE_HOST'] || 'localhost'
@@ -54,3 +58,13 @@ CONNECTION_PARAMS = {
   :username => DATABASE_USERS_AND_PASSWORDS[0][0],
   :password => DATABASE_USERS_AND_PASSWORDS[0][1]
 }
+
+class Hash
+  def except(*blacklist)
+    self.reject {|key, value| blacklist.include?(key) }
+  end unless method_defined?(:except)
+
+  def only(*whitelist)
+    self.reject {|key, value| !whitelist.include?(key) }
+  end unless method_defined?(:only)
+end