activerecord-jdbcteradata-adapter 0.3.2 → 0.3.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    activerecord-jdbcteradata-adapter (0.3.1)
+    activerecord-jdbcteradata-adapter (0.3.2)
       activerecord
       activerecord-jdbc-adapter
       jdbc-teradata

data/activerecord-jdbcteradata-adapter.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = "activerecord-jdbcteradata-adapter"
-  s.version     = "0.3.2"
+  s.version     = "0.3.3"
   s.authors     = ["Chris Parker"]
   s.email       = [ "mrcsparker@gmail.com"]
   s.homepage    = "https://github.com/mrcsparker/activerecord-jdbcteradata-adapter"

data/lib/activerecord-jdbcteradata-adapter.rb

@@ -1,5 +1,5 @@
 module ArJdbc
   module Teradata
-    VERSION = "0.2.0"
+    VERSION = '0.2.0'
   end
 end

data/lib/arel/visitors/teradata.rb

@@ -1,104 +1,391 @@
+# A good deal of this code is from https://github.com/rails-sqlserver/activerecord-sqlserver-adapter
+
+require 'arel'
+
 module Arel
+
+  module Nodes
+
+    # Extending the Ordering class to be comparrison friendly which allows us to call #uniq on a
+    # collection of them. See SelectManager#order for more details.
+    class Ordering < Arel::Nodes::Unary
+      def hash
+        expr.hash
+      end
+      def ==(other)
+        other.is_a?(Arel::Nodes::Ordering) && self.expr == other.expr
+      end
+      def eql?(other)
+        self == other
+      end
+    end
+
+  end
+
+  class SelectManager < Arel::TreeManager
+    
+    AR_CA_SQLSA_NAME = 'ActiveRecord::ConnectionAdapters::TeradataAdapter'.freeze
+    
+    # Getting real Ordering objects is very important for us. We need to be able to call #uniq on
+    # a colleciton of them reliably as well as using their true object attributes to mutate them
+    # to grouping objects for the inner sql during a select statment with an offset/rownumber. So this
+    # is here till ActiveRecord & ARel does this for us instead of using SqlLiteral objects.
+    alias :order_without_sqlserver :order
+    def order(*expr)
+      return order_without_sqlserver(*expr) unless engine_activerecord_sqlserver_adapter?
+      @ast.orders.concat(expr.map{ |x|
+        case x
+        when Arel::Attributes::Attribute
+          table = Arel::Table.new(x.relation.table_alias || x.relation.name)
+          e = table[x.name]
+          Arel::Nodes::Ascending.new e
+        when Arel::Nodes::Ordering
+          x
+        when String
+          x.split(',').map do |s|
+            s = x if x.strip =~ /\A\b\w+\b\(.*,.*\)(\s+(ASC|DESC))?\Z/i # Allow functions with comma(s) to pass thru.
+            s.strip!
+            d = s =~ /(ASC|DESC)\Z/i ? $1.upcase : nil
+            e = d.nil? ? s : s.mb_chars[0...-d.length].strip
+            e = Arel.sql(e)
+            d && d == "DESC" ? Arel::Nodes::Descending.new(e) : Arel::Nodes::Ascending.new(e)
+          end
+        else
+          e = Arel.sql(x.to_s)
+          Arel::Nodes::Ascending.new e
+        end
+      }.flatten)
+      self
+    end
+
+    # A friendly over ride that allows us to put a special lock object that can have a default or pass
+    # custom string hints down. See the visit_Arel_Nodes_LockWithTeradata delegation method.
+    alias :lock_without_sqlserver :lock
+    def lock(locking=true)
+      if engine_activerecord_sqlserver_adapter?
+        case locking
+        when true
+          locking = Arel.sql('WITH(HOLDLOCK, ROWLOCK)')
+        when Arel::Nodes::SqlLiteral
+        when String
+          locking = Arel.sql locking
+        end
+        @ast.lock = Arel::Nodes::Lock.new(locking)
+        self
+      else
+        lock_without_sqlserver(locking)
+      end
+    end
+    
+    private
+    
+    def engine_activerecord_sqlserver_adapter?
+      @engine.connection && @engine.connection.class.name == AR_CA_SQLSA_NAME
+    end
+    
+  end
+
   module Visitors
     class Teradata < Arel::Visitors::ToSql
 
