storage

package
v1.9.9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 3, 2026 License: MIT Imports: 15 Imported by: 0

README

Storage Layer

存储层是sfsDb数据库的核心组件，负责数据的持久化存储和检索。该层采用了模块化设计，支持多种存储引擎，包括LevelDB、RocksDB和ToplingDB。

目录结构

storage/
├── kv.go            # KV存储接口定义
├── leveldb.go       # LevelDB存储引擎实现
├── rocksdb.go       # RocksDB存储引擎实现
├── toplingdb.go     # ToplingDB存储引擎实现
└── README.md        # 存储层文档

核心组件

1. KV存储接口 (kv.go)

定义了存储层的核心接口，包括：

  • Store：KV存储的主要接口，提供数据的增删改查、批量操作、迭代器和快照功能
  • Batch：批量操作接口，支持批量Put和Delete操作
  • Iterator：迭代器接口，支持顺序遍历数据
  • Snapshot：快照接口，提供一致读功能
2. LevelDB实现 (leveldb.go)

基于LevelDB的存储引擎实现，特点：

  • 高效的键值存储
  • 支持范围查询
  • 支持快照功能
  • 线程安全的读取操作
  • 批量操作支持
3. RocksDB实现 (rocksdb.go)

基于RocksDB的存储引擎实现，特点：

  • 高性能的键值存储
  • 支持列族（Column Families）
  • 支持多种压缩算法
  • 支持快照功能
  • 批量操作支持
  • 可配置的缓存和内存管理
4. ToplingDB实现 (toplingdb.go)

基于ToplingDB的存储引擎实现，特点：

  • 超高性能的键值存储
  • 支持分布式部署
  • 支持多种索引类型
  • 支持快照功能
  • 批量操作支持
  • 自适应的压缩算法

接口设计

Store接口
type Store interface {
    // Get 获取指定key的值
    Get(key []byte) ([]byte, error)

    // Put 设置key-value对
    Put(key []byte, value []byte) error

    // Delete 删除指定key
    Delete(key []byte) error

    // Batch 创建批量操作对象
    Batch() Batch

    // Iterator 创建迭代器
    Iterator(para ...[]byte) Iterator

    // Snapshot 创建快照
    Snapshot() (Snapshot, error)

    // Close 关闭存储
    Close() error
}
Batch接口
type Batch interface {
    // Put 添加put操作
    Put(key []byte, value []byte)

    // Delete 添加delete操作
    Delete(key []byte)

    // Commit 提交批量操作
    Commit() error
}
Iterator接口
type Iterator interface {
    // First 移动到第一个元素
    First() bool

    // Last 移动到最后一个元素
    Last() bool

    // Seek 移动到大于等于指定key的位置
    Seek(key []byte) bool

    // Next 移动到下一个元素
    Next() bool

    // Prev 移动到前一个元素
    Prev() bool

    // Key 获取当前元素的key
    Key() []byte

    // Value 获取当前元素的value
    Value() []byte

    // Valid 检查迭代器是否有效
    Valid() bool

    // Release 释放迭代器资源
    Release()
}
Snapshot接口
type Snapshot interface {
    // Get 从快照中获取指定key的值
    Get(key []byte) ([]byte, error)

    // Iterator 从快照中创建迭代器
    Iterator(para ...[]byte) Iterator

    // Release 释放快照资源
    Release() error
}

使用示例

基本使用
// 导入存储层包
import "github.com/liaoran123/sfsDb/storage"

// 创建存储实例
config := storage.StoreConfig{Path: "./test_db"}
store, err := storage.NewStore(config)
if err != nil {
    // 处理错误
}
defer store.Close()

// 写入数据
err = store.Put([]byte("key1"), []byte("value1"))
if err != nil {
    // 处理错误
}

// 读取数据
value, err := store.Get([]byte("key1"))
if err != nil {
    // 处理错误
}

// 删除数据
err = store.Delete([]byte("key1"))
if err != nil {
    // 处理错误
}
批量操作
// 创建批量操作对象
batch := store.Batch()

// 添加操作
batch.Put([]byte("key1"), []byte("value1"))
batch.Put([]byte("key2"), []byte("value2"))
batch.Delete([]byte("key3"))

// 提交批量操作
err = batch.Commit()
if err != nil {
    // 处理错误
}
使用迭代器
// 创建迭代器
iter := store.Iterator()
defer iter.Release()

