Module: Mongoid::Tasks::Database

Extended by:
Database
Included in:
Database
Defined in:
build/mongoid-8.1/lib/mongoid/tasks/database.rb

Instance Method Summary collapse

Instance Method Details

#create_collections(models = ::Mongoid.models, force: false) ⇒ Object

Create collections for each model given the provided globs and the class is not embedded.

Parameters:

  • models. (Array<Mongoid::Document>) —

    Array of document classes for which collections should be created. Defaulted to all document classes in the application.

  • force (true | false) (defaults to: false) —

    If true, the method will drop existing collections before creating new ones. If false, the method will create only new collection (that do not exist in the database).



17
18
19
20
21
22
23
24
25
26
 
# File 'build/mongoid-8.1/lib/mongoid/tasks/database.rb', line 17

def create_collections(models = ::Mongoid.models, force: false)
  models.each do |model|
    if !model.embedded? || model.cyclic?
      model.create_collection(force: force)
      logger.info("MONGOID: Created collection for #{model}:")
    else
      logger.info("MONGOID: collection options ignored on: #{model}, please define in the root model.")
    end
  end
end

#create_indexes(models = ::Mongoid.models) ⇒ Array<Class>

Create indexes for each model given the provided globs and the class is not embedded.

Examples:

Create all the indexes.

Mongoid::Tasks::Database.create_indexes

Returns:

  • (Array<Class>) —

    The indexed models.



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'build/mongoid-8.1/lib/mongoid/tasks/database.rb', line 35

def create_indexes(models = ::Mongoid.models)
  models.each do |model|
    next if model.index_specifications.empty?
    if !model.embedded? || model.cyclic?
      model.create_indexes
      logger.info("MONGOID: Created indexes on #{model}:")
      model.index_specifications.each do |spec|
        logger.info("MONGOID: Index: #{spec.key}, Options: #{spec.options}")
      end
      model
    else
      logger.info("MONGOID: Index ignored on: #{model}, please define in the root model.")
      nil
    end
  end.compact
end

#remove_indexes(models = ::Mongoid.models) ⇒ Array<Class>

Remove indexes for each model given the provided globs and the class is not embedded.

Examples:

Remove all the indexes.

Mongoid::Tasks::Database.remove_indexes

Returns:

  • (Array<Class>) —

    The un-indexed models.



112
113
114
115
116
117
118
119
120
121
122
 
# File 'build/mongoid-8.1/lib/mongoid/tasks/database.rb', line 112

def remove_indexes(models = ::Mongoid.models)
  models.each do |model|
    next if model.embedded?
    begin
      model.remove_indexes
    rescue Mongo::Error::OperationFailure
      next
    end
    model
  end.compact
end

#remove_undefined_indexes(models = ::Mongoid.models) ⇒ Hash{Class => Array(Hash)}

Remove indexes that exist in the database but aren’t specified on the models.

Examples:

Remove undefined indexes.

Mongoid::Tasks::Database.remove_undefined_indexes

Returns:

  • (Hash{Class => Array(Hash)}) —

    The list of indexes that were removed by model.



91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'build/mongoid-8.1/lib/mongoid/tasks/database.rb', line 91

def remove_undefined_indexes(models = ::Mongoid.models)
  undefined_indexes(models).each do |model, indexes|
    indexes.each do |index|
      key = index['key'].symbolize_keys
      collection = model.collection
      collection.indexes(session: model.send(:_session)).drop_one(key)
      logger.info(
        "MONGOID: Removed index '#{index['name']}' on collection " +
        "'#{collection.name}' in database '#{collection.database.name}'."
      )
    end
  end
end

#shard_collections(models = ::Mongoid.models) ⇒ Array<Class>

Shard collections for models that declare shard keys.

Returns the model classes that have had their collections sharded, including model classes whose collections had already been sharded prior to the invocation of this method.

Examples:

Shard all collections

Mongoid::Tasks::Database.shard_collections

Returns:

  • (Array<Class>) —

    The sharded models



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'build/mongoid-8.1/lib/mongoid/tasks/database.rb', line 134

def shard_collections(models = ::Mongoid.models)
  models.map do |model|
    next if model.shard_config.nil?

    if model.embedded? && !model.cyclic?
      logger.warn("MONGOID: #{model} has shard config but is embedded")
      next
    end

    unless model.collection.cluster.sharded?
      logger.warn("MONGOID: #{model} has shard config but is not persisted in a sharded cluster: #{model.collection.cluster.summary}")
      next
    end

    # Database of the collection must exist in order to run collStats.
    # Depending on server version, the collection itself must also
    # exist.
    # MongoDB does not have a command to create the database; the best
    # approximation of it is to create the collection we want.
    # On older servers, creating a collection that already exists is
    # an error.
    # Additionally, 3.6 and potentially older servers do not provide
    # the error code when they are asked to collStats a non-existent
    # collection (https://jira.mongodb.org/browse/SERVER-50070).
    begin
      stats = model.collection.database.command(collStats: model.collection.name).first
    rescue Mongo::Error::OperationFailure => exc
      # Code 26 is database does not exist.
      # Code 8 is collection does not exist, as of 4.0.
      # On 3.6 and earlier match the text of exception message.
      if exc.code == 26 || exc.code == 8 ||
        exc.code.nil? && exc.message =~ /not found/
      then
        model.collection.create

        stats = model.collection.database.command(collStats: model.collection.name).first
      else
        raise
      end
    end

    stats = model.collection.database.command(collStats: model.collection.name).first
    if stats[:sharded]
      logger.info("MONGOID: #{model.collection.namespace} is already sharded for #{model}")
      next model
    end

    admin_db = model.collection.client.use(:admin).database

    begin
      admin_db.command(enableSharding: model.collection.database.name)
    rescue Mongo::Error::OperationFailure => exc
      # Server 2.6 fails if sharding is already enabled
      if exc.code == 23 || exc.code.nil? && exc.message =~ /already enabled/
        # Nothing
      else
        raise
      end
    end

    begin
      admin_db.command(shardCollection: model.collection.namespace, **model.shard_config)
    rescue Mongo::Error::OperationFailure => e
      logger.error("MONGOID: Failed to shard collection #{model.collection.namespace} for #{model}: #{e.class}: #{e}")
      next
    end

    logger.info("MONGOID: Sharded collection #{model.collection.namespace} for #{model}")

    model
  end.compact
end

#undefined_indexes(models = ::Mongoid.models) ⇒ Array<Hash>

Return the list of indexes by model that exist in the database but aren’t specified on the models.

Examples:

Return the list of unused indexes.

Mongoid::Tasks::Database.undefined_indexes

Returns:

  • (Array<Hash>) —

    The list of undefined indexes by model.



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'build/mongoid-8.1/lib/mongoid/tasks/database.rb', line 59

def undefined_indexes(models = ::Mongoid.models)
  undefined_by_model = {}

  models.each do |model|
    unless model.embedded?
      begin
        model.collection.indexes(session: model.send(:_session)).each do |index|
          # ignore default index
          unless index['name'] == '_id_'
            key = index['key'].symbolize_keys
            spec = model.index_specification(key, index['name'])
            unless spec
              # index not specified
              undefined_by_model[model] ||= []
              undefined_by_model[model] << index
            end
          end
        end
      rescue Mongo::Error::OperationFailure; end
    end
  end

  undefined_by_model
end