activerecord 3.0.0 → 4.0.0

data/lib/active_record/connection_adapters/postgresql/array_parser.rb

@@ -0,0 +1,97 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLColumn < Column
+      module ArrayParser
+        private
+          # Loads pg_array_parser if available. String parsing can be
+          # performed quicker by a native extension, which will not create
+          # a large amount of Ruby objects that will need to be garbage
+          # collected. pg_array_parser has a C and Java extension
+          begin
+            require 'pg_array_parser'
+            include PgArrayParser
+          rescue LoadError
+            def parse_pg_array(string)
+              parse_data(string, 0)
+            end
+          end
+
+          def parse_data(string, index)
+            local_index = index
+            array = []
+            while(local_index < string.length)
+              case string[local_index]
+              when '{'
+                local_index,array = parse_array_contents(array, string, local_index + 1)
+              when '}'
+                return array
+              end
+              local_index += 1
+            end
+
+            array
+          end
+
+          def parse_array_contents(array, string, index)
+            is_escaping = false
+            is_quoted = false
+            was_quoted = false
+            current_item = ''
+
+            local_index = index
+            while local_index
+              token = string[local_index]
+              if is_escaping
+                current_item << token
+                is_escaping = false
+              else
+                if is_quoted
+                  case token
+                  when '"'
+                    is_quoted = false
+                    was_quoted = true
+                  when "\\"
+                    is_escaping = true
+                  else
+                    current_item << token
+                  end
+                else
+                  case token
+                  when "\\"
+                    is_escaping = true
+                  when ','
+                    add_item_to_array(array, current_item, was_quoted)
+                    current_item = ''
+                    was_quoted = false
+                  when '"'
+                    is_quoted = true
+                  when '{'
+                    internal_items = []
+                    local_index,internal_items = parse_array_contents(internal_items, string, local_index + 1)
+                    array.push(internal_items)
+                  when '}'
+                    add_item_to_array(array, current_item, was_quoted)
+                    return local_index,array
+                  else
+                    current_item << token
+                  end
+                end
+              end
+
+              local_index += 1
+            end
+            return local_index,array
+          end
+
+          def add_item_to_array(array, current_item, quoted)
+            if current_item.length == 0
+            elsif !quoted && current_item == 'NULL'
+              array.push nil
+            else
+              array.push current_item
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/cast.rb

