golangÔ´Âë·ÖÎö£ºboltdb£¨2£©

// Options represents the options that can be set when opening a database.
type Options struct {
  // Timeout is the amount of time to wait to obtain a file lock.
  // When set to zero it will wait indefinitely. This option is only
  // available on Darwin and Linux.
  Timeout time.Duration


  // Sets the DB.NoGrowSync flag before memory mapping the file.
  NoGrowSync bool


  // Open database in read-only mode. Uses flock(..., LOCK_SH |LOCK_NB) to
  // grab a shared lock (UNIX).
  ReadOnly bool


  // Sets the DB.MmapFlags flag before memory mapping the file.
  MmapFlags int


  // InitialMmapSize is the initial mmap size of the database
  // in bytes. Read transactions won't block write transaction
  // if the InitialMmapSize is large enough to hold database mmap
  // size. (See DB.Begin for more information)
  //
  // If <=0, the initial map size is 0.
  // If initialMmapSize is smaller than the previous database size,
  // it takes no effect.
  InitialMmapSize int
}

// DB represents a collection of buckets persisted to a file on disk.
// All data access is performed through transactions which can be obtained through the DB.
// All the functions on DB will return a ErrDatabaseNotOpen if accessed before Open() is called.
type DB struct {
  // When enabled, the database will perform a Check() after every commit.
  // A panic is issued if the database is in an inconsistent state. This
  // flag has a large performance impact so it should only be used for
  // debugging purposes.
  StrictMode bool


  // Setting the NoSync flag will cause the database to skip fsync()
  // calls after each commit. This can be useful when bulk loading data
  // into a database and you can restart the bulk load in the event of
  // a system failure or database corruption. Do not set this flag for
  // normal use.
  //
  // If the package global IgnoreNoSync constant is true, this value is
  // ignored.  See the comment on that constant for more details.
  //
  // THIS IS UNSAFE. PLEASE USE WITH CAUTION.
  NoSync bool


  // When true, skips the truncate call when growing the database.
  // Setting this to true is only safe on non-ext3/ext4 systems.
  // Skipping truncation avoids preallocation of hard drive space and
  // bypasses a truncate() and fsync() syscall on remapping.
  //
  // https://github.com/boltdb/bolt/issues/284
  NoGrowSync bool


  // If you want to read the entire database fast, you can set MmapFlag to
  // syscall.MAP_POPULATE on Linux 2.6.23+ for sequential read-ahead.
  MmapFlags int


  // MaxBatchSize is the maximum size of a batch. Default value is
  // copied from DefaultMaxBatchSize in Open.
  //
  // If <=0, disables batching.
  //
  // Do not change concurrently with calls to Batch.
  MaxBatchSize int


  // MaxBatchDelay is the maximum delay before a batch starts.
  // Default value is copied from DefaultMaxBatchDelay in Open.
  //
  // If <=0, effectively disables batching.
  //
  // Do not change concurrently with calls to Batch.
  MaxBatchDelay time.Duration


  // AllocSize is the amount of space allocated when the database
  // needs to create new pages. This is done to amortize the cost
  // of truncate() and fsync() when growing the data file.
  AllocSize int


  path     string
  file     *os.File
  lockfile *os.File // windows only
  dataref  []byte   // mmap'ed readonly, write throws SEGV
  data     *[maxMapSize]byte
  datasz   int
  filesz   int // current on disk file size
  meta0    *meta
  meta1    *meta
  pageSize int
  opened   bool
  rwtx     *Tx
  txs      []*Tx
  freelist *freelist
  stats    Stats


  pagePool sync.Pool


  batchMu sync.Mutex
  batch   *batch


  rwlock   sync.Mutex   // Allows only one writer at a time.
  metalock sync.Mutex   // Protects meta page access.
  mmaplock sync.RWMutex // Protects mmap access during remapping.
  statlock sync.RWMutex // Protects stats access.


  ops struct {
    writeAt func(b []byte, off int64) (n int, err error)
  }


  // Read only mode.
  // When true, Update() and Begin(true) return ErrDatabaseReadOnly immediately.
  readOnly bool
}

meta0    *meta
  meta1    *meta
  pageSize int
  opened   bool
  rwtx     *Tx
  txs      []*Tx
  freelist *freelist

  batchMu sync.Mutex
  batch   *batch

  rwlock   sync.Mutex   // Allows only one writer at a time.
  metalock sync.Mutex   // Protects meta page access.
  mmaplock sync.RWMutex // Protects mmap access during remapping.
  statlock sync.RWMutex // Protects stats access.

