SYMBOL INDEX (1018 symbols across 116 files)

FILE: lib/generators/torque/function_generator.rb
  type Torque (line 5) | module Torque
    type Generators (line 6) | module Generators
      class FunctionGenerator (line 7) | class FunctionGenerator < Rails::Generators::Base

FILE: lib/generators/torque/type_generator.rb
  type Torque (line 5) | module Torque
    type Generators (line 6) | module Generators
      class TypeGenerator (line 7) | class TypeGenerator < Rails::Generators::Base

FILE: lib/generators/torque/view_generator.rb
  type Torque (line 5) | module Torque
    type Generators (line 6) | module Generators
      class ViewGenerator (line 7) | class ViewGenerator < Rails::Generators::Base

FILE: lib/torque/postgresql/adapter.rb
  type Torque (line 11) | module Torque
    type PostgreSQL (line 12) | module PostgreSQL
      type Adapter (line 13) | module Adapter
        class DeduplicatableArray (line 19) | class DeduplicatableArray < ::Array
          method deduplicate (line 20) | def deduplicate
        function version (line 28) | def version
        function extract_table_options! (line 35) | def extract_table_options!(options)
        function build_insert_sql (line 41) | def build_insert_sql(insert)

FILE: lib/torque/postgresql/adapter/database_statements.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type DatabaseStatements (line 6) | module DatabaseStatements
          function dump_mode! (line 11) | def dump_mode!
          function schemas_blacklist (line 16) | def schemas_blacklist
          function schemas_whitelist (line 22) | def schemas_whitelist
          function schemas_search_path_sanitized (line 28) | def schemas_search_path_sanitized
          function valid_type? (line 36) | def valid_type?(type)
          function extended_types (line 41) | def extended_types
          function schema_exists? (line 48) | def schema_exists?(name, filtered: true)
          function type_exists? (line 57) | def type_exists?(name)
          function initialize_type_map (line 63) | def initialize_type_map(m = type_map)
          function load_additional_types (line 79) | def load_additional_types(oids = nil)
          function torque_load_additional_types (line 87) | def torque_load_additional_types(oids = nil)
          function torque_load_additional_types? (line 116) | def torque_load_additional_types?
          function user_defined_types (line 122) | def user_defined_types(*categories)
          function inherited_tables (line 135) | def inherited_tables
          function user_defined_schemas (line 151) | def user_defined_schemas
          function user_defined_schemas_sql (line 156) | def user_defined_schemas_sql
          function column_definitions (line 167) | def column_definitions(table_name)
          function list_versioned_commands (line 188) | def list_versioned_commands(type)
          function filter_by_schema (line 220) | def filter_by_schema

FILE: lib/torque/postgresql/adapter/oid/array.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type OID (line 6) | module OID
          type Array (line 7) | module Array
            function force_equality? (line 8) | def force_equality?(value)

FILE: lib/torque/postgresql/adapter/oid/box.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class Box (line 5) | class Box < Struct.new(:x1, :y1, :x2, :y2)
        method points (line 6) | def points
      type Adapter (line 19) | module Adapter
        type OID (line 20) | module OID
          class Box (line 21) | class Box < Torque::PostgreSQL::GeometryBuilder

FILE: lib/torque/postgresql/adapter/oid/circle.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class Circle (line 5) | class Circle < Struct.new(:x, :y, :r)
        method center (line 9) | def center
        method center= (line 13) | def center=(value)
        method point_class (line 21) | def point_class
      type Adapter (line 28) | module Adapter
        type OID (line 29) | module OID
          class Circle (line 30) | class Circle < Torque::PostgreSQL::GeometryBuilder

FILE: lib/torque/postgresql/adapter/oid/enum.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type OID (line 6) | module OID
          class Enum (line 7) | class Enum < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::...
            method create (line 11) | def self.create(row, type_map)
            method initialize (line 24) | def initialize(name)
            method hash (line 31) | def hash
            method serialize (line 35) | def serialize(value)
            method assert_valid_value (line 41) | def assert_valid_value(value)
            method type_cast_for_schema (line 46) | def type_cast_for_schema(value)
            method == (line 50) | def ==(other)
            method cast_value (line 58) | def cast_value(value)

FILE: lib/torque/postgresql/adapter/oid/enum_set.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type OID (line 6) | module OID
          class EnumSet (line 7) | class EnumSet < Enum
            method initialize (line 8) | def initialize(name, enum_klass)
            method type (line 16) | def type
            method deserialize (line 20) | def deserialize(value)
            method serialize (line 26) | def serialize(value)
            method type_cast_for_schema (line 35) | def type_cast_for_schema(value)
            method cast_value (line 41) | def cast_value(value)

FILE: lib/torque/postgresql/adapter/oid/interval.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type OID (line 6) | module OID
          class Interval (line 7) | class Interval < ActiveModel::Type::Value
            method type (line 11) | def type
            method cast (line 27) | def cast(value)
            method deserialize (line 52) | def deserialize(value)
            method serialize (line 59) | def serialize(value)
            method type_cast_for_schema (line 67) | def type_cast_for_schema(value)
            method assert_valid_value (line 72) | def assert_valid_value(value)
            method parts_to_duration (line 77) | def parts_to_duration(parts)
            method remove_weeks (line 98) | def remove_weeks(value)

FILE: lib/torque/postgresql/adapter/oid/line.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class Line (line 5) | class Line < Struct.new(:slope, :intercept)
        method a= (line 9) | def a=(value)
        method a (line 13) | def a
        method b= (line 17) | def b=(value)
        method b (line 21) | def b
        method horizontal? (line 25) | def horizontal?
        method vertical? (line 29) | def vertical?
      type Adapter (line 36) | module Adapter
        type OID (line 37) | module OID
          class Line (line 38) | class Line < Torque::PostgreSQL::GeometryBuilder
            method build_klass (line 45) | def build_klass(*args)

FILE: lib/torque/postgresql/adapter/oid/range.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type OID (line 6) | module OID
          class Range (line 7) | class Range < ActiveRecord::ConnectionAdapters::PostgreSQL::OID:...
            type Comparison (line 10) | module Comparison
              function <=> (line 11) | def <=>(other)
            method cast_value (line 18) | def cast_value(value)
            method map (line 30) | def map(value) # :nodoc:
            method cast_custom (line 39) | def cast_custom(from, to)
            method custom_cast_single (line 45) | def custom_cast_single(value, negative = false)
            method custom_infinity (line 49) | def custom_infinity(negative)

FILE: lib/torque/postgresql/adapter/oid/segment.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class Segment (line 5) | class Segment < Struct.new(:point0, :point1)
        method x1= (line 6) | def x1=(value)
        method x1 (line 10) | def x1
        method y1= (line 14) | def y1=(value)
        method y1 (line 18) | def y1
        method x2= (line 22) | def x2=(value)
        method x2 (line 26) | def x2
        method y2= (line 30) | def y2=(value)
        method y2 (line 34) | def y2
        method new_point (line 40) | def new_point(x, y)
      type Adapter (line 47) | module Adapter
        type OID (line 48) | module OID
          class Segment (line 49) | class Segment < Torque::PostgreSQL::GeometryBuilder
            method point_class (line 56) | def point_class
            method build_klass (line 60) | def build_klass(*args)

