ctreatma-activerecord-oracle_enhanced-adapter 1.4.1.1

data/spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb

@@ -0,0 +1,310 @@
+require 'spec_helper'
+
+describe "OracleEnhancedConnection" do
+
+  describe "create connection" do
+    before(:all) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+    end
+
+    before(:each) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS) unless @conn.active?
+    end
+
+    it "should create new connection" do
+      @conn.should be_active
+    end
+
+    it "should ping active connection" do
+      @conn.ping.should be_true
+    end
+
+    it "should not ping inactive connection" do
+      @conn.logoff
+      lambda { @conn.ping }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
+    end
+
+    it "should reset active connection" do
+      @conn.reset!
+      @conn.should be_active
+    end
+
+    it "should be in autocommit mode after connection" do
+      @conn.should be_autocommit
+    end
+
+  end
+
+  describe "create connection with NLS parameters" do
+    after do
+      ENV['NLS_DATE_FORMAT'] = nil
+    end
+
+    it "should use NLS_DATE_FORMAT environment variable" do
+      ENV['NLS_DATE_FORMAT'] = 'YYYY-MM-DD'
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => 'YYYY-MM-DD'}]
+    end
+
+    it "should use configuration value and ignore NLS_DATE_FORMAT environment variable" do
+      ENV['NLS_DATE_FORMAT'] = 'YYYY-MM-DD'
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS.merge(:nls_date_format => 'YYYY-MM-DD HH24:MI'))
+      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => 'YYYY-MM-DD HH24:MI'}]
+    end
+
+    it "should use default value when NLS_DATE_FORMAT environment variable is not set" do
+      ENV['NLS_DATE_FORMAT'] = nil
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+      default = ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS[:nls_date_format]
+      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => default}]
+    end
+  end
+
+  describe "with non-string parameters" do
+    before(:all) do
+      params = CONNECTION_PARAMS.dup
+      params[:username] = params[:username].to_sym
+      params[:password] = params[:password].to_sym
+      params[:database] = params[:database].to_sym
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+    end
+
+    it "should create new connection" do
+      @conn.should be_active
+    end
+  end
+
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+    describe "create JDBC connection" do
+
+      it "should create new connection using :url" do
+        params = CONNECTION_PARAMS.dup
+        params[:url] = "jdbc:oracle:thin:@#{DATABASE_HOST && "#{DATABASE_HOST}:"}#{DATABASE_PORT && "#{DATABASE_PORT}:"}#{DATABASE_NAME}"
+        params[:host] = nil
+        params[:database] = nil
+        @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+        @conn.should be_active
+      end
+
+      it "should create new connection using :url and tnsnames alias" do
+        params = CONNECTION_PARAMS.dup
+        params[:url] = "jdbc:oracle:thin:@#{DATABASE_NAME}"
+        params[:host] = nil
+        params[:database] = nil
+        @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+        @conn.should be_active
+      end
+
+      it "should create new connection using just tnsnames alias" do
+        params = CONNECTION_PARAMS.dup
+        params[:host] = nil
+        @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+        @conn.should be_active
+      end
+
+      it "should create a new connection using JNDI" do
+
+        begin
+          import 'oracle.jdbc.driver.OracleDriver'
+          import 'org.apache.commons.pool.impl.GenericObjectPool'
+          import 'org.apache.commons.dbcp.PoolingDataSource'
+          import 'org.apache.commons.dbcp.PoolableConnectionFactory'
+          import 'org.apache.commons.dbcp.DriverManagerConnectionFactory'
+        rescue NameError => e
+          return pending e.message
+        end
+
+        class InitialContextMock
+          def initialize
+            connection_pool = GenericObjectPool.new(nil)
+            uri = "jdbc:oracle:thin:@#{DATABASE_HOST && "#{DATABASE_HOST}:"}#{DATABASE_PORT && "#{DATABASE_PORT}:"}#{DATABASE_NAME}"
+            connection_factory = DriverManagerConnectionFactory.new(uri, DATABASE_USER, DATABASE_PASSWORD)
+            poolable_connection_factory = PoolableConnectionFactory.new(connection_factory,connection_pool,nil,nil,false,true)
+            @data_source = PoolingDataSource.new(connection_pool)
+            @data_source.access_to_underlying_connection_allowed = true
+          end
+          def lookup(path)
+            if (path == 'java:/comp/env')
+              return self
+            else
+              return @data_source
+            end
+          end
+        end
+
+        javax.naming.InitialContext.stub!(:new).and_return(InitialContextMock.new)
+
+        params = {}
+        params[:jndi] = 'java:comp/env/jdbc/test'
+        @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+        @conn.should be_active
+      end
+
+    end
+
+  end
+
+  describe "SQL execution" do
+    before(:all) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+    end
+
+    it "should execute SQL statement" do
+      @conn.exec("SELECT * FROM dual").should_not be_nil
+    end
+
+    it "should execute SQL select" do
+      @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
+    end
+
+    it "should execute SQL select and return also columns" do
+      @conn.select("SELECT * FROM dual", nil, true).should == [ [{'dummy' => 'X'}], ['dummy'] ]
+    end
+
+  end
+
+  describe "SQL with bind parameters" do
+    before(:all) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+    end
+
+    it "should execute SQL statement with bind parameter" do
+      cursor = @conn.prepare("SELECT * FROM dual WHERE :1 = 1")
+      cursor.bind_param(1, 1)
+      cursor.exec
+      cursor.get_col_names.should == ['DUMMY']
+      cursor.fetch.should == ["X"]
+      cursor.close
+    end
+
+    it "should execute prepared statement with different bind parameters" do
+      cursor = @conn.prepare("SELECT * FROM dual WHERE :1 = 1")
+      cursor.bind_param(1, 1)
+      cursor.exec
+      cursor.fetch.should == ["X"]
+      cursor.bind_param(1, 0)
+      cursor.exec
+      cursor.fetch.should be_nil
+      cursor.close
+    end
+  end
+
+  describe "SQL with bind parameters when NLS_NUMERIC_CHARACTERS is set to ', '" do
+    before(:all) do
+      ENV['NLS_NUMERIC_CHARACTERS'] = ", "
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+      @conn.exec "CREATE TABLE test_employees (age NUMBER(10,2))"
+    end
+
+    after(:all) do
+      ENV['NLS_NUMERIC_CHARACTERS'] = nil
+      @conn.exec "DROP TABLE test_employees" rescue nil
+    end
+
+    it "should execute prepared statement with decimal bind parameter " do
+      cursor = @conn.prepare("INSERT INTO test_employees VALUES(:1)")
+      cursor.bind_param(1, "1.5", :decimal)
+      cursor.exec
+      cursor.close
+      cursor = @conn.prepare("SELECT age FROM test_employees")
+      cursor.exec
+      cursor.fetch.should == [1.5]
+      cursor.close
+    end
+  end
+
+  describe "auto reconnection" do
+    before(:all) do
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+      @conn = ActiveRecord::Base.connection.instance_variable_get("@connection")
+      @sys_conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(SYS_CONNECTION_PARAMS)
+    end
+
+    before(:each) do
+      ActiveRecord::Base.connection.reconnect! unless @conn.active?
+    end
+
+    def kill_current_session
+      audsid = @conn.select("SELECT userenv('sessionid') audsid FROM dual").first['audsid']
+      sid_serial = @sys_conn.select("SELECT s.sid||','||s.serial# sid_serial
+          FROM   v$session s
+          WHERE  audsid = '#{audsid}'").first['sid_serial']
+      @sys_conn.exec "ALTER SYSTEM KILL SESSION '#{sid_serial}' IMMEDIATE"
+    end
+
+    it "should reconnect and execute SQL statement if connection is lost and auto retry is enabled" do
+      # @conn.auto_retry = true
+      ActiveRecord::Base.connection.auto_retry = true
+      kill_current_session
+      @conn.exec("SELECT * FROM dual").should_not be_nil
+    end
+
+    it "should not reconnect and execute SQL statement if connection is lost and auto retry is disabled" do
+      # @conn.auto_retry = false
+      ActiveRecord::Base.connection.auto_retry = false
+      kill_current_session
+      lambda { @conn.exec("SELECT * FROM dual") }.should raise_error
+    end
+
+    it "should reconnect and execute SQL select if connection is lost and auto retry is enabled" do
+      # @conn.auto_retry = true
+      ActiveRecord::Base.connection.auto_retry = true
+      kill_current_session
+      @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
+    end
+
+    it "should not reconnect and execute SQL select if connection is lost and auto retry is disabled" do
+      # @conn.auto_retry = false
+      ActiveRecord::Base.connection.auto_retry = false
+      kill_current_session
+      lambda { @conn.select("SELECT * FROM dual") }.should raise_error
+    end
+
+  end
+
+  describe "describe table" do
+    before(:all) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+      @owner = CONNECTION_PARAMS[:username].upcase
+    end
+
+    it "should describe existing table" do
+      @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+      @conn.describe("test_employees").should == [@owner, "TEST_EMPLOYEES"]
+      @conn.exec "DROP TABLE test_employees" rescue nil
+    end
+
+    it "should not describe non-existing table" do
+      lambda { @conn.describe("test_xxx") }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
+    end
+
+    it "should describe table in other schema" do
+      @conn.describe("sys.dual").should == ["SYS", "DUAL"]
+    end
+
+    it "should describe existing view" do
+      @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+      @conn.exec "CREATE VIEW test_employees_v AS SELECT * FROM test_employees" rescue nil
+      @conn.describe("test_employees_v").should == [@owner, "TEST_EMPLOYEES_V"]
+      @conn.exec "DROP VIEW test_employees_v" rescue nil
+      @conn.exec "DROP TABLE test_employees" rescue nil
+    end
+
+    it "should describe view in other schema" do
+      @conn.describe("sys.v_$version").should == ["SYS", "V_$VERSION"]
+    end
+
+    it "should describe existing private synonym" do
+      @conn.exec "CREATE SYNONYM test_dual FOR sys.dual" rescue nil
+      @conn.describe("test_dual").should == ["SYS", "DUAL"]
+      @conn.exec "DROP SYNONYM test_dual" rescue nil
+    end
+
+    it "should describe existing public synonym" do
+      @conn.describe("all_tables").should == ["SYS", "ALL_TABLES"]
+    end
+
+  end
+
+end

data/spec/active_record/connection_adapters/oracle_enhanced_context_index_spec.rb

@@ -0,0 +1,426 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe "OracleEnhancedAdapter context index" do
+  include SchemaSpecHelper
+  include LoggerSpecHelper
+
+  def create_table_posts
+    schema_define do
+      create_table :posts, :force => true do |t|
+        t.string :title
+        t.text :body
+        t.integer :comments_count
+        t.timestamps
+        t.string :all_text, :limit => 2 # will be used for multi-column index
+      end
+    end
+  end
+
+  def create_table_comments
+    schema_define do
+      create_table :comments, :force => true do |t|
+        t.integer :post_id
+        t.string :author
+        t.text :body
+        t.timestamps
+      end
+    end
+  end
+
+  def create_tables
+    create_table_posts
+    create_table_comments
+  end
+
+  def drop_table_posts
+    schema_define { drop_table :posts }
+  end
+
+  def drop_table_comments
+    schema_define { drop_table :comments }
+  end
+
+  def drop_tables
+    drop_table_comments
+    drop_table_posts
+  end
+
+  # Try to grant CTXAPP role to be able to set CONTEXT index parameters.
+  def grant_ctxapp
+    @sys_conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(SYS_CONNECTION_PARAMS)
+    @sys_conn.exec "GRANT CTXAPP TO #{DATABASE_USER}"
+  rescue
+    nil
+  end
+
+  before(:all) do
+    grant_ctxapp
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+  end
+
+  describe "on single table" do
+    before(:all) do
+      @conn = ActiveRecord::Base.connection
+      @title_words = %w{aaa bbb ccc}
+      @body_words = %w{foo bar baz}
+      create_table_posts
+      class ::Post < ActiveRecord::Base
+        has_context_index
+      end
+      @post0 = Post.create(:title => "dummy title", :body => "dummy body")
+      @post1 = Post.create(:title => @title_words.join(' '), :body => @body_words.join(' '))
+      @post2 = Post.create(:title => (@title_words*2).join(' '), :body => (@body_words*2).join(' '))
+      @post_with_null_body = Post.create(:title => "withnull", :body => nil)
+      @post_with_null_title = Post.create(:title => nil, :body => "withnull")
+    end
+
+    after(:all) do
+      drop_table_posts
+      Object.send(:remove_const, "Post")
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    end
+
+    after(:each) do
+      @post.destroy if @post
+    end
+
+    it "should create single VARCHAR2 column index" do
+      @conn.add_context_index :posts, :title
+      @title_words.each do |word|
+        Post.contains(:title, word).all.should == [@post2, @post1]
+      end
+      @conn.remove_context_index :posts, :title
+    end
+
+    it "should create single CLOB column index" do
+      @conn.add_context_index :posts, :body
+      @body_words.each do |word|
+        Post.contains(:body, word).all.should == [@post2, @post1]
+      end
+      @conn.remove_context_index :posts, :body
+    end
+
+    it "should not include text index secondary tables in user tables list" do
+      @conn.add_context_index :posts, :title
+      @conn.tables.any?{|t| t =~ /^dr\$/i}.should be_false
+      @conn.remove_context_index :posts, :title
+    end
+
+    it "should create multiple column index" do
+      @conn.add_context_index :posts, [:title, :body]
+      (@title_words+@body_words).each do |word|
+        Post.contains(:title, word).all.should == [@post2, @post1]
+      end
+      @conn.remove_context_index :posts, [:title, :body]
+    end
+
+    it "should index records with null values" do
+      @conn.add_context_index :posts, [:title, :body]
+      Post.contains(:title, "withnull").all.should == [@post_with_null_body, @post_with_null_title]
+      @conn.remove_context_index :posts, [:title, :body]
+    end
+
+    it "should create multiple column index with specified main index column" do
+      @conn.add_context_index :posts, [:title, :body],
+        :index_column => :all_text, :sync => 'ON COMMIT'
+      @post = Post.create(:title => "abc", :body => "def")
+      Post.contains(:all_text, "abc").all.should == [@post]
+      Post.contains(:all_text, "def").all.should == [@post]
+      @post.update_attributes!(:title => "ghi")
+      # index will not be updated as all_text column is not changed
+      Post.contains(:all_text, "ghi").all.should be_empty
+      @post.update_attributes!(:all_text => "1")
+      # index will be updated when all_text column is changed
+      Post.contains(:all_text, "ghi").all.should == [@post]
+      @conn.remove_context_index :posts, :index_column => :all_text
+    end
+
+    it "should create multiple column index with trigger updated main index column" do
+      @conn.add_context_index :posts, [:title, :body],
+        :index_column => :all_text, :index_column_trigger_on => [:created_at, :updated_at],
+        :sync => 'ON COMMIT'
+      @post = Post.create(:title => "abc", :body => "def")
+      Post.contains(:all_text, "abc").all.should == [@post]
+      Post.contains(:all_text, "def").all.should == [@post]
+      @post.update_attributes!(:title => "ghi")
+      # index should be updated as created_at column is changed
+      Post.contains(:all_text, "ghi").all.should == [@post]
+      @conn.remove_context_index :posts, :index_column => :all_text
+    end
+
+    it "should use base letter conversion with BASIC_LEXER" do
+      @post = Post.create!(:title => "āčē", :body => "dummy")
+      @conn.add_context_index :posts, :title,
+        :lexer => { :type => "BASIC_LEXER", :base_letter_type => 'GENERIC', :base_letter => true }
+      Post.contains(:title, "āčē").all.should == [@post]
+      Post.contains(:title, "ace").all.should == [@post]
+      Post.contains(:title, "ACE").all.should == [@post]
+      @conn.remove_context_index :posts, :title
+    end
+
+    it "should create transactional index and sync index within transaction on inserts and updates" do
+      @conn.add_context_index :posts, :title, :transactional => true
+      Post.transaction do
+        @post = Post.create(:title => "abc")
+        Post.contains(:title, "abc").all.should == [@post]
+        @post.update_attributes!(:title => "ghi")
+        Post.contains(:title, "ghi").all.should == [@post]
+      end
+      @conn.remove_context_index :posts, :title
+    end
+  end
+
+  describe "on multiple tables" do
+    before(:all) do
+      @conn = ActiveRecord::Base.connection
+      create_tables
+      class ::Post < ActiveRecord::Base
+        has_many :comments, :dependent => :destroy
+        has_context_index
+      end
+      class ::Comment < ActiveRecord::Base
+        belongs_to :post, :counter_cache => true
+      end
+    end
+
+    after(:all) do
+      drop_tables
+      Object.send(:remove_const, "Comment")
+      Object.send(:remove_const, "Post")
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    end
+
+    after(:each) do
+      Post.destroy_all
+    end
+
+    it "should create multiple table index with specified main index column" do
+      @conn.add_context_index :posts,
+        [:title, :body,
+        # specify aliases always with AS keyword
+        "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"
+        ],
+        :name => 'post_and_comments_index',
+        :index_column => :all_text, :index_column_trigger_on => [:updated_at, :comments_count],
+        :sync => 'ON COMMIT'
+      @post = Post.create!(:title => "aaa", :body => "bbb")
+      @post.comments.create!(:author => "ccc", :body => "ddd")
+      @post.comments.create!(:author => "eee", :body => "fff")
+      ["aaa", "bbb", "ccc", "ddd", "eee", "fff"].each do |word|
+        Post.contains(:all_text, word).all.should == [@post]
+      end
+      @conn.remove_context_index :posts, :name => 'post_and_comments_index'
+    end
+
+    it "should create multiple table index with specified main index column (when subquery has newlines)" do
+      @conn.add_context_index :posts,
+        [:title, :body,
+         # specify aliases always with AS keyword
+         %{ SELECT
+             comments.author AS comment_author,
+             comments.body AS comment_body
+            FROM comments
+            WHERE comments.post_id = :id }
+        ],
+        :name => 'post_and_comments_index',
+        :index_column => :all_text, :index_column_trigger_on => [:updated_at, :comments_count],
+        :sync => 'ON COMMIT'
+      @post = Post.create!(:title => "aaa", :body => "bbb")
+      @post.comments.create!(:author => "ccc", :body => "ddd")
+      @post.comments.create!(:author => "eee", :body => "fff")
+      ["aaa", "bbb", "ccc", "ddd", "eee", "fff"].each do |word|
+        Post.contains(:all_text, word).all.should == [@post]
+      end
+      @conn.remove_context_index :posts, :name => 'post_and_comments_index'
+    end
+
+    it "should find by search term within specified field" do
+      @post = Post.create!(:title => "aaa", :body => "bbb")
+      @post.comments.create!(:author => "ccc", :body => "ddd")
+      @conn.add_context_index :posts,
+        [:title, :body,
+        # specify aliases always with AS keyword
+        "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"
+        ],
+        :index_column => :all_text
+      Post.contains(:all_text, "aaa within title").all.should == [@post]
+      Post.contains(:all_text, "aaa within body").all.should be_empty
+      Post.contains(:all_text, "bbb within body").all.should == [@post]
+      Post.contains(:all_text, "bbb within title").all.should be_empty
+      Post.contains(:all_text, "ccc within comment_author").all.should == [@post]
+      Post.contains(:all_text, "ccc within comment_body").all.should be_empty
+      Post.contains(:all_text, "ddd within comment_body").all.should == [@post]
+      Post.contains(:all_text, "ddd within comment_author").all.should be_empty
+      @conn.remove_context_index :posts, :index_column => :all_text
+    end
+
+  end
+
+  describe "with specified tablespace" do
+    before(:all) do
+      @conn = ActiveRecord::Base.connection
+      create_table_posts
+      class ::Post < ActiveRecord::Base
+        has_context_index
+      end
+      @post = Post.create(:title => 'aaa', :body => 'bbb')
+      @tablespace = @conn.default_tablespace
+      set_logger
+      @conn = ActiveRecord::Base.connection
+    end
+
+    after(:all) do
+      drop_table_posts
+      Object.send(:remove_const, "Post")
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    end
+
+    after(:each) do
+      clear_logger
+    end
+
+    def verify_logged_statements
+      ['K_TABLE_CLAUSE', 'R_TABLE_CLAUSE', 'N_TABLE_CLAUSE', 'I_INDEX_CLAUSE', 'P_TABLE_CLAUSE'].each do |clause|
+        @logger.output(:debug).should =~ /CTX_DDL\.SET_ATTRIBUTE\('index_posts_on_title_sto', '#{clause}', '.*TABLESPACE #{@tablespace}'\)/
+      end
+      @logger.output(:debug).should =~ /CREATE INDEX .* PARAMETERS \('STORAGE index_posts_on_title_sto'\)/
+    end
+
+    it "should create index on single column" do
+      @conn.add_context_index :posts, :title, :tablespace => @tablespace
+      verify_logged_statements
+      Post.contains(:title, 'aaa').all.should == [@post]
+      @conn.remove_context_index :posts, :title
+    end
+
+    it "should create index on multiple columns" do
+      @conn.add_context_index :posts, [:title, :body], :name => 'index_posts_text', :tablespace => @conn.default_tablespace
+      verify_logged_statements
+      Post.contains(:title, 'aaa AND bbb').all.should == [@post]
+      @conn.remove_context_index :posts, :name => 'index_posts_text'
+    end
+
+  end
+
+  describe "schema dump" do
+
+    def standard_dump
+      stream = StringIO.new
+      ActiveRecord::SchemaDumper.ignore_tables = []
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      stream.string
+    end
+
+    describe "without table prefixe and suffix" do
+
+      before(:all) do
+        @conn = ActiveRecord::Base.connection
+        create_tables
+      end
+
+      after(:all) do
+        drop_tables
+      end
+
+      it "should dump definition of single column index" do
+        @conn.add_context_index :posts, :title
+        standard_dump.should =~ /add_context_index "posts", \["title"\], :name => \"index_posts_on_title\"$/
+        @conn.remove_context_index :posts, :title
+      end
+
+      it "should dump definition of multiple column index" do
+        @conn.add_context_index :posts, [:title, :body]
+        standard_dump.should =~ /add_context_index "posts", \[:title, :body\]$/
+        @conn.remove_context_index :posts, [:title, :body]
+      end
+
+      it "should dump definition of multiple table index with options" do
+        options = {
+          :name => 'post_and_comments_index',
+          :index_column => :all_text, :index_column_trigger_on => :updated_at,
+          :transactional => true,
+          :sync => 'ON COMMIT'
+        }
+        sub_query = "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"
+        @conn.add_context_index :posts, [:title, :body, sub_query], options
+        standard_dump.should =~ /add_context_index "posts", \[:title, :body, "#{sub_query}"\], #{options.inspect[1..-2]}$/
+        @conn.remove_context_index :posts, :name => 'post_and_comments_index'
+      end
+
+      it "should dump definition of multiple table index with options (when definition is larger than 4000 bytes)" do
+        options = {
+          :name => 'post_and_comments_index',
+          :index_column => :all_text, :index_column_trigger_on => :updated_at,
+          :transactional => true,
+          :sync => 'ON COMMIT'
+        }
+        sub_query = "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id#{' AND 1=1' * 500}"
+        @conn.add_context_index :posts, [:title, :body, sub_query], options
+        standard_dump.should =~ /add_context_index "posts", \[:title, :body, "#{sub_query}"\], #{options.inspect[1..-2]}$/
+        @conn.remove_context_index :posts, :name => 'post_and_comments_index'
+      end
+
+      it "should dump definition of multiple table index with options (when subquery has newlines)" do
+        options = {
+          :name => 'post_and_comments_index',
+          :index_column => :all_text, :index_column_trigger_on => :updated_at,
+          :transactional => true,
+          :sync => 'ON COMMIT'
+        }
+        sub_query = "SELECT comments.author AS comment_author, comments.body AS comment_body\nFROM comments\nWHERE comments.post_id = :id"
+        @conn.add_context_index :posts, [:title, :body, sub_query], options
+        standard_dump.should =~ /add_context_index "posts", \[:title, :body, "#{sub_query.gsub(/\n/, ' ')}"\], #{options.inspect[1..-2]}$/
+        @conn.remove_context_index :posts, :name => 'post_and_comments_index'
+      end
+
+    end
+
+    describe "with table prefix and suffix" do
+      before(:all) do
+        ActiveRecord::Base.table_name_prefix = 'xxx_'
+        ActiveRecord::Base.table_name_suffix = '_xxx'
+        create_tables
+      end
+
+      after(:all) do
+        drop_tables
+        ActiveRecord::Base.table_name_prefix = ''
+        ActiveRecord::Base.table_name_suffix = ''
+      end
+
+      it "should dump definition of single column index" do
+        schema_define { add_context_index :posts, :title }
+        standard_dump.should =~ /add_context_index "posts", \["title"\], :name => "i_xxx_posts_xxx_title"$/
+        schema_define { remove_context_index :posts, :title }
+      end
+
+      it "should dump definition of multiple column index" do
+        schema_define { add_context_index :posts, [:title, :body] }
+        standard_dump.should =~ /add_context_index "posts", \[:title, :body\]$/
+        schema_define { remove_context_index :posts, [:title, :body] }
+      end
+
+      it "should dump definition of multiple table index with options" do
+        options = {
+          :name => 'xxx_post_and_comments_i',
+          :index_column => :all_text, :index_column_trigger_on => :updated_at,
+          :lexer => { :type => "BASIC_LEXER", :base_letter_type => 'GENERIC', :base_letter => true },
+          :sync => 'ON COMMIT'
+        }
+        schema_define do
+          add_context_index :posts,
+            [:title, :body,
+            "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"
+            ], options
+        end
+        standard_dump.should =~ /add_context_index "posts", \[:title, :body, "SELECT comments.author AS comment_author, comments.body AS comment_body FROM comments WHERE comments.post_id = :id"\], #{
+          options.inspect[1..-2].gsub(/[{}]/){|s| '\\'<<s }}$/
+        schema_define { remove_context_index :posts, :name => 'xxx_post_and_comments_i' }
+      end
+
+    end
+
+  end
+
+end