// 遍历所有数据
for iter.First(); iter.Valid(); iter.Next() {
    key := iter.Key()
    value := iter.Value()
    // 处理数据
}

// 前缀扫描
iter = store.Iterator([]byte("prefix"))
defer iter.Release()

// 范围扫描
iter = store.Iterator([]byte("start"), []byte("end"))
defer iter.Release()
使用快照
// 创建快照
snapshot, err := store.Snapshot()
if err != nil {
    // 处理错误
}
defer snapshot.Release()

// 从快照中读取数据
value, err := snapshot.Get([]byte("key"))
if err != nil {
    // 处理错误
}

// 从快照中创建迭代器
iter := snapshot.Iterator()
defer iter.Release()
使用外部存储实例

sfsDb 支持使用外部实现的 Store 实例，只需通过 SetStore 函数设置即可：

// 导入存储层包
import "github.com/liaoran123/sfsDb/storage"

// 创建自定义存储实例
customStore := NewCustomStore()

// 设置外部存储实例
storage.SetStore(customStore)

// 现在整个 sfsdb 项目都会使用这个自定义存储实例
// 例如，BackupDb 等函数会自动使用这个实例

// 注意：使用外部存储实例时，需要自行管理其生命周期
// 确保在不再使用时正确关闭存储实例
// customStore.Close()

使用场景：

  • 集成第三方存储实现
  • 为特定场景定制存储逻辑
  • 在测试中使用内存存储或模拟存储
  • 实现特殊的存储功能，如加密、压缩等

支持的存储引擎

存储引擎 特点 适用场景
LevelDB 轻量级，性能稳定 小规模数据，对性能要求不高的场景
RocksDB 高性能，功能丰富 中等规模数据，对性能要求较高的场景
ToplingDB 超高性能，分布式支持 大规模数据，高并发场景

如何添加新的存储引擎

要添加新的存储引擎，只需要实现Store、Batch、Iterator和Snapshot接口即可。

  1. 创建新的引擎实现文件（如newengine.go）
  2. 实现Store接口的所有方法
  3. 实现Batch、Iterator和Snapshot接口
  4. 添加创建新引擎实例的函数

最佳实践

  1. 关闭资源：使用完存储实例、迭代器和快照后，一定要调用Close()或Release()方法释放资源
  2. 批量操作：对于大量的写操作，使用批量操作可以提高性能
  3. 使用迭代器：对于范围查询，使用迭代器比多次Get操作更高效
  4. 合理使用快照：快照可以提供一致读，但会增加内存使用，使用后及时释放
  5. 选择合适的存储引擎：根据数据规模和性能要求选择合适的存储引擎
  6. 错误处理：妥善处理存储操作返回的错误，避免数据丢失

性能优化

  1. 调整缓存大小：根据可用内存调整存储引擎的缓存大小
  2. 优化压缩算法：根据数据特点选择合适的压缩算法
  3. 使用前缀扫描：对于前缀查询，使用前缀扫描比全表扫描更高效
  4. 批量提交：合并多个小的写操作，减少磁盘IO
  5. 避免频繁创建和销毁迭代器：复用迭代器可以减少资源消耗

监控和调试

  1. 添加日志：在关键操作点添加日志，便于调试和监控
  2. 收集性能指标：收集存储引擎的性能指标，如读写延迟、吞吐量等
  3. 使用存储引擎自带的工具：如LevelDB的ldb工具、RocksDB的rocksdb工具
  4. 定期检查数据完整性：使用校验和等机制检查数据完整性

未来规划

  1. 支持更多存储引擎
  2. 实现分布式存储
  3. 支持数据分片和复制
  4. 实现自动故障恢复
  5. 提供更丰富的监控和调试工具
  6. 优化存储引擎的性能和资源使用

Documentation

Index

Constants