FILE: lib/torque/postgresql/adapter/quoting.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type Quoting (line 6) | module Quoting
          function quote_type_name (line 15) | def quote_type_name(name, *args)
          function quote_identifier_name (line 24) | def quote_identifier_name(name, schema = nil)
          function quote_default_expression (line 30) | def quote_default_expression(value, column)

FILE: lib/torque/postgresql/adapter/schema_creation.rb
  type Torque (line 1) | module Torque
    type PostgreSQL (line 2) | module PostgreSQL
      type Adapter (line 3) | module Adapter
        type SchemaCreation (line 4) | module SchemaCreation
          function add_table_options! (line 8) | def add_table_options!(create_sql, o)

FILE: lib/torque/postgresql/adapter/schema_definitions.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type ColumnMethods (line 6) | module ColumnMethods
          function search_language (line 9) | def search_language(*names, **options)
          function search_vector (line 15) | def search_vector(*names, columns:, **options)
        type TableDefinition (line 23) | module TableDefinition
          function initialize (line 28) | def initialize(*args, **options)
          function set_primary_key (line 35) | def set_primary_key(tn, id, primary_key, *, **)
          function create_column_definition (line 41) | def create_column_definition(name, type, options)
        type Definition (line 55) | module Definition
          function create_function (line 57) | def create_function(name, version:, dir: pool.migrations_paths)
          function create_type (line 62) | def create_type(name, version:, dir: pool.migrations_paths)
          function create_view (line 67) | def create_view(name, version:, dir: pool.migrations_paths)

FILE: lib/torque/postgresql/adapter/schema_dumper.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type SchemaDumper (line 6) | module SchemaDumper
          function initialize (line 15) | def initialize(*)
          function dump (line 24) | def dump(stream) # :nodoc:
          function types (line 34) | def types(stream) # :nodoc:
          function tables (line 41) | def tables(stream) # :nodoc:
          function around_tables (line 45) | def around_tables(stream)
          function dump_tables (line 55) | def dump_tables(stream)
          function remove_prefix_and_suffix (line 101) | def remove_prefix_and_suffix(table)
          function schemas (line 106) | def schemas(stream)
          function schema_type_with_virtual (line 116) | def schema_type_with_virtual(column)
          function schema_type (line 121) | def schema_type(column)
          function prepare_column_options (line 126) | def prepare_column_options(column)
          function parse_search_vector_options (line 133) | def parse_search_vector_options(column, options)
          function parse_search_vector_columns (line 149) | def parse_search_vector_columns(settings)
          function versioned_commands (line 168) | def versioned_commands(stream, type, add_newline = false)
          function list_existing_versioned_commands (line 186) | def list_existing_versioned_commands(type)
          function with_versioned_commands? (line 192) | def with_versioned_commands?
          function fx_functions_position (line 196) | def fx_functions_position

FILE: lib/torque/postgresql/adapter/schema_overrides.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type SchemaOverrides (line 6) | module SchemaOverrides
          function quote_table_name (line 8) | def quote_table_name(name)
          function drop_table (line 30) | def drop_table(*table_names, **options)
          function validate_table_length! (line 37) | def validate_table_length!(table_name)

FILE: lib/torque/postgresql/adapter/schema_statements.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Adapter (line 5) | module Adapter
        type SchemaStatements (line 6) | module SchemaStatements
          function drop_type (line 8) | def drop_type(name, options = {})
          function rename_type (line 20) | def rename_type(type_name, new_name, options = {})
          function add_search_language (line 31) | def add_search_language(table, name, options = {})
          function add_search_vector (line 51) | def add_search_vector(table, name, columns, options = {})
          function add_enum_values (line 63) | def add_enum_values(name, values, options = {})
          function enum_values (line 86) | def enum_values(name)
          function table_options (line 96) | def table_options(table_name)
          function quoted_scope (line 118) | def quoted_scope(name = nil, type: nil)
          function data_source_sql (line 128) | def data_source_sql(name = nil, type: nil)
          function valid_table_definition_options (line 136) | def valid_table_definition_options
          function assume_migrated_upto_version (line 141) | def assume_migrated_upto_version(version)
          function insert_versions_sql (line 165) | def insert_versions_sql(versions)
          function sequence_name_from_parts (line 188) | def sequence_name_from_parts(table_name, column_name, suffix)
          function sanitize_name_with_schema (line 193) | def sanitize_name_with_schema(name, options)
          function quote_enum_values (line 198) | def quote_enum_values(name, values, options)

FILE: lib/torque/postgresql/arel/infix_operation.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Arel (line 5) | module Arel
        function build_operations (line 8) | def self.build_operations(operations)

FILE: lib/torque/postgresql/arel/join_source.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Arel (line 5) | module Arel
        type JoinSource (line 6) | module JoinSource
          function only? (line 9) | def only?

FILE: lib/torque/postgresql/arel/nodes.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Arel (line 5) | module Arel
        type Nodes (line 6) | module Nodes
          class Cast (line 8) | class Cast < ::Arel::Nodes::Binary
            method initialize (line 15) | def initialize(left, right, array = false)
          class Ref (line 22) | class Ref < ::Arel::Nodes::Unary
            method initialize (line 26) | def initialize(expr, reference = nil)
            method as (line 31) | def as(other)

FILE: lib/torque/postgresql/arel/operations.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Arel (line 5) | module Arel
        type Operations (line 6) | module Operations
          function pg_cast (line 9) | def pg_cast(type, array = false)
          function cast (line 15) | def cast(type, array = false)

FILE: lib/torque/postgresql/arel/select_manager.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Arel (line 5) | module Arel
        type SelectManager (line 6) | module SelectManager
          function only (line 8) | def only

FILE: lib/torque/postgresql/arel/visitors.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Arel (line 5) | module Arel
        type Visitors (line 6) | module Visitors
          function visit_Arel_Nodes_JoinSource (line 8) | def visit_Arel_Nodes_JoinSource(o, collector)
          function visit_Arel_Nodes_Quoted (line 14) | def visit_Arel_Nodes_Quoted(o, collector)
          function visit_Arel_Nodes_Casted (line 20) | def visit_Arel_Nodes_Casted(o, collector)
          function visit_Torque_PostgreSQL_Arel_Nodes_Ref (line 28) | def visit_Torque_PostgreSQL_Arel_Nodes_Ref(o, collector)
          function visit_Torque_PostgreSQL_Arel_Nodes_Cast (line 33) | def visit_Torque_PostgreSQL_Arel_Nodes_Cast(o, collector)
          function quote_array (line 39) | def quote_array(value, collector)

FILE: lib/torque/postgresql/associations/association_scope.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Associations (line 5) | module Associations
        type AssociationScope (line 6) | module AssociationScope
          class PredicateBuilderArray (line 9) | class PredicateBuilderArray
            method call_with_empty (line 12) | def call_with_empty(attribute)
          type ClassMethods (line 17) | module ClassMethods
            function get_bind_values (line 18) | def get_bind_values(*)
          function last_chain_scope (line 28) | def last_chain_scope(scope, reflection, owner)
          function next_chain_scope (line 43) | def next_chain_scope(scope, reflection, next_reflection)
          function transform_value (line 55) | def transform_value(value)

