badgerhold

package
v2.0.10 Latest Latest
Warning

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

 Go to latest Published: Jan 11, 2025 License: MIT Imports: 14 Imported by: 0

Documentation

Overview

badgerhold 是一个基于 Badger DB 之上的索引和查询层。它的目的是提供一种简单、持久的 Go 类型存储和检索方法。Badger DB 是一个嵌入式键值存储，而 badgerhold 提供了一个更高级的接口，适用于 Badger 的常见用例。

Go 类型

badgerhold 直接处理 Go 类型。插入数据时，您可以直接传递结构体。当查询数据时，您需要传递一个指向要返回类型的切片的指针。默认情况下，使用 Gob 编码。 您可以在同一个 DB 文件中存储多种不同的类型，并且它们（及其索引）会被分别存储。

示例代码展示了如何插入数据和查询数据： 

err := store.Insert(1234, Item{
	Name:    "Test Name",
	Created: time.Now(),
})

var result []Item

err := store.Find(&result, query)

索引

badgerhold 会自动为结构体中标记为 badgerholdIndex 的字段创建索引。例如： 

type Item struct {
	ID       int
	Name     string
	Category string `badgerholdIndex:"Category"`
	Created  time.Time
}

查询时，第一个指定的字段（如果存在索引）将用作索引。

查询

查询是对一组字段应用的链式条件。例如： 

badgerhold.Where("Name").Eq("John Doe").And("DOB").Lt(time.Now())

这个查询语句表示查找 Name 为 "John Doe" 且 DOB 小于当前时间的记录。

总结

badgerhold 提供了一种高效且易于使用的方法来在 Badger DB 之上进行复杂的查询和数据操作，并自动处理了索引的创建和使用。

Example

Example 函数展示了如何使用 badgerhold 插入数据并查询最近一个小时内创建的指定类别的项。 

// 目的：提供项目功能的示例测试，通常用于生成文档中的示例代码。
// 测试内容：展示如何使用 badgerhold 的基本功能，包括插入、查询、删除等操作。

package main

import (
	"fmt"
	"os"
	"time"

	"github.com/bpfs/defs/v2/badgerhold"
	logging "github.com/dep2p/log"
	"github.com/dgraph-io/badger/v4"
)

var logger = logging.Logger("badgerhold_test")

// Item 结构体表示一个项，其中包含 ID、Category（类别）和 Created（创建时间）。
// Category 字段通过 `badgerholdIndex` 标签在 badgerhold 中建立索引。
type Item struct {
	ID       int       // 项的唯一标识符
	Category string    `badgerholdIndex:"Category"` // 项的类别，使用 badgerholdIndex 建立索引
	Created  time.Time // 项的创建时间
}

// Example 函数展示了如何使用 badgerhold 插入数据并查询最近一个小时内创建的指定类别的项。
func main() {
	// 定义一组待插入的数据
	data := []Item{
		{
			ID:       0,
			Category: "blue",                         // 设置类别为 blue
			Created:  time.Now().Add(-4 * time.Hour), // 设置创建时间为当前时间的 4 小时前
		},
		{
			ID:       1,
			Category: "red",                          // 设置类别为 red
			Created:  time.Now().Add(-3 * time.Hour), // 设置创建时间为当前时间的 3 小时前
		},
		{
			ID:       2,
			Category: "blue",                         // 设置类别为 blue
			Created:  time.Now().Add(-2 * time.Hour), // 设置创建时间为当前时间的 2 小时前
		},
		{
			ID:       3,
			Category: "blue",                            // 设置类别为 blue
			Created:  time.Now().Add(-20 * time.Minute), // 设置创建时间为当前时间的 20 分钟前
		},
	}

	// 创建一个临时目录，用于存储 badgerhold 数据库文件
	dir := tempdir()
	defer os.RemoveAll(dir) // 在函数结束时删除该临时目录

	// 配置 badgerhold 数据库选项
	options := badgerhold.DefaultOptions
	options.Dir = dir                      // 设置数据库目录
	options.ValueDir = dir                 // 设置值存储目录
	store, err := badgerhold.Open(options) // 打开 badgerhold 数据库
	defer store.Close()                    // 在函数结束时关闭数据库

	if err != nil {
		// 如果打开数据库失败，处理错误
		logger.Fatal(err)
	}

	// 在一个事务中插入数据
	err = store.Badger().Update(func(tx *badger.Txn) error {
		for i := range data { // 遍历每个数据项
			err := store.TxInsert(tx, data[i].ID, data[i]) // 将数据插入数据库
			if err != nil {
				return err // 如果插入失败，返回错误
			}
		}
		return nil // 事务成功完成，返回 nil
	})

	if err != nil {
		// 如果插入数据失败，处理错误
		logger.Fatal(err)
	}

	// 查询最近一个小时内创建的类别为 "blue" 的所有项
	var result []Item

	err = store.Find(&result, badgerhold.Where("Category").Eq("blue").And("Created").Ge(time.Now().UTC().Add(-1*time.Hour)))

	if err != nil {
		// 如果查询失败，处理错误
		logger.Fatal(err)
	}

	// 输出查询到的第一个结果的 ID
	fmt.Println("1", result[0].ID)
}

