adapter.rb in ardm-do-adapter-1.2.1

- old
+ new

@@ -308,23 +308,43 @@
 
       # This module is just for organization. The methods are included into the
       # Adapter below.
       module SQL #:nodoc:
         IDENTIFIER_MAX_LENGTH = 128
+        QUESTION_MARK    = '?'.freeze
+        GT_OPERATOR      = '>'.freeze
+        LT_OPERATOR      = '<'.freeze
+        GTE_OPERATOR     = '>='.freeze
+        LTE_OPERATOR     = '<='.freeze
+        IS_OPERATOR      = 'IS'.freeze
+        EQ_OPERATOR      = '='.freeze
+        IN_OPERATOR      = 'IN'.freeze
+        BETWEEN_OPERATOR = 'BETWEEN'.freeze
+        REGEXP_OPERATOR  = '~'.freeze
+        LIKE_OPERATOR    = 'LIKE'.freeze
+        NULL_KEYWORD     = 'NULL'.freeze
+        AND_KEYWORD      = ' AND '.freeze
+        ON_KEYWORD       = 'ON'.freeze
+        COLUMN_SEPARATOR = ', '.freeze
+        SPACE            = ' '.freeze
+        ONE_EQ_ZERO      = '1 = 0'.freeze
+        SINGLE_QUOTE     = /"/.freeze
+        DOUBLE_QUOTE     = '""'.freeze
 
         # @api semipublic
         def property_to_column_name(property, qualify)
-          column_name = ''
+          column_name = quote_name(property.field)
 
           case qualify
-            when true
-              column_name << "#{quote_name(property.model.storage_name(name))}."
-            when String
-              column_name << "#{quote_name(qualify)}."
+          when true
+            "#{quote_name(property.model.storage_name(name))}.#{column_name}"
+          when String
+            "#{quote_name(qualify)}.#{column_name}"
+          else
+            column_name
           end
 
-          column_name << quote_name(property.field)
         end
 
         private
 
         # Adapters requiring a RETURNING syntax for INSERT statements
@@ -394,13 +414,13 @@
 
           if supports_default_values? && properties.empty?
             statement << default_values_clause
           else
             statement << DataMapper::Ext::String.compress_lines(<<-SQL)
