method

query_conditions_for_known_type_names

Importance_0
v7.0.0 - Show latest stable - 0 notes - Class: TypeMapInitializer
query_conditions_for_known_type_names() public

No documentation

This method has no description. You can help the Ruby on Rails community by adding new notes.

Hide source
# File activerecord/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb, line 36
          def query_conditions_for_known_type_names
            known_type_names = @store.keys.map { |n| "'#{n}'" }
            <<~SQL % known_type_names.join(", ")
              WHERE
                t.typname IN (%(
            SQL
          end

          def query_conditions_for_known_type_types
            known_type_types = %w('r' 'e' 'd')
            <<~SQL % known_type_types.join(", ")
              WHERE
                t.typtype IN (%s)
            SQL
          end

          def query_conditions_for_array_types
            known_type_oids = @store.keys.reject { |k| k.is_a?(String) }
            <<~SQL % [known_type_oids.join(", ")]
              WHERE
                t.typelem IN (%s)
            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
Register or log in to add new notes.