activerecord-jdbc-adapter 1.3.0.beta2 → 1.3.0.rc1

data/bench/bench_attributes.rb

@@ -1,13 +0,0 @@
-require File.dirname(__FILE__) + '/bench_model'
-
-puts "Widget.find(:first).attributes"
-Benchmark.bm do |make|
-  TIMES.times do
-    w = Widget.find(:first)
-    make.report do
-      10_000.times do
-        w.attributes # rails makes copy for every call
-      end
-    end
-  end
-end

data/bench/bench_attributes_new.rb

@@ -1,14 +0,0 @@
-require File.dirname(__FILE__) + '/bench_model'
-
-puts "w = Widget.find(:first); Widget.new(w.attributes)"
-Benchmark.bm do |make|
-  TIMES.times do
-    w = Widget.find(:first)
-    params = w.attributes
-    make.report do
-      10_000.times do
-        Widget.new(params)
-      end
-    end
-  end
-end

data/bench/bench_create.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + '/bench_model'
-
-puts "Widget.create"
-Benchmark.bm do |make|
-  TIMES.times do
-    make.report do
-      10_000.times do
-        Widget.create!(:name => "bench", :description => "Bench record")
-      end
-    end
-  end
-end

data/bench/bench_find_all.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + '/bench_model'
-
-puts "Widget.find(:all)"
-Benchmark.bm do |make|
-  TIMES.times do
-    make.report do
-      10_000.times do
-        Widget.find(:all)
-      end
-    end
-  end
-end

data/bench/bench_find_all_mt.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + '/bench_model'
-
-Benchmark.bm do |make|
-  TIMES.times do
-    make.report do
-      thrs = []
-      errs = 0
-      10.times do
-        thrs << Thread.new do
-          1000.times do
-            begin
-              Widget.find(:all)
-            rescue Exception => e
-              errs += 1
-              Widget.logger.warn e.to_s
-            end
-          end
-          Widget.clear_active_connections!
-        end
-      end
-      thrs.each {|t| t.join}
-      puts "errors: #{errs}" if errs > 0
-    end
-  end
-end

data/bench/bench_model.rb