func Open(path string, mode os.FileMode, options *Options) (*DB, error) {
  var db = &DB{opened: true}
          if db.file, err = os.OpenFile(db.path, flag|os.O_CREATE, mode); err != nil {
    _ = db.close()
          if err := flock(db, mode, !db.readOnly, options.Timeout); err != nil {
    _ = db.close()
        if info, err := db.file.Stat(); err != nil {
          } else if info.Size() == 0 {
    // Initialize new files with meta pages.
    if err := db.init(); err != nil {
        var buf [0x1000]byte
    if _, err := db.file.ReadAt(buf[:], 0); err == nil {
      m := db.pageInBuffer(buf[:], 0).meta()
      if err := m.validate(); err != nil {
        db.pageSize = os.Getpagesize()
          db.pagePool = sync.Pool{
    New: func() interface{} {
      return make([]byte, db.pageSize)
    },
  }
        if err := db.mmap(options.InitialMmapSize); err != nil {
    _ = db.close()
          db.freelist = newFreelist()
  db.freelist.read(db.page(db.meta().freelist))
      // pageInBuffer retrieves a page reference from a given byte array based on the current page size.

func (db *DB) pageInBuffer(b []byte, id pgid) *page {
  return (*page)(unsafe.Pointer(&b[id*pgid(db.pageSize)]))
}

func (m *meta) validate() error {
  if m.magic != magic {
    return ErrInvalid
  } else if m.version != version {
    return ErrVersionMismatch
  } else if m.checksum != 0 && m.checksum != m.sum64() {
    return ErrChecksum

      // mmap opens the underlying memory-mapped file and initializes the meta references.
// minsz is the minimum size that the new mmap can be.
func (db *DB) mmap(minsz int) error {
  db.mmaplock.Lock()
  defer db.mmaplock.Unlock()
        info, err := db.file.Stat()
        var size = int(info.Size())
        size, err = db.mmapSize(size)
          // Dereference all mmap references before unmapping.
  if db.rwtx != nil {
    db.rwtx.root.dereference()
  }
          // Unmap existing data before continuing.
  if err := db.munmap(); err != nil {
    return err
  }
          // Memory-map the data file as a byte slice.
  if err := mmap(db, size); err != nil {
    return err
  }
          // Save references to the meta pages.
  db.meta0 = db.page(0).meta()
  db.meta1 = db.page(1).meta()
          err0 := db.meta0.validate()
  err1 := db.meta1.validate()

    // mmapSize determines the appropriate size for the mmap given the current size
// of the database. The minimum size is 32KB and doubles until it reaches 1GB.
// Returns an error if the new mmap size is greater than the max allowed.
func (db *DB) mmapSize(size int) (int, error) {
          // Double the size from 32KB until 1GB.
  for i := uint(15); i <= 30; i++ {
    if size <= 1<<i {
      return 1 << i, nil
    }
  }

    // munmap unmaps the data file from memory.
func (db *DB) munmap() error {
  if err := munmap(db); err != nil {

func (db *DB) page(id pgid) *page {
  pos := id * pgid(db.pageSize)
  return (*page)(unsafe.Pointer(&db.data[pos]))
}

func flock(db *DB, mode os.FileMode, exclusive bool, timeout time.Duration) error {
        for {
          } else if timeout > 0 && time.Since(t) > timeout {
      return ErrTimeout
          flag := syscall.LOCK_SH
    if exclusive {
      flag = syscall.LOCK_EX
    }
          err := syscall.Flock(int(db.file.Fd()), flag|syscall.LOCK_NB)
    if err == nil {
      return nil
    } else if err != syscall.EWOULDBLOCK {
      return err
    }
          time.Sleep(50 * time.Millisecond)

func munmap(db *DB) error {
  // Ignore the unmap if we have no mapped data.
  if db.dataref == nil {
    return nil
  }


  // Unmap using the original byte slice.
  err := syscall.Munmap(db.dataref)  

// mmap memory maps a DB's data file.
func mmap(db *DB, sz int) error {
        b, err := syscall.Mmap(int(db.file.Fd()), 0, sz, syscall.PROT_READ, syscall.MAP_SHARED|db.MmapFlags)
        if err := madvise(b, syscall.MADV_RANDOM); err != nil {

func madvise(b []byte, advice int) (err error) {
  _, _, e1 := syscall.Syscall(syscall.SYS_MADVISE, uintptr(unsafe.Pointer(&b[0])), uintptr(len(b)), uintptr(advice))

func (p *page) meta() *meta {
  return (*meta)(unsafe.Pointer(&p.ptr))
}