View Source 
const (
	DefaultWriteBuffer             = 64 * 1024 * 1024  // 默认写入缓冲区大小，64MB
	DefaultOpenFilesCacheCapacity  = 200               // 默认打开文件缓存容量，200
	DefaultBlockCacheCapacity      = 128 * 1024 * 1024 // 默认块缓存容量，128MB
	DefaultMaxOpenFiles            = 200               // 默认最大打开文件数
	EmbeddedWriteBuffer            = 2 * 1024 * 1024   // 嵌入式场景写入缓冲区大小，2MB
	EmbeddedOpenFilesCacheCapacity = 10                // 嵌入式场景打开文件缓存容量，10
	EmbeddedBlockCacheCapacity     = 4 * 1024 * 1024   // 嵌入式场景块缓存容量，4MB
	EmbeddedMaxOpenFiles           = 20                // 嵌入式场景最大打开文件数
	IoTWriteBuffer                 = 4 * 1024 * 1024   // 物联网场景写入缓冲区大小，4MB
	IoTOpenFilesCacheCapacity      = 10                // 物联网场景打开文件缓存容量，10
	IoTBlockCacheCapacity          = 8 * 1024 * 1024   // 物联网场景块缓存容量，8MB
	IoTMaxOpenFiles                = 30                // 物联网场景最大打开文件数
	EdgeWriteBuffer                = 16 * 1024 * 1024  // 边缘场景写入缓冲区大小，16MB
	EdgeOpenFilesCacheCapacity     = 50                // 边缘场景打开文件缓存容量，50
	EdgeBlockCacheCapacity         = 32 * 1024 * 1024  // 边缘场景块缓存容量，32MB
	EdgeMaxOpenFiles               = 100               // 边缘场景最大打开文件数
	GameWriteBuffer                = 64 * 1024 * 1024  // 游戏场景写入缓冲区大小，64MB
	GameOpenFilesCacheCapacity     = 200
	GameBlockCacheCapacity         = 128 * 1024 * 1024 // 游戏场景块缓存容量，128MB
	GameMaxOpenFiles               = 200               // 游戏场景最大打开文件数
	// 极限生存模式（128MB 内存设备）
	ExtremeWriteBuffer            = 2 * 1024 * 1024 // 极限模式写入缓冲区，2MB
	ExtremeOpenFilesCacheCapacity = 5               // 极限模式打开文件缓存，5
	ExtremeBlockCacheCapacity     = 4 * 1024 * 1024 // 极限模式块缓存，4MB
	ExtremeMaxOpenFiles           = 20              // 极限模式最大打开文件数
)
View Source 
const (
	ScenarioEmbedded = "embedded" // 嵌入式场景，默认配置
	ScenarioIoT      = "iot"      // 物联网场景
	ScenarioEdge     = "edge"     // 边缘场景
	ScenarioGame     = "game"     // 游戏场景
	ScenarioDefault  = "default"  // 默认场景
	ScenarioExtreme  = "extreme"  // 极限生存模式（128MB内存设备）
)

Variables

View Source 
var (
	ErrInvalidKeyLength = NewError("invalid key length")
	ErrInvalidAlgorithm = NewError("invalid algorithm")
	ErrEncryptionFailed = NewError("encryption failed")
	ErrDecryptionFailed = NewError("decryption failed")
)

定义加密相关错误

View Source 
var (
	ErrNotFound     = NewError("key not found")
	ErrInvalidKey   = NewError("invalid key")
	ErrInvalidValue = NewError("invalid value")
	ErrStoreClosed  = NewError("store is closed")
)

Error definitions

View Source 
var (
	SetConfig = configManager.SetConfig // 设置配置
	GetConfig = configManager.GetConfig // 获取配置
)
View Source 
var LdbBatchPool = &batchPool{
	pool: sync.Pool{
		New: func() any {
			return new(leveldb.Batch)
		},
	},
}

批处理对象池

View Source 
var LdbSnapshotPool = &snapshotPool{
	pool: sync.Pool{
		New: func() any {
			return new(LevelDBStore)
		},
	},
}

快照对象池

View Source 
var (
	// MaxBatchSize 批处理对象大小阈值（字节），超过此值的批处理对象不会被缓存
	MaxBatchSize = 1024 * 1024 // 1MB
)

批处理对象池配置

Functions

func BackupDb 

func BackupDb(Path string) error

备份数据库

func BatchBackupDb added in v1.9.3 

func BatchBackupDb(Path string, batchSize ...int) error

BatchBackupDb 批量备份数据库 Path: 备份路径 batchSize: 批量操作的大小阈值

func DeriveKey 

func DeriveKey(password, salt []byte, iterations int) ([]byte, error)

DeriveKey 使用PBKDF2派生密钥

func GetMaxBatchSize 

func GetMaxBatchSize() int