Output:

3

Index

Examples

Constants

View Source 
const (
	// BadgerHoldIndexTag 是用于将字段定义为可索引的 badgerhold 结构体标签
	BadgerHoldIndexTag = "badgerholdIndex"

	// BadgerholdKeyTag 是用于将字段定义为键以用于 Find 查询的结构体标签
	BadgerholdKeyTag = "badgerholdKey"
)
View Source 
const Key = ""

Key 是用于在 badgerhold 中指定查询键的简写，只返回空字符串 例如：Where(badgerhold.Key).Eq("testkey")

Variables

View Source 
var DefaultOptions = Options{
	Options:          badger.DefaultOptions(""),
	Encoder:          DefaultEncode,
	Decoder:          DefaultDecode,
	SequenceBandwith: 100,
}

DefaultOptions 是一组用于打开 BadgerHold 数据库的默认选项 包括 Badger 自己的默认选项

View Source 
var ErrKeyExists = errors.New("该类型的键已存在于badgerhold中")

ErrKeyExists 是在插入已存在的键时返回的错误

View Source 
var ErrNotFound = errors.New("未找到该键对应的数据")

ErrNotFound 在未找到给定键的数据时返回

View Source 
var ErrUniqueExists = errors.New("由于字段的唯一性约束，无法写入该值")

ErrUniqueExists 是在插入违反唯一性约束的值时抛出的错误

Functions

func DefaultDecode 

func DefaultDecode(data []byte, value interface{}) error

DefaultDecode 是 badgerhold 的默认解码函数，使用 Gob 解码 参数:

  • data: []byte 类型，表示要解码的字节数据
  • value: interface{} 类型，表示要解码到的目标值

返回值：

  • error: 如果解码过程中出现错误，则返回错误信息

func DefaultEncode 

func DefaultEncode(value interface{}) ([]byte, error)

DefaultEncode 是 badgerhold 的默认编码函数，使用 Gob 编码 参数:

  • value: interface{} 类型，表示要编码的值

返回值：

  • []byte: 编码后的字节切片
  • error: 如果编码过程中出现错误，则返回错误信息

func NextSequence 

func NextSequence() interface{}

NextSequence 用于创建插入时的顺序键 插入时使用 uint64 作为键 store.Insert(badgerhold.NextSequence(), data)

func Slice 

func Slice(value interface{}) []interface{}

Slice 将任何类型的切片转换为 []interface{}，通过复制切片值，以便可以轻松传递到接受可变参数的查询中。 如果传入的值不是切片，则会触发 panic 参数:

  • value: interface{} 类型，表示要转换的切片

返回值：

  • []interface{}: 转换后的接口切片

Types

type AggregateResult 

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

AggregateResult 允许您访问聚合查询的结果

func (*AggregateResult) Avg 

func (a *AggregateResult) Avg(field string) float64

Avg 返回聚合分组的平均值 如果字段不能转换为 float64，则抛出异常 参数:

  • field: string 类型，表示用于计算平均值的字段名称

返回值：

  • float64: 计算出的平均值

func (*AggregateResult) Count 

func (a *AggregateResult) Count() uint64

