ovirt_metrics 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0972797c4ecb7eddabc08532a7890321e856027
-  data.tar.gz: ec1207a571b31f0a97edc69c49f99ce6cbf72910
+  metadata.gz: d77fbff78ca341555af7b4aedeacfb4cdc993b19
+  data.tar.gz: 0abdcd35775f8553286f60341eb9790f18ec646e
 SHA512:
-  metadata.gz: 57da84932314838e52e990ffe4c55ec49a8066e1f7d3f1b49b565f66a587aa384f8b7a16e327da8a583a6d74ddb5f69fc277069987103d2fb277aed018887ff4
-  data.tar.gz: 3a1c778df4042d75041f418391d10a9ac13faf685e251f7f5507d264a9a2da7b134b5938907144b8559cd4a94143ddce5d0b2ea67b8991fed1dae76864d132fa
+  metadata.gz: 50ddf0f9c933aefe585b85431e7b85c1a5064f8dc06137548500805512f18a65a2f9e27ae67e1d6035043401443fce3a2c8165df76f4a3a858733620cc86f369
+  data.tar.gz: aa04cc6baec4d034ae7a4ead3db42c6e965990163574b762d7fef83e19ca1bcf8cf2833617908b66d8c09f521469bd14ee6e47e0d710eda1ab382ca88b4cece2

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/column.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # PostgreSQL-specific extensions to column definitions in a table.
+    class OvirtLegacyPostgreSQLColumn < Column #:nodoc:
+      delegate :array, :oid, :fmod, to: :sql_type_metadata
+      alias :array? :array
+
+      def serial?
+        return unless default_function
+
+        %r{\Anextval\('"?#{table_name}_#{name}_seq"?'::regclass\)\z} === default_function
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module DatabaseStatements
+        def explain(arel, binds = [])
+          sql = "EXPLAIN #{to_sql(arel, binds)}"
+          OvirtLegacyPostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+        end
+
+        def select_value(arel, name = nil, binds = [])
+          arel, binds = binds_from_relation arel, binds
+          sql = to_sql(arel, binds)
+          execute_and_clear(sql, name, binds) do |result|
+            result.getvalue(0, 0) if result.ntuples > 0 && result.nfields > 0
+          end
+        end
+
+        def select_values(arel, name = nil, binds = [])
+          arel, binds = binds_from_relation arel, binds
+          sql = to_sql(arel, binds)
+          execute_and_clear(sql, name, binds) do |result|
+            if result.nfields > 0
+              result.column_values(0)
+            else
+              []
+            end
+          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, binds = [])
+          execute_and_clear(sql, name, binds) do |result|
+            result.values
+          end
+        end
+
+        # The internal PostgreSQL identifier of the money data type.
+        MONEY_COLUMN_TYPE_OID = 790 #:nodoc:
+        # The internal PostgreSQL identifier of the BYTEA data type.
+        BYTEA_COLUMN_TYPE_OID = 17 #:nodoc:
+
+        # 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
+            # OvirtLegacyPostgreSQLColumn.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.
+        # Note: the PGresult object is manually memory managed; if you don't
+        # need it specifically, you many want consider the exec_query wrapper.
+        def execute(sql, name = nil)
+          log(sql, name) do
+            @connection.async_exec(sql)
+          end
+        end
+
+        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+          execute_and_clear(sql, name, binds, prepare: prepare) do |result|
+            types = {}
+            fields = result.fields
+            fields.each_with_index do |fname, i|
+              ftype = result.ftype i
+              fmod  = result.fmod i
+              types[fname] = get_oid_type(ftype, fmod, fname)
+            end
+            ActiveRecord::Result.new(fields, result.values, types)
+          end
+        end
+
+        def exec_delete(sql, name = 'SQL', binds = [])
+          execute_and_clear(sql, name, binds) {|result| result.cmd_tuples }
+        end
+        alias :exec_update :exec_delete
+
+        def sql_for_insert(sql, pk, id_value, sequence_name, binds) # :nodoc:
+          if pk.nil?
+            # 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
+
+          super
+        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
+
+        # 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 exec_rollback_db_transaction
+          execute "ROLLBACK"
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/explain_pretty_printer.rb

@@ -0,0 +1,42 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of an 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
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/array.rb

@@ -0,0 +1,70 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Array < Type::Value # :nodoc:
+          include Type::Helpers::Mutable
+
+          attr_reader :subtype, :delimiter
+          delegate :type, :user_input_in_time_zone, :limit, to: :subtype
+
+          def initialize(subtype, delimiter = ',')
+            @subtype = subtype
+            @delimiter = delimiter
+
+            @pg_encoder = PG::TextEncoder::Array.new name: "#{type}[]", delimiter: delimiter
+            @pg_decoder = PG::TextDecoder::Array.new name: "#{type}[]", delimiter: delimiter
+          end
+
+          def deserialize(value)
+            if value.is_a?(::String)
+              type_cast_array(@pg_decoder.decode(value), :deserialize)
+            else
+              super
+            end
+          end
+
+          def cast(value)
+            if value.is_a?(::String)
+              value = @pg_decoder.decode(value)
+            end
+            type_cast_array(value, :cast)
+          end
+
+          def serialize(value)
+            if value.is_a?(::Array)
+              @pg_encoder.encode(type_cast_array(value, :serialize))
+            else
+              super
+            end
+          end
+
+          def ==(other)
+            other.is_a?(Array) &&
+              subtype == other.subtype &&
+              delimiter == other.delimiter
+          end
+
+          def type_cast_for_schema(value)
+            return super unless value.is_a?(::Array)
+            "[" + value.map { |v| subtype.type_cast_for_schema(v) }.join(", ") + "]"
+          end
+
+          def map(value, &block)
+            value.map(&block)
+          end
+
+          private
+
+          def type_cast_array(value, method)
+            if value.is_a?(::Array)
+              value.map { |item| type_cast_array(item, method) }
+            else
+              @subtype.public_send(method, value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/bit.rb

@@ -0,0 +1,52 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Bit < Type::Value # :nodoc:
+          def type
+            :bit
+          end
+
+          def cast(value)
+            if ::String === value
+              case value
+              when /^0x/i
+                value[2..-1].hex.to_s(2) # Hexadecimal notation
+              else
+                value                    # Bit-string notation
+              end
+            else
+              value
+            end
+          end
+
+          def serialize(value)
+            Data.new(super) if value
+          end
+
+          class Data
+            def initialize(value)
+              @value = value
+            end
+
+            def to_s
+              value
+            end
+
+            def binary?
+              /\A[01]*\Z/ === value
+            end
+
+            def hex?
+              /\A[0-9A-F]*\Z/i === value
+            end
+
+            protected
+
+            attr_reader :value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/bit_varying.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class BitVarying < OID::Bit # :nodoc:
+          def type
+            :bit_varying
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/bytea.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Bytea < Type::Binary # :nodoc:
+          def deserialize(value)
+            return if value.nil?
+            return value.to_s if value.is_a?(Type::Binary::Data)
+            PGconn.unescape_bytea(super)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/cidr.rb

@@ -0,0 +1,48 @@
+require 'ipaddr'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Cidr < Type::Value # :nodoc:
+          def type
+            :cidr
+          end
+
+          def type_cast_for_schema(value)
+            subnet_mask = value.instance_variable_get(:@mask_addr)
+
+            # If the subnet mask is equal to /32, don't output it
+            if subnet_mask == (2**32 - 1)
+              "\"#{value}\""
+            else
+              "\"#{value}/#{subnet_mask.to_s(2).count('1')}\""
+            end
+          end
+
+          def serialize(value)
+            if IPAddr === value
+              "#{value}/#{value.instance_variable_get(:@mask_addr).to_s(2).count('1')}"
+            else
+              value
+            end
+          end
+
+          def cast_value(value)
+            if value.nil?
+              nil
+            elsif String === value
+              begin
+                IPAddr.new(value)
+              rescue ArgumentError
+                nil
+              end
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/date_time.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class DateTime < Type::DateTime # :nodoc:
+          def cast_value(value)
+            case value
+            when 'infinity' then ::Float::INFINITY
+            when '-infinity' then -::Float::INFINITY
+            when / BC$/
+              astronomical_year = format("%04d", -value[/^\d+/].to_i + 1)
+              super(value.sub(/ BC$/, "").sub(/^\d+/, astronomical_year))
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/decimal.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Decimal < Type::Decimal # :nodoc:
+          def infinity(options = {})
+            BigDecimal.new("Infinity") * (options[:negative] ? -1 : 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/enum.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Enum < Type::Value # :nodoc:
+          def type
+            :enum
+          end
+
+          private
+
+          def cast_value(value)
+            value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/hstore.rb

@@ -0,0 +1,59 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Hstore < Type::Value # :nodoc:
+          include Type::Helpers::Mutable
+
+          def type
+            :hstore
+          end
+
+          def deserialize(value)
+            if value.is_a?(::String)
+              ::Hash[value.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
+              value
+            end
+          end
+
+          def serialize(value)
+            if value.is_a?(::Hash)
+              value.map { |k, v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(', ')
+            else
+              value
+            end
+          end
+
+          def accessor
+            ActiveRecord::Store::StringKeyedHashAccessor
+          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
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/inet.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Inet < Cidr # :nodoc:
+          def type
+            :inet
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/json.rb

@@ -0,0 +1,10 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Json < Type::Internal::AbstractJson
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/jsonb.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Jsonb < Json # :nodoc:
+          def type
+            :jsonb
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            # Postgres does not preserve insignificant whitespaces when
+            # round-tripping jsonb columns. This causes some false positives for
+            # the comparison here. Therefore, we need to parse and re-dump the
+            # raw value here to ensure the insignificant whitespaces are
+            # consistent with our encoder's output.
+            raw_old_value = serialize(deserialize(raw_old_value))
+            super(raw_old_value, new_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/ovirt_legacy_postgresql/oid/money.rb

@@ -0,0 +1,39 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OvirtLegacyPostgreSQL
+      module OID # :nodoc:
+        class Money < Type::Decimal # :nodoc:
+          def type
+            :money
+          end
+
+          def scale
+            2
+          end
+
+          def cast_value(value)
+            return value unless ::String === value
+
+            # 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
+            # Negative values are represented as follows:
+            #  (3) -$2.55
+            #  (4) ($2.55)
+
+            value.sub!(/^\((.+)\)$/, '-\1') # (4)
+            case value
+            when /^-?\D+[\d,]+\.\d{2}$/  # (1)
+              value.gsub!(/[^-\d.]/, '')
+            when /^-?\D+[\d.]+,\d{2}$/  # (2)
+              value.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
+            end
+
+            super(value)
+          end
+        end
+      end
+    end
+  end
+end