@@ -1,85 +0,0 @@
-=begin
-
-* This scripts looks for an optional argv0 which is number of times to
-  execute the particular benchmark this file is getting required into. argv1
-  is an optional parameter which represents the number of rows to create.
-* Use ENV['LOGGER'] (=severe|warn|info|debug) to turn on the logger
-* Add ActiveRecord to load path to use a specific (non-gem version) for testing (e.g., edge).
-
-+----------+------+-----+---------+-----------------+----------------+
-| Field       | Type         | Null | Key | Default | Extra          |
-+-------------+--------------+------+-----+---------+----------------+
-| id          | int(11)      | NO   | PRI | NULL    | auto_increment |
-| name        | varchar(255) | YES  |     | NULL    |                |
-| description | text         | YES  |     | NULL    |                |
-| created_at  | datetime     | YES  |     | NULL    |                |
-| updated_at  | datetime     | YES  |     | NULL    |                |
-+-------------+--------------+------+-----+---------+----------------+
-=end
-
-TIMES = (ARGV[0] || 5).to_i
-ROW_COUNT = (ARGV[1] || 10).to_i
-
-ENV["RAILS_ENV"] = "production"
-begin
-  print "Loading ActiveRecord w/o gems..."
-  require 'active_record'
-  require 'active_record/version'
-  puts "version #{ActiveRecord::VERSION::STRING}"
-rescue LoadError
-  puts "FAILED."
-  print "Loading ActiveRecord with gems..."
-  require 'rubygems'
-  gem 'activerecord'
-  puts "version #{Gem.loaded_specs['activerecord'].version.version}"
-  require 'active_record'
-end
-require 'benchmark'
-
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-  $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-  $LOAD_PATH.unshift File.dirname(__FILE__) + '/../drivers/mysql/lib'
-  $LOAD_PATH.unshift File.dirname(__FILE__) + '/../adapters/mysql/lib'
-  require 'active_record/connection_adapters/jdbcmysql_adapter'
-end
-
-if ENV['LOGGER']
-  require 'logger'
-  ActiveRecord::Base.logger = Logger.new(File.expand_path(File.dirname(__FILE__) + "/debug.log"))
-  lvl = %(DEBUG INFO WARN ERROR FATAL).detect {|s| s =~ /#{ENV['LOGGER'].upcase}/}
-  ActiveRecord::Base.logger.level = lvl && Logger.const_get(lvl) || Logger::INFO
-else
-  ActiveRecord::Base.logger = Logger.new($stdout)
-  ActiveRecord::Base.logger.level = Logger::UNKNOWN
-end
-
-ActiveRecord::Base.establish_connection(
-  :adapter => "mysql",
-  :host => "localhost",
-  :username => "root",
-  :database => "ar_bench",
-  :pool => 10,
-  :wait_timeout => 0.5
-)
-
-class CreateWidgets < ActiveRecord::Migration
-  def self.up
-    create_table :widgets do |t|
-      t.string :name
-      t.text :description
-      t.timestamps
-    end
-  end
-end
-
-CreateWidgets.up unless ActiveRecord::Base.connection.tables.include?("widgets")
-
-class Widget < ActiveRecord::Base; end
-Widget.destroy_all if Widget.count > ROW_COUNT
-count = Widget.count
-while (count < ROW_COUNT)
-  Widget.create!(:name => "bench#{count}", :description => "Bench record#{count}")
-  count = Widget.count
-end
-
-ActiveRecord::Base.clear_active_connections!

data/bench/bench_new.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + '/bench_model'
-
-puts "Widget.new"
-Benchmark.bm do |make|
-  TIMES.times do
-    make.report do
-      100_000.times do
-        Widget.new
-      end
-    end
-  end
-end

data/bench/bench_new_valid.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + '/bench_model'
-
-puts "Widget.new.valid?"
-Benchmark.bm do |make|
-  TIMES.times do
-    make.report do
-      100_000.times do
-        Widget.new.valid?
-      end
-    end
-  end
-end

data/bench/bench_valid.rb

@@ -1,13 +0,0 @@
-require File.dirname(__FILE__) + '/bench_model'
-
-puts "Widget.new.valid?"
-Benchmark.bm do |make|
-  TIMES.times do
-    make.report do
-      widget = Widget.new
-      100_000.times do
-        widget.valid?
-      end
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/db2_compiler.rb

@@ -1,9 +0,0 @@
-require 'arel/engines/sql/compilers/ibm_db_compiler'
-
-module Arel
-  module SqlCompiler
-    class DB2Compiler < IBM_DBCompiler
-    end
-  end
-end
-

data/lib/arel/engines/sql/compilers/derby_compiler.rb

@@ -1,6 +0,0 @@
-module Arel
-  module SqlCompiler
-    class DerbyCompiler < GenericCompiler
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/h2_compiler.rb

@@ -1,6 +0,0 @@
-module Arel
-  module SqlCompiler
-    class H2Compiler < GenericCompiler
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/hsqldb_compiler.rb

@@ -1,15 +0,0 @@
-module Arel
-  module SqlCompiler
-    class HsqldbCompiler < GenericCompiler
-      def select_sql
-        # HSQLDB needs to add LIMIT in right after SELECT
-        query = super
-        offset = relation.skipped
-        limit = relation.taken
-        @engine.connection.add_limit_offset!(query, :limit => limit,
-                                             :offset => offset) if offset || limit
-        query
-      end
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/jdbc_compiler.rb

@@ -1,6 +0,0 @@
-module Arel
-  module SqlCompiler
-    class JDBCCompiler < GenericCompiler
-    end
-  end
-end

data/lib/arel/engines/sql/compilers/mssql_compiler.rb

@@ -1,46 +0,0 @@
-module Arel
-  module SqlCompiler
-    class MSSQLCompiler < GenericCompiler
-      def select_sql
-        projections = @relation.projections
-        offset = relation.skipped
-        limit = relation.taken
-        if Count === projections.first && projections.size == 1 &&
-          (relation.taken.present? || relation.wheres.present?) && relation.joins(self).blank?
-          subquery = [
-            "SELECT * FROM #{relation.from_clauses}", build_clauses
-          ].join ' '
-          @engine.connection.add_limit_offset!(subquery, :limit => limit, :offset => offset) if offset || limit
-          query = "SELECT COUNT(*) AS count_id FROM (#{subquery}) AS subquery"
-        else
-          query = [
-            "SELECT     #{relation.select_clauses.join(', ')}",
-            "FROM       #{relation.from_clauses}",
-            build_clauses
-          ].compact.join ' '
-          @engine.connection.add_limit_offset!(query, :limit => limit, :offset => offset) if offset || limit
-        end
-        query
-      end
-
-      def build_clauses
-        joins   = relation.joins(self)
-        wheres  = relation.where_clauses
-        groups  = relation.group_clauses
-        havings = relation.having_clauses
-        orders  = relation.order_clauses
-
-        clauses = [ "",
-          joins,
-          ("WHERE     #{wheres.join(' AND ')}" unless wheres.empty?),
-          ("GROUP BY  #{groups.join(', ')}" unless groups.empty?),
-          ("HAVING    #{havings.join(' AND ')}" unless havings.empty?),
-          ("ORDER BY  #{orders.join(', ')}" unless orders.empty?)
-        ].compact.join ' '
-
-        clauses << " #{locked}" unless locked.blank?
-        clauses unless clauses.blank?
-      end
-    end
-  end
-end

data/lib/arjdbc/jdbc/missing_functionality_helper.rb

@@ -1,98 +0,0 @@
-module ArJdbc
-  module MissingFunctionalityHelper
-    
-    # taken from SQLite adapter, code loosely based on http://git.io/P7tFQA
-
-    def alter_table(table_name, options = {}) #:nodoc:
-      table_name = table_name.to_s.downcase
-      altered_table_name = "a#{table_name}"
-      caller = lambda { |definition| yield definition if block_given? }
-
-      transaction do
-        # A temporary table might improve performance here, but
-        # it doesn't seem to maintain indices across the whole move.
-        move_table(table_name, altered_table_name, options)
-        move_table(altered_table_name, table_name, &caller)
-      end
-    end
-    
-    def move_table(from, to, options = {}, &block) #:nodoc:
-      copy_table(from, to, options, &block)
-      drop_table(from)
-    end
-
-    def copy_table(from, to, options = {}) # :nodoc:
-      from_primary_key = primary_key(from)
-      create_table(to, options.merge(:id => false)) do |definition|
-        @definition = definition
-        @definition.primary_key(from_primary_key) if from_primary_key.present?
-        columns(from).each do |column|
-          column_name = options[:rename] ?
-            (options[:rename][column.name] ||
-             options[:rename][column.name.to_sym] ||
-             column.name) : column.name
-         
-          next if column_name == from_primary_key
-          
-          @definition.column(column_name, column.type,
-            :limit => column.limit, :default => column.default,
-            :precision => column.precision, :scale => column.scale,
-            :null => column.null)
-        end
-        yield @definition if block_given?
-      end
-
-      copy_table_indexes(from, to, options[:rename] || {})
-      copy_table_contents(from, to,
-        @definition.columns.map {|column| column.name},
-        options[:rename] || {})
-    end
-
-    def copy_table_indexes(from, to, rename = {}) #:nodoc:
-      indexes(from).each do |index|
-        name = index.name.downcase
-        if to == "a#{from}"
-          name = "t#{name}"
-        elsif from == "a#{to}"
-          name = name[1..-1]
-        end
-
-        to_column_names = columns(to).map(&:name)
-        columns = index.columns.map { |column| rename[column] || column }
-        columns = columns.select { |column| to_column_names.include?(column) }
-
-        unless columns.empty?
-          # index name can't be the same
-          opts = { :name => name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), :internal => true }
-          opts[:unique] = true if index.unique
-          add_index(to, columns, opts)
-        end
-      end
-    end
-
-    def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
-      column_mappings = Hash[ columns.map { |name| [name, name] } ]
-      rename.each { |a| column_mappings[a.last] = a.first }
-      from_columns = columns(from).collect {|col| col.name}
-      columns = columns.find_all{ |col| from_columns.include?(column_mappings[col]) }
-      quoted_columns = columns.map { |col| quote_column_name(col) } * ','
-
-      quoted_to = quote_table_name(to)
-      
-      raw_column_mappings = Hash[ columns(from).map { |c| [c.name, c] } ]
-      
-      execute("SELECT * FROM #{quote_table_name(from)}", 'Copy Table').each do |row|
-        sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
-        
-        column_values = columns.map do |col|
-          quote(row[column_mappings[col]], raw_column_mappings[col])
-        end
-
-        sql << column_values * ', '
-        sql << ')'
-        exec_insert sql, 'Copy Table', []
-      end
-    end
-    
-  end
-end