Count 返回聚合分组中的记录数量 返回值：

  • uint64: 记录的数量

func (*AggregateResult) Group 

func (a *AggregateResult) Group(result ...interface{})

Group 返回在查询中按字段分组的值 参数:

  • result: interface{} 类型的变长参数，表示用于接收分组结果的变量，必须为指针类型

func (*AggregateResult) Max 

func (a *AggregateResult) Max(field string, result interface{})

Max 返回聚合分组的最大值，使用 Comparer 接口 参数:

  • field: string 类型，表示用于获取最大值的字段名称
  • result: interface{} 类型，表示用于接收最大值的变量，必须为指针类型

func (*AggregateResult) Min 

func (a *AggregateResult) Min(field string, result interface{})

Min 返回聚合分组的最小值，使用 Comparer 接口 参数:

  • field: string 类型，表示用于获取最小值的字段名称
  • result: interface{} 类型，表示用于接收最小值的变量，必须为指针类型

func (*AggregateResult) Reduction 

func (a *AggregateResult) Reduction(result interface{})

Reduction 返回属于 AggregateResult 分组的记录集合 参数:

  • result: interface{} 类型的参数，表示用于接收聚合结果的切片变量，必须为切片指针类型

func (*AggregateResult) Sort 

func (a *AggregateResult) Sort(field string)

Sort 按传入的字段对聚合结果进行升序排序 Sort 方法会自动在调用 Min/Max 函数时被调用，以获取最小值和最大值 参数:

  • field: string 类型，表示用于排序的字段名称，必须以大写字母开头

func (*AggregateResult) Sum 

func (a *AggregateResult) Sum(field string) float64

Sum 返回聚合分组的总和 如果字段不能转换为 float64，则抛出异常 参数:

  • field: string 类型，表示用于计算总和的字段名称

返回值：

  • float64: 计算出的总和

type Comparer 

type Comparer interface {
	Compare(other interface{}) (int, error) // Compare 方法用于比较当前值与另一个值
}

Comparer 接口用于将类型与存储中的编码值进行比较。如果当前值等于 other，结果应该是 0； 如果当前值小于 other，则结果应为 -1；如果当前值大于 other，则结果应为 +1。 如果结构体中的字段没有指定 comparer，则使用默认比较（转换为字符串并比较）。 该接口已经为标准 Go 类型以及更复杂的类型（如 time 和 big）进行了处理。 如果类型无法比较，则返回错误。 实现此接口的具体类型将始终以非指针形式传递。

type Criterion 

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

Criterion 是一个操作符和一个值，字段需要与之匹配

func Where 

func Where(field string) *Criterion

Where 开始一个查询，用于指定 badgerhold 中对象需要匹配的条件 例如： s.Find(badgerhold.Where("FieldName").Eq(value).And("AnotherField").Lt(AnotherValue). Or(badgerhold.Where("FieldName").Eq(anotherValue) 由于 Gobs 只编码导出的字段，如果传入的字段名称首字母为小写，则会触发 panic 参数:

  • field: string 类型，表示字段名称

返回值：

  • *Criterion: 返回创建的条件

func (*Criterion) Contains 

func (c *Criterion) Contains(value interface{}) *Query

Contains 测试当前字段是否为包含传入值的切片 参数:

  • value: interface{} 类型，表示要检查的值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) ContainsAll 

func (c *Criterion) ContainsAll(values ...interface{}) *Query

ContainsAll 测试当前字段是否为包含所有传入值的切片。如果切片中不包含任何一个值，则不匹配 参数:

  • values: 可变参数，表示要检查的多个值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) ContainsAny 

func (c *Criterion) ContainsAny(values ...interface{}) *Query

ContainsAny 测试当前字段是否为包含任意一个传入值的切片。如果切片中包含任何一个值，则匹配 参数:

  • values: 可变参数，表示要检查的多个值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) Eq 

func (c *Criterion) Eq(value interface{}) *Query

Eq 测试当前字段是否等于传入的值 参数:

  • value: interface{} 类型，表示要比较的值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) Ge 

func (c *Criterion) Ge(value interface{}) *Query

Ge 测试当前字段是否大于或等于传入的值 参数:

  • value: interface{} 类型，表示要比较的值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) Gt 

func (c *Criterion) Gt(value interface{}) *Query

Gt 测试当前字段是否大于传入的值 参数:

  • value: interface{} 类型，表示要比较的值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) HasKey 

func (c *Criterion) HasKey(value interface{}) *Query

HasKey 测试字段是否具有与传入值匹配的 map 键 参数:

  • value: interface{} 类型，表示要检查的键值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) HasPrefix 

func (c *Criterion) HasPrefix(prefix string) *Query

HasPrefix 测试字段是否以提供的字符串作为前缀 参数:

  • prefix: string 类型，表示要匹配的前缀

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) HasSuffix 

func (c *Criterion) HasSuffix(suffix string) *Query

HasSuffix 测试字段是否以提供的字符串作为后缀 参数:

  • suffix: string 类型，表示要匹配的后缀

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) In 

func (c *Criterion) In(values ...interface{}) *Query

In 测试当前字段是否是传入的值列表的成员 参数:

  • values: 可变参数，表示要比较的值列表

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) IsNil 

func (c *Criterion) IsNil() *Query

IsNil 测试字段是否等于 nil 返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) Le 

func (c *Criterion) Le(value interface{}) *Query

Le 测试当前字段是否小于或等于传入的值 参数:

  • value: interface{} 类型，表示要比较的值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) Lt 

func (c *Criterion) Lt(value interface{}) *Query

Lt 测试当前字段是否小于传入的值 参数:

  • value: interface{} 类型，表示要比较的值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) MatchFunc 

func (c *Criterion) MatchFunc(match MatchFunc) *Query

MatchFunc 测试一个字段是否与传入的函数匹配 参数:

  • match: MatchFunc 类型，表示要匹配的函数

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) Ne 

func (c *Criterion) Ne(value interface{}) *Query

Ne 测试当前字段是否不等于传入的值 参数:

  • value: interface{} 类型，表示要比较的值

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) RegExp 

func (c *Criterion) RegExp(expression *regexp.Regexp) *Query

RegExp 测试字段是否与正则表达式匹配 字段值将被转换为字符串 (%s) 进行测试 参数:

  • expression: *regexp.Regexp 类型，表示要匹配的正则表达式

返回值：

  • *Query: 返回更新后的查询对象

func (*Criterion) String 

func (c *Criterion) String() string

String 返回条件的字符串表示形式 返回值：

  • string: 条件的字符串表示形式

type DecodeFunc 

type DecodeFunc func(data []byte, value interface{}) error

DecodeFunc 是一个用于从字节解码值的函数类型

type EncodeFunc 

type EncodeFunc func(value interface{}) ([]byte, error)

EncodeFunc 是一个用于将值编码为字节的函数类型

type ErrTypeMismatch 

type ErrTypeMismatch struct {
	Value interface{} // Value 表示其中一个无法比较的值
	Other interface{} // Other 表示另一个无法比较的值
}

ErrTypeMismatch 是在两个类型无法进行比较时抛出的错误类型

func (*ErrTypeMismatch) Error 

func (e *ErrTypeMismatch) Error() string

Error 返回错误的描述信息 返回值：

  • string: 描述无法比较的两个值及其类型的字符串

type Field 

type Field string

Field 允许引用正在比较的结构中的字段

type Index 

type Index struct {
	IndexFunc func(name string, value interface{}) ([]byte, error) // IndexFunc 返回传入值的索引编码字节
	Unique    bool                                                 // Unique 指示索引是否唯一
}

Index 是一个结构体，包含一个返回可索引的编码字节的函数，以及一个标志来指示索引是否唯一

type KeyList 

type KeyList [][]byte

KeyList 是一个唯一的、排序的键（[]byte）的切片，例如索引所指向的内容

type MatchFunc 

type MatchFunc func(ra *RecordAccess) (bool, error)

MatchFunc 是一个用于在查询中测试任意匹配值的函数类型

type Options 

type Options struct {
	Encoder          EncodeFunc // 用于编码的函数
	Decoder          DecodeFunc // 用于解码的函数
	SequenceBandwith uint64     // 序列带宽，用于生成序列键
	badger.Options              // Badger 的配置选项
}

Options 允许设置不同于默认值的选项 例如，编码和解码函数，默认为 Gob

type Query 

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

Query 是一系列条件的集合，badgerhold 中的对象需要匹配这些条件才能被返回 空查询会匹配所有记录

func (*Query) And 

func (q *Query) And(field string) *Criterion

And 创建另一个应用于查询的条件 参数:

  • field: string 类型，表示字段名称

返回值：

  • *Criterion: 返回创建的条件

func (*Query) Index 

func (q *Query) Index(indexName string) *Query

Index 指定运行此查询时使用的索引 参数:

  • indexName: string 类型，表示索引名称

返回值：

  • *Query: 返回更新后的查询对象

func (*Query) IsEmpty 

func (q *Query) IsEmpty() bool

IsEmpty 如果查询为空，则返回 true。空查询会匹配所有记录。 返回值：

  • bool: 如果查询为空，返回 true，否则返回 false

func (*Query) Limit 

func (q *Query) Limit(amount int) *Query

Limit 设置查询最多返回的记录数量。多次设置 Limit 或将其设置为负值会触发 panic 参数:

  • amount: int 类型，表示最大返回记录数量

返回值：

  • *Query: 返回更新后的查询对象

func (*Query) Matches 

func (q *Query) Matches(s *Store, data interface{}) (bool, error)

Matches 返回提供的数据是否与查询匹配。 将匹配所有字段条件，包括嵌套的 OR 查询，但忽略限制、跳过、排序顺序等。 参数:

  • s: *Store 类型，表示要查询的存储
  • data: interface{} 类型，表示要检查的数据

返回值：

  • bool: 如果匹配，返回 true，否则返回 false
  • error: 如果匹配过程中出现错误，返回错误信息

func (*Query) Or 

func (q *Query) Or(query *Query) *Query

Or 创建另一个单独的查询，并将其与查询中的其他结果合并 如果传入的查询包含 limit 或 skip 值，则 Or 会触发 panic，因为它们只允许在顶层查询中使用 参数:

  • query: *Query 类型，表示要合并的查询

返回值：

  • *Query: 返回更新后的查询对象

func (*Query) Reverse 

func (q *Query) Reverse() *Query

Reverse 反转当前结果集，与 SortBy 一起使用 返回值：

  • *Query: 返回更新后的查询对象

func (*Query) Skip 

func (q *Query) Skip(amount int) *Query

Skip 跳过与查询条件匹配的记录，并不在结果集中返回这些记录。设置 skip 多次或为负数会触发 panic 参数:

  • amount: int 类型，表示要跳过的记录数量

返回值：

  • *Query: 返回更新后的查询对象

func (*Query) SortBy 

func (q *Query) SortBy(fields ...string) *Query

SortBy 根据给定的字段名称排序结果集。可以使用多个字段 参数:

  • fields: 可变参数，表示排序的字段名称

返回值：

  • *Query: 返回更新后的查询对象

func (*Query) String 

func (q *Query) String() string

String 返回查询对象的字符串表示形式 返回值：

  • string: 查询对象的字符串表示形式

type RecordAccess 

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

RecordAccess 允许在 MatchFunc 中访问当前记录、字段，或运行子查询

func (*RecordAccess) Field 

func (r *RecordAccess) Field() interface{}

Field 返回正在查询的当前字段 返回值：

  • interface{}: 当前字段的值

func (*RecordAccess) Record 

func (r *RecordAccess) Record() interface{}

Record 返回 badgerhold 中给定行的完整记录 返回值：

  • interface{}: 当前记录的值

func (*RecordAccess) SubAggregateQuery 

func (r *RecordAccess) SubAggregateQuery(query *Query, groupBy ...string) ([]*AggregateResult, error)

SubAggregateQuery 允许在父查询的每条记录上运行另一个聚合查询，使用相同的事务 参数:

  • query: *Query 类型，表示要运行的聚合子查询
  • groupBy: 可变参数，表示分组字段

返回值：

  • []*AggregateResult: 返回聚合查询的结果集合
  • error: 如果聚合查询过程中发生错误，返回错误信息