-      def visit_Arel_Nodes_SelectStatement o
-        if !o.limit && o.offset
-          raise ActiveRecord::ActiveRecordError, "You must specify :limit with :offset."
+      private
+
+      # Teradata ToSql/Visitor (Overides)
+
+      def visit_Arel_Nodes_SelectStatement(o)
+        if complex_count_sql?(o)
+          visit_Arel_Nodes_SelectStatementForComplexCount(o)
+        elsif o.offset
+          visit_Arel_Nodes_SelectStatementWithOffset(o)
+        else
+          visit_Arel_Nodes_SelectStatementWithOutOffset(o)
         end
-        order = "ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?
-        if o.limit
-          if select_count?(o)
-            subquery = true
-            sql = o.cores.map do |x|
-              x = x.dup
-              x.projections = [Arel::Nodes::SqlLiteral.new("*")]
-              visit_Arel_Nodes_SelectCore x
-            end.join
-          else
-            sql = o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join
-          end
+      end
+      
+      def visit_Arel_Nodes_UpdateStatement(o)
+        if o.orders.any? && o.limit.nil?
+          o.limit = Nodes::Limit.new(9223372036854775807)
+        end
+        super
+      end
+
+      def visit_Arel_Nodes_Offset(o)
+        "WHERE [__rnt].[__rn] > (#{visit o.expr})"
+      end
+
+      def visit_Arel_Nodes_Limit(o)
+        "TOP #{visit o.expr}"
+      end
 
-          order ||= "ORDER BY #{determine_order_clause(sql)}"
-          replace_limit_offset!(sql, limit_for(o.limit).to_i, o.offset && o.offset.value.to_i, order)
-          sql = "SELECT COUNT(*) AS count_id FROM (#{sql}) AS subquery" if subquery
+      def visit_Arel_Nodes_Lock(o)
+        visit o.expr
+      end
+      
+      def visit_Arel_Nodes_Ordering(o)
+        if o.respond_to?(:direction)
+          "#{visit o.expr} #{o.ascending? ? 'ASC' : 'DESC'}"
         else
-          sql = super
+          visit o.expr
         end
-        sql
+      end
+      
+      def visit_Arel_Nodes_Bin(o)
+        "#{visit o.expr} #{@connection.cs_equality_operator}"
       end
 
-      # <Helpers>
-      # Lots of this code was pulled from the activerecord JDBC MSSQL driver
+      # Teradata ToSql/Visitor (Additions)
 