FILE: lib/torque/postgresql/associations/belongs_to_many_association.rb
  type Torque (line 6) | module Torque
    type PostgreSQL (line 7) | module PostgreSQL
      type Associations (line 8) | module Associations
        class BelongsToManyAssociation (line 9) | class BelongsToManyAssociation < ::ActiveRecord::Associations::Col...
          method ids_reader (line 13) | def ids_reader
          method ids_writer (line 23) | def ids_writer(ids)
          method size (line 31) | def size
          method empty? (line 42) | def empty?
          method include? (line 46) | def include?(record)
          method load_target (line 54) | def load_target
          method build_changes (line 64) | def build_changes(from_target = false)
          method trigger (line 73) | def trigger(prefix, before_ids, after_ids)
          method handle_dependency (line 95) | def handle_dependency
          method insert_record (line 137) | def insert_record(record, *)
          method default (line 144) | def default(&block)
          method _create_record (line 151) | def _create_record(attributes, raises = false, &block)
          method delete_count (line 169) | def delete_count(method, scope, ids)
          method delete_or_nullify_all_records (line 174) | def delete_or_nullify_all_records(method)
          method delete_records (line 179) | def delete_records(records, method)
          method source_attr (line 191) | def source_attr
          method klass_attr (line 195) | def klass_attr
          method read_records_ids (line 199) | def read_records_ids(records)
          method ids_rewriter (line 204) | def ids_rewriter(ids, operator)
          method column_default_value (line 213) | def column_default_value
          method callback (line 217) | def callback(*)
          method replace_records (line 222) | def replace_records(*)
          method concat_records (line 226) | def concat_records(*)
          method delete_or_destroy (line 230) | def delete_or_destroy(*)
          method difference (line 234) | def difference(a, b)
          method intersection (line 238) | def intersection(a, b)
          method scope_for_create (line 243) | def scope_for_create
          method find_target? (line 247) | def find_target?
          method foreign_key_present? (line 251) | def foreign_key_present?
          method invertible_for? (line 255) | def invertible_for?(record)
          method stale_state (line 261) | def stale_state