func (*RecordAccess) SubQuery 

func (r *RecordAccess) SubQuery(result interface{}, query *Query) error

SubQuery 允许在父查询的每条记录上运行另一个查询，使用相同的事务 参数:

  • result: interface{} 类型，用于存储子查询结果的变量
  • query: *Query 类型，表示要运行的子查询

返回值：

  • error: 如果子查询过程中发生错误，返回错误信息

type Store 

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

Store 是 badgerhold 的包装器，封装了一个 Badger 数据库

func Open 

func Open(options Options) (*Store, error)

Open 打开或创建一个 BadgerHold 文件 参数:

  • options: Options 类型，表示要使用的选项

返回值：

  • *Store: 返回打开的 Store 实例
  • error: 如果打开过程中出现错误，则返回错误信息

func (*Store) Badger 

func (s *Store) Badger() *badger.DB

Badger 返回 BadgerHold 所基于的底层 Badger 数据库 返回值：

  • *badger.DB: 返回底层的 Badger 数据库实例

func (*Store) Close 

func (s *Store) Close() error

Close 关闭 Badger 数据库 返回值：

  • error: 如果关闭过程中出现错误，则返回错误信息

func (*Store) Count 

func (s *Store) Count(dataType interface{}, query *Query) (uint64, error)

Count 返回当前数据类型的记录数量 参数:

  • dataType: interface{} 类型，表示要统计记录数量的数据类型
  • query: *Query 类型，表示查询条件

返回值：

  • uint64: 当前数据类型的记录数量
  • error: 如果统计过程中出现错误，则返回错误信息

func (*Store) Delete 

func (s *Store) Delete(key, dataType interface{}) error

Delete 从 badgerhold 中删除一条记录，dataType 只需要是存储类型的一个示例，以便正确更新桶和索引 参数:

  • key: interface{} 类型，表示要删除记录的键
  • dataType: interface{} 类型，表示要删除记录的类型

返回值：

  • error: 如果删除过程中出现错误，则返回错误信息

func (*Store) DeleteMatching 

func (s *Store) DeleteMatching(dataType interface{}, query *Query) error

DeleteMatching 删除所有与传入查询匹配的记录 参数:

  • dataType: interface{} 类型，表示要删除记录的类型
  • query: *Query 类型，表示查询条件

返回值：

  • error: 如果删除过程中出现错误，则返回错误信息

func (*Store) Find 

func (s *Store) Find(result interface{}, query *Query) error

Find 从 badgerhold 中检索符合传入查询的值集，result 必须是指向切片的指针。 查询结果将被追加到传入的 result 切片中，而不是清空传入的切片。 参数:

  • result: interface{} 类型，表示存储检索结果的切片，必须为指针类型
  • query: *Query 类型，表示查询条件

返回值：

  • error: 如果检索过程中出现错误，则返回错误信息

func (*Store) FindAggregate 

func (s *Store) FindAggregate(dataType interface{}, query *Query, groupBy ...string) ([]*AggregateResult, error)

FindAggregate 返回传入查询的聚合分组 groupBy 是可选参数，用于指定分组字段 参数:

  • dataType: interface{} 类型，表示查询的数据类型
  • query: *Query 类型，表示要执行的查询
  • groupBy: 变长字符串参数，表示分组的字段名称

返回值：

  • []*AggregateResult: 包含聚合结果的切片
  • error: 如果查询失败，返回错误信息

func (*Store) FindOne 

func (s *Store) FindOne(result interface{}, query *Query) error

FindOne 返回单个记录，因此 result 不是切片，而是指向结构体的指针。 如果没有找到符合查询条件的记录，则返回 ErrNotFound 错误。 参数:

  • result: interface{} 类型，表示存储检索结果的变量，必须为指向结构体的指针
  • query: *Query 类型，表示查询条件

返回值：

  • error: 如果未找到记录或检索过程中出现错误，则返回错误信息

func (*Store) ForEach 

func (s *Store) ForEach(query *Query, fn interface{}) error

ForEach 针对每个匹配查询条件的记录运行函数 fn 当处理大批量数据时非常有用，因为你不需要将整个结果集保存在内存中，类似于数据库游标 如果 fn 返回错误，将停止游标的迭代 参数:

  • query: *Query 类型，表示查询条件
  • fn: interface{} 类型，表示对每个记录执行的函数