-              (#{properties.map { |property| quote_name(property.field) }.join(', ')})
+              (#{properties.map { |property| quote_name(property.field) }.join(COLUMN_SEPARATOR)})
               VALUES
-              (#{(['?'] * properties.size).join(', ')})
+              (#{([QUESTION_MARK] * properties.size).join(COLUMN_SEPARATOR)})
             SQL
           end
 
           if supports_returning? && serial
             statement << returning_clause(serial)
@@ -436,11 +456,11 @@
           else
             conditions_statement(query.conditions)
           end
 
           statement = "UPDATE #{quote_name(model.storage_name(name))}"
-          statement << " SET #{properties.map { |property| "#{quote_name(property.field)} = ?" }.join(', ')}"
+          statement << " SET #{properties.map { |property| "#{quote_name(property.field)} = ?" }.join(COLUMN_SEPARATOR)}"
           statement << " WHERE #{conditions_statement}" unless DataMapper::Ext.blank?(conditions_statement)
 
           return statement, bind_values
         end
 
@@ -471,11 +491,11 @@
         # @return [String]
         #   list of fields as a string
         #
         # @api private
         def columns_statement(properties, qualify)
-          properties.map { |property| property_to_column_name(property, qualify) }.join(', ')
+          properties.map { |property| property_to_column_name(property, qualify) }.join(COLUMN_SEPARATOR)
         end
 
         # Constructs joins clause
         #
         # @return [String]
@@ -502,26 +522,26 @@
               statements << quote_name(source_alias)
             else
               seen[source_alias] = 0
             end
 
-            statements << 'ON'
+            statements << ON_KEYWORD
 
             add_join_conditions(relationship, target_alias, source_alias, statements)
             add_extra_join_conditions(relationship, target_alias, statements, join_bind_values)
           end
 
           # prepend the join bind values to the statement bind values
           bind_values.unshift(*join_bind_values)
 
-          statements.join(' ')
+          statements.join(SPACE)
         end
 
         def add_join_conditions(relationship, target_alias, source_alias, statements)
           statements << relationship.target_key.zip(relationship.source_key).map do |target_property, source_property|
             "#{property_to_column_name(target_property, target_alias)} = #{property_to_column_name(source_property, source_alias)}"
-          end.join(' AND ')
+          end.join(AND_KEYWORD)
         end
 
         def add_extra_join_conditions(relationship, target_alias, statements, bind_values)
           conditions = DataMapper.repository(name).scope do
             relationship.target_model.all(relationship.query).query.conditions
@@ -573,14 +593,14 @@
           select_statement, bind_values = select_statement(query)
 
           statement = if target_key.size == 1
             property_to_column_name(target_key.first, qualify)
           else
-            "(#{target_key.map { |property| property_to_column_name(property, qualify) }.join(', ')})"
+            "(#{target_key.map { |property| property_to_column_name(property, qualify) }.join(COLUMN_SEPARATOR)})"
           end
 
-          statement << " IN (#{select_statement})"
+          statement = "#{statement} IN (#{select_statement})"
 
           return statement, bind_values
         end
 
         # @api private
@@ -590,11 +610,11 @@
           conditions = Query.target_conditions(sources, source_key, target_key)
 
           if conditions.valid?
             conditions_statement(conditions, qualify)
           else
-            [ '1 = 0', [] ]
+            [ ONE_EQ_ZERO, [] ]
           end
         end
 
         # @api private
         def subquery_keys(subject)
@@ -624,15 +644,15 @@
         #
         # @api private
         def order_statement(order, qualify)
           statements = order.map do |direction|
             statement = property_to_column_name(direction.target, qualify)
-            statement << ' DESC' if direction.operator == :desc
+            statement = "#{statement} DESC" if direction.operator == :desc
             statement
           end
 
-          statements.join(', ')
+          statements.join(COLUMN_SEPARATOR)
         end
 
         # @api private
         def negate_operation(operand, qualify)
           statement, bind_values = conditions_statement(operand, qualify)
@@ -697,14 +717,14 @@
           operator    = comparison_operator(comparison)
           column_name = property_to_column_name(subject, qualify)
 
           # if operator return value contains ? then it means that it is function call
           # and it contains placeholder (%s) for property name as well (used in Oracle adapter for regexp operator)
-          if operator.include?('?')
+          if operator.include?(QUESTION_MARK)
             return operator % column_name, [ value ]
           else
-            return "#{column_name} #{operator} #{value.nil? ? 'NULL' : '?'}", [ value ].compact
+            return "#{column_name} #{operator} #{value.nil? ? NULL_KEYWORD : QUESTION_MARK}", [ value ].compact
           end
         end
 
         def comparison_operator(comparison)
           subject = comparison.subject
@@ -713,42 +733,42 @@
           case comparison.slug
             when :eql    then equality_operator(subject, value)
             when :in     then include_operator(subject, value)
             when :regexp then regexp_operator(value)
             when :like   then like_operator(value)
-            when :gt     then '>'
-            when :lt     then '<'
-            when :gte    then '>='
-            when :lte    then '<='
+            when :gt     then GT_OPERATOR
+            when :lt     then LT_OPERATOR
+            when :gte    then GTE_OPERATOR
+            when :lte    then LTE_OPERATOR
           end
         end
 
         # @api private
         def equality_operator(property, operand)
-          operand.nil? ? 'IS' : '='
+          operand.nil? ? IS_OPERATOR : EQ_OPERATOR
         end
 
         # @api private
         def include_operator(property, operand)
           case operand
-            when Array then 'IN'
-            when Range then 'BETWEEN'
+            when Array then IN_OPERATOR
+            when Range then BETWEEN_OPERATOR
           end
         end
 
         # @api private
         def regexp_operator(operand)
-          '~'
+          REGEXP_OPERATOR
         end
 
         # @api private
         def like_operator(operand)
-          'LIKE'
+          LIKE_OPERATOR
         end
 
         # @api private
         def quote_name(name)
-          "\"#{name[0, self.class::IDENTIFIER_MAX_LENGTH].gsub('"', '""')}\""
+          "\"#{name[0, self.class::IDENTIFIER_MAX_LENGTH].gsub(SINGLE_QUOTE,DOUBLE_QUOTE)}\""
         end
 
       end
 
       include SQL