data/lib/arjdbc/mssql/lock_helpers.rb

@@ -1,76 +0,0 @@
-module ArJdbc
-  module MSSQL
-    module LockHelpers
-      module SqlServerAddLock
-        
-        SELECT_FROM_WHERE_RE = /\A(\s*SELECT\s.*?)(\sFROM\s)(.*?)(\sWHERE\s.*|)\Z/mi # :nodoc:
-        
-        # Microsoft SQL Server uses its own syntax for SELECT .. FOR UPDATE:
-        # SELECT .. FROM table1 WITH(ROWLOCK,UPDLOCK), table2 WITH(ROWLOCK,UPDLOCK) WHERE ..
-        #
-        # This does in-place modification of the passed-in string.
-        def add_lock!(sql, options)
-          if options[:lock] and sql =~ /\A\s*SELECT/mi
-            # Check for and extract the :limit/:offset sub-query
-            if sql =~ /\A(\s*SELECT t\.\* FROM \()(.*)(\) AS t WHERE t._row_num BETWEEN \d+ AND \d+\s*)\Z/m
-              prefix, subselect, suffix = [$1, $2, $3]
-              add_lock!(subselect, options)
-              return sql.replace(prefix + subselect + suffix)
-            end
-            unless sql =~ SELECT_FROM_WHERE_RE
-              # If you get this error, this driver probably needs to be fixed.
-              raise NotImplementedError, "Don't know how to add_lock! to SQL statement: #{sql.inspect}"
-            end
-            select_clause, from_word, from_tables, where_clause = [$1, $2, $3, $4]
-            with_clause = options[:lock].is_a?(String) ? " #{options[:lock]} " : " WITH(ROWLOCK,UPDLOCK) "
-
-            # Split the FROM clause into its constituent tables, and add the with clause after each one.
-            new_from_tables = []
-            s = StringScanner.new(from_tables)
-            until s.eos?
-              prev_pos = s.pos
-              if s.scan_until(/,|(INNER\s+JOIN|CROSS\s+JOIN|(LEFT|RIGHT|FULL)(\s+OUTER)?\s+JOIN)\s+/mi)
-                join_operand = s.pre_match[prev_pos..-1]
-                join_operator = s.matched
-              else
-                join_operand = s.rest
-                join_operator = ""
-                s.terminate
-              end
-
-              # At this point, we have something like:
-              #   join_operand == "appointments "
-              #   join_operator == "INNER JOIN "
-              # or:
-              #   join_operand == "appointment_details AS d1 ON appointments.[id] = d1.[appointment_id]"
-              #   join_operator == ""
-              if join_operand =~ /\A(.*)(\s+ON\s+.*)\Z/mi
-                table_spec, on_clause = [$1, $2]
-              else
-                table_spec = join_operand
-                on_clause = ""
-              end
-
-              # Add the "WITH(ROWLOCK,UPDLOCK)" option to the table specification
-              table_spec << with_clause unless table_spec =~ /\A\(\s*SELECT\s+/mi  # HACK - this parser isn't so great
-              join_operand = table_spec + on_clause
-
-              # So now we have something like:
-              #   join_operand == "appointments  WITH(ROWLOCK,UPDLOCK) "
-              #   join_operator == "INNER JOIN "
-              # or:
-              #   join_operand == "appointment_details AS d1 WITH(ROWLOCK,UPDLOCK)  ON appointments.[id] = d1.[appointment_id]"
-              #   join_operator == ""
-
-              new_from_tables << join_operand
-              new_from_tables << join_operator
-            end
-            sql.replace([select_clause, from_word, new_from_tables, where_clause].flatten.join)
-          end
-          sql
-        end
-        
-      end
-    end
-  end
-end