GetMaxBatchSize 获取批处理对象大小阈值（字节）

func GetScenarioOptions 

func GetScenarioOptions(scenario string) *opt.Options

获取指定场景的自定义配置，根据GetScenarioConfig返回的配置创建opt.Options

func SetMaxBatchSize 

func SetMaxBatchSize(size int)

SetMaxBatchSize 设置批处理对象大小阈值（字节） size: 批处理对象大小阈值（字节）

Types

type AESGCMEncryptor 

type AESGCMEncryptor struct {
	// contains filtered or unexported fields
}

AESGCMEncryptor AES-256-GCM加密器实现

func NewAESGCMEncryptor 

func NewAESGCMEncryptor(key []byte) (*AESGCMEncryptor, error)

NewAESGCMEncryptor 创建新的AES-GCM加密器

func (*AESGCMEncryptor) Algorithm 

func (e *AESGCMEncryptor) Algorithm() string

Algorithm 返回加密算法

func (*AESGCMEncryptor) Decrypt 

func (e *AESGCMEncryptor) Decrypt(ciphertext []byte) ([]byte, error)

Decrypt 解密数据

func (*AESGCMEncryptor) Encrypt 

func (e *AESGCMEncryptor) Encrypt(plaintext []byte) ([]byte, error)

Encrypt 加密数据

type Batch 

type Batch interface {
	// Put 添加put操作
	Put(key []byte, value []byte)

	// Delete 添加delete操作
	Delete(key []byte)

	// Len 获取批量操作数量
	Len() int

	// Reset 重置批量操作
	Reset()
}

Batch 批量操作接口

type Config 

type Config struct {
	WriteBuffer            int             // 写入缓冲区大小，默认64MB
	OpenFilesCacheCapacity int             // 打开文件缓存容量，默认200
	BlockCacheCapacity     int             // 块缓存容量，默认128MB
	MaxOpenFiles           int             // 最大打开文件数，默认200
	Compression            opt.Compression // 压缩算法，默认Snappy压缩
	FilterBitsPerKey       int             // 布隆过滤器每Key位数，默认10（0表示不启用）
}

func GetScenarioConfig added in v1.9.6 

func GetScenarioConfig(scenario string) Config

获取指定场景的配置

type ConfigManager 

type ConfigManager struct {
	// contains filtered or unexported fields
}

func GetConfigManager 

func GetConfigManager() *ConfigManager

获取配置管理器实例

func (*ConfigManager) GetConfig 

func (cm *ConfigManager) GetConfig() Config

获取配置

func (*ConfigManager) GetOptions 

func (cm *ConfigManager) GetOptions() *opt.Options

自定义配置

func (*ConfigManager) SetConfig 

func (cm *ConfigManager) SetConfig(config Config)

设置配置

type DBManager 

type DBManager struct {
	// contains filtered or unexported fields
}

DBManager 管理数据库实例的创建、打开和关闭

func GetDBManager 

func GetDBManager() *DBManager

GetDBManager 获取数据库管理器实例

func (*DBManager) CloseDB 

func (dm *DBManager) CloseDB() error

CloseDB 关闭数据库

func (*DBManager) GetDB 

func (dm *DBManager) GetDB() Store

GetDB 获取当前数据库实例

func (*DBManager) NewLevelDBStore added in v1.9.6 

func (dm *DBManager) NewLevelDBStore(Path string, opts *opt.Options, encryptConfig ...*EncryptionConfig) (Store, error)

NewLevelDBStore 创建新的LevelDB存储实例

func (*DBManager) OpenDB 

func (dm *DBManager) OpenDB(path string, encryptConfig ...*EncryptionConfig) (Store, error)

OpenDB 打开存储数据库，使用管理器内部的db变量，保证全局唯一实例

func (*DBManager) OpenDBWithScenario added in v1.9.6 

func (dm *DBManager) OpenDBWithScenario(path string, scenario string, encryptConfig ...*EncryptionConfig) (Store, error)

OpenDBWithScenario 根据场景打开存储数据库，使用管理器内部的db变量，保证全局唯一实例

func (*DBManager) SetDB 

func (dm *DBManager) SetDB(store Store)

SetDB 设置数据库实例

type EncryptedStoreWrapper 

type EncryptedStoreWrapper struct {
	// contains filtered or unexported fields
}

EncryptedStoreWrapper 加密存储包装器