返回值：

  • error: 如果迭代过程中出现错误，则返回错误信息

func (*Store) Get 

func (s *Store) Get(key, result interface{}) error

Get 从 badgerhold 中检索一个值并将其存入 result。result 必须是指针 参数:

  • key: interface{} 类型，表示要检索记录的键
  • result: interface{} 类型，表示存储检索结果的变量，必须为指针类型

返回值：

  • error: 如果检索过程中出现错误，则返回错误信息

func (*Store) Insert 

func (s *Store) Insert(key, data interface{}) error

Insert 将传入的数据插入到 badgerhold 中 如果键已存在于 badgerhold 中，则返回 ErrKeyExists 错误 如果数据结构有一个字段标记为 `badgerholdKey`，并且该字段的类型与插入的键类型相同， 且数据结构是通过引用传递的，并且键字段当前设置为该类型的零值，则该字段将设置为插入键的值。 要与 badgerhold.NextSequence() 一起使用，请使用 `uint64` 类型的键字段。 参数:

  • key: interface{} 类型，表示要插入记录的键
  • data: interface{} 类型，表示要插入的数据

返回值：

  • error: 如果插入过程中出现错误，则返回错误信息

func (*Store) TxCount 

func (s *Store) TxCount(tx *badger.Txn, dataType interface{}, query *Query) (uint64, error)

TxCount 返回在指定事务内的当前数据类型的记录数量 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • dataType: interface{} 类型，表示要统计记录数量的数据类型
  • query: *Query 类型，表示查询条件

返回值：

  • uint64: 当前数据类型的记录数量
  • error: 如果统计过程中出现错误，则返回错误信息

func (*Store) TxDelete 

func (s *Store) TxDelete(tx *badger.Txn, key, dataType interface{}) error

TxDelete 与 Delete 方法相同，但允许用户指定自己的事务 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • key: interface{} 类型，表示要删除记录的键
  • dataType: interface{} 类型，表示要删除记录的类型

返回值：

  • error: 如果删除过程中出现错误，则返回错误信息

func (*Store) TxDeleteMatching 

func (s *Store) TxDeleteMatching(tx *badger.Txn, dataType interface{}, query *Query) error

TxDeleteMatching 与 DeleteMatching 方法相同，但允许用户指定自己的事务 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • dataType: interface{} 类型，表示要删除记录的类型
  • query: *Query 类型，表示查询条件

返回值：

  • error: 如果删除过程中出现错误，则返回错误信息

func (*Store) TxFind 

func (s *Store) TxFind(tx *badger.Txn, result interface{}, query *Query) error

TxFind 允许用户传入自己的 badger 事务来从 badgerhold 中检索符合查询条件的一组值 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • result: interface{} 类型，表示存储检索结果的切片，必须为指针类型
  • query: *Query 类型，表示查询条件

返回值：

  • error: 如果检索过程中出现错误，则返回错误信息

func (*Store) TxFindAggregate 

func (s *Store) TxFindAggregate(tx *badger.Txn, dataType interface{}, query *Query,
	groupBy ...string) ([]*AggregateResult, error)

TxFindAggregate 与 FindAggregate 类似，但您可以指定自己的事务 groupBy 是可选参数，用于指定分组字段 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • dataType: interface{} 类型，表示查询的数据类型
  • query: *Query 类型，表示要执行的查询
  • groupBy: 变长字符串参数，表示分组的字段名称

返回值：

  • []*AggregateResult: 包含聚合结果的切片
  • error: 如果查询失败，返回错误信息

func (*Store) TxFindOne 

func (s *Store) TxFindOne(tx *badger.Txn, result interface{}, query *Query) error

TxFindOne 允许用户传入自己的 badger 事务来从 badgerhold 中检索单个记录 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • result: interface{} 类型，表示存储检索结果的变量，必须为指向结构体的指针
  • query: *Query 类型，表示查询条件

返回值：

  • error: 如果未找到记录或检索过程中出现错误，则返回错误信息

func (*Store) TxForEach 

func (s *Store) TxForEach(tx *badger.Txn, query *Query, fn interface{}) error

TxForEach 与 ForEach 方法相同，但允许用户指定自己的事务 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • query: *Query 类型，表示查询条件
  • fn: interface{} 类型，表示对每个记录执行的函数

返回值：

  • error: 如果迭代过程中出现错误，则返回错误信息

func (*Store) TxGet 

func (s *Store) TxGet(tx *badger.Txn, key, result interface{}) error

TxGet 允许用户传入自己的 badger 事务来从 badgerhold 中检索一个值，并将其存入 result 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • key: interface{} 类型，表示要检索记录的键
  • result: interface{} 类型，表示存储检索结果的变量，必须为指针类型

返回值：

  • error: 如果检索过程中出现错误，则返回错误信息

func (*Store) TxInsert 

func (s *Store) TxInsert(tx *badger.Txn, key, data interface{}) error

TxInsert 与 Insert 方法相同，但允许用户指定自己的事务 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • key: interface{} 类型，表示要插入记录的键
  • data: interface{} 类型，表示要插入的数据

返回值：

  • error: 如果插入过程中出现错误，则返回错误信息

func (*Store) TxUpdate 

func (s *Store) TxUpdate(tx *badger.Txn, key interface{}, data interface{}) error

TxUpdate 与 Update 方法相同，但允许用户指定自己的事务 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • key: interface{} 类型，表示要更新记录的键
  • data: interface{} 类型，表示要更新的数据

返回值：

  • error: 如果更新过程中出现错误，则返回错误信息

func (*Store) TxUpdateMatching 

func (s *Store) TxUpdateMatching(tx *badger.Txn, dataType interface{}, query *Query,
	update func(record interface{}) error) error

TxUpdateMatching 与 UpdateMatching 方法相同，但允许用户指定自己的事务 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • dataType: interface{} 类型，表示要更新的数据类型
  • query: *Query 类型，表示查询条件
  • update: func(record interface{}) error 类型，表示更新函数

返回值：

  • error: 如果更新过程中出现错误，则返回错误信息

func (*Store) TxUpsert 

func (s *Store) TxUpsert(tx *badger.Txn, key interface{}, data interface{}) error

TxUpsert 与 Upsert 方法相同，但允许用户指定自己的事务 参数:

  • tx: *badger.Txn 类型，表示要使用的事务
  • key: interface{} 类型，表示要插入或更新记录的键
  • data: interface{} 类型，表示要插入或更新的数据

返回值：

  • error: 如果插入或更新过程中出现错误，则返回错误信息

func (*Store) Update 

func (s *Store) Update(key interface{}, data interface{}) error

Update 更新 badgerhold 中的现有记录 如果键在存储中不存在，则返回 ErrNotFound 错误 参数:

  • key: interface{} 类型，表示要更新记录的键
  • data: interface{} 类型，表示要更新的数据

返回值：

  • error: 如果更新过程中出现错误，则返回错误信息

func (*Store) UpdateMatching 

func (s *Store) UpdateMatching(dataType interface{}, query *Query, update func(record interface{}) error) error

UpdateMatching 对匹配查询条件的每个记录运行更新函数 注意，更新函数中的记录类型必须是指针 参数:

  • dataType: interface{} 类型，表示要更新的数据类型
  • query: *Query 类型，表示查询条件
  • update: func(record interface{}) error 类型，表示更新函数

返回值：

  • error: 如果更新过程中出现错误，则返回错误信息

func (*Store) Upsert 

func (s *Store) Upsert(key interface{}, data interface{}) error

Upsert 如果记录不存在，则将其插入到 badgerhold 中。如果记录已存在，则更新现有记录 参数:

  • key: interface{} 类型，表示要插入或更新记录的键
  • data: interface{} 类型，表示要插入或更新的数据

返回值：

  • error: 如果插入或更新过程中出现错误，则返回错误信息

type Storer 

type Storer interface {
	Type() string              // 用作 badgerdb 索引前缀
	Indexes() map[string]Index // [索引名称]索引函数
}

Storer 是一个接口，用于实现跳过传入 badgerhold 的所有数据的反射调用

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.