FILE: lib/torque/postgresql/associations/builder/belongs_to_many.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Associations (line 5) | module Associations
        type Builder (line 6) | module Builder
          class BelongsToMany (line 7) | class BelongsToMany < ::ActiveRecord::Associations::Builder::Col...
            method macro (line 8) | def self.macro
            method valid_options (line 12) | def self.valid_options(options)
            method valid_dependent_options (line 16) | def self.valid_dependent_options
            method define_callbacks (line 20) | def self.define_callbacks(model, reflection)
            method define_readers (line 27) | def self.define_readers(mixin, name)
            method define_writers (line 35) | def self.define_writers(mixin, name)
            method add_default_callbacks (line 43) | def self.add_default_callbacks(model, reflection)
            method add_touch_callbacks (line 49) | def self.add_touch_callbacks(model, reflection)
            method touch_record (line 67) | def self.touch_record(o, changes, foreign_key, name, touch, to...
            method add_change_callbacks (line 98) | def self.add_change_callbacks(model, reflection)
            method add_destroy_callbacks (line 113) | def self.add_destroy_callbacks(model, reflection)
            method define_validations (line 117) | def self.define_validations(model, reflection)

FILE: lib/torque/postgresql/associations/builder/has_many.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Associations (line 5) | module Associations
        type Builder (line 6) | module Builder
          type HasMany (line 7) | module HasMany
            function valid_options (line 8) | def valid_options(options)

FILE: lib/torque/postgresql/associations/foreign_association.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Associations (line 5) | module Associations
        type ForeignAssociation (line 6) | module ForeignAssociation
          function inversed_from (line 10) | def inversed_from(record)
          function skip_statement_cache? (line 19) | def skip_statement_cache?(*)
          function set_owner_attributes (line 27) | def set_owner_attributes(record)

FILE: lib/torque/postgresql/associations/preloader/association.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Associations (line 5) | module Associations
        type Preloader (line 6) | module Preloader
          type Association (line 7) | module Association
            function run (line 13) | def run
            function set_inverse (line 23) | def set_inverse(record)
            function load_records (line 38) | def load_records(raw_records = nil)
            function owners_by_key (line 62) | def owners_by_key
            function run_array_for_belongs_to_many (line 74) | def run_array_for_belongs_to_many
            function run_array_for_has_many (line 84) | def run_array_for_has_many
            function records_for (line 99) | def records_for(ids, &block)
            function associate_records_to_owner (line 106) | def associate_records_to_owner(owner, records)
            function groupped_records (line 113) | def groupped_records

FILE: lib/torque/postgresql/associations/preloader/loader_query.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Associations (line 5) | module Associations
        type Preloader (line 6) | module Preloader
          type LoaderQuery (line 7) | module LoaderQuery
            function foreign_column (line 8) | def foreign_column
            function load_records_for_keys (line 12) | def load_records_for_keys(keys, &block)
            function query_condition_for (line 19) | def query_condition_for(keys)
            function connected_through_array? (line 26) | def connected_through_array?

FILE: lib/torque/postgresql/attributes/builder.rb
  type Torque (line 7) | module Torque
    type PostgreSQL (line 8) | module PostgreSQL
      type Attributes (line 9) | module Attributes
        type Builder (line 10) | module Builder
          function include_on (line 11) | def self.include_on(klass, method_name, builder_klass, **extra, ...
          function search_vector_options (line 29) | def self.search_vector_options(columns:, language: nil, stored: ...
          function to_search_weights (line 40) | def self.to_search_weights(columns)
          function to_search_vector_operation (line 50) | def self.to_search_vector_operation(language, weights)

FILE: lib/torque/postgresql/attributes/builder/enum.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Attributes (line 5) | module Attributes
        type Builder (line 6) | module Builder
          class Enum (line 7) | class Enum
            method initialize (line 15) | def initialize(klass, attribute, options)
            method values_methods (line 34) | def values_methods
            method set_features? (line 57) | def set_features?
            method conflicting? (line 63) | def conflicting?
            method build (line 92) | def build
            method dangerous? (line 108) | def dangerous?(method_name, class_method = false)
            method plural (line 130) | def plural
            method set_scopes (line 155) | def set_scopes
            method stringify (line 174) | def stringify
            method all_values (line 184) | def all_values

FILE: lib/torque/postgresql/attributes/builder/full_text_search.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Attributes (line 5) | module Attributes
        type Builder (line 6) | module Builder
          class FullTextSearch (line 7) | class FullTextSearch
            method initialize (line 11) | def initialize(klass, attribute, options = {})
            method scope_name (line 32) | def scope_name
            method conflicting? (line 41) | def conflicting?
            method build (line 50) | def build
            method add_scope_to_module (line 57) | def add_scope_to_module
            method scope_args (line 97) | def scope_args

FILE: lib/torque/postgresql/attributes/builder/period.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Attributes (line 5) | module Attributes
        type Builder (line 6) | module Builder
          class Period (line 7) | class Period
            method initialize (line 29) | def initialize(klass, attribute, options)
            method threshold (line 47) | def threshold
            method method_names (line 74) | def method_names
            method klass_method_names (line 79) | def klass_method_names
            method instance_method_names (line 84) | def instance_method_names
            method conflicting? (line 90) | def conflicting?
            method build (line 104) | def build
            method build_method_helper (line 161) | def build_method_helper(type, key, args = [])
            method default_method_names (line 175) | def default_method_names
            method dangerous? (line 187) | def dangerous?(method_name, class_method = false)
            method define_string_method (line 200) | def define_string_method(name, body, args = [])
            method arel_attribute (line 206) | def arel_attribute
            method arel_default_sql (line 210) | def arel_default_sql
            method arel_sql_bind (line 214) | def arel_sql_bind(value)
            method arel_threshold_value (line 219) | def arel_threshold_value
            method arel_start_at (line 237) | def arel_start_at
            method arel_finish_at (line 242) | def arel_finish_at
            method arel_real_start_at (line 247) | def arel_real_start_at
            method arel_real_finish_at (line 257) | def arel_real_finish_at
            method arel_real_attribute (line 267) | def arel_real_attribute
            method arel_convert_to_type (line 275) | def arel_convert_to_type(left, right = nil, set_type = nil)
            method arel_named_function (line 280) | def arel_named_function(name, *args)
            method arel_nullif (line 287) | def arel_nullif(*args)
            method arel_coalesce (line 292) | def arel_coalesce(*args)
            method arel_empty_value (line 297) | def arel_empty_value
            method arel_daterange (line 302) | def arel_daterange(real = false)
            method arel_check_condition (line 311) | def arel_check_condition(type)
            method arel_formatting_value (line 317) | def arel_formatting_value(condition = nil, value = 'value', ca...
            method arel_formatting_left_right (line 328) | def arel_formatting_left_right(condition, set_type = nil, cast...
            method klass_current_on (line 344) | def klass_current_on
            method klass_current (line 348) | def klass_current
            method klass_not_current (line 355) | def klass_not_current
            method klass_containing (line 362) | def klass_containing
            method klass_not_containing (line 366) | def klass_not_containing
            method klass_overlapping (line 370) | def klass_overlapping
            method klass_not_overlapping (line 374) | def klass_not_overlapping
            method klass_starting_after (line 378) | def klass_starting_after
            method klass_starting_before (line 382) | def klass_starting_before
            method klass_finishing_after (line 386) | def klass_finishing_after
            method klass_finishing_before (line 390) | def klass_finishing_before
            method klass_real_containing (line 394) | def klass_real_containing
            method klass_real_overlapping (line 398) | def klass_real_overlapping
            method klass_real_starting_after (line 402) | def klass_real_starting_after
            method klass_real_starting_before (line 406) | def klass_real_starting_before
            method klass_real_finishing_after (line 410) | def klass_real_finishing_after
            method klass_real_finishing_before (line 414) | def klass_real_finishing_before
            method klass_containing_date (line 418) | def klass_containing_date
            method klass_not_containing_date (line 423) | def klass_not_containing_date
            method klass_overlapping_date (line 428) | def klass_overlapping_date
            method klass_not_overlapping_date (line 433) | def klass_not_overlapping_date
            method klass_real_containing_date (line 438) | def klass_real_containing_date
            method klass_real_overlapping_date (line 443) | def klass_real_overlapping_date
            method instance_current? (line 448) | def instance_current?
            method instance_current_on? (line 452) | def instance_current_on?
            method instance_start (line 463) | def instance_start
            method instance_finish (line 467) | def instance_finish
            method instance_real (line 471) | def instance_real
            method instance_real_start (line 483) | def instance_real_start
            method instance_real_finish (line 497) | def instance_real_finish

FILE: lib/torque/postgresql/attributes/enum.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Attributes (line 5) | module Attributes
        class Enum (line 6) | class Enum < String
          class EnumError (line 9) | class EnumError < ArgumentError; end
          method lookup (line 19) | def lookup(name)
          method include_on (line 29) | def include_on(klass, method_name = nil)
          method new (line 37) | def new(value)
          method values (line 43) | def values
          method keys (line 50) | def keys
          method members (line 55) | def members
          method texts (line 60) | def texts
          method to_options (line 65) | def to_options
          method fetch (line 72) | def fetch(value, *)
          method type_name (line 78) | def type_name
          method valid? (line 83) | def valid?(value)
          method scope (line 90) | def scope(attribute, value)
          method respond_to_missing? (line 97) | def respond_to_missing?(method_name, include_private = false)
          method method_missing (line 102) | def method_missing(method_name, *arguments)
          method connection (line 108) | def connection
          method initialize (line 115) | def initialize(value)
          method <=> (line 122) | def <=>(other)
          method == (line 133) | def ==(other)
          method nil? (line 141) | def nil?
          method replace (line 147) | def replace(value)
          method text (line 153) | def text(attr = nil, model = nil)
          method to_s (line 159) | def to_s
          method to_i (line 164) | def to_i
          method inspect (line 169) | def inspect
          method i18n_keys (line 176) | def i18n_keys(attr = nil, model = nil)
          method respond_to_missing? (line 192) | def respond_to_missing?(method_name, include_private = false)
          method method_missing (line 200) | def method_missing(method_name, *arguments)
          method raise_invalid (line 213) | def raise_invalid(value)
          method raise_comparison (line 222) | def raise_comparison(other)

FILE: lib/torque/postgresql/attributes/enum_set.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Attributes (line 5) | module Attributes
        class EnumSet (line 6) | class EnumSet < Set
          class EnumSetError (line 9) | class EnumSetError < Enum::EnumError; end
          method lookup (line 19) | def lookup(name, enum_klass)
          method include_on (line 32) | def include_on(klass, method_name = nil)
          method enum_source (line 40) | def enum_source
          method sample (line 45) | def sample
          method new (line 50) | def new(*values)
          method type_name (line 56) | def type_name
          method fetch (line 63) | def fetch(value, *)
          method power (line 69) | def power(*values)
          method scope (line 80) | def scope(attribute, value)
          method respond_to_missing? (line 87) | def respond_to_missing?(method_name, include_private = false)
          method method_missing (line 92) | def method_missing(method_name, *arguments)
          method initialize (line 99) | def initialize(*values)
          method <=> (line 111) | def <=>(other)
          method == (line 124) | def ==(other)
          method replace (line 132) | def replace(*values)
          method text (line 137) | def text(attr = nil, model = nil)
          method to_i (line 143) | def to_i
          method inspect (line 148) | def inspect
          method []= (line 153) | def []=(key, value)
          method merge (line 158) | def merge(other)
          method & (line 163) | def &(other)
          method instantiate (line 188) | def instantiate(value)
          method transform_power (line 193) | def transform_power(value)
          method transform_values (line 203) | def transform_values(values)
          method respond_to_missing? (line 209) | def respond_to_missing?(method_name, include_private = false)
          method method_missing (line 217) | def method_missing(method_name, *arguments)
          method raise_invalid (line 230) | def raise_invalid(value)
          method raise_comparison (line 239) | def raise_comparison(other)

FILE: lib/torque/postgresql/attributes/full_text_search.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Attributes (line 5) | module Attributes
        type FullTextSearch (line 7) | module FullTextSearch
          function include_on (line 11) | def include_on(klass, method_name = nil)

FILE: lib/torque/postgresql/attributes/lazy.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Attributes (line 5) | module Attributes
        class Lazy (line 6) | class Lazy < BasicObject
          method initialize (line 8) | def initialize(klass, *values)
          method == (line 12) | def ==(other)
          method nil? (line 16) | def nil?
          method inspect (line 20) | def inspect
          method __class__ (line 24) | def __class__
          method method_missing (line 28) | def method_missing(name, *args, &block)

FILE: lib/torque/postgresql/attributes/period.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Attributes (line 5) | module Attributes
        type Period (line 7) | module Period
          function include_on (line 11) | def include_on(klass, method_name = nil)

FILE: lib/torque/postgresql/autosave_association.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type AutosaveAssociation (line 5) | module AutosaveAssociation
        type ClassMethods (line 6) | module ClassMethods
          function add_autosave_association_callbacks (line 10) | def add_autosave_association_callbacks(reflection)
        function save_belongs_to_many_association (line 26) | def save_belongs_to_many_association(reflection)

FILE: lib/torque/postgresql/auxiliary_statement.rb
  type Torque (line 6) | module Torque
    type PostgreSQL (line 7) | module PostgreSQL
      class AuxiliaryStatement (line 8) | class AuxiliaryStatement
        method lookup (line 15) | def lookup(name, base)
        method instantiate (line 25) | def instantiate(statement, base, **options)
        method build (line 40) | def build(statement, base, bound_attributes = [], join_sources = [...
        method relation_query? (line 50) | def relation_query?(obj)
        method arel_query? (line 56) | def arel_query?(obj)
        method create (line 62) | def create(table_or_settings, &block)
        method configurator (line 78) | def configurator(config)
        method configure (line 93) | def configure(base, instance)
        method table (line 103) | def table
        method initialize (line 114) | def initialize(*, **options)
        method build (line 128) | def build(base)
        method prepare (line 145) | def prepare(base, settings)
        method build_query (line 174) | def build_query(base)
        method build_join (line 195) | def build_join(base)
        method arel_join (line 239) | def arel_join
        method expose_columns (line 253) | def expose_columns(base, query_table = nil)
        method ensure_dependencies (line 272) | def ensure_dependencies(list, base)
        method project (line 292) | def project(column, arel_table = nil)

FILE: lib/torque/postgresql/auxiliary_statement/recursive.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class AuxiliaryStatement (line 5) | class AuxiliaryStatement
        class Recursive (line 6) | class Recursive < AuxiliaryStatement
          method initialize (line 8) | def initialize(*, **options)
          method build_query (line 29) | def build_query(base)
          method prepare (line 65) | def prepare(base, settings)
          method prepare_sub_query (line 72) | def prepare_sub_query(base, settings)
          method extra_columns (line 113) | def extra_columns(base, columns, sub_columns)

FILE: lib/torque/postgresql/auxiliary_statement/settings.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class AuxiliaryStatement (line 5) | class AuxiliaryStatement
        class Settings (line 6) | class Settings < Collector.new(:attributes, :join, :join_type, :qu...
          method initialize (line 17) | def initialize(base, source, recursive = false)
          method base_name (line 23) | def base_name
          method base_table (line 27) | def base_table
          method recursive? (line 31) | def recursive?
          method depth? (line 35) | def depth?
          method path? (line 39) | def path?
          method with_depth (line 44) | def with_depth(name = 'depth', start: 0, as: nil)
          method with_path (line 49) | def with_path(name = 'path', source: nil, as: nil)
          method union_all! (line 54) | def union_all!
          method with_depth_and_path (line 59) | def with_depth_and_path
          method query_table (line 64) | def query_table
          method col (line 71) | def col(name)
          method query (line 81) | def query(value = nil, command = nil)
          method sub_query (line 88) | def sub_query(value = nil, command = nil)
          method connect (line 96) | def connect(value = nil)
          method sanitize_query (line 111) | def sanitize_query(value, command = nil)

FILE: lib/torque/postgresql/base.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Base (line 5) | module Base
        function reset_table_name (line 24) | def reset_table_name
        function inherited (line 31) | def inherited(subclass)
        function belongs_to_many (line 199) | def belongs_to_many(name, scope = nil, **options, &extension)
        function dynamic_attribute (line 230) | def dynamic_attribute(name, &block)
        function auxiliary_statement (line 286) | def auxiliary_statement(table, &block)
        function recursive_auxiliary_statement (line 296) | def recursive_auxiliary_statement(table, &block)

FILE: lib/torque/postgresql/collector.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Collector (line 5) | module Collector
        function new (line 9) | def self.new(*args)

FILE: lib/torque/postgresql/config.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      function logger (line 8) | def self.logger
      function irregular_models= (line 33) | def config.irregular_models=(hash)

FILE: lib/torque/postgresql/function.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Function (line 7) | module Function
        function bind (line 12) | def bind(*args)
        function bind_for (line 19) | def bind_for(model, attribute, value)
        function bind_with (line 24) | def bind_with(arel_attribute, value)
        function bind_type (line 29) | def bind_type(value, type = nil, name: 'value', cast: nil)
        function infix (line 37) | def infix(op, left, right)
        function concat (line 44) | def concat(*args)
        function group_by (line 51) | def group_by(arel, name)
        function respond_to_missing? (line 58) | def respond_to_missing?(*)
        function method_missing (line 66) | def method_missing(name, *args, &block)
        function ruby_type_to_model_type (line 72) | def ruby_type_to_model_type(value)

FILE: lib/torque/postgresql/geometry_builder.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class GeometryBuilder (line 5) | class GeometryBuilder < ActiveModel::Type::Value
        method type (line 10) | def type
        method pieces (line 15) | def pieces
        method formation (line 19) | def formation
        method cast (line 23) | def cast(value)
        method serialize (line 38) | def serialize(value)
        method deserialize (line 56) | def deserialize(value)
        method type_cast_for_schema (line 60) | def type_cast_for_schema(value)
        method changed_in_place? (line 68) | def changed_in_place?(raw_old_value, new_value)
        method number_serializer (line 74) | def number_serializer
        method config_class (line 78) | def config_class
        method build_klass (line 82) | def build_klass(*args)
        method check_invalid_format! (line 89) | def check_invalid_format!(args)

FILE: lib/torque/postgresql/i18n.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type I18n (line 5) | module I18n
        function localize (line 10) | def localize(locale, object, format = :default, options = {})

FILE: lib/torque/postgresql/inheritance.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Inheritance (line 7) | module Inheritance
        function cast_record (line 11) | def cast_record
        function inheritance_merged_attributes (line 27) | def inheritance_merged_attributes
        function inheritance_mergeable_attributes (line 36) | def inheritance_mergeable_attributes
        function physically_inherited? (line 56) | def physically_inherited?
        function inheritance_dependents (line 68) | def inheritance_dependents
        function physically_inheritances? (line 73) | def physically_inheritances?
        function casted_dependents (line 79) | def casted_dependents
        function reset_table_name (line 87) | def reset_table_name
        function decorated_table_name (line 99) | def decorated_table_name
        function base_class (line 112) | def base_class
        function primary_key (line 118) | def primary_key
        function compute_table_name (line 124) | def compute_table_name
        function raise_unable_to_cast (line 130) | def raise_unable_to_cast(record_class_value)
        function instantiate_instance_of (line 143) | def instantiate_instance_of(klass, attributes, types = {}, &block)
        function sanitize_attributes (line 155) | def sanitize_attributes(real_class, attributes, types)
        function torque_discriminate_class_for_record (line 184) | def torque_discriminate_class_for_record(klass, record)

FILE: lib/torque/postgresql/insert_all.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type InsertAll (line 5) | module InsertAll
        function initialize (line 8) | def initialize(*args, where: nil, **xargs)
      type InsertAll::Builder (line 15) | module InsertAll::Builder
        function where_condition? (line 18) | def where_condition?

FILE: lib/torque/postgresql/migration/command_recorder.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Migration (line 5) | module Migration
        type CommandRecorder (line 6) | module CommandRecorder
          function rename_type (line 9) | def rename_type(*args, &block)
          function invert_rename_type (line 14) | def invert_rename_type(args)
          function create_schema (line 19) | def create_schema(*args, &block)
          function invert_create_schema (line 24) | def invert_create_schema(args)

FILE: lib/torque/postgresql/predicate_builder.rb
  type Torque (line 9) | module Torque
    type PostgreSQL (line 10) | module PostgreSQL
      type PredicateBuilder (line 11) | module PredicateBuilder
        function initialize (line 14) | def initialize(*)

FILE: lib/torque/postgresql/predicate_builder/arel_attribute_handler.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type PredicateBuilder (line 5) | module PredicateBuilder
        class ArelAttributeHandler (line 6) | class ArelAttributeHandler
          method call (line 8) | def self.call(*args)
          method initialize (line 12) | def initialize(*)
          method call (line 16) | def call(attribute, value)
          method array_typed? (line 27) | def array_typed?(attribute)

FILE: lib/torque/postgresql/predicate_builder/array_handler.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type PredicateBuilder (line 5) | module PredicateBuilder
        type ArrayHandler (line 6) | module ArrayHandler
          function call (line 7) | def call(attribute, value)
          function call_for_array (line 14) | def call_for_array(attribute, value)
          function call_with_value (line 26) | def call_with_value(attribute, value)
          function call_with_array (line 30) | def call_with_array(attribute, value)
          function call_with_empty (line 34) | def call_with_empty(attribute)
          function array_attribute? (line 38) | def array_attribute?(attribute)

FILE: lib/torque/postgresql/predicate_builder/enumerator_lazy_handler.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type PredicateBuilder (line 5) | module PredicateBuilder
        class EnumeratorLazyHandler (line 6) | class EnumeratorLazyHandler < ::ActiveRecord::PredicateBuilder::Ar...
          method call (line 9) | def call(attribute, value)
          method with_timeout (line 17) | def with_timeout
          method timeout (line 27) | def timeout
          method limit (line 31) | def limit

FILE: lib/torque/postgresql/predicate_builder/regexp_handler.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type PredicateBuilder (line 5) | module PredicateBuilder
        class RegexpHandler (line 6) | class RegexpHandler
          method initialize (line 7) | def initialize(predicate_builder)
          method call (line 11) | def call(attribute, value)

FILE: lib/torque/postgresql/railtie.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class Railtie (line 6) | class Railtie < Rails::Railtie # :nodoc:

FILE: lib/torque/postgresql/reflection.rb
  type Torque (line 10) | module Torque
    type PostgreSQL (line 11) | module PostgreSQL
      type Reflection (line 12) | module Reflection
        function create (line 14) | def create(macro, name, scope, options, ar)

FILE: lib/torque/postgresql/reflection/abstract_reflection.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Reflection (line 5) | module Reflection
        type AbstractReflection (line 6) | module AbstractReflection
          function connected_through_array? (line 11) | def connected_through_array?
          function join_scope (line 18) | def join_scope(table, foreign_table, foreign_klass)
          function build_join_constraint (line 31) | def build_join_constraint(table, foreign_table)
          function build_id_constraint_between (line 43) | def build_id_constraint_between(table, foreign_table)

FILE: lib/torque/postgresql/reflection/association_reflection.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Reflection (line 5) | module Reflection
        type AssociationReflection (line 6) | module AssociationReflection
          function initialize (line 8) | def initialize(name, scope, options, active_record)
          function derive_foreign_key (line 20) | def derive_foreign_key(*, **)
          function automatic_inverse_of (line 28) | def automatic_inverse_of

FILE: lib/torque/postgresql/reflection/belongs_to_many_reflection.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Reflection (line 5) | module Reflection
        class BelongsToManyReflection (line 6) | class BelongsToManyReflection < ::ActiveRecord::Reflection::Associ...
          method macro (line 7) | def macro
          method connected_through_array? (line 11) | def connected_through_array?
          method belongs_to? (line 15) | def belongs_to?
          method collection? (line 19) | def collection?
          method association_class (line 23) | def association_class
          method foreign_key (line 27) | def foreign_key
          method association_foreign_key (line 31) | def association_foreign_key
          method active_record_primary_key (line 35) | def active_record_primary_key
          method join_primary_key (line 39) | def join_primary_key(*)
          method join_foreign_key (line 43) | def join_foreign_key
          method array_attribute (line 47) | def array_attribute
          method derive_primary_key (line 53) | def derive_primary_key
          method derive_foreign_key (line 57) | def derive_foreign_key

FILE: lib/torque/postgresql/reflection/has_many_reflection.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Reflection (line 5) | module Reflection
        type HasManyReflection (line 6) | module HasManyReflection
          function connected_through_array? (line 7) | def connected_through_array?
          function array_attribute (line 11) | def array_attribute

FILE: lib/torque/postgresql/reflection/runtime_reflection.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Reflection (line 5) | module Reflection
        type RuntimeReflection (line 6) | module RuntimeReflection

FILE: lib/torque/postgresql/reflection/through_reflection.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Reflection (line 5) | module Reflection
        type ThroughReflection (line 6) | module ThroughReflection

FILE: lib/torque/postgresql/relation.rb
  type Torque (line 8) | module Torque
    type PostgreSQL (line 9) | module PostgreSQL
      type Relation (line 10) | module Relation
        function select_extra_values (line 27) | def select_extra_values
        function select_extra_values= (line 31) | def select_extra_values=(value)
        function calculate (line 38) | def calculate(operation, column_name)
        function resolve_column (line 54) | def resolve_column(list, base = false)
        function resolve_base_table (line 75) | def resolve_base_table(relation)
        function cast_for_condition (line 88) | def cast_for_condition(column, value)
        function build_arel (line 96) | def build_arel(*)
        function _record_class_attribute (line 105) | def _record_class_attribute
        function _auto_cast_attribute (line 112) | def _auto_cast_attribute
        type Initializer (line 121) | module Initializer
          function initialize (line 122) | def initialize(klass, *, **)
          function upsert_all (line 130) | def upsert_all(attributes, **xargs)

FILE: lib/torque/postgresql/relation/auxiliary_statement.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Relation (line 5) | module Relation
        type AuxiliaryStatement (line 6) | module AuxiliaryStatement
          function auxiliary_statements_values (line 9) | def auxiliary_statements_values
          function auxiliary_statements_values= (line 13) | def auxiliary_statements_values=(value)
          function with (line 19) | def with(*args, **settings)
          function with! (line 24) | def with!(*args, **settings)
          function bound_attributes (line 34) | def bound_attributes
          function build_arel (line 45) | def build_arel(*)
          function instantiate_auxiliary_statements (line 53) | def instantiate_auxiliary_statements(*args, **options)
          function build_auxiliary_statements (line 67) | def build_auxiliary_statements(arel)
          function auxiliary_statement_type (line 75) | def auxiliary_statement_type
          function auxiliary_statement_error (line 82) | def auxiliary_statement_error(name)

FILE: lib/torque/postgresql/relation/buckets.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Relation (line 5) | module Relation
        type Buckets (line 6) | module Buckets
          function buckets_value (line 9) | def buckets_value
          function buckets_value= (line 13) | def buckets_value=(value)
          function buckets (line 26) | def buckets(*value, **xargs)
          function buckets! (line 31) | def buckets!(attribute, values, count: nil, cast: nil, as: nil)
          function calculate (line 45) | def calculate(*)
          type Initializer (line 57) | module Initializer
            function records (line 59) | def records
          function build_arel (line 74) | def build_arel(*)
          function build_buckets_node (line 82) | def build_buckets_node
          function buckets_column (line 98) | def buckets_column
          function buckets_keys (line 103) | def buckets_keys

FILE: lib/torque/postgresql/relation/distinct_on.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Relation (line 5) | module Relation
        type DistinctOn (line 6) | module DistinctOn
          function distinct_on_values (line 9) | def distinct_on_values
          function distinct_on_values= (line 13) | def distinct_on_values=(value)
          function distinct_on (line 29) | def distinct_on(*value)
          function distinct_on! (line 34) | def distinct_on!(*value)
          function build_arel (line 42) | def build_arel(*)

FILE: lib/torque/postgresql/relation/inheritance.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Relation (line 5) | module Relation
        type Inheritance (line 6) | module Inheritance
          function cast_records_values (line 9) | def cast_records_values
          function cast_records_values= (line 13) | def cast_records_values=(value)
          function itself_only_value (line 19) | def itself_only_value
          function itself_only_value= (line 23) | def itself_only_value=(value)
          function itself_only (line 35) | def itself_only
          function itself_only! (line 40) | def itself_only!(*)
          function cast_records (line 51) | def cast_records(*types, **options)
          function cast_records! (line 56) | def cast_records!(*types, **options)
          function build_arel (line 66) | def build_arel(*)
          function build_inheritances (line 74) | def build_inheritances(arel)
          function build_inheritances_joins (line 95) | def build_inheritances_joins(arel, types)
          function build_auto_caster_marker (line 114) | def build_auto_caster_marker(arel, types)
          function regclass (line 119) | def regclass

FILE: lib/torque/postgresql/relation/join_series.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Relation (line 5) | module Relation
        type JoinSeries (line 6) | module JoinSeries
          function build (line 10) | def build(relation, range, with: nil, as: :series, step: nil, ti...
          function validate_build! (line 26) | def validate_build!(range, step)
          function bind_value (line 45) | def bind_value(value)
          function arel_join (line 69) | def arel_join(mode)
          function build_join_on (line 83) | def build_join_on(result, relation, with, cast)
          function join_series (line 101) | def join_series(range, **xargs, &block)
          function join_series! (line 106) | def join_series!(range, **xargs, &block)

FILE: lib/torque/postgresql/relation/merger.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type Relation (line 5) | module Relation
        type Merger (line 6) | module Merger
          function merge (line 8) | def merge # :nodoc:
          function merge_select_extra (line 23) | def merge_select_extra
          function merge_distinct_on (line 29) | def merge_distinct_on
          function merge_auxiliary_statements (line 37) | def merge_auxiliary_statements
          function merge_inheritance (line 50) | def merge_inheritance
          function merge_buckets (line 62) | def merge_buckets

FILE: lib/torque/postgresql/schema_cache.rb
  type Torque (line 7) | module Torque
    type PostgreSQL (line 8) | module PostgreSQL
      type SchemaCache (line 12) | module SchemaCache
        function initialize (line 15) | def initialize(*) # :nodoc:
        function initialize_dup (line 24) | def initialize_dup(*) # :nodoc:
        function encode_with (line 31) | def encode_with(coder) # :nodoc:
        function init_with (line 38) | def init_with(coder) # :nodoc:
        function add (line 45) | def add(connection_or_table_name, table_name = connection_or_table...
        function clear! (line 56) | def clear! # :nodoc:
        function size (line 64) | def size # :nodoc:
        function clear_data_source_cache! (line 72) | def clear_data_source_cache!(connection_or_name, name = connection...
        function marshal_dump (line 79) | def marshal_dump # :nodoc:
        function marshal_load (line 88) | def marshal_load(array) # :nodoc:
        function add_model_name (line 97) | def add_model_name(*args)
        function dependencies (line 105) | def dependencies(source, table_name = source)
        function associations (line 112) | def associations(source, table_name = source)
        function lookup_model (line 119) | def lookup_model(*args, **xargs)
        function reload_inheritance_data! (line 127) | def reload_inheritance_data!(source)
        function generate_associations (line 139) | def generate_associations
        function add_all (line 144) | def add_all(source = nil)

FILE: lib/torque/postgresql/schema_cache/bound_schema_reflection.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type BoundSchemaReflection (line 5) | module BoundSchemaReflection
        function add_model_name (line 6) | def add_model_name(table_name, model)
        function dependencies (line 11) | def dependencies(table_name)
        function associations (line 16) | def associations(table_name)
        function lookup_model (line 21) | def lookup_model(table_name, scoped_class = '')

FILE: lib/torque/postgresql/schema_cache/inheritance.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type SchemaCache (line 5) | module SchemaCache
        type Inheritance (line 6) | module Inheritance
          function lookup_model (line 9) | def lookup_model(table_name, scoped_class = '', source_to_model:)
          function find_model (line 47) | def find_model(max_name, table_name, scope = Object)
          function generate_associations (line 80) | def generate_associations(inheritance_dependencies)
          function prepare_irregular_models (line 107) | def prepare_irregular_models(data_sources)

FILE: lib/torque/postgresql/schema_cache/schema_reflection.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type SchemaReflection (line 5) | module SchemaReflection
        function add_model_name (line 6) | def add_model_name(source, table_name, model)
        function dependencies (line 10) | def dependencies(source, table_name)
        function associations (line 14) | def associations(source, table_name)
        function lookup_model (line 18) | def lookup_model(source, table_name, scoped_class)

FILE: lib/torque/postgresql/table_name.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class TableName (line 5) | class TableName < Delegator
        method initialize (line 6) | def initialize(klass, table_name)
        method schema (line 11) | def schema
        method to_s (line 20) | def to_s
        method == (line 26) | def ==(other)
        method __setobj__ (line 30) | def __setobj__(value)
        method search_path_schemes (line 36) | def search_path_schemes

FILE: lib/torque/postgresql/version.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL

FILE: lib/torque/postgresql/versioned_commands.rb
  type Torque (line 8) | module Torque
    type PostgreSQL (line 9) | module PostgreSQL
      type VersionedCommands (line 15) | module VersionedCommands
        function valid_type? (line 21) | def valid_type?(type)
        function validate! (line 26) | def validate!(type, content, name)
        function fetch_command (line 33) | def fetch_command(dirs, type, name, version)
        function filename_regexp (line 50) | def filename_regexp
        function validate_function! (line 68) | def validate_function!(content, name)
        function validate_type! (line 90) | def validate_type!(content, name)
        function validate_view! (line 121) | def validate_view!(content, name)

FILE: lib/torque/postgresql/versioned_commands/command_migration.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type VersionedCommands (line 5) | module VersionedCommands
        type Migration (line 6) | module Migration
          function initialize (line 7) | def initialize(*args)
          function migrate (line 13) | def migrate(direction)
          function exec_migration (line 19) | def exec_migration(conn, direction)
          function announce (line 28) | def announce(message)
          function description_for (line 46) | def description_for(direction)
          function execute (line 59) | def execute(command)
        function initialize (line 68) | def initialize(filename, *args)
        function name (line 74) | def name
        function disable_ddl_transaction (line 79) | def disable_ddl_transaction
        function migrate (line 84) | def migrate(direction)
        function up (line 94) | def up
        function down (line 101) | def down
        function drop (line 109) | def drop
        function drop_function (line 118) | def drop_function
        function drop_type (line 129) | def drop_type
        function drop_view (line 135) | def drop_view

FILE: lib/torque/postgresql/versioned_commands/generator.rb
  type Torque (line 6) | module Torque
    type PostgreSQL (line 7) | module PostgreSQL
      type VersionedCommands (line 8) | module VersionedCommands
        type Generator (line 9) | module Generator
          function included (line 14) | def self.included(base)
          function type (line 32) | def type
          function create_migration_file (line 36) | def create_migration_file
          function count_object_entries (line 45) | def count_object_entries
          function validate_file_name! (line 49) | def validate_file_name!

FILE: lib/torque/postgresql/versioned_commands/migration_context.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      class IllegalCommandTypeError (line 5) | class IllegalCommandTypeError < ActiveRecord::MigrationError
        method initialize (line 6) | def initialize(file)
      type VersionedCommands (line 16) | module VersionedCommands
        type MigrationContext (line 17) | module MigrationContext
          function migrations (line 21) | def migrations
          function migrations_status (line 38) | def migrations_status
          function migration_commands (line 57) | def migration_commands
          function running_for_pg? (line 64) | def running_for_pg?
          function command_files (line 69) | def command_files
          function parse_command_filename (line 75) | def parse_command_filename(filename)

FILE: lib/torque/postgresql/versioned_commands/migrator.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type VersionedCommands (line 5) | module VersionedCommands
        type Migrator (line 6) | module Migrator
          function execute_migration_in_transaction (line 7) | def execute_migration_in_transaction(migration)
          function record_version_state_after_migrating (line 14) | def record_version_state_after_migrating(version)
          function versioned_command? (line 31) | def versioned_command?(migration)

FILE: lib/torque/postgresql/versioned_commands/schema_table.rb
  type Torque (line 3) | module Torque
    type PostgreSQL (line 4) | module PostgreSQL
      type VersionedCommands (line 5) | module VersionedCommands
        class SchemaTable (line 6) | class SchemaTable
          method initialize (line 9) | def initialize(pool)
          method create_version (line 14) | def create_version(command)
          method delete_version (line 27) | def delete_version(command)
          method primary_key (line 36) | def primary_key
          method name (line 40) | def name
          method table_name (line 44) | def table_name
          method create_table (line 52) | def create_table
          method drop_table (line 64) | def drop_table
          method count (line 70) | def count
          method table_exists? (line 81) | def table_exists?
          method versions_of (line 85) | def versions_of(type)

FILE: spec/initialize.rb
  type Torque (line 24) | module Torque
    type PostgreSQL (line 25) | module PostgreSQL

FILE: spec/mocks/cache_query.rb
  type Mocks (line 1) | module Mocks
    type CacheQuery (line 2) | module CacheQuery
      function get_last_executed_query (line 3) | def get_last_executed_query(&block)
      function get_query_with_binds (line 18) | def get_query_with_binds(&block)

FILE: spec/mocks/create_table.rb
  type Mocks (line 1) | module Mocks
    type CreateTable (line 2) | module CreateTable
      function mock_create_table (line 3) | def mock_create_table

FILE: spec/models/activity.rb
  class Activity (line 1) | class Activity < ActiveRecord::Base

FILE: spec/models/activity_book.rb
  class ActivityBook (line 3) | class ActivityBook < Activity

FILE: spec/models/activity_post.rb
  class ActivityPost (line 3) | class ActivityPost < Activity

FILE: spec/models/activity_post/sample.rb
  class ActivityPost (line 1) | class ActivityPost < Activity
    class Sample (line 2) | class Sample < ActivityPost

FILE: spec/models/author.rb
  class Author (line 1) | class Author < ActiveRecord::Base

FILE: spec/models/author_journalist.rb
  class AuthorJournalist (line 3) | class AuthorJournalist < Author

FILE: spec/models/category.rb
  class Category (line 1) | class Category< ActiveRecord::Base

FILE: spec/models/comment.rb
  class Comment (line 1) | class Comment < ActiveRecord::Base

FILE: spec/models/course.rb
  class Course (line 1) | class Course < ActiveRecord::Base

FILE: spec/models/geometry.rb
  class Geometry (line 1) | class Geometry < ActiveRecord::Base

FILE: spec/models/guest_comment.rb
  class GuestComment (line 3) | class GuestComment < Comment

FILE: spec/models/internal/user.rb
  type Internal (line 1) | module Internal
    class User (line 2) | class User < ActiveRecord::Base

FILE: spec/models/item.rb
  class Item (line 1) | class Item < ActiveRecord::Base

FILE: spec/models/post.rb
  class Post (line 1) | class Post < ActiveRecord::Base

FILE: spec/models/question.rb
  class Question (line 1) | class Question < ActiveRecord::Base

FILE: spec/models/question_select.rb
  class QuestionSelect (line 3) | class QuestionSelect < Question

FILE: spec/models/tag.rb
  class Tag (line 1) | class Tag < ActiveRecord::Base

FILE: spec/models/text.rb
  class Text (line 1) | class Text < ActiveRecord::Base

FILE: spec/models/time_keeper.rb
  class TimeKeeper (line 1) | class TimeKeeper < ActiveRecord::Base

FILE: spec/models/user.rb
  class User (line 1) | class User < ActiveRecord::Base

FILE: spec/models/video.rb
  class Video (line 1) | class Video < ActiveRecord::Base

FILE: spec/tests/enum_set_spec.rb
  function decorate (line 8) | def decorate(model, field, options = {})

FILE: spec/tests/enum_spec.rb
  function decorate (line 8) | def decorate(model, field, options = {})

FILE: spec/tests/period_spec.rb
  function decorate (line 22) | def decorate(model, field, options = {})

FILE: spec/tests/relation_spec.rb
  function attribute (line 16) | def attribute(relation, name)

FILE: spec/tests/versioned_commands_spec.rb
  function migration (line 432) | def migration(command)