func NewEncryptedStoreWrapper 

func NewEncryptedStoreWrapper(underlyingStore Store, config *EncryptionConfig) (*EncryptedStoreWrapper, error)

NewEncryptedStoreWrapper 创建新的加密存储包装器

func (*EncryptedStoreWrapper) Close 

func (es *EncryptedStoreWrapper) Close() error

Close 关闭存储

func (*EncryptedStoreWrapper) Delete 

func (es *EncryptedStoreWrapper) Delete(key []byte) error

Delete 删除指定key

func (*EncryptedStoreWrapper) Get 

func (es *EncryptedStoreWrapper) Get(key []byte) ([]byte, error)

Get 获取并解密数据

func (*EncryptedStoreWrapper) GetBatch 

func (es *EncryptedStoreWrapper) GetBatch() Batch

GetBatch 创建批量操作对象

func (*EncryptedStoreWrapper) GetEncryptionConfig 

func (es *EncryptedStoreWrapper) GetEncryptionConfig() *EncryptionConfig

GetEncryptionConfig 获取加密配置（返回副本，避免外部修改）

func (*EncryptedStoreWrapper) Iterator 

func (es *EncryptedStoreWrapper) Iterator(start, limit []byte) Iterator

Iterator 创建迭代器

func (*EncryptedStoreWrapper) Put 

func (es *EncryptedStoreWrapper) Put(key, value []byte) error

Put 加密存储数据

func (*EncryptedStoreWrapper) ReEncrypt 

func (es *EncryptedStoreWrapper) ReEncrypt(newKey []byte) error

ReEncrypt 重新加密所有数据

func (*EncryptedStoreWrapper) Snapshot 

func (es *EncryptedStoreWrapper) Snapshot() (Snapshot, error)

Snapshot 创建快照

func (*EncryptedStoreWrapper) SwitchToDB 

func (es *EncryptedStoreWrapper) SwitchToDB() error

SwitchToDB 切换到数据库模式

func (*EncryptedStoreWrapper) SwitchToSnapshot 

func (es *EncryptedStoreWrapper) SwitchToSnapshot() error

SwitchToSnapshot 切换到快照模式

func (*EncryptedStoreWrapper) WriteBatch 

func (es *EncryptedStoreWrapper) WriteBatch(batch Batch, writeOpts ...*opt.WriteOptions) error

WriteBatch 执行批量操作

type EncryptionConfig 

type EncryptionConfig struct {
	// 是否启用加密
	Enabled bool `json:"enabled"`

	// 加密算法，默认AES-256-GCM
	Algorithm string `json:"algorithm"`

	// 主密钥，可以是直接的密钥或密码派生
	MasterKey []byte `json:"master_key,omitempty"`

	// 密码，用于派生密钥
	Password string `json:"password,omitempty"`

	// 盐值，用于密码派生
	Salt []byte `json:"salt,omitempty"`

	// 迭代次数，用于密码派生
	Iterations int `json:"iterations,omitempty"`
}

EncryptionConfig 加密配置

type Encryptor 

type Encryptor interface {
	// 加密数据
	Encrypt(plaintext []byte) ([]byte, error)

	// 解密数据
	Decrypt(ciphertext []byte) ([]byte, error)

	// 获取加密算法
	Algorithm() string
}

Encryptor 加密器接口

type Error 

type Error struct {
	// contains filtered or unexported fields
}

Error KV存储错误类型

func NewError 

func NewError(msg string) *Error

NewError 创建新的KV存储错误

func (*Error) Error 

func (e *Error) Error() string

Error 返回错误消息

type FunIter 

type FunIter func(start, limit []byte) Iterator

type FunIter func(start, limit []byte) Iterator

// Iterator 创建迭代器 

func (s *LevelDBStore) Iterator1(slice *util.Range) Iterator {
	return s.ldb.NewIterator(slice, nil)
}

type Iterator 

type Iterator interface {

	// First 移动到第一个元素
	First() bool

	// Last 移动到最后一个元素
	Last() bool

	// Seek 移动到大于等于指定key的位置
	Seek(key []byte) bool

	// Next 移动到下一个元素
	Next() bool

	// Prev 移动到前一个元素
	Prev() bool

	// Key 获取当前元素的key
	Key() []byte

	// Value 获取当前元素的value
	Value() []byte

	// Valid 检查迭代器是否有效
	Valid() bool

	// Release 释放迭代器资源
	Release()
}