-      def get_table_name(sql)
-        if sql =~ /^\s*insert\s+into\s+([^\(\s,]+)\s*|^\s*update\s+([^\(\s,]+)\s*/i
-          $1
-        elsif sql =~ /\bfrom\s+([^\(\s,]+)\s*/i
-          $1
+      def visit_Arel_Nodes_SelectStatementWithOutOffset(o, windowed=false)
+        find_and_fix_uncorrelated_joins_in_select_statement(o)
+        core = o.cores.first
+        projections = core.projections
+        groups = core.groups
+        orders = o.orders.uniq
+        if windowed
+          projections = function_select_statement?(o) ? projections : projections.map { |x| projection_without_expression(x) }
+          groups = projections.map { |x| projection_without_expression(x) } if windowed_single_distinct_select_statement?(o) && groups.empty?
+          groups += orders.map { |x| Arel.sql(x.expr) } if windowed_single_distinct_select_statement?(o)
+        elsif eager_limiting_select_statement?(o)
+          projections = projections.map { |x| projection_without_expression(x) }
+          groups = projections.map { |x| projection_without_expression(x) }
+          orders = orders.map do |x|
+            expr = Arel.sql projection_without_expression(x.expr)
+            x.descending? ? Arel::Nodes::Max.new([expr]) : Arel::Nodes::Min.new([expr])
+          end
+        elsif top_one_everything_for_through_join?(o)
+          projections = projections.map { |x| projection_without_expression(x) }
+        end
+        [ ("SELECT" if !windowed),
+          (visit(core.set_quantifier) if core.set_quantifier && !windowed),
+          (visit(o.limit) if o.limit && !windowed),
+          (projections.map{ |x| v = visit(x); v == "1" ? "1 AS [__wrp]" : v }.join(', ')),
+          (source_with_lock_for_select_statement(o)),
+          ("WHERE #{core.wheres.map{ |x| visit(x) }.join ' AND ' }" unless core.wheres.empty?),
+          ("GROUP BY #{groups.map { |x| visit x }.join ', ' }" unless groups.empty?),
+          (visit(core.having) if core.having),
+          ("ORDER BY #{orders.map{ |x| visit(x) }.join(', ')}" if !orders.empty? && !windowed)
+        ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_SelectStatementWithOffset(o)
+        core = o.cores.first
+        o.limit ||= Arel::Nodes::Limit.new(9223372036854775807)
+        orders = rowtable_orders(o)
+        [ "SELECT",
+          (visit(o.limit) if o.limit && !windowed_single_distinct_select_statement?(o)),
+          (rowtable_projections(o).map{ |x| visit(x) }.join(', ')),
+          "FROM (",
+            "SELECT #{core.set_quantifier ? 'DISTINCT DENSE_RANK()' : 'ROW_NUMBER()'} OVER (ORDER BY #{orders.map{ |x| visit(x) }.join(', ')}) AS [__rn],",
+            visit_Arel_Nodes_SelectStatementWithOutOffset(o,true),
+          ") AS [__rnt]",
+          (visit(o.offset) if o.offset),
+          "ORDER BY [__rnt].[__rn] ASC"
+        ].compact.join ' '
+      end
+
+      def visit_Arel_Nodes_SelectStatementForComplexCount(o)
+        core = o.cores.first
+        o.limit.expr = Arel.sql("#{o.limit.expr} + #{o.offset ? o.offset.expr : 0}") if o.limit
+        orders = rowtable_orders(o)
+        [ "SELECT COUNT([count]) AS [count_id]",
+          "FROM (",
+            "SELECT",
+            (visit(o.limit) if o.limit),
+            "ROW_NUMBER() OVER (ORDER BY #{orders.map{ |x| visit(x) }.join(', ')}) AS [__rn],",
+            "1 AS [count]",
+            (source_with_lock_for_select_statement(o)),
+            ("WHERE #{core.wheres.map{ |x| visit(x) }.join ' AND ' }" unless core.wheres.empty?),
+            ("GROUP BY #{core.groups.map { |x| visit x }.join ', ' }" unless core.groups.empty?),
+            (visit(core.having) if core.having),
+            ("ORDER BY #{o.orders.map{ |x| visit(x) }.join(', ')}" if !o.orders.empty?),
+          ") AS [__rnt]",
+          (visit(o.offset) if o.offset)
+        ].compact.join ' '
+      end
+
+
+      # Teradata Helpers
+
+      def source_with_lock_for_select_statement(o)
+        core = o.cores.first
+        source = "FROM #{visit(core.source).strip}" if core.source
+        if source && o.lock
+          lock = visit o.lock
+          index = source.match(/FROM [\w\[\]\.]+/)[0].mb_chars.length
+          source.insert index, " #{lock}"
         else
-          nil
+          source
         end
       end
 
-      def determine_order_clause(sql)
-        return $1 if sql =~ /ORDER BY (.*)$/
-        table_name = get_table_name(sql)
-        "#{table_name}.#{determine_primary_key(table_name)}"
+      def table_from_select_statement(o)
+        core = o.cores.first
+        # TODO: [ARel 2.2] Use #from/#source vs. #froms
+        # if Arel::Table === core.from
+        #   core.from
+        # elsif Arel::Nodes::SqlLiteral === core.from
+        #   Arel::Table.new(core.from, @engine)
+        # elsif Arel::Nodes::JoinSource === core.source
+        #   Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
+        # end
+        table_finder = lambda { |x|
+          case x
+          when Arel::Table
+            x
+          when Arel::Nodes::SqlLiteral
+            Arel::Table.new(x, @engine)
+          when Arel::Nodes::Join
+            table_finder.call(x.left)
+          end
+        }
+        table_finder.call(core.froms)
       end
 
-      def determine_primary_key(table_name)
-        table_name = table_name.gsub('"', '')
-        primary_key = @connection.columns(table_name).detect { |column| column.primary }
-        return primary_key.name if primary_key
-        # Look for an id column.  Return it, without changing case, to cover dbs with a case-sensitive collation.
-        @connection.columns(table_name).each { |column| return column.name if column.name =~ /^id$/i }
-        # Give up and provide something which is going to crash almost certainly
-        @connection.columns(table_name)[0].name
+      def single_distinct_select_statement?(o)
+        projections = o.cores.first.projections
+        p1 = projections.first
+        projections.size == 1 &&
+          ((p1.respond_to?(:distinct) && p1.distinct) ||
+            p1.respond_to?(:include?) && p1.include?('DISTINCT'))
+      end
+      
+      def windowed_single_distinct_select_statement?(o)
+        o.limit && o.offset && single_distinct_select_statement?(o)
+      end
+      
+      def single_distinct_select_everything_statement?(o)
+        single_distinct_select_statement?(o) && visit(o.cores.first.projections.first).ends_with?(".*")
+      end
+      
+      def top_one_everything_for_through_join?(o)
+        single_distinct_select_everything_statement?(o) && 
+          (o.limit && !o.offset) && 
+          join_in_select_statement?(o)
       end
 
-      def add_limit_offset!(sql, options)
-        if options[:limit]
-          order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
-          sql.sub!(/ ORDER BY.*$/i, '')
-          replace_limit_offset!(sql, options[:limit], options[:offset], order)
+      def all_projections_aliased_in_select_statement?(o)
+        projections = o.cores.first.projections
+        projections.all? do |x|
+          visit(x).split(',').all? { |y| y.include?(' AS ') }
         end
       end
 
-      def replace_limit_offset!(sql, limit, offset, order)
-        if limit
-          offset ||= 0
-          start_row = offset + 1
-          end_row = offset + limit.to_i
-          find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im
-          whole, select, rest_of_query = find_select.match(sql).to_a
-          rest_of_query.strip!
-          if rest_of_query[0...1] == "1" && rest_of_query !~ /1 AS/i
-            rest_of_query[0] = "*"
+      def function_select_statement?(o)
+        core = o.cores.first
+        core.projections.any? { |x| Arel::Nodes::Function === x }
+      end
+
+      def eager_limiting_select_statement?(o)
+        core = o.cores.first
+        single_distinct_select_statement?(o) && 
+          (o.limit && !o.offset) && 
+          core.groups.empty? && 
+          !single_distinct_select_everything_statement?(o)
+      end
+
+      def join_in_select_statement?(o)
+        core = o.cores.first
+        core.source.right.any? { |x| Arel::Nodes::Join === x }
+      end
+
+      def complex_count_sql?(o)
+        core = o.cores.first
+        core.projections.size == 1 &&
+          Arel::Nodes::Count === core.projections.first &&
+          o.limit &&
+          !join_in_select_statement?(o)
+      end
+      
+      def select_primary_key_sql?(o)
+        core = o.cores.first
+        return false if core.projections.size != 1
+        p = core.projections.first
+        t = table_from_select_statement(o)
+        Arel::Attributes::Attribute === p && t.primary_key && t.primary_key.name == p.name
+      end
+
+      def find_and_fix_uncorrelated_joins_in_select_statement(o)
+        core = o.cores.first
+        # TODO: [ARel 2.2] Use #from/#source vs. #froms
+        # return if !join_in_select_statement?(o) || core.source.right.size != 2
+        # j1 = core.source.right.first
+        # j2 = core.source.right.second
+        # return unless Arel::Nodes::OuterJoin === j1 && Arel::Nodes::StringJoin === j2
+        # j1_tn = j1.left.name
+        # j2_tn = j2.left.match(/JOIN \[(.*)\].*ON/).try(:[],1)
+        # return unless j1_tn == j2_tn
+        # crltd_tn = "#{j1_tn}_crltd"
+        # j1.left.table_alias = crltd_tn
+        # j1.right.expr.left.relation.table_alias = crltd_tn
+        return if !join_in_select_statement?(o) || !(Arel::Nodes::StringJoin === core.froms)
+        j1 = core.froms.left
+        j2 = core.froms.right
+        return unless Arel::Nodes::OuterJoin === j1 && Arel::Nodes::SqlLiteral === j2 && j2.include?('JOIN ')
+        j1_tn = j1.right.name
+        j2_tn = j2.match(/JOIN \[(.*)\].*ON/).try(:[],1)
+        return unless j1_tn == j2_tn
+        on_index = j2.index(' ON ')
+        j2.insert on_index, " AS [#{j2_tn}_crltd]"
+        j2.sub! "[#{j2_tn}].", "[#{j2_tn}_crltd]."
+      end
+
+      def rowtable_projections(o)
+        core = o.cores.first
+        if windowed_single_distinct_select_statement?(o) && core.groups.blank?
+          tn = table_from_select_statement(o).name
+          core.projections.map do |x|
+            x.dup.tap do |p|
+              p.sub! 'DISTINCT', ''
+              p.insert 0, visit(o.limit) if o.limit
+              p.gsub! /\[?#{tn}\]?\./, '[__rnt].'
+              p.strip!
+            end
           end
-          if rest_of_query[0] == "*"
-            from_table = get_table_name(rest_of_query)
-            rest_of_query = from_table + '.' + rest_of_query
+        elsif single_distinct_select_statement?(o)
+          tn = table_from_select_statement(o).name
+          core.projections.map do |x|
+            x.dup.tap do |p|
+              p.sub! 'DISTINCT', "DISTINCT #{visit(o.limit)}".strip if o.limit
+              p.gsub! /\[?#{tn}\]?\./, '[__rnt].'
+              p.strip!
+            end
           end
-          new_sql = "#{select} t.* FROM (SELECT ROW_NUMBER() OVER(#{order}) AS _row_num, #{rest_of_query}"
-          new_sql << ") AS t WHERE t._row_num BETWEEN #{start_row.to_s} AND #{end_row.to_s}"
-          sql.replace(new_sql)
+        elsif join_in_select_statement?(o) && all_projections_aliased_in_select_statement?(o)
+          core.projections.map do |x|
+            Arel.sql visit(x).split(',').map{ |y| y.split(' AS ').last.strip }.join(', ')
+          end
+        elsif select_primary_key_sql?(o)
+          [Arel.sql("[__rnt].#{quote_column_name(core.projections.first.name)}")]
+        else
+          [Arel.sql('[__rnt].*')]
         end
-        sql
       end
 
-      def limit_for(limit_or_node)
-        limit_or_node.respond_to?(:expr) ? limit_or_node.expr.to_i : limit_or_node
+      def rowtable_orders(o)
+        core = o.cores.first
+        if !o.orders.empty?
+          o.orders
+        else
+          t = table_from_select_statement(o)
+          c = t.primary_key || t.columns.first
+          [c.asc]
+        end.uniq
       end
 
-      def select_count? o
-        sel = o.cores.length == 1 && o.cores.first
-        projections = sel && sel.projections.length == 1 && sel.projections
-        projections && Arel::Nodes::Count === projections.first
+      # TODO: We use this for grouping too, maybe make Grouping objects vs SqlLiteral.
+      def projection_without_expression(projection)
+        Arel.sql(visit(projection).split(',').map do |x|
+          x.strip!
+          x.sub!(/^(COUNT|SUM|MAX|MIN|AVG)\s*(\((.*)\))?/,'\3')
+          x.sub!(/^DISTINCT\s*/,'')
+          x.sub!(/TOP\s*\(\d+\)\s*/i,'')
+          x.strip
+        end.join(', '))
       end
 
-      # </Helpers>
-
     end
   end
+
 end
+
+Arel::Visitors::VISITORS['teradata'] = Arel::Visitors::Teradata

data/lib/arjdbc/teradata/adapter.rb

@@ -59,16 +59,16 @@ module ::ArJdbc
       super.merge({
         :primary_key => 'INTEGER PRIMARY KEY NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1 INCREMENT BY 1 MINVALUE -2147483647 MAXVALUE 1000000000 NO CYCLE)',
         :string => { :name => 'VARCHAR', :limit => 255 },
-        :integer => { :name => "INTEGER" },
-        :float => { :name => "FLOAT" },
-        :decimal => { :name => "DECIMAL" },
-        :datetime => { :name => "TIMESTAMP" },
-        :timestamp => { :name => "TIMESTAMP" },
-        :time => { :name => "TIMESTAMP" },
-        :date => { :name => "DATE" },
-        :binary => { :name => "BLOB" },
-        :boolean => { :name => "BYTEINT" },
-        :raw => { :name => "BYTE" }
+        :integer => { :name => 'INTEGER'},
+        :float => { :name => 'FLOAT'},
+        :decimal => { :name => 'DECIMAL'},
+        :datetime => { :name => 'TIMESTAMP'},
+        :timestamp => { :name => 'TIMESTAMP'},
+        :time => { :name => 'TIMESTAMP'},
+        :date => { :name => 'DATE'},
+        :binary => { :name => 'BLOB'},
+        :boolean => { :name => 'BYTEINT'},
+        :raw => { :name => 'BYTE'}
       })
     end
 
@@ -105,7 +105,7 @@ module ::ArJdbc
     private :_execute
 
     def _table_name_from_insert(sql)
-      sql.split(" ", 4)[2].gsub('"', '').gsub("'", "")
+      sql.split(' ', 4)[2].gsub('"', '').gsub("'", '')
     end
     private :_table_name_from_insert
 
@@ -125,6 +125,9 @@ module ::ArJdbc
     #- insert_sql
 
     #- tables
+    def tables
+      @connection.tables(nil, database_name, nil, %w(TABLE))
+    end
 
     #- table_exists?
     def table_exists?(table_name)
@@ -137,9 +140,9 @@ module ::ArJdbc
     # TODO: Multiple indexes per column
     IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition # :nodoc:
     def indexes(table_name, name = nil, schema_name = nil)
-      result = select_rows("SELECT" <<
-                           " DatabaseName, TableName, ColumnName, IndexType, IndexName, UniqueFlag" <<
-                           " FROM DBC.Indices" <<
+      result = select_rows('SELECT' <<
+                               ' DatabaseName, TableName, ColumnName, IndexType, IndexName, UniqueFlag' <<
+                               ' FROM DBC.Indices' <<
                            " WHERE TableName = '#{table_name}' AND DatabaseName = '#{database_name}'")
     
       result.map do |row|
@@ -153,7 +156,7 @@ module ::ArJdbc
         columns = []
         columns << idx_column_name
 
-        IndexDefinition.new(idx_table_name, idx_index_name, (idx_unique_flag == "Y"), columns)
+        IndexDefinition.new(idx_table_name, idx_index_name, (idx_unique_flag == 'Y'), columns)
       end
     end
 
@@ -202,9 +205,9 @@ module ::ArJdbc
 
     #- remove_column
     def remove_column(table_name, *column_names) #:nodoc:
-      for column_name in column_names.flatten
+      column_names.flatten.each { |column_name|
         execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
-      end
+      }
     end
 
     #+ change_column
@@ -312,10 +315,14 @@ module ::ArJdbc
     IDENTIFIER_LENGTH = 30 # :nodoc:
     
     # maximum length of Teradata identifiers is 30
-    def table_alias_length; IDENTIFIER_LENGTH; end # :nodoc:
-    def table_name_length;  IDENTIFIER_LENGTH; end # :nodoc:
-    def index_name_length;  IDENTIFIER_LENGTH; end # :nodoc:
-    def column_name_length; IDENTIFIER_LENGTH; end # :nodoc:
+    def table_alias_length; IDENTIFIER_LENGTH
+    end # :nodoc:
+    def table_name_length;  IDENTIFIER_LENGTH
+    end # :nodoc:
+    def index_name_length;  IDENTIFIER_LENGTH
+    end # :nodoc:
+    def column_name_length; IDENTIFIER_LENGTH
+    end # :nodoc:
 
   end
 end

data/lib/arjdbc/teradata/connection_methods.rb

@@ -11,7 +11,7 @@ class ActiveRecord::Base
       config[:host] ||= 'localhost'
       config[:port] ||= 1025
       config[:url] ||= "jdbc:teradata://#{config[:host]}/DATABASE=#{config[:database]},DBS_PORT=#{config[:port]},COP=OFF"
-      config[:driver] ||= "com.teradata.jdbc.TeraDriver"
+      config[:driver] ||= 'com.teradata.jdbc.TeraDriver'
       jdbc_connection(config)
     end
     alias_method :jdbcteradata_connection, :teradata_connection

data/spec/adapter_spec.rb

@@ -59,9 +59,9 @@ describe 'Adapter' do
   it '#indexes' do
     id_index = @adapter.indexes('articles').first
     id_index.table.should eq('articles')
-    id_index.name.should == ""
+    id_index.name.should == ''
     id_index.unique.should be_true
-    id_index.columns.should eq([ 'id' ])
+    id_index.columns.should eq(%w(id))
   end
 
   it '#pk_and_sequence_for' do

data/spec/associations_spec.rb

@@ -19,7 +19,7 @@ describe 'AssociationsSpec' do
     purchase_order = PurchaseOrder.new
     purchase_order.product = vendor.products.first
 
-    purchase_order.code = "ORDER1"
+    purchase_order.code = 'ORDER1'
     purchase_order.quantity = 2
     purchase_order.save
 

data/spec/models/active_record_schema.rb

@@ -88,7 +88,7 @@ class CreateActiveRecordSchema < ActiveRecord::Migration
       t.string :color
     end
 
-    create_table "CamelCase", :force => true do |t|
+    create_table 'CamelCase', :force => true do |t|
       t.string :name
     end
 
@@ -154,10 +154,10 @@ class CreateActiveRecordSchema < ActiveRecord::Migration
       t.integer :client_of
       t.integer :rating, :default => 1
       t.integer :account_id
-      t.string :description, :default => ""
+      t.string :description, :default => ''
     end
 
-    add_index :ar_companies, [:firm_id, :type, :rating, :ruby_type], :name => "company_index"
+    add_index :ar_companies, [:firm_id, :type, :rating, :ruby_type], :name => 'company_index'
 
     create_table :ar_vegetables, :force => true do |t|
       t.string :name
@@ -275,7 +275,7 @@ class CreateActiveRecordSchema < ActiveRecord::Migration
     end
 
     create_table :ar_integer_limits, :force => true do |t|
-      t.integer :"c_int_without_limit"
+      t.integer :'c_int_without_limit'
       (1..8).each do |i|
         t.integer :"c_int_#{i}", :limit => i
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbcteradata-adapter
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
   prerelease:
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-04-05 00:00:00.000000000 Z
+date: 2013-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake