ovirt_metrics 3.0.0 → 3.0.1

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

@@ -1,15 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class SpecializedString < Type::String # :nodoc:
-          attr_reader :type
-
-          def initialize(type)
-            @type = type
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        # This class uses the data from PostgreSQL pg_type table to build
-        # the OID -> Type mapping.
-        #   - OID is an integer representing the type.
-        #   - Type is an OID::Type object.
-        # This class has side effects on the +store+ passed during initialization.
-        class TypeMapInitializer # :nodoc:
-          def initialize(store)
-            @store = store
-          end
-
-          def run(records)
-            nodes = records.reject { |row| @store.key? row['oid'].to_i }
-            mapped, nodes = nodes.partition { |row| @store.key? row['typname'] }
-            ranges, nodes = nodes.partition { |row| row['typtype'] == 'r'.freeze }
-            enums, nodes = nodes.partition { |row| row['typtype'] == 'e'.freeze }
-            domains, nodes = nodes.partition { |row| row['typtype'] == 'd'.freeze }
-            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in'.freeze }
-            composites, nodes = nodes.partition { |row| row['typelem'].to_i != 0 }
-
-            mapped.each     { |row| register_mapped_type(row)    }
-            enums.each      { |row| register_enum_type(row)      }
-            domains.each    { |row| register_domain_type(row)    }
-            arrays.each     { |row| register_array_type(row)     }
-            ranges.each     { |row| register_range_type(row)     }
-            composites.each { |row| register_composite_type(row) }
-          end
-
-          def query_conditions_for_initial_load(type_map)
-            known_type_names = type_map.keys.map { |n| "'#{n}'" }
-            known_type_types = %w('r' 'e' 'd')
-            <<-SQL % [known_type_names.join(", "), known_type_types.join(", ")]
-              WHERE
-                t.typname IN (%s)
-                OR t.typtype IN (%s)
-                OR t.typinput = 'array_in(cstring,oid,integer)'::regprocedure
-                OR t.typelem != 0
-            SQL
-          end
-
-          private
-          def register_mapped_type(row)
-            alias_type row['oid'], row['typname']
-          end
-
-          def register_enum_type(row)
-            register row['oid'], OID::Enum.new
-          end
-
-          def register_array_type(row)
-            register_with_subtype(row['oid'], row['typelem'].to_i) do |subtype|
-              OID::Array.new(subtype, row['typdelim'])
-            end
-          end
-
-          def register_range_type(row)
-            register_with_subtype(row['oid'], row['rngsubtype'].to_i) do |subtype|
-              OID::Range.new(subtype, row['typname'].to_sym)
-            end
-          end
-
-          def register_domain_type(row)
-            if base_type = @store.lookup(row["typbasetype"].to_i)
-              register row['oid'], base_type
-            else
-              warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
-            end
-          end
-
-          def register_composite_type(row)
-            if subtype = @store.lookup(row['typelem'].to_i)
-              register row['oid'], OID::Vector.new(row['typdelim'], subtype)
-            end
-          end
-
-          def register(oid, oid_type = nil, &block)
-            oid = assert_valid_registration(oid, oid_type || block)
-            if block_given?
-              @store.register_type(oid, &block)
-            else
-              @store.register_type(oid, oid_type)
-            end
-          end
-
-          def alias_type(oid, target)
-            oid = assert_valid_registration(oid, target)
-            @store.alias_type(oid, target)
-          end
-
-          def register_with_subtype(oid, target_oid)
-            if @store.key?(target_oid)
-              register(oid) do |_, *args|
-                yield @store.lookup(target_oid, *args)
-              end
-            end
-          end
-
-          def assert_valid_registration(oid, oid_type)
-            raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
-            oid.to_i
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Uuid < Type::Value # :nodoc:
-          ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
-
-          alias_method :serialize, :deserialize
-
-          def type
-            :uuid
-          end
-
-          def cast(value)
-            value.to_s[ACCEPTABLE_UUID, 0]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Vector < Type::Value # :nodoc:
-          attr_reader :delim, :subtype
-
-          # +delim+ corresponds to the `typdelim` column in the pg_types
-          # table.  +subtype+ is derived from the `typelem` column in the
-          # pg_types table.
-          def initialize(delim, subtype)
-            @delim   = delim
-            @subtype = subtype
-          end
-
-          # FIXME: this should probably split on +delim+ and use +subtype+
-          # to cast the values.  Unfortunately, the current Rails behavior
-          # is to just return the string.
-          def cast(value)
-            value
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module OID # :nodoc:
-        class Xml < Type::String # :nodoc:
-          def type
-            :xml
-          end
-
-          def serialize(value)
-            return unless value
-            Data.new(super)
-          end
-
-          class Data # :nodoc:
-            def initialize(value)
-              @value = value
-            end
-
-            def to_s
-              @value
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,116 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module Quoting
-        # Escapes binary strings for bytea input to the database.
-        def escape_bytea(value)
-          @connection.escape_bytea(value) if value
-        end
-
-        # Unescapes bytea output from a database to the binary string it represents.
-        # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
-        # on escaped binary output from database drive.
-        def unescape_bytea(value)
-          @connection.unescape_bytea(value) if value
-        end
-
-        # Quotes strings for use in SQL input.
-        def quote_string(s) #:nodoc:
-          @connection.escape(s)
-        end
-
-        # Checks the following cases:
-        #
-        # - table_name
-        # - "table.name"
-        # - schema_name.table_name
-        # - schema_name."table.name"
-        # - "schema.name".table_name
-        # - "schema.name"."table.name"
-        def quote_table_name(name) # :nodoc:
-          @quoted_table_names[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted
-        end
-
-        # Quotes schema names for use in SQL queries.
-        def quote_schema_name(name)
-          PGconn.quote_ident(name)
-        end
-
-        def quote_table_name_for_assignment(table, attr)
-          quote_column_name(attr)
-        end
-
-        # Quotes column names for use in SQL queries.
-        def quote_column_name(name) # :nodoc:
-          @quoted_column_names[name] ||= PGconn.quote_ident(super)
-        end
-
-        # Quote date/time values for use in SQL input.
-        def quoted_date(value) #:nodoc:
-          if value.year <= 0
-            bce_year = format("%04d", -value.year + 1)
-            super.sub(/^-?\d+/, bce_year) + " BC"
-          else
-            super
-          end
-        end
-
-        def quote_default_expression(value, column) # :nodoc:
-          if value.is_a?(Proc)
-            value.call
-          elsif column.type == :uuid && value =~ /\(\)/
-            value # Does not quote function default values for UUID columns
-          elsif column.respond_to?(:array?)
-            value = type_cast_from_column(column, value)
-            quote(value)
-          else
-            super
-          end
-        end
-
-        def lookup_cast_type_from_column(column) # :nodoc:
-          type_map.lookup(column.oid, column.fmod, column.sql_type)
-        end
-
-        private
-
-        def _quote(value)
-          case value
-          when Type::Binary::Data
-            "'#{escape_bytea(value.to_s)}'"
-          when OID::Xml::Data
-            "xml '#{quote_string(value.to_s)}'"
-          when OID::Bit::Data
-            if value.binary?
-              "B'#{value}'"
-            elsif value.hex?
-              "X'#{value}'"
-            end
-          when Float
-            if value.infinite? || value.nan?
-              "'#{value}'"
-            else
-              super
-            end
-          else
-            super
-          end
-        end
-
-        def _type_cast(value)
-          case value
-          when Type::Binary::Data
-            # Return a bind param hash with format as binary.
-            # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
-            # for more information
-            { value: value.to_s, format: 1 }
-          when OID::Xml::Data, OID::Bit::Data
-            value.to_s
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module ReferentialIntegrity # :nodoc:
-        def supports_disable_referential_integrity? # :nodoc:
-          true
-        end
-
-        def disable_referential_integrity # :nodoc:
-          if supports_disable_referential_integrity?
-            original_exception = nil
-
-            begin
-              transaction(requires_new: true) do
-                execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
-              end
-            rescue ActiveRecord::ActiveRecordError => e
-              original_exception = e
-            end
-
-            begin
-              yield
-            rescue ActiveRecord::InvalidForeignKey => e
-              warn <<-WARNING
-WARNING: Rails was not able to disable referential integrity.
-
-This is most likely caused due to missing permissions.
-Rails needs superuser privileges to disable referential integrity.
-
-    cause: #{original_exception.try(:message)}
-
-              WARNING
-              raise e
-            end
-
-            begin
-              transaction(requires_new: true) do
-                execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
-              end
-            rescue ActiveRecord::ActiveRecordError
-            end
-          else
-            yield
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,180 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    module OvirtLegacyPostgreSQL
-      module ColumnMethods
-        # Defines the primary key field.
-        # Use of the native PostgreSQL UUID type is supported, and can be used
-        # by defining your tables as such:
-        #
-        #   create_table :stuffs, id: :uuid do |t|
-        #     t.string :content
-        #     t.timestamps
-        #   end
-        #
-        # By default, this will use the +uuid_generate_v4()+ function from the
-        # +uuid-ossp+ extension, which MUST be enabled on your database. To enable
-        # the +uuid-ossp+ extension, you can use the +enable_extension+ method in your
-        # migrations. To use a UUID primary key without +uuid-ossp+ enabled, you can
-        # set the +:default+ option to +nil+:
-        #
-        #   create_table :stuffs, id: false do |t|
-        #     t.primary_key :id, :uuid, default: nil
-        #     t.uuid :foo_id
-        #     t.timestamps
-        #   end
-        #
-        # You may also pass a different UUID generation function from +uuid-ossp+
-        # or another library.
-        #
-        # Note that setting the UUID primary key default value to +nil+ will
-        # require you to assure that you always provide a UUID value before saving
-        # a record (as primary keys cannot be +nil+). This might be done via the
-        # +SecureRandom.uuid+ method and a +before_save+ callback, for instance.
-        def primary_key(name, type = :primary_key, **options)
-          options[:default] = options.fetch(:default, 'uuid_generate_v4()') if type == :uuid
-          super
-        end
-
-        def bigserial(*args, **options)
-          args.each { |name| column(name, :bigserial, options) }
-        end
-
-        def bit(*args, **options)
-          args.each { |name| column(name, :bit, options) }
-        end
-
-        def bit_varying(*args, **options)
-          args.each { |name| column(name, :bit_varying, options) }
-        end
-
-        def cidr(*args, **options)
-          args.each { |name| column(name, :cidr, options) }
-        end
-
-        def citext(*args, **options)
-          args.each { |name| column(name, :citext, options) }
-        end
-
-        def daterange(*args, **options)
-          args.each { |name| column(name, :daterange, options) }
-        end
-
-        def hstore(*args, **options)
-          args.each { |name| column(name, :hstore, options) }
-        end
-
-        def inet(*args, **options)
-          args.each { |name| column(name, :inet, options) }
-        end
-
-        def int4range(*args, **options)
-          args.each { |name| column(name, :int4range, options) }
-        end
-
-        def int8range(*args, **options)
-          args.each { |name| column(name, :int8range, options) }
-        end
-
-        def json(*args, **options)
-          args.each { |name| column(name, :json, options) }
-        end
-
-        def jsonb(*args, **options)
-          args.each { |name| column(name, :jsonb, options) }
-        end
-
-        def ltree(*args, **options)
-          args.each { |name| column(name, :ltree, options) }
-        end
-
-        def macaddr(*args, **options)
-          args.each { |name| column(name, :macaddr, options) }
-        end
-
-        def money(*args, **options)
-          args.each { |name| column(name, :money, options) }
-        end
-
-        def numrange(*args, **options)
-          args.each { |name| column(name, :numrange, options) }
-        end
-
-        def point(*args, **options)
-          args.each { |name| column(name, :point, options) }
-        end
-
-        def line(*args, **options)
-          args.each { |name| column(name, :line, options) }
-        end
-
-        def lseg(*args, **options)
-          args.each { |name| column(name, :lseg, options) }
-        end
-
-        def box(*args, **options)
-          args.each { |name| column(name, :box, options) }
-        end
-
-        def path(*args, **options)
-          args.each { |name| column(name, :path, options) }
-        end
-
-        def polygon(*args, **options)
-          args.each { |name| column(name, :polygon, options) }
-        end
-
-        def circle(*args, **options)
-          args.each { |name| column(name, :circle, options) }
-        end
-
-        def serial(*args, **options)
-          args.each { |name| column(name, :serial, options) }
-        end
-
-        def tsrange(*args, **options)
-          args.each { |name| column(name, :tsrange, options) }
-        end
-
-        def tstzrange(*args, **options)
-          args.each { |name| column(name, :tstzrange, options) }
-        end
-
-        def tsvector(*args, **options)
-          args.each { |name| column(name, :tsvector, options) }
-        end
-
-        def uuid(*args, **options)
-          args.each { |name| column(name, :uuid, options) }
-        end
-
-        def xml(*args, **options)
-          args.each { |name| column(name, :xml, options) }
-        end
-      end
-
-      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
-        attr_accessor :array
-      end
-
-      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-        include ColumnMethods
-
-        def new_column_definition(name, type, options) # :nodoc:
-          column = super
-          column.array = options[:array]
-          column
-        end
-
-        private
-
-          def create_column_definition(name, type)
-            OvirtLegacyPostgreSQL::ColumnDefinition.new name, type
-          end
-      end
-
-      class Table < ActiveRecord::ConnectionAdapters::Table
-        include ColumnMethods
-      end
-    end
-  end
-end