Iterator 迭代器接口

type LevelDBGetter 

type LevelDBGetter interface {
	// Get 获取指定key的值
	Get(key []byte, ro *opt.ReadOptions) (value []byte, err error)

	// NewIterator 创建迭代器
	NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator
}

LevelDBGetter 定义LevelDB读取操作的公共接口，适用于DB和Snapshot

type LevelDBStore 

type LevelDBStore struct {
	// contains filtered or unexported fields
}

LevelDBStore LevelDB存储实现，支持快照功能

func (*LevelDBStore) Close 

func (s *LevelDBStore) Close() error

Close 关闭存储

func (*LevelDBStore) Delete 

func (s *LevelDBStore) Delete(key []byte) error

Delete 删除指定key

func (*LevelDBStore) Get 

func (s *LevelDBStore) Get(key []byte) ([]byte, error)

Get 获取指定key的值

func (*LevelDBStore) GetBatch 

func (s *LevelDBStore) GetBatch() Batch

GetBatch 获取批处理操作对象

返回值： 

Batch - 批处理操作对象，可用于执行多个写操作

说明：

  • 从批处理对象池中获取一个批处理对象，实现了对象复用
  • 即使在快照模式下也返回有效的批处理对象
  • 批处理对象的写操作会通过WriteBatch方法使用originalDB执行
  • 如果对象池获取失败，会创建一个新的批处理对象

func (*LevelDBStore) GetDB added in v1.9.3 

func (s *LevelDBStore) GetDB() *leveldb.DB

GetDB 获取底层的 LevelDB 实例 注意：这个方法应该谨慎使用，仅用于需要直接操作 LevelDB 的场景

func (*LevelDBStore) Iterator 

func (s *LevelDBStore) Iterator(start, limit []byte) Iterator

Iterator 创建迭代器

func (*LevelDBStore) Put 

func (s *LevelDBStore) Put(key []byte, value []byte) error

Put 设置key-value对

func (*LevelDBStore) Release 

func (s *LevelDBStore) Release() error

Release 释放快照资源 对于普通数据库实例，Release方法不做任何事情 对于快照实例，Release方法会释放快照资源

func (*LevelDBStore) Snapshot 

func (s *LevelDBStore) Snapshot() (Snapshot, error)

Snapshot 创建快照

func (*LevelDBStore) SwitchToDB 

func (s *LevelDBStore) SwitchToDB() error

SwitchToDB 将当前实例切换回数据库模式 如果当前已是数据库模式，则返回错误 如果当前是快照模式，会先释放快照资源

func (*LevelDBStore) SwitchToSnapshot 

func (s *LevelDBStore) SwitchToSnapshot() error

SwitchToSnapshot 将当前实例切换到快照模式 如果当前已是快照模式，则返回错误

func (*LevelDBStore) WriteBatch 

func (s *LevelDBStore) WriteBatch(batch Batch, writeOpts ...*opt.WriteOptions) error

WriteBatch 执行批量写入操作 batch: 批量操作对象 writeOpts: 可选的写入选项（用于 IoT 等特殊场景）

type Snapshot 

type Snapshot interface {
	// Get 从快照中获取指定key的值
	Get(key []byte) ([]byte, error)

	// Iterator 从快照中创建迭代器
	Iterator(start, limit []byte) Iterator

	// Release 释放快照资源
	Release() error
}

Snapshot 快照接口

type Store 

type Store interface {
	// Get 获取指定key的值
	Get(key []byte) ([]byte, error)

	// Put 设置key-value对
	Put(key []byte, value []byte) error

	// Delete 删除指定key
	Delete(key []byte) error

	// Batch 创建批量操作对象
	GetBatch() Batch

	// WriteBatch 执行批量操作
	WriteBatch(batch Batch, writeOpts ...*opt.WriteOptions) error

	// Iterator 创建迭代器
	//Iterator(slice *util.Range) Iterator
	Iterator(start, limit []byte) Iterator

	// Snapshot 创建快照
	Snapshot() (Snapshot, error)
	// SwitchToSnapshot 切换到数据库模式
	SwitchToSnapshot() error
	// SwitchToDB 切换到数据库模式
	SwitchToDB() error
	// Close 关闭存储
	Close() error
}

Store KV存储接口

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.