namespace_details.h

Go to the documentation of this file.

#pragma once

#include "mongo/base/static_assert.h"
#include "mongo/db/namespace_string.h"
#include "mongo/db/storage/mmap_v1/catalog/index_details.h"
#include "mongo/db/storage/mmap_v1/catalog/namespace.h"
#include "mongo/db/storage/mmap_v1/diskloc.h"

namespace mongo {

class Collection;
class NamespaceIndex;
class OperationContext;

#pragma pack(1)
/* NamespaceDetails : this is the "header" for a collection that has all its details.
   It's in the .ns file and this is a memory mapped region (thus the pack pragma above).
*/
class NamespaceDetails {
public:
    enum { NIndexesMax = 64, NIndexesExtra = 30, NIndexesBase = 10 };

    // deleted lists -- linked lists of deleted records -- are placed in 'buckets' of various
    // sizes so you can look for a deleted record of about the right size. These buckets are
    // split into small and large groups for compatibility with old versions.
    static const int SmallBuckets = 18;
    static const int LargeBuckets = 8;


    /*-------- data fields, as present on disk : */

    DiskLoc firstExtent;
    DiskLoc lastExtent;

    /* NOTE: capped collections v1 override the meaning of deletedList.
             deletedList[0] points to a list of free records (DeletedRecord's) for all extents in
             the capped namespace.
             deletedList[1] points to the last record in the prev extent.  When the "current extent"
             changes, this value is updated.  !deletedList[1].isValid() when this value is not
             yet computed.
    */
    DiskLoc deletedListSmall[SmallBuckets];
    DiskLoc deletedListLegacyGrabBag;  // old implementations put records of multiple sizes here.

    // ofs 168 (8 byte aligned)
    struct Stats {
        // datasize and nrecords MUST Be adjacent code assumes!
        long long datasize;  // this includes padding, but not record headers
        long long nrecords;
    } stats;


    int lastExtentSize;

    int nIndexes;

    // ofs 192
    IndexDetails _indexes[NIndexesBase];

public:
    // ofs 352 (16 byte aligned)
    int isCapped;  // there is wasted space here if I'm right (ERH)

    int maxDocsInCapped;  // max # of objects for a capped table, -1 for inf.

    double paddingFactorOldDoNotUse;
    // ofs 368 (16)
    int systemFlagsOldDoNotUse;  // things that the system sets/cares about

    DiskLoc capExtent;  // the "current" extent we're writing too for a capped collection
    DiskLoc capFirstNewRecord;

    // NamespaceDetails version.  So we can do backward compatibility in the future. See filever.h
    unsigned short _dataFileVersion;
    unsigned short _indexFileVersion;

    unsigned long long multiKeyIndexBits;

    // ofs 400 (16)
    unsigned long long _reservedA;
    long long _extraOffset;  // where the $extra info is located (bytes relative to this)

public:
    int indexBuildsInProgress;  // Number of indexes currently being built

    int userFlags;

    DiskLoc deletedListLarge[LargeBuckets];

    // Think carefully before using this. We need at least 8 bytes reserved to leave room for a
    // DiskLoc pointing to more data (eg in a dummy MmapV1RecordHeader or Extent). There is still
    // _reservedA above, but these are the final two reserved 8-byte regions.
    char _reserved[8];
    /*-------- end data 496 bytes */
public:
    explicit NamespaceDetails(const DiskLoc& loc, bool _capped);

    class Extra {
        long long _next;

    public:
        IndexDetails details[NIndexesExtra];

    private:
        unsigned reserved2;
        unsigned reserved3;
        Extra(const Extra&) {
            verify(false);
        }
        Extra& operator=(const Extra& r) {
            verify(false);
            return *this;
        }

    public:
        Extra() {}
        long ofsFrom(NamespaceDetails* d) {
            return ((char*)this) - ((char*)d);
        }
        void init() {
            memset(this, 0, sizeof(Extra));
        }
        Extra* next(const NamespaceDetails* d) const {
            if (_next == 0)
                return 0;
            return (Extra*)(((char*)d) + _next);
        }
        void setNext(OperationContext* opCtx, long ofs);
        void copy(NamespaceDetails* d, const Extra& e) {
            memcpy(this, &e, sizeof(Extra));
            _next = 0;
        }
    };
    Extra* extra() const {
        if (_extraOffset == 0)
            return 0;
        return (Extra*)(((char*)this) + _extraOffset);
    }
    /* add extra space for indexes when more than 10 */
    Extra* allocExtra(OperationContext* opCtx,
                      StringData ns,
                      NamespaceIndex& ni,
                      int nindexessofar);

    void copyingFrom(OperationContext* opCtx,
                     StringData thisns,
                     NamespaceIndex& ni,
                     NamespaceDetails* src);  // must be called when renaming a NS to fix up extra

public:
    void setMaxCappedDocs(OperationContext* opCtx, long long max);

    enum UserFlags {
        Flag_UsePowerOf2Sizes = 1 << 0,
        Flag_NoPadding = 1 << 1,
    };

    IndexDetails& idx(int idxNo, bool missingExpected = false);
    const IndexDetails& idx(int idxNo, bool missingExpected = false) const;

    class IndexIterator {
    public:
        int pos() {
            return i;
        }  // note this is the next one to come
        bool more() {
            return i < n;
        }
        const IndexDetails& next() {
            return d->idx(i++);
        }

    private:
        friend class NamespaceDetails;
        int i, n;
        const NamespaceDetails* d;
        IndexIterator(const NamespaceDetails* _d, bool includeBackgroundInProgress);
    };

    IndexIterator ii(bool includeBackgroundInProgress = false) const {
        return IndexIterator(this, includeBackgroundInProgress);
    }

    IndexDetails& getNextIndexDetails(OperationContext* opCtx, Collection* collection);

    NamespaceDetails* writingWithoutExtra(OperationContext* opCtx);

    NamespaceDetails* writingWithExtra(OperationContext* opCtx);

    int _catalogFindIndexByName(OperationContext* opCtx,
                                const Collection* coll,
                                StringData name,
                                bool includeBackgroundInProgress) const;

private:
    void swapIndex(OperationContext* opCtx, int a, int b);

    friend class IndexCatalog;
    friend class IndexCatalogEntry;

    void cappedTruncateLastDelUpdate();
    MONGO_STATIC_ASSERT(NIndexesMax <= NIndexesBase + NIndexesExtra * 2);
    MONGO_STATIC_ASSERT(NIndexesMax <= 64);  // multiKey bits
    MONGO_STATIC_ASSERT(sizeof(NamespaceDetails::Extra) == 496);
};  // NamespaceDetails
MONGO_STATIC_ASSERT(sizeof(NamespaceDetails) == 496);
#pragma pack()

}  // namespace mongo