@@ -0,0 +1,152 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLColumn < Column
+      module Cast
+        def point_to_string(point)
+          "(#{point[0]},#{point[1]})"
+        end
+
+        def string_to_point(string)
+          if string[0] == '(' && string[-1] == ')'
+            string = string[1...-1]
+          end
+          string.split(',').map{ |v| Float(v) }
+        end
+
+        def string_to_time(string)
+          return string unless String === string
+
+          case string
+          when 'infinity'; 1.0 / 0.0
+          when '-infinity'; -1.0 / 0.0
+          when / BC$/
+            super("-" + string.sub(/ BC$/, ""))
+          else
+            super
+          end
+        end
+
+        def string_to_bit(value)
+          case value
+          when /^0x/i
+            value[2..-1].hex.to_s(2) # Hexadecimal notation
+          else
+            value                    # Bit-string notation
+          end
+        end
+
+        def hstore_to_string(object)
+          if Hash === object
+            object.map { |k,v|
+              "#{escape_hstore(k)}=>#{escape_hstore(v)}"
+            }.join ','
+          else
+            object
+          end
+        end
+
+        def string_to_hstore(string)
+          if string.nil?
+            nil
+          elsif String === string
+            Hash[string.scan(HstorePair).map { |k,v|
+              v = v.upcase == 'NULL' ? nil : v.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
+              k = k.gsub(/\A"(.*)"\Z/m,'\1').gsub(/\\(.)/, '\1')
+              [k,v]
+            }]
+          else
+            string
+          end
+        end
+
+        def json_to_string(object)
+          if Hash === object
+            ActiveSupport::JSON.encode(object)
+          else
+            object
+          end
+        end
+
+        def array_to_string(value, column, adapter, should_be_quoted = false)
+          casted_values = value.map do |val|
+            if String === val
+              if val == "NULL"
+                "\"#{val}\""
+              else
+                quote_and_escape(adapter.type_cast(val, column, true))
+              end
+            else
+              adapter.type_cast(val, column, true)
+            end
+          end
+          "{#{casted_values.join(',')}}"
+        end
+
+        def range_to_string(object)
+          from = object.begin.respond_to?(:infinite?) && object.begin.infinite? ? '' : object.begin
+          to   = object.end.respond_to?(:infinite?) && object.end.infinite? ? '' : object.end
+          "[#{from},#{to}#{object.exclude_end? ? ')' : ']'}"
+        end
+
+        def string_to_json(string)
+          if String === string
+            ActiveSupport::JSON.decode(string)
+          else
+            string
+          end
+        end
+
+        def string_to_cidr(string)
+          if string.nil?
+            nil
+          elsif String === string
+            IPAddr.new(string)
+          else
+            string
+          end
+        end
+
+        def cidr_to_string(object)
+          if IPAddr === object
+            "#{object.to_s}/#{object.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
+          else
+            object
+          end
+        end
+
+        def string_to_array(string, oid)
+          parse_pg_array(string).map{|val| oid.type_cast val}
+        end
+
+        private
+
+          HstorePair = begin
+            quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+            unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+            /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
+          end
+
+          def escape_hstore(value)
+            if value.nil?
+              'NULL'
+            else
+              if value == ""
+                '""'
+              else
+                '"%s"' % value.to_s.gsub(/(["\\])/, '\\\\\1')
+              end
+            end
+          end
+
+          def quote_and_escape(value)
+            case value
+            when "NULL"
+              value
+            else
+              "\"#{value.gsub(/"/,"\\\"")}\""
+            end
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -0,0 +1,242 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      module DatabaseStatements
+        def explain(arel, binds = [])
+          sql = "EXPLAIN #{to_sql(arel, binds)}"
+          ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+        end
+
+        class ExplainPrettyPrinter # :nodoc:
+          # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
+          # PostgreSQL shell:
+          #
+          #                                     QUERY PLAN
+          #   ------------------------------------------------------------------------------
+          #    Nested Loop Left Join  (cost=0.00..37.24 rows=8 width=0)
+          #      Join Filter: (posts.user_id = users.id)
+          #      ->  Index Scan using users_pkey on users  (cost=0.00..8.27 rows=1 width=4)
+          #            Index Cond: (id = 1)
+          #      ->  Seq Scan on posts  (cost=0.00..28.88 rows=8 width=4)
+          #            Filter: (posts.user_id = 1)
+          #   (6 rows)
+          #
+          def pp(result)
+            header = result.columns.first
+            lines  = result.rows.map(&:first)
+
+            # We add 2 because there's one char of padding at both sides, note
+            # the extra hyphens in the example above.
+            width = [header, *lines].map(&:length).max + 2
+
+            pp = []
+
+            pp << header.center(width).rstrip
+            pp << '-' * width
+
+            pp += lines.map {|line| " #{line}"}
+
+            nrows = result.rows.length
+            rows_label = nrows == 1 ? 'row' : 'rows'
+            pp << "(#{nrows} #{rows_label})"
+
+            pp.join("\n") + "\n"
+          end
+        end
+
+        # Executes a SELECT query and returns an array of rows. Each row is an
+        # array of field values.
+        def select_rows(sql, name = nil)
+          select_raw(sql, name).last
+        end
+
+        # Executes an INSERT query and returns the new record's ID
+        def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+          unless pk
+            # Extract the table from the insert sql. Yuck.
+            table_ref = extract_table_ref_from_insert_sql(sql)
+            pk = primary_key(table_ref) if table_ref
+          end
+
+          if pk && use_insert_returning?
+            select_value("#{sql} RETURNING #{quote_column_name(pk)}")
+          elsif pk
+            super
+            last_insert_id_value(sequence_name || default_sequence_name(table_ref, pk))
+          else
+            super
+          end
+        end
+
+        def create
+          super.insert
+        end
+
+        # create a 2D array representing the result set
+        def result_as_array(res) #:nodoc:
+          # check if we have any binary column and if they need escaping
+          ftypes = Array.new(res.nfields) do |i|
+            [i, res.ftype(i)]
+          end
+
+          rows = res.values
+          return rows unless ftypes.any? { |_, x|
+            x == BYTEA_COLUMN_TYPE_OID || x == MONEY_COLUMN_TYPE_OID
+          }
+
+          typehash = ftypes.group_by { |_, type| type }
+          binaries = typehash[BYTEA_COLUMN_TYPE_OID] || []
+          monies   = typehash[MONEY_COLUMN_TYPE_OID] || []
+
+          rows.each do |row|
+            # unescape string passed BYTEA field (OID == 17)
+            binaries.each do |index, _|
+              row[index] = unescape_bytea(row[index])
+            end
+
+            # If this is a money type column and there are any currency symbols,
+            # then strip them off. Indeed it would be prettier to do this in
+            # PostgreSQLColumn.string_to_decimal but would break form input
+            # fields that call value_before_type_cast.
+            monies.each do |index, _|
+              data = row[index]
+              # Because money output is formatted according to the locale, there are two
+              # cases to consider (note the decimal separators):
+              #  (1) $12,345,678.12
+              #  (2) $12.345.678,12
+              case data
+              when /^-?\D+[\d,]+\.\d{2}$/  # (1)
+                data.gsub!(/[^-\d.]/, '')
+              when /^-?\D+[\d.]+,\d{2}$/  # (2)
+                data.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
+              end
+            end
+          end
+        end
+
+        # Queries the database and returns the results in an Array-like object
+        def query(sql, name = nil) #:nodoc:
+          log(sql, name) do
+            result_as_array @connection.async_exec(sql)
+          end
+        end
+
+        # Executes an SQL statement, returning a PGresult object on success
+        # or raising a PGError exception otherwise.
+        def execute(sql, name = nil)
+          log(sql, name) do
+            @connection.async_exec(sql)
+          end
+        end
+
+        def substitute_at(column, index)
+          Arel::Nodes::BindParam.new "$#{index + 1}"
+        end
+
+        def exec_query(sql, name = 'SQL', binds = [])
+          log(sql, name, binds) do
+            result = binds.empty? ? exec_no_cache(sql, binds) :
+                                    exec_cache(sql, binds)
+
+            types = {}
+            result.fields.each_with_index do |fname, i|
+              ftype = result.ftype i
+              fmod  = result.fmod i
+              types[fname] = OID::TYPE_MAP.fetch(ftype, fmod) { |oid, mod|
+                warn "unknown OID: #{fname}(#{oid}) (#{sql})"
+                OID::Identity.new
+              }
+            end
+
+            ret = ActiveRecord::Result.new(result.fields, result.values, types)
+            result.clear
+            return ret
+          end
+        end
+
+        def exec_delete(sql, name = 'SQL', binds = [])
+          log(sql, name, binds) do
+            result = binds.empty? ? exec_no_cache(sql, binds) :
+                                    exec_cache(sql, binds)
+            affected = result.cmd_tuples
+            result.clear
+            affected
+          end
+        end
+        alias :exec_update :exec_delete
+
+        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+          unless pk
+            # Extract the table from the insert sql. Yuck.
+            table_ref = extract_table_ref_from_insert_sql(sql)
+            pk = primary_key(table_ref) if table_ref
+          end
+
+          if pk && use_insert_returning?
+            sql = "#{sql} RETURNING #{quote_column_name(pk)}"
+          end
+
+          [sql, binds]
+        end
+
+        def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+          val = exec_query(sql, name, binds)
+          if !use_insert_returning? && pk
+            unless sequence_name
+              table_ref = extract_table_ref_from_insert_sql(sql)
+              sequence_name = default_sequence_name(table_ref, pk)
+              return val unless sequence_name
+            end
+            last_insert_id_result(sequence_name)
+          else
+            val
+          end
+        end
+
+        # Executes an UPDATE query and returns the number of affected tuples.
+        def update_sql(sql, name = nil)
+          super.cmd_tuples
+        end
+
+        # Begins a transaction.
+        def begin_db_transaction
+          execute "BEGIN"
+        end
+
+        def begin_isolated_db_transaction(isolation)
+          begin_db_transaction
+          execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
+        end
+
+        # Commits a transaction.
+        def commit_db_transaction
+          execute "COMMIT"
+        end
+
+        # Aborts a transaction.
+        def rollback_db_transaction
+          execute "ROLLBACK"
+        end
+
+        def outside_transaction?
+          message = "#outside_transaction? is deprecated. This method was only really used " \
+                    "internally, but you can use #transaction_open? instead."
+          ActiveSupport::Deprecation.warn message
+          @connection.transaction_status == PGconn::PQTRANS_IDLE
+        end
+
+        def create_savepoint
+          execute("SAVEPOINT #{current_savepoint_name}")
+        end
+
+        def rollback_to_savepoint
+          execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+        end
+
+        def release_savepoint
+          execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+        end
+      end
+    end
+  end
+end