ovirt_metrics 1.4.0 → 3.0.2

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

@@ -1,15 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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.rb

@@ -1,31 +0,0 @@
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/array'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/bit'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/bit_varying'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/bytea'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/cidr'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/date_time'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/decimal'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/enum'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/hstore'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/inet'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/json'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/jsonb'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/money'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/point'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/rails_5_1_point'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/range'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/specialized_string'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/uuid'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/vector'
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/xml'
-
-require 'active_record/connection_adapters/ovirt_legacy_postgresql/oid/type_map_initializer'
-
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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