Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Add support for FrontBase (http://www.frontbase.com/) with a new adap…

…ter thanks to the hard work of one Mike Laster. Closes #4093. [mlaster@metavillage.com]

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@4291 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
  • Loading branch information...
commit b2c0ddf033fbf143539ad8a7630747a0e866e4fc 1 parent dd5397a
Marcel Molina authored
Showing with 1,282 additions and 55 deletions.
  1. +2 −0  activerecord/CHANGELOG
  2. +40 −1 activerecord/Rakefile
  3. +1 −1  activerecord/lib/active_record.rb
  4. +4 −4 activerecord/lib/active_record/base.rb
  5. +12 −2 activerecord/lib/active_record/calculations.rb
  6. +837 −0 activerecord/lib/active_record/connection_adapters/frontbase_adapter.rb
  7. +7 −1 activerecord/lib/active_record/fixtures.rb
  8. +9 −7 activerecord/test/adapter_test.rb
  9. +6 −6 activerecord/test/base_test.rb
  10. +26 −0 activerecord/test/connections/native_frontbase/connection.rb
  11. +1 −0  activerecord/test/deprecated_finder_test.rb
  12. +6 −0 activerecord/test/finder_test.rb
  13. +30 −0 activerecord/test/fixtures/db_definitions/frontbase.drop.sql
  14. +251 −0 activerecord/test/fixtures/db_definitions/frontbase.sql
  15. +1 −0  activerecord/test/fixtures/db_definitions/frontbase2.drop.sql
  16. +4 −0 activerecord/test/fixtures/db_definitions/frontbase2.sql
  17. +19 −17 activerecord/test/migration_test.rb
  18. +1 −0  activerecord/test/pk_test.rb
  19. +6 −0 activerecord/test/reflection_test.rb
  20. +18 −16 activerecord/test/threaded_connections_test.rb
  21. +1 −0  activerecord/test/transactions_test.rb
View
2  activerecord/CHANGELOG
@@ -1,5 +1,7 @@
*SVN*
+* Add support for FrontBase (http://www.frontbase.com/) with a new adapter thanks to the hard work of one Mike Laster. Closes #4093. [mlaster@metavillage.com]
+
* Add warning about the proper way to validate the presence of a foreign key. Closes #4147. [Francois Beausoleil <francois.beausoleil@gmail.com>]
* Fix syntax error in documentation. Closes #4679. [mislav@nippur.irb.hr]
View
41 activerecord/Rakefile
@@ -27,7 +27,7 @@ task :default => [ :test_mysql, :test_sqlite, :test_postgresql ]
# Run the unit tests
-for adapter in %w( mysql postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oracle sybase openbase )
+for adapter in %w( mysql postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oracle sybase openbase frontbase )
Rake::TestTask.new("test_#{adapter}") { |t|
t.libs << "test" << "test/connections/native_#{adapter}"
t.pattern = "test/*_test{,_#{adapter}}.rb"
@@ -71,6 +71,45 @@ end
desc 'Rebuild the PostgreSQL test databases'
task :rebuild_postgresql_databases => [:drop_postgresql_databases, :build_postgresql_databases]
+desc 'Build the FrontBase test databases'
+task :build_frontbase_databases => :rebuild_frontbase_databases
+
+desc 'Rebuild the FrontBase test databases'
+task :rebuild_frontbase_databases do
+ build_frontbase_database = Proc.new do |db_name, sql_definition_file|
+ %(
+ STOP DATABASE #{db_name};
+ DELETE DATABASE #{db_name};
+ CREATE DATABASE #{db_name};
+
+ CONNECT TO #{db_name} AS SESSION_NAME USER _SYSTEM;
+ SET COMMIT FALSE;
+
+ CREATE USER RAILS;
+ CREATE SCHEMA RAILS AUTHORIZATION RAILS;
+ COMMIT;
+
+ SET SESSION AUTHORIZATION RAILS;
+ SCRIPT '#{sql_definition_file}';
+
+ COMMIT;
+
+ DISCONNECT ALL;
+ )
+ end
+ create_activerecord_unittest = build_frontbase_database['activerecord_unittest', File.join(SCHEMA_PATH, 'frontbase.sql')]
+ create_activerecord_unittest2 = build_frontbase_database['activerecord_unittest2', File.join(SCHEMA_PATH, 'frontbase2.sql')]
+ execute_frontbase_sql = Proc.new do |sql|
+ system(<<-SHELL)
+ /Library/FrontBase/bin/sql92 <<-SQL
+ #{sql}
+ SQL
+ SHELL
+ end
+ execute_frontbase_sql[create_activerecord_unittest]
+ execute_frontbase_sql[create_activerecord_unittest2]
+end
+
# Generate the RDoc documentation
Rake::RDocTask.new { |rdoc|
View
2  activerecord/lib/active_record.rb
@@ -68,7 +68,7 @@
end
unless defined?(RAILS_CONNECTION_ADAPTERS)
- RAILS_CONNECTION_ADAPTERS = %w( mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase )
+ RAILS_CONNECTION_ADAPTERS = %w( mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase frontbase )
end
RAILS_CONNECTION_ADAPTERS.each do |adapter|
View
8 activerecord/lib/active_record/base.rb
@@ -755,8 +755,8 @@ def descends_from_active_record? # :nodoc:
superclass == Base || !columns_hash.include?(inheritance_column)
end
- def quote(object) #:nodoc:
- connection.quote(object)
+ def quote(value, column = nil) #:nodoc:
+ connection.quote(value,column)
end
# Used to sanitize objects before they're used in an SELECT SQL-statement. Delegates to <tt>connection.quote</tt>.
@@ -947,7 +947,7 @@ def find_from_ids(ids, options)
def find_one(id, options)
conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
- options.update :conditions => "#{table_name}.#{primary_key} = #{sanitize(id)}#{conditions}"
+ options.update :conditions => "#{table_name}.#{primary_key} = #{quote(id,columns_hash[primary_key])}#{conditions}"
if result = find_initial(options)
result
@@ -958,7 +958,7 @@ def find_one(id, options)
def find_some(ids, options)
conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
- ids_list = ids.map { |id| sanitize(id) }.join(',')
+ ids_list = ids.map { |id| quote(id,columns_hash[primary_key]) }.join(',')
options.update :conditions => "#{table_name}.#{primary_key} IN (#{ids_list})#{conditions}"
result = find_every(options)
View
14 activerecord/lib/active_record/calculations.rb
@@ -173,8 +173,18 @@ def construct_calculation_sql(operation, column_name, options) #:nodoc:
add_joins!(sql, options, scope)
add_conditions!(sql, options[:conditions], scope)
add_limited_ids_condition!(sql, options, join_dependency) if join_dependency && !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
- sql << " GROUP BY #{options[:group_field]} " if options[:group]
- sql << " HAVING #{options[:having]} " if options[:group] && options[:having]
+ sql << " GROUP BY #{options[:group_alias]} " if options[:group]
+
+ if options[:group] && options[:having]
+ # FrontBase requires identifiers in the HAVING clause and chokes on function calls
+ if Base.connection.adapter_name == 'FrontBase'
+ options[:having].downcase!
+ options[:having].gsub!(/#{operation}\s*\(\s*#{column_name}\s*\)/, aggregate_alias)
+ end
+
+ sql << " HAVING #{options[:having]} "
+ end
+
sql << " ORDER BY #{options[:order]} " if options[:order]
add_limit!(sql, options, scope)
sql << ')' if use_workaround
View
837 activerecord/lib/active_record/connection_adapters/frontbase_adapter.rb
@@ -0,0 +1,837 @@
+# Requires FrontBase Ruby bindings from:
+# svn://rubyforge.org/var/svn/frontbase-rails/trunk/ruby-frontbase
+
+require 'active_record/connection_adapters/abstract_adapter'
+require 'frontbase'
+
+FB_TRACE = false
+
+module ActiveRecord
+
+ class Base
+
+ class << self
+ # FrontBase only supports one unnamed sequence per table
+ def set_sequence_name( value=nil, &block )
+ end
+
+ # Establishes a connection to the database that's used by all Active Record objects.
+ def frontbase_connection(config) # :nodoc:
+ config = config.symbolize_keys
+ database = config[:database]
+ port = config[:port]
+ host = config[:host]
+ username = config[:username]
+ password = config[:password]
+ dbpassword = config[:dbpassword]
+ session_name = config[:session_name]
+
+ dbpassword = '' if dbpassword.nil?
+
+ # Turn off colorization since it makes tail/less output difficult
+ self.colorize_logging = false
+
+
+ connection = FBSQL_Connect.connect(host, port, database, username, password, dbpassword, session_name)
+ ConnectionAdapters::FrontBaseAdapter.new(connection, logger, [host, port, database, username, password, dbpassword, session_name], config)
+ end
+ end
+ end
+
+ module ConnectionAdapters
+
+ # From EOF Documentation....
+ # buffer should have space for EOUniqueBinaryKeyLength (12) bytes.
+ # Assigns a world-wide unique ID made up of:
+ # < Sequence [2], ProcessID [2] , Time [4], IP Addr [4] >
+
+ class TwelveByteKey < String #:nodoc
+ @@mutex = Mutex.new
+ @@sequence_number = rand(65536)
+ @@key_cached_pid_component = nil
+ @@key_cached_ip_component = nil
+
+ def initialize(string = nil)
+ # Generate a unique key
+ if string.nil?
+ new_key = replace('_' * 12)
+
+ new_key[0..1] = self.class.key_sequence_component
+ new_key[2..3] = self.class.key_pid_component
+ new_key[4..7] = self.class.key_time_component
+ new_key[8..11] = self.class.key_ip_component
+ new_key
+ else
+ if string.size == 24
+ string.gsub!(/[[:xdigit:]]{2}/) { |x| x.hex.chr }
+ end
+ raise "string is not 12 bytes long" unless string.size == 12
+ super(string)
+ end
+ end
+
+ def inspect
+ unpack("H*").first.upcase
+ end
+
+ alias_method :to_s, :inspect
+
+ private
+
+ class << self
+ def key_sequence_component
+ seq = nil
+ @@mutex.synchronize do
+ seq = @@sequence_number
+ @@sequence_number = (@@sequence_number + 1) % 65536
+ end
+
+ sequence_component = "__"
+ sequence_component[0] = seq >> 8
+ sequence_component[1] = seq
+ sequence_component
+ end
+
+ def key_pid_component
+ if @@key_cached_pid_component.nil?
+ @@mutex.synchronize do
+ pid = $$
+ pid_component = "__"
+ pid_component[0] = pid >> 8
+ pid_component[1] = pid
+ @@key_cached_pid_component = pid_component
+ end
+ end
+ @@key_cached_pid_component
+ end
+
+ def key_time_component
+ time = Time.new.to_i
+ time_component = "____"
+ time_component[0] = (time & 0xFF000000) >> 24
+ time_component[1] = (time & 0x00FF0000) >> 16
+ time_component[2] = (time & 0x0000FF00) >> 8
+ time_component[3] = (time & 0x000000FF)
+ time_component
+ end
+
+ def key_ip_component
+ if @@key_cached_ip_component.nil?
+ @@mutex.synchronize do
+ old_lookup_flag = BasicSocket.do_not_reverse_lookup
+ BasicSocket.do_not_reverse_lookup = true
+ udpsocket = UDPSocket.new
+ udpsocket.connect("17.112.152.32",1)
+ ip_string = udpsocket.addr[3]
+ BasicSocket.do_not_reverse_lookup = old_lookup_flag
+ packed = Socket.pack_sockaddr_in(0,ip_string)
+ addr_subset = packed[4..7]
+ ip = addr_subset[0] << 24 | addr_subset[1] << 16 | addr_subset[2] << 8 | addr_subset[3]
+ ip_component = "____"
+ ip_component[0] = (ip & 0xFF000000) >> 24
+ ip_component[1] = (ip & 0x00FF0000) >> 16
+ ip_component[2] = (ip & 0x0000FF00) >> 8
+ ip_component[3] = (ip & 0x000000FF)
+ @@key_cached_ip_component = ip_component
+ end
+ end
+ @@key_cached_ip_component
+ end
+ end
+ end
+
+ class FrontBaseColumn < Column #:nodoc:
+ attr_reader :fb_autogen
+
+ def initialize(base, name, type, typename, limit, precision, scale, default, nullable)
+
+ @base = base
+ @name = name
+ @type = simplified_type(type,typename,limit)
+ @limit = limit
+ @precision = precision
+ @scale = scale
+ @default = default
+ @null = nullable == "YES"
+ @text = [:string, :text].include? @type
+ @number = [:float, :integer].include? @type
+ @fb_autogen = false
+
+ if @default
+ @default.gsub!(/^'(.*)'$/,'\1') if @text
+ @fb_autogen = @default.include?("SELECT UNIQUE FROM")
+ case @type
+ when :boolean
+ @default = @default == "TRUE"
+ when :binary
+ if @default != "X''"
+ buffer = ""
+ @default.scan(/../) { |h| buffer << h.hex.chr }
+ @default = buffer
+ else
+ @default = ""
+ end
+ else
+ @default = type_cast(@default)
+ end
+ end
+ end
+
+ # Casts value (which is a String) to an appropriate instance.
+ def type_cast(value)
+ if type == :twelvebytekey
+ ActiveRecord::ConnectionAdapters::TwelveByteKey.new(value)
+ else
+ super(value)
+ end
+ end
+
+ def type_cast_code(var_name)
+ if type == :twelvebytekey
+ "ActiveRecord::ConnectionAdapters::TwelveByteKey.new(#{var_name})"
+ else
+ super(var_name)
+ end
+ end
+
+ private
+ def simplified_type(field_type, type_name,limit)
+ ret_type = :string
+ puts "typecode: [#{field_type}] [#{type_name}]" if FB_TRACE
+
+ # 12 byte primary keys are a special case that Apple's EOF
+ # used heavily. Optimize for this case
+ if field_type == 11 && limit == 96
+ ret_type = :twelvebytekey # BIT(96)
+ else
+ ret_type = case field_type
+ when 1 then :boolean # BOOLEAN
+ when 2 then :integer # INTEGER
+ when 4 then :float # FLOAT
+ when 10 then :string # CHARACTER VARYING
+ when 11 then :bitfield # BIT
+ when 13 then :date # DATE
+ when 14 then :time # TIME
+ when 16 then :timestamp # TIMESTAMP
+ when 20 then :text # CLOB
+ when 21 then :binary # BLOB
+ when 22 then :integer # TINYINT
+ else
+ puts "ERROR: Unknown typecode: [#{field_type}] [#{type_name}]"
+ end
+ end
+ puts "ret_type: #{ret_type.inspect}" if FB_TRACE
+ ret_type
+ end
+ end
+
+ class FrontBaseAdapter < AbstractAdapter
+
+ def initialize(connection, logger, connection_options, config)
+ super(connection, logger)
+ @connection_options, @config = connection_options, config
+ @transaction_mode = :pessimistic
+
+ # threaded_connections_test.rb will fail unless we set the session
+ # to optimistic locking mode
+# set_pessimistic_transactions
+# execute "SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, LOCKING OPTIMISTIC"
+ end
+
+ # Returns the human-readable name of the adapter. Use mixed case - one
+ # can always use downcase if needed.
+ def adapter_name #:nodoc:
+ 'FrontBase'
+ end
+
+ # Does this adapter support migrations? Backend specific, as the
+ # abstract adapter always returns +false+.
+ def supports_migrations? #:nodoc:
+ true
+ end
+
+ def native_database_types #:nodoc
+ {
+ :primary_key => "INTEGER DEFAULT UNIQUE PRIMARY KEY",
+ :string => { :name => "VARCHAR", :limit => 255 },
+ :text => { :name => "CLOB" },
+ :integer => { :name => "INTEGER" },
+ :float => { :name => "FLOAT" },
+ :datetime => { :name => "TIMESTAMP" },
+ :timestamp => { :name => "TIMESTAMP" },
+ :time => { :name => "TIME" },
+ :date => { :name => "DATE" },
+ :binary => { :name => "BLOB" },
+ :boolean => { :name => "BOOLEAN" },
+ :twelvebytekey => { :name => "BYTE", :limit => 12}
+ }
+ end
+
+
+ # QUOTING ==================================================
+
+ # Quotes the column value to help prevent
+ # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+ def quote(value, column = nil)
+ retvalue = "<INVALID>"
+
+ puts "quote(#{value.inspect}(#{value.class}),#{column.type.inspect})" if FB_TRACE
+ # If a column was passed in, use column type information
+ unless value.nil?
+ if column
+ retvalue = case column.type
+ when :string
+ if value.kind_of?(String)
+ "'#{quote_string(value.to_s)}'" # ' (for ruby-mode)
+ else
+ "'#{quote_string(value.to_yaml)}'"
+ end
+ when :integer
+ if value.kind_of?(TrueClass)
+ '1'
+ elsif value.kind_of?(FalseClass)
+ '0'
+ else
+ value.to_i.to_s
+ end
+ when :float
+ value.to_f.to_s
+ when :datetime, :timestamp
+ "TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+ when :time
+ "TIME '#{value.strftime("%H:%M:%S")}'"
+ when :date
+ "DATE '#{value.strftime("%Y-%m-%d")}'"
+ when :twelvebytekey
+ value = value.to_s.unpack("H*").first unless value.kind_of?(TwelveByteKey)
+ "X'#{value.to_s}'"
+ when :boolean
+ value = quoted_true if value.kind_of?(TrueClass)
+ value = quoted_false if value.kind_of?(FalseClass)
+ value
+ when :binary
+ blob_handle = @connection.create_blob(value.to_s)
+ puts "SQL -> Insert #{value.to_s.length} byte blob as #{retvalue}" if FB_TRACE
+ blob_handle.handle
+ when :text
+ if value.kind_of?(String)
+ clobdata = value.to_s # ' (for ruby-mode)
+ else
+ clobdata = value.to_yaml
+ end
+ clob_handle = @connection.create_clob(clobdata)
+ puts "SQL -> Insert #{value.to_s.length} byte clob as #{retvalue}" if FB_TRACE
+ clob_handle.handle
+ else
+ raise "*** UNKNOWN TYPE: #{column.type.inspect}"
+ end # case
+ # Since we don't have column type info, make a best guess based
+ # on the Ruby class of the value
+ else
+ retvalue = case value
+ when ActiveRecord::ConnectionAdapters::TwelveByteKey
+ s = value.unpack("H*").first
+ "X'#{s}'"
+ when String
+ if column && column.type == :binary
+ s = value.unpack("H*").first
+ "X'#{s}'"
+ elsif column && [:integer, :float].include?(column.type)
+ value.to_s
+ else
+ "'#{quote_string(value)}'" # ' (for ruby-mode)
+ end
+ when NilClass
+ "NULL"
+ when TrueClass
+ (column && column.type == :integer ? '1' : quoted_true)
+ when FalseClass
+ (column && column.type == :integer ? '0' : quoted_false)
+ when Float, Fixnum, Bignum
+ value.to_s
+ when Time, Date, DateTime
+ if column
+ case column.type
+ when :date
+ "DATE '#{value.strftime("%Y-%m-%d")}'"
+ when :time
+ "TIME '#{value.strftime("%H:%M:%S")}'"
+ when :timestamp
+ "TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+ else
+ raise NotImplementedError, "Unknown column type!"
+ end # case
+ else # Column wasn't passed in, so try to guess the right type
+ if value.kind_of? Date
+ "DATE '#{value.strftime("%Y-%m-%d")}'"
+ else
+ if [:hour, :min, :sec].all? {|part| value.send(:part).zero? }
+ "TIME '#{value.strftime("%H:%M:%S")}'"
+ else
+ "TIMESTAMP '#{quoted_date(value)}'"
+ end
+ end
+ end #if column
+ else
+ "'#{quote_string(value.to_yaml)}'"
+ end #case
+ end
+ else
+ retvalue = "NULL"
+ end
+
+ retvalue
+ end # def
+
+ # Quotes a string, escaping any ' (single quote) characters.
+ def quote_string(s)
+ s.gsub(/'/, "''") # ' (for ruby-mode)
+ end
+
+ def quote_column_name(name) #:nodoc:
+ %( "#{name}" )
+ end
+
+ def quoted_true
+ "true"
+ end
+
+ def quoted_false
+ "false"
+ end
+
+
+ # CONNECTION MANAGEMENT ====================================
+
+ def active?
+ true if @connection.status == 1
+ rescue => e
+ false
+ end
+
+ def reconnect!
+ @connection.close rescue nil
+ @connection = FBSQL_Connect.connect(*@connection_options.first(7))
+ end
+
+ # Close this connection
+ def disconnect!
+ @connection.close rescue nil
+ @active = false
+ end
+
+ # DATABASE STATEMENTS ======================================
+
+ # Returns an array of record hashes with the column names as keys and
+ # column values as values.
+ def select_all(sql, name = nil) #:nodoc:
+ fbsql = cleanup_fb_sql(sql)
+ return_value = []
+ fbresult = execute(sql, name)
+ puts "select_all SQL -> #{fbsql}" if FB_TRACE
+ columns = fbresult.columns
+
+ fbresult.each do |row|
+ puts "SQL <- #{row.inspect}" if FB_TRACE
+ hashed_row = {}
+ colnum = 0
+ row.each do |col|
+ hashed_row[columns[colnum]] = col
+ if col.kind_of?(FBSQL_LOB)
+ hashed_row[columns[colnum]] = col.read
+ end
+ colnum += 1
+ end
+ puts "raw row: #{hashed_row.inspect}" if FB_TRACE
+ return_value << hashed_row
+ end
+ return_value
+ end
+
+ def select_one(sql, name = nil) #:nodoc:
+ fbsql = cleanup_fb_sql(sql)
+ return_value = []
+ fbresult = execute(fbsql, name)
+ puts "SQL -> #{fbsql}" if FB_TRACE
+ columns = fbresult.columns
+
+ fbresult.each do |row|
+ puts "SQL <- #{row.inspect}" if FB_TRACE
+ hashed_row = {}
+ colnum = 0
+ row.each do |col|
+ hashed_row[columns[colnum]] = col
+ if col.kind_of?(FBSQL_LOB)
+ hashed_row[columns[colnum]] = col.read
+ end
+ colnum += 1
+ end
+ return_value << hashed_row
+ break
+ end
+ fbresult.clear
+ return_value.first
+ end
+
+ def query(sql, name = nil) #:nodoc:
+ fbsql = cleanup_fb_sql(sql)
+ puts "SQL(query) -> #{fbsql}" if FB_TRACE
+ log(fbsql, name) { @connection.query(fbsql) }
+ rescue => e
+ puts "FB Exception: #{e.inspect}" if FB_TRACE
+ raise e
+ end
+
+ def execute(sql, name = nil) #:nodoc:
+ fbsql = cleanup_fb_sql(sql)
+ puts "SQL(execute) -> #{fbsql}" if FB_TRACE
+ log(fbsql, name) { @connection.query(fbsql) }
+ rescue ActiveRecord::StatementInvalid => e
+ if e.message.scan(/Table name - \w* - exists/).empty?
+ puts "FB Exception: #{e.inspect}" if FB_TRACE
+ raise e
+ end
+ end
+
+ # Returns the last auto-generated ID from the affected table.
+ def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+ puts "SQL -> #{sql.inspect}" if FB_TRACE
+ execute(sql, name)
+ id_value || pk
+ end
+
+ # Executes the update statement and returns the number of rows affected.
+ def update(sql, name = nil) #:nodoc:
+ puts "SQL -> #{sql.inspect}" if FB_TRACE
+ execute(sql, name).num_rows
+ end
+
+ alias_method :delete, :update #:nodoc:
+
+ def set_pessimistic_transactions
+ if @transaction_mode == :optimistic
+ execute "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE, LOCKING PESSIMISTIC, READ WRITE"
+ @transaction_mode = :pessimistic
+ end
+ end
+
+ def set_optimistic_transactions
+ if @transaction_mode == :pessimistic
+ execute "SET TRANSACTION ISOLATION LEVEL REPEATABLE READ, READ WRITE, LOCKING OPTIMISTIC"
+ @transaction_mode = :optimistic
+ end
+ end
+
+ def begin_db_transaction #:nodoc:
+ execute "SET COMMIT FALSE" rescue nil
+ end
+
+ def commit_db_transaction #:nodoc:
+ execute "COMMIT"
+ ensure
+ execute "SET COMMIT TRUE"
+ end
+
+ def rollback_db_transaction #:nodoc:
+ execute "ROLLBACK"
+ ensure
+ execute "SET COMMIT TRUE"
+ end
+
+ def add_limit_offset!(sql, options) #:nodoc
+ if limit = options[:limit]
+ offset = options[:offset] || 0
+
+# Here is the full syntax FrontBase supports:
+# (from gclem@frontbase.com)
+#
+# TOP <limit - unsigned integer>
+# TOP ( <offset expr>, <limit expr>)
+
+ # "TOP 0" is not allowed, so we have
+ # to use a cheap trick.
+ if limit.zero?
+ case sql
+ when /WHERE/i
+ sql.sub!(/WHERE/i, 'WHERE 0 = 1 AND ')
+ when /ORDER\s+BY/i
+ sql.sub!(/ORDER\s+BY/i, 'WHERE 0 = 1 ORDER BY')
+ else
+ sql << 'WHERE 0 = 1'
+ end
+ else
+ if offset.zero?
+ sql.replace sql.gsub("SELECT ","SELECT TOP #{limit} ")
+ else
+ sql.replace sql.gsub("SELECT ","SELECT TOP(#{offset},#{limit}) ")
+ end
+ end
+ end
+ end
+
+ def prefetch_primary_key?(table_name = nil)
+ true
+ end
+
+ # Returns the next sequence value from a sequence generator. Not generally
+ # called directly; used by ActiveRecord to get the next primary key value
+ # when inserting a new database record (see #prefetch_primary_key?).
+ def next_sequence_value(sequence_name)
+ unique = select_value("SELECT UNIQUE FROM #{sequence_name}","Next Sequence Value")
+ # The test cases cannot handle a zero primary key
+ unique.zero? ? select_value("SELECT UNIQUE FROM #{sequence_name}","Next Sequence Value") : unique
+ end
+
+ def default_sequence_name(table, column)
+ table
+ end
+
+ # Set the sequence to the max value of the table's column.
+ def reset_sequence!(table, column, sequence = nil)
+ klasses = classes_for_table_name(table)
+ klass = klasses.nil? ? nil : klasses.first
+ pk = klass.primary_key unless klass.nil?
+ if pk && klass.columns_hash[pk].type == :integer
+ execute("SET UNIQUE FOR #{klass.table_name}(#{pk})")
+ end
+ end
+
+ def classes_for_table_name(table)
+ ActiveRecord::Base.send(:subclasses).select {|klass| klass.table_name == table}
+ end
+
+ def reset_pk_sequence!(table, pk = nil, sequence = nil)
+ klasses = classes_for_table_name(table)
+ klass = klasses.nil? ? nil : klasses.first
+ pk = klass.primary_key unless klass.nil?
+ if pk && klass.columns_hash[pk].type == :integer
+ mpk = select_value("SELECT MAX(#{pk}) FROM #{table}")
+ execute("SET UNIQUE FOR #{klass.table_name}(#{pk})")
+ end
+ end
+
+ # SCHEMA STATEMENTS ========================================
+
+ def structure_dump #:nodoc:
+ select_all("SHOW TABLES").inject('') do |structure, table|
+ structure << select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] << ";\n\n"
+ end
+ end
+
+ def recreate_database(name) #:nodoc:
+ drop_database(name)
+ create_database(name)
+ end
+
+ def create_database(name) #:nodoc:
+ execute "CREATE DATABASE #{name}"
+ end
+
+ def drop_database(name) #:nodoc:
+ execute "DROP DATABASE #{name}"
+ end
+
+ def current_database
+ select_value('SELECT "CATALOG_NAME" FROM INFORMATION_SCHEMA.CATALOGS').downcase
+ end
+
+ def tables(name = nil) #:nodoc:
+ select_values(<<-SQL, nil)
+ SELECT "TABLE_NAME"
+ FROM INFORMATION_SCHEMA.TABLES AS T0,
+ INFORMATION_SCHEMA.SCHEMATA AS T1
+ WHERE T0.SCHEMA_PK = T1.SCHEMA_PK
+ AND "SCHEMA_NAME" = CURRENT_SCHEMA
+ SQL
+ end
+
+ def indexes(table_name, name = nil)#:nodoc:
+ indexes = []
+ current_index = nil
+ sql = <<-SQL
+ SELECT INDEX_NAME, T2.ORDINAL_POSITION, INDEX_COLUMN_COUNT, INDEX_TYPE,
+ "COLUMN_NAME", IS_NULLABLE
+ FROM INFORMATION_SCHEMA.TABLES AS T0,
+ INFORMATION_SCHEMA.INDEXES AS T1,
+ INFORMATION_SCHEMA.INDEX_COLUMN_USAGE AS T2,
+ INFORMATION_SCHEMA.COLUMNS AS T3
+ WHERE T0."TABLE_NAME" = '#{table_name}'
+ AND INDEX_TYPE <> 0
+ AND T0.TABLE_PK = T1.TABLE_PK
+ AND T0.TABLE_PK = T2.TABLE_PK
+ AND T0.TABLE_PK = T3.TABLE_PK
+ AND T1.INDEXES_PK = T2.INDEX_PK
+ AND T2.COLUMN_PK = T3.COLUMN_PK
+ ORDER BY INDEX_NAME, T2.ORDINAL_POSITION
+ SQL
+
+ columns = []
+ query(sql).each do |row|
+ index_name = row[0]
+ ord_position = row[1]
+ ndx_colcount = row[2]
+ index_type = row[3]
+ column_name = row[4]
+
+ is_unique = index_type == 1
+
+ columns << column_name
+ if ord_position == ndx_colcount
+ indexes << IndexDefinition.new(table_name, index_name, is_unique , columns)
+ columns = []
+ end
+ end
+ indexes
+ end
+
+ def columns(table_name, name = nil)#:nodoc:
+ sql = <<-SQL
+ SELECT "TABLE_NAME", "COLUMN_NAME", ORDINAL_POSITION, IS_NULLABLE, COLUMN_DEFAULT,
+ DATA_TYPE, DATA_TYPE_CODE, CHARACTER_MAXIMUM_LENGTH, NUMERIC_PRECISION,
+ NUMERIC_PRECISION_RADIX, NUMERIC_SCALE, DATETIME_PRECISION, DATETIME_PRECISION_LEADING
+ FROM INFORMATION_SCHEMA.TABLES T0,
+ INFORMATION_SCHEMA.COLUMNS T1,
+ INFORMATION_SCHEMA.DATA_TYPE_DESCRIPTOR T3
+ WHERE "TABLE_NAME" = '#{table_name}'
+ AND T0.TABLE_PK = T1.TABLE_PK
+ AND T0.TABLE_PK = T3.TABLE_OR_DOMAIN_PK
+ AND T1.COLUMN_PK = T3.COLUMN_NAME_PK
+ ORDER BY T1.ORDINAL_POSITION
+ SQL
+
+ rawresults = query(sql,name)
+ columns = []
+ rawresults.each do |field|
+ args = [base = field[0],
+ name = field[1],
+ typecode = field[6],
+ typestring = field[5],
+ limit = field[7],
+ precision = field[8],
+ scale = field[9],
+ default = field[4],
+ nullable = field[3]]
+ columns << FrontBaseColumn.new(*args)
+ end
+ columns
+ end
+
+ def create_table(name, options = {})
+ table_definition = TableDefinition.new(self)
+ table_definition.primary_key(options[:primary_key] || "id") unless options[:id] == false
+
+ yield table_definition
+
+ if options[:force]
+ drop_table(name) rescue nil
+ end
+
+ create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+ create_sql << "#{name} ("
+ create_sql << table_definition.to_sql
+ create_sql << ") #{options[:options]}"
+ begin_db_transaction
+ execute create_sql
+ commit_db_transaction
+ rescue ActiveRecord::StatementInvalid => e
+ raise e unless e.message.match(/Table name - \w* - exists/)
+ end
+
+ def rename_table(name, new_name)
+ columns = columns(name)
+ pkcol = columns.find {|c| c.fb_autogen}
+ execute "ALTER TABLE NAME #{name} TO #{new_name}"
+ if pkcol
+ change_column_default(new_name,pkcol.name,"UNIQUE")
+ begin_db_transaction
+ mpk = select_value("SELECT MAX(#{pkcol.name}) FROM #{new_name}")
+ mpk = 0 if mpk.nil?
+ execute "SET UNIQUE=#{mpk} FOR #{new_name}"
+ commit_db_transaction
+ end
+ end
+
+ # Drops a table from the database.
+ def drop_table(name)
+ execute "DROP TABLE #{name} RESTRICT"
+ rescue ActiveRecord::StatementInvalid => e
+ raise e unless e.message.match(/Referenced TABLE - \w* - does not exist/)
+ end
+
+ # Adds a new column to the named table.
+ # See TableDefinition#column for details of the options you can use.
+ def add_column(table_name, column_name, type, options = {})
+ add_column_sql = "ALTER TABLE #{table_name} ADD #{column_name} #{type_to_sql(type, options[:limit])}"
+ options[:type] = type
+ add_column_options!(add_column_sql, options)
+ execute(add_column_sql)
+ end
+
+ def add_column_options!(sql, options) #:nodoc:
+ default_value = quote(options[:default], options[:column])
+ if options[:default]
+ if options[:type] == :boolean
+ default_value = options[:default] == 0 ? quoted_false : quoted_true
+ end
+ end
+ sql << " DEFAULT #{default_value}" unless options[:default].nil?
+ sql << " NOT NULL" if options[:null] == false
+ end
+
+ # Removes the column from the table definition.
+ # ===== Examples
+ # remove_column(:suppliers, :qualification)
+ def remove_column(table_name, column_name)
+ execute "ALTER TABLE #{table_name} DROP #{column_name} RESTRICT"
+ end
+
+ def remove_index(table_name, options = {}) #:nodoc:
+ if options[:unique]
+ execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{quote_column_name(index_name(table_name, options))} RESTRICT"
+ else
+ execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+ end
+ end
+
+ def change_column_default(table_name, column_name, default) #:nodoc:
+ execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT #{default}" if default != "NULL"
+ end
+
+ def change_column(table_name, column_name, type, options = {}) #:nodoc:
+ change_column_sql = %( ALTER COLUMN "#{table_name}"."#{column_name}" TO #{type_to_sql(type, options[:limit])} )
+ execute(change_column_sql)
+ change_column_sql = %( ALTER TABLE "#{table_name}" ALTER COLUMN "#{column_name}" )
+
+ default_value = quote(options[:default], options[:column])
+ if options[:default]
+ if type == :boolean
+ default_value = options[:default] == 0 ? quoted_false : quoted_true
+ end
+ end
+
+ if default_value != "NULL"
+ change_column_sql << " SET DEFAULT #{default_value}"
+ execute(change_column_sql)
+ end
+
+# change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit])}"
+# add_column_options!(change_column_sql, options)
+# execute(change_column_sql)
+ end
+
+ def rename_column(table_name, column_name, new_column_name) #:nodoc:
+ execute %( ALTER COLUMN NAME "#{table_name}"."#{column_name}" TO "#{new_column_name}" )
+ end
+
+ private
+
+ # Clean up sql to make it something FrontBase can digest
+ def cleanup_fb_sql(sql) #:nodoc:
+ # Turn non-standard != into standard <>
+ cleansql = sql.gsub("!=", "<>")
+ # Strip blank lines and comments
+ cleansql.split("\n").reject { |line| line.match(/^(?:\s*|--.*)$/) } * "\n"
+ end
+ end
+ end
+end
View
8 activerecord/lib/active_record/fixtures.rb
@@ -392,7 +392,13 @@ def key_list
end
def value_list
- @fixture.values.map { |v| ActiveRecord::Base.connection.quote(v).gsub('\\n', "\n").gsub('\\r', "\r") }.join(", ")
+ klass = @class_name.constantize rescue nil
+
+ list = @fixture.inject([]) do |fixtures, (key, value)|
+ col = klass.columns_hash[key] unless klass.nil?
+ fixtures << ActiveRecord::Base.connection.quote(value, col).gsub('\\n', "\n").gsub('\\r', "\r")
+ end
+ list * ', '
end
def find
View
16 activerecord/test/adapter_test.rb
@@ -66,19 +66,21 @@ class << @connection
if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
require 'fixtures/movie'
require 'fixtures/subscriber'
+
def test_reset_empty_table_with_custom_pk
Movie.delete_all
Movie.connection.reset_pk_sequence! 'movies'
assert_equal 1, Movie.create(:name => 'fight club').id
end
- def test_reset_table_with_non_integer_pk
- Subscriber.delete_all
- Subscriber.connection.reset_pk_sequence! 'subscribers'
-
- sub = Subscriber.new(:name => 'robert drake')
- sub.id = 'bob drake'
- assert_nothing_raised { sub.save! }
+ if ActiveRecord::Base.connection.adapter_name != "FrontBase"
+ def test_reset_table_with_non_integer_pk
+ Subscriber.delete_all
+ Subscriber.connection.reset_pk_sequence! 'subscribers'
+ sub = Subscriber.new(:name => 'robert drake')
+ sub.id = 'bob drake'
+ assert_nothing_raised { sub.save! }
+ end
end
end
View
12 activerecord/test/base_test.rb
@@ -1094,21 +1094,21 @@ def test_count_with_join
end
assert_equal res, res3
- res4 = Post.count_by_sql "SELECT COUNT(p.id) FROM posts p, comments c WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=c.post_id"
+ res4 = Post.count_by_sql "SELECT COUNT(p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
res5 = nil
assert_nothing_raised do
- res5 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=c.post_id",
- :joins => "p, comments c",
+ res5 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id",
+ :joins => "p, comments co",
:select => "p.id")
end
assert_equal res4, res5
- res6 = Post.count_by_sql "SELECT COUNT(DISTINCT p.id) FROM posts p, comments c WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=c.post_id"
+ res6 = Post.count_by_sql "SELECT COUNT(DISTINCT p.id) FROM posts p, comments co WHERE p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id"
res7 = nil
assert_nothing_raised do
- res7 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=c.post_id",
- :joins => "p, comments c",
+ res7 = Post.count(:conditions => "p.#{QUOTED_TYPE} = 'Post' AND p.id=co.post_id",
+ :joins => "p, comments co",
:select => "p.id",
:distinct => true)
end
View
26 activerecord/test/connections/native_frontbase/connection.rb
@@ -0,0 +1,26 @@
+puts 'Using native Frontbase'
+require_dependency 'fixtures/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+db1 = 'activerecord_unittest'
+db2 = 'activerecord_unittest2'
+
+ActiveRecord::Base.establish_connection(
+ :adapter => "frontbase",
+ :host => "localhost",
+ :username => "rails",
+ :password => "",
+ :database => db1,
+ :session_name => "unittest-#{$$}"
+)
+
+Course.establish_connection(
+ :adapter => "frontbase",
+ :host => "localhost",
+ :username => "rails",
+ :password => "",
+ :database => db2,
+ :session_name => "unittest-#{$$}"
+)
View
1  activerecord/test/deprecated_finder_test.rb
@@ -1,6 +1,7 @@
require 'abstract_unit'
require 'fixtures/company'
require 'fixtures/topic'
+require 'fixtures/reply'
require 'fixtures/entrant'
require 'fixtures/developer'
View
6 activerecord/test/finder_test.rb
@@ -13,6 +13,12 @@ def test_find
assert_equal(topics(:first).title, Topic.find(1).title)
end
+ # find should handle strings that come from URLs
+ # (example: Category.find(params[:id]))
+ def test_find_with_string
+ assert_equal(Topic.find(1).title,Topic.find("1").title)
+ end
+
def test_exists
assert (Topic.exists?(1))
assert !(Topic.exists?(45))
View
30 activerecord/test/fixtures/db_definitions/frontbase.drop.sql
@@ -0,0 +1,30 @@
+DROP TABLE accounts CASCADE;
+DROP TABLE funny_jokes CASCADE;
+DROP TABLE companies CASCADE;
+DROP TABLE topics CASCADE;
+DROP TABLE developers CASCADE;
+DROP TABLE projects CASCADE;
+DROP TABLE developers_projects CASCADE;
+DROP TABLE orders CASCADE;
+DROP TABLE customers CASCADE;
+DROP TABLE movies CASCADE;
+DROP TABLE subscribers CASCADE;
+DROP TABLE booleantests CASCADE;
+DROP TABLE auto_id_tests CASCADE;
+DROP TABLE entrants CASCADE;
+DROP TABLE colnametests CASCADE;
+DROP TABLE mixins CASCADE;
+DROP TABLE people CASCADE;
+DROP TABLE readers CASCADE;
+DROP TABLE binaries CASCADE;
+DROP TABLE computers CASCADE;
+DROP TABLE posts CASCADE;
+DROP TABLE comments CASCADE;
+DROP TABLE authors CASCADE;
+DROP TABLE tasks CASCADE;
+DROP TABLE categories CASCADE;
+DROP TABLE categories_posts CASCADE;
+DROP TABLE fk_test_has_fk CASCADE;
+DROP TABLE fk_test_has_pk CASCADE;
+DROP TABLE keyboards CASCADE;
+DROP TABLE legacy_things CASCADE;
View
251 activerecord/test/fixtures/db_definitions/frontbase.sql
@@ -0,0 +1,251 @@
+CREATE TABLE accounts (
+ id integer DEFAULT unique,
+ firm_id integer,
+ credit_limit integer,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR accounts(id);
+
+CREATE TABLE funny_jokes (
+ id integer DEFAULT unique,
+ firm_id integer default NULL,
+ name character varying(50),
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR funny_jokes(id);
+
+CREATE TABLE companies (
+ id integer DEFAULT unique,
+ "type" character varying(50),
+ "ruby_type" character varying(50),
+ firm_id integer,
+ name character varying(50),
+ client_of integer,
+ rating integer default 1,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR companies(id);
+
+CREATE TABLE topics (
+ id integer DEFAULT unique,
+ title character varying(255),
+ author_name character varying(255),
+ author_email_address character varying(255),
+ written_on timestamp,
+ bonus_time time,
+ last_read date,
+ content varchar(65536),
+ approved boolean default true,
+ replies_count integer default 0,
+ parent_id integer,
+ "type" character varying(50),
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR topics(id);
+
+CREATE TABLE developers (
+ id integer DEFAULT unique,
+ name character varying(100),
+ salary integer DEFAULT 70000,
+ created_at timestamp,
+ updated_at timestamp,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR developers(id);
+
+CREATE TABLE projects (
+ id integer DEFAULT unique,
+ name character varying(100),
+ type varchar(255),
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR projects(id);
+
+CREATE TABLE developers_projects (
+ developer_id integer NOT NULL,
+ project_id integer NOT NULL,
+ joined_on date,
+ access_level integer default 1
+);
+
+CREATE TABLE orders (
+ id integer DEFAULT unique,
+ name character varying(100),
+ billing_customer_id integer,
+ shipping_customer_id integer,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR orders(id);
+
+CREATE TABLE customers (
+ id integer DEFAULT unique,
+ name character varying(100),
+ balance integer default 0,
+ address_street character varying(100),
+ address_city character varying(100),
+ address_country character varying(100),
+ gps_location character varying(100),
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR customers(id);
+
+CREATE TABLE movies (
+ movieid integer DEFAULT unique,
+ name varchar(65536),
+ PRIMARY KEY (movieid)
+);
+SET UNIQUE FOR movies(movieid);
+
+CREATE TABLE subscribers (
+ nick varchar(65536) NOT NULL,
+ name varchar(65536),
+ PRIMARY KEY (nick)
+);
+
+CREATE TABLE booleantests (
+ id integer DEFAULT unique,
+ value boolean,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR booleantests(id);
+
+CREATE TABLE auto_id_tests (
+ auto_id integer DEFAULT unique,
+ value integer,
+ PRIMARY KEY (auto_id)
+);
+SET UNIQUE FOR auto_id_tests(auto_id);
+
+CREATE TABLE entrants (
+ id integer DEFAULT unique,
+ name varchar(65536),
+ course_id integer,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR entrants(id);
+
+CREATE TABLE colnametests (
+ id integer DEFAULT unique,
+ "references" integer NOT NULL,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR colnametests(id);
+
+CREATE TABLE mixins (
+ id integer DEFAULT unique,
+ parent_id integer,
+ type character varying(100),
+ pos integer,
+ lft integer,
+ rgt integer,
+ root_id integer,
+ created_at timestamp,
+ updated_at timestamp,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR mixins(id);
+
+CREATE TABLE people (
+ id integer DEFAULT unique,
+ first_name varchar(65536),
+ lock_version integer default 0,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR people(id);
+
+CREATE TABLE readers (
+ id integer DEFAULT unique,
+ post_id INTEGER NOT NULL,
+ person_id INTEGER NOT NULL,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR readers(id);
+
+CREATE TABLE binaries (
+ id integer DEFAULT unique,
+ data BLOB,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR binaries(id);
+
+CREATE TABLE computers (
+ id integer DEFAULT unique,
+ developer integer NOT NULL,
+ "extendedWarranty" integer NOT NULL,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR computers(id);
+
+CREATE TABLE posts (
+ id integer DEFAULT unique,
+ author_id integer,
+ title varchar(255),
+ type varchar(255),
+ body varchar(65536),
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR posts(id);
+
+CREATE TABLE comments (
+ id integer DEFAULT unique,
+ post_id integer,
+ type varchar(255),
+ body varchar(65536),
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR comments(id);
+
+CREATE TABLE authors (
+ id integer DEFAULT unique,
+ name varchar(255) default NULL,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR authors(id);
+
+CREATE TABLE tasks (
+ id integer DEFAULT unique,
+ starting timestamp,
+ ending timestamp,
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR tasks(id);
+
+CREATE TABLE categories (
+ id integer DEFAULT unique,
+ name varchar(255),
+ type varchar(255),
+ PRIMARY KEY (id)
+);
+SET UNIQUE FOR categories(id);
+
+CREATE TABLE categories_posts (
+ category_id integer NOT NULL,
+ post_id integer NOT NULL
+);
+
+CREATE TABLE fk_test_has_pk (
+ id INTEGER NOT NULL PRIMARY KEY
+);
+SET UNIQUE FOR fk_test_has_pk(id);
+
+CREATE TABLE fk_test_has_fk (
+ id INTEGER NOT NULL PRIMARY KEY,
+ fk_id INTEGER NOT NULL REFERENCES fk_test_has_fk(id)
+);
+SET UNIQUE FOR fk_test_has_fk(id);
+
+CREATE TABLE keyboards (
+ key_number integer DEFAULT unique,
+ "name" character varying(50),
+ PRIMARY KEY (key_number)
+);
+SET UNIQUE FOR keyboards(key_number);
+
+create table "legacy_things"
+(
+ "id" int,
+ "tps_report_number" int default NULL,
+ "version" int default 0 not null,
+ primary key ("id")
+);
+SET UNIQUE FOR legacy_things(id);
View
1  activerecord/test/fixtures/db_definitions/frontbase2.drop.sql
@@ -0,0 +1 @@
+DROP TABLE courses CASCADE;
View
4 activerecord/test/fixtures/db_definitions/frontbase2.sql
@@ -0,0 +1,4 @@
+CREATE TABLE courses (
+ id integer DEFAULT unique,
+ name varchar(100)
+);
View
36 activerecord/test/migration_test.rb
@@ -58,7 +58,7 @@ def test_add_index
# quoting
assert_nothing_raised { Person.connection.add_index("people", ["key"], :name => "key", :unique => true) }
- assert_nothing_raised { Person.connection.remove_index("people", :name => "key") }
+ assert_nothing_raised { Person.connection.remove_index("people", :name => "key", :unique => true) }
# Sybase adapter does not support indexes on :boolean columns
unless current_adapter?(:SybaseAdapter)
@@ -461,27 +461,29 @@ def test_add_drop_table_with_prefix_and_suffix
Reminder.reset_sequence_name
end
- def test_create_table_with_binary_column
- Person.connection.drop_table :binary_testings rescue nil
+# FrontBase does not support default values on BLOB/CLOB columns
+ unless current_adapter?(:FrontBaseAdapter)
+ def test_create_table_with_binary_column
+ Person.connection.drop_table :binary_testings rescue nil
- assert_nothing_raised {
- Person.connection.create_table :binary_testings do |t|
- t.column "data", :binary, :default => "", :null => false
- end
- }
+ assert_nothing_raised {
+ Person.connection.create_table :binary_testings do |t|
+ t.column "data", :binary, :default => "", :null => false
+ end
+ }
- columns = Person.connection.columns(:binary_testings)
- data_column = columns.detect { |c| c.name == "data" }
+ columns = Person.connection.columns(:binary_testings)
+ data_column = columns.detect { |c| c.name == "data" }
- if current_adapter?(:OracleAdapter)
- assert_equal "empty_blob()", data_column.default
- else
- assert_equal "", data_column.default
- end
+ if current_adapter?(:OracleAdapter)
+ assert_equal "empty_blob()", data_column.default
+ else
+ assert_equal "", data_column.default
+ end
- Person.connection.drop_table :binary_testings rescue nil
+ Person.connection.drop_table :binary_testings rescue nil
+ end
end
-
def test_migrator_with_duplicates
assert_raises(ActiveRecord::DuplicateMigrationVersionError) do
ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_duplicate/', nil)
View
1  activerecord/test/pk_test.rb
@@ -1,5 +1,6 @@
require "#{File.dirname(__FILE__)}/abstract_unit"
require 'fixtures/topic'
+require 'fixtures/reply'
require 'fixtures/subscriber'
require 'fixtures/movie'
require 'fixtures/keyboard'
View
6 activerecord/test/reflection_test.rb
@@ -45,6 +45,12 @@ def test_column_string_type_and_limit
assert_equal :string, @first.column_for_attribute("title").type
assert_equal 255, @first.column_for_attribute("title").limit
end
+
+ def test_column_null_not_null
+ subscriber = Subscriber.find(:first)
+ assert subscriber.column_for_attribute("name").null
+ assert !subscriber.column_for_attribute("nick").null
+ end
def test_human_name_for_column
assert_equal "Author name", @first.column_for_attribute("author_name").human_name
View
34 activerecord/test/threaded_connections_test.rb
@@ -1,10 +1,11 @@
require 'abstract_unit'
require 'fixtures/topic'
-class ThreadedConnectionsTest < Test::Unit::TestCase
- self.use_transactional_fixtures = false
+unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
+ class ThreadedConnectionsTest < Test::Unit::TestCase
+ self.use_transactional_fixtures = false
- fixtures :topics
+ fixtures :topics
def setup
@connection = ActiveRecord::Base.remove_connection
@@ -25,21 +26,22 @@ def gather_connections(use_threaded_connections)
ActiveRecord::Base.allow_concurrency = use_threaded_connections
ActiveRecord::Base.establish_connection(@connection)
- 5.times do
- Thread.new do
- Topic.find :first
- @connections << ActiveRecord::Base.active_connections.values.first
- end.join
+ 5.times do
+ Thread.new do
+ Topic.find :first
+ @connections << ActiveRecord::Base.active_connections.values.first
+ end.join
+ end
end
- end
- def test_threaded_connections
- gather_connections(true)
- assert_equal @connections.uniq.length, 5
- end
+ def test_threaded_connections
+ gather_connections(true)
+ assert_equal @connections.uniq.length, 5
+ end
- def test_unthreaded_connections
- gather_connections(false)
- assert_equal @connections.uniq.length, 1
+ def test_unthreaded_connections
+ gather_connections(false)
+ assert_equal @connections.uniq.length, 1
+ end
end
end
View
1  activerecord/test/transactions_test.rb
@@ -1,5 +1,6 @@
require 'abstract_unit'
require 'fixtures/topic'
+require 'fixtures/reply'
require 'fixtures/developer'
class TransactionTest < Test::Unit::TestCase
Please sign in to comment.
Something went wrong with that request. Please try again.