数据库API

在区块链EOS.IO中用来存储和获取数据的API

目录:

数据库API 1

1 概述

2 模型

2.1 数据库C语言版API

2.1.1 单字符索引表

2.1.2单64位索引表

2.1.3 双位128bit索引表

2.1.4三位64bit索引表

2.2 数据库C++版本API

2.2.1 单索引表

2.2.2 双重索引表

3 索引

3.1 主索引 47

3.1.1 描述 47

3.1.2 静态公共成员函数 47

3.2 二级索引 50

3.2.1 描述 50

3.2.2 静态公共成员函数 51

 

1. 概述

数据是根据以下的广泛结构进行组织的:

  • Scope  – 存储数据的账户
  • Code   – 有写权限的账户名
  • Table  – 正被存储的表的名称
  • Record – 表中的一行

每个交易都指定可读和/或写入的有效范围集。运行中的code决定了可以写什么。因此,写操作不允许您指定/配置code。

 

注意:在有效范围和/或代码段之外读取和/或写入的尝试将导致您的交易失败

数据库API假定每个记录的第一个字节表示主键和/或次键,这些键后面跟随着任意数量的数据。

2.模型

2.1 数据库C语言版API

用于和数据库交互的C版本 API。

2.1.1单字符索引表

这些方法给具有字符串唯一主键和任意二进制数据值的简单表提供了一个接口。

2.2.1.1 函数文档

store_str

int32_t store_str (account_name scope, table_name table, char*key, uint32_t keylen, char *value, uint32_t valuelen)

参数

  • scope – 将被读取的帐户范围,必须存在于交易范围列表中
  • table – 在要修改的当前范围/代码上下文中的表的ID /名称

返回值

如果创建了一条新纪录则返回1,更新了一条已经存在的记录则返回0。

前提

datalen >= sizeof(uint64_t)数据是一个有效的内存指针,指向至少datalen字节长((名称)数据)的内存范围。主键范围是由当前交易声明的,该方法是从应用上下文调用的(非验证或前置条件)。

后置条件

在所给定的范围和表内的记录要么被创建要么被更新。

异常

如果调用无效的前提条件,运行将会出现异常。

 

update_str

int32_t update_str (account_name scope, table_name table, char*key, uint32_t keylen, char *value, uint32_t valuelen)

返回值

如果记录被更新则返回1,未找到关键字对应的记录则返回0。

 

load_str

int32_t load_str (account_name scope, account_name code, table_name table, char*key, uint32_t keylen, char *value, uint32_t valuelen)

参数

  • scope –要被读取的账户的范围,该范围必须存在于交易范围列表中。
  • code –控制数据写访问的标识代码
  • table – 查询的范围/代码上下文中表的ID /名称
  • data -复制存储的记录,应该用键值初始化获取
  • datalen – 读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数, 若未找到对应的键则返回-1。

 

front_str

int32_t front_str (account_name scope, account_name code, table_name table, char*value, uint32_t valuelen)

 

back_str

int32_t back_str (account_name scope, account_name code, table_name table, char*value, uint32_t valuelen)

 

next_str

int32_t next_str (account_name scope, account_name code, table_name table, char*key, uint32_t keylen, char *value, uint32_t valuelen)

 

previous_str

int32_t previous_str (account_name scope, account_name code, table_name table, char*key, uint32_t keylen, char *value, uint32_t valuelen)

 

lower_bound_str

int32_t lower_bound_str (account_name scope, account_name code, table_name table, char*key, uint32_t keylen, char *value, uint32_t valuelen)

 

upper_bound_str

int32_t upper_bound_str (account_name scope, account_name code, table_name table, char*key, uint32_t keylen, char *value, uint32_t valuelen)

返回值

记录被更新返回1,若未找到键对应的记录则返回0。

 

remove_str

int32_t remove_str (account_name scope, table_name table, char*key, uint32_t keylen)

参数

  • data -必须指向至少包含主键的8个字节

返回值

记录删除成功返回1,若未找到键对应的记录则返回0。

 

2.1.2 64位索引表

这些方法给具有64位唯一主键和任意二进制数据值的简单表提供了一个接口。

2.1.2.1示例

#pragma pack(push, 1)

structtest_model {

account_name   name;

unsigned char age;

uint64_t      phone;

};

 

test_model alice{ N(alice), 20, 4234622};

test_model bob  { N(bob),   15, 11932435};

test_model carol{ N(carol), 30, 545342453};

test_model dave { N(dave),  46, 6535354};

 

int32_t res = store_i64(currentCode(),  N(test_table), &dave,  sizeof(test_model));

res = store_i64(currentCode(), N(test_table), &carol, sizeof(test_model));

res = store_i64(currentCode(), N(test_table), &bob, sizeof(test_model));

res = store_i64(currentCode(), N(test_table), &alice, sizeof(test_model));

 

test_model alice;

name = N(alice);

 

res = load_i64( currentCode(), currentCode(), N(test_table), &alice, sizeof(test_model) );

ASSERT(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, “load_i64”);

 

res = load_i64

( currentCode(), currentCode(), N(test_table), &tmp, sizeof(test_model) );

ASSERT(res == sizeof(test_model) && tmp.name == N(alice) && tmp.age == 20 && tmp.phone == 4234622, “front_i64 1”);

 

res = back_i64( currentCode(), currentCode(), N(test_table), &tmp, sizeof(test_model) );

ASSERT(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, “back_i64 2”);

 

res = previous_i64( currentCode(), currentCode(), N(test_table), &tmp, sizeof(test_model) );

ASSERT(res == sizeof(test_model) && tmp.name == N(carol) && tmp.age == 30 && tmp.phone == 545342453, “carol previous”);

 

res = next_i64( currentCode(), currentCode(), N(test_table), &tmp, sizeof(test_model) );

ASSERT(res == sizeof(test_model) && tmp.name == N(dave) && tmp.age == 46 && tmp.phone == 6535354, “back_i64 2”);

 

uint64_t key = N(alice);

res = remove_i64(currentCode(), N(test_table), &key);

ASSERT(res == 1, “remove alice”);

 

test_model lb;

name = N(bob);

 

res = lower_bound_i64( currentCode(), currentCode(), N(test_table), &lb, sizeof(test_model) );

ASSERT(res == sizeof(test_model) && lb.name == N(bob), “lower_bound_i64 bob”);

 

test_model ub;

name = N(alice);

 

res = upper_bound_i64( currentCode(), currentCode(), N(test_table), &ub, sizeof(test_model) );

ASSERT(res == sizeof(test_model) && ub.age == 15 && ub.name == N(bob), “upper_bound_i64 bob”);

2.1.2.2函数文档

store_i64

int32_t store_i64 (account_name scope, table_name table, constvoid *data, uint32_t datalen)

参数

  • scope -要读取的帐户范围,该范围必须存在于交易范围列表中
  • table -要修改的当前范围/代码上下文中的表的ID /名称

返回值

创建一条新纪录返回1,若更新了已存在的记录则返回0

前提

datalen >= sizeof(uint64_t)数据是一个有效的指针,指向至少datalen字节长((uint64_t)数据)的内存范围。主键范围是由当前交易声明的,该方法是从应用上下文调用的(非验证或前置条件)。

后置条件

所给定的范围和表内的记录要么被创建要么被更新。

异常

如果调用无效的前提条件,运行将会出现异常。

 

update_i64

int32_t update_i64 (account_name scope, table_name table, constvoid *data, uint32_t datalen)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • table -要修改的当前范围/代码上下文中的表的ID /名称

返回值:

记录被更新返回1,未找到键值对应的记录则返回0。

前提

datalen >= sizeof(uint64_t)数据是一个有效的指针,指向至少datalen字节长((uint64_t)数据)的内存范围。主键范围是由当前交易声明的,该方法是从应用上下文调用的(非验证或前置条件)。

后置条件

所给定的范围和表内的记录要么被创建要么被更新。

异常

如果调用无效的前提条件,运行将会出现异常。

 

load_i64

int32_t load_i64 (account_name scope, account_name code, table_name table, void*data, uint32_t datalen)

参数

  • scope -要读取的帐户范围,该范围必须存在于交易范围列表中
  • code – 控制数据写访问的标识代码
  • table – 要查询的范围/代码上下文中的表的ID /名称
  • data – 要复制存储的记录,应该用密钥初始化
  • datalen – 读取数据的最大长度,必须大于sizeof(uint64_t)

 

返回值

返回读取到的字节数,如果未找到任何记录则返回-1。

 

front_i64

int32_t front_i64 (account_name scope, account_name code, table_name table, void *data, uint32_t datalen)

参数

  • scope -要读取的帐户范围,该范围必须存在于交易范围列表中
  • code -控制数据写访问的标识代码
  • table -要查询的范围/代码上下文中的表的ID /名称
  • data -复制front记录的位置
  • datalen -读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

返回读取到的字节数,如果未找到任何记录则返回-1。

 

 

 

back_i64

  1. int32_t back_i64 (account_name scope, account_name code, table_name table, void*data, uint32_t datalen)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code – 控制数据写访问的标识代码
  • table – 要查询的范围/代码上下文中的表的ID /名称
  • data -复制back记录的位置
  • datalen – 读取数据的最大长度,必须大于sizeof(uint64_t)

 

返回值

返回读取到的字节数,如果未找到任何记录则返回-1。

 

next_i64

  1. int32_t next_i64 (account_name scope, account_name code, table_name table, void*data, uint32_t datalen)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制数据写访问的标识代码
  • table – 要查询的范围/代码上下文中表的ID /名称
  • data -复制next记录的位置,必须用主键初始化加载
  • datalen-读取数据的最大长度,必须大于sizeof(uint64_t)

 

返回值
返回读取到的字节数,如果未找到键值则返回-1。

 

previous_i64

  1. int32_t previous_i64 (account_name scope, account_name code, table_name table, void*data, uint32_t datalen)

参数

  • scope -要读取的帐户范围必须存在于交易范围列表中
  • code – 控制数据写访问的标识代码
  • table – 要查询的范围/代码上下文中的表的ID /名称
  • data -复制前一记录的位置,应该用密钥初始化以获得以前的记录
  • datalen – 读取数据的最大长度,必须大于sizeof(uint64_t)

 

返回值

返回读取到的字节数,如果未找到键值则返回-1。

 

lower_bound_i64

  1. int32_t lower_bound_i64 (account_name scope, account_name code, table_name table, void*data, uint32_t datalen)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code – 控制数据写访问的标识代码
  • table – 要查询的范围/代码上下文中的表的ID /名称
  • data -复制下边界的位置,应该用键初始化以找到下边界
  • datalen – 读取数据的最大长度,必须大于sizeof(uint64_t)

 

返回值

返回读取到的字节数,如果未找到键值则返回-1。

 

upper_bound_i64

int32_t upper_bound_i64 (account_name scope, account_name code, table_name table, void*data, uint32_t datalen)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code – 控制数据写访问的标识代码
  • table – 要查询的范围/代码上下文中的表的ID /名称
  • data -复制上边界的位置,应该用键初始化以找到上边界
  • datalen – 读取数据的最大长度,必须大于sizeof(uint64_t)

 

返回值

返回读取到的字节数,如果未找到键值则返回-1。

remove_bound_i64

int32_t remove_i64 (account_name scope, table_name table, void*data)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • table – 要查询的范围/代码上下文中的表的ID /名称
  • data -指向必须包含主键的至少8个字节

返回值

删除成功返回1,未找到键值对应的记录返回0。

2.1.3 双位128bit索引表

一个带有128位主键、二级键和任意二进制数据值的数据库表的接口。

2.1.3.1 描述

参数

  • scope – 查找表数据的账户
  • code – 拥有该表的代码
  • table -存储记录的表的名称
  • data – 一个至少有32个字节的内存指针
  • len -数据长度,必须大于或等于32字节

返回值

返回读取到的总字节数,或者当读取到的字节包含32字节的键值而出现”not found” 或 “end”时返回-1。这些方法假设数据库表中有如下格式的记录:

structrecord { uint128 primary; uint128 secondary; … arbitrary data … };

你可以反复排序,通过 { 主, 次 }键实现主索引排序记录和{ 次,主 }键实现次索引排序记录。这意味着,只要不存在组合{主、次}键的副本,就允许复制主值或副值。

 

2.1.3.2 示例

struct test_model128x2 {

uint128_t number;

uint128_t price;

uint64_t  extra;

uint64_t  table_name;

};

 

test_model128x2 alice{0, 500, N(alice), N(table_name)};

test_model128x2 bob{1, 1000, N(bob), N(table_name)};

test_model128x2 carol{2, 1500, N(carol), N(table_name)};

test_model128x2 dave{3, 2000, N(dave), N(table_name)};

 

int32_t res = store_i128i128(CurrentCode(), N(table_name), &alice, sizeof(test_model128x2));

res = store_i128i128(CurrentCode(), N(table_name), &bob, sizeof(test_model128x2));

ASSERT(res == 1, “db store failed”);

res = store_i128i128(CurrentCode(), N(table_name), &carol, sizeof(test_model128x2));

ASSERT(res == 1, “db store failed”);

res = store_i128i128(CurrentCode(), N(table_name), &dave, sizeof(test_model128x2));

ASSERT(res == 1, “db store failed”);

 

test_model128x2 query;

number = 0;

 

res = load_primary_i128i128(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model128x2));

ASSERT(res == sizeof(test_model128x2) && query.number == 0 && query.price == 500 && query.extra == N(alice), “load”);

 

res = front_primary_i128i128(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model128x2));

ASSERT(res == sizeof(test_model128x2) && query.number == 3 && query.price = 2000 && query.extra == N(dave), “front”);

 

res = next_primary_i128i128(CurrentCode(), CurrentCode(), N(table_name), & query, sizeof(test_model128x2));

ASSERT(res == sizeof(test_model128x2) && query.number == 2 && query.price == 1500 && query.extra == N(carol), “next”);

 

res = back_primary_i128i128(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model128x2));

ASSERT(res == sizeof(test_model128x2) && query.number == 0 && query.price == 500 && query.extra == N(alice), “back”);

 

res = previous_primary_i128i128(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model128x2));

ASSERT(res == sizeof(test_model128x2) && query.number == 1 && query.price == 1000 && query.extra == N(bob), “previous”);

 

number = 0;

res = lower_bound_primary_i128i128(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model128x2));

ASSERT(res == sizeof(test_model128x2) && query.number == 0 && query.price == 500 && query.extra == N(alice), “lower”);

 

res = upper_bound_primary_i128i128(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model128x2));

ASSERT(res == sizeof(test_model128x2) && query.number == 1 && query.price == 1000 && query.extra == N(bob), “upper”);

 

extra = N(bobby);

res = update_i128128(CurrentCode(), N(table_name), &query, sizeof(test_model128x2));

ASSERT(res == sizeof(test_model128x2) && query.number == 1 & query.price == 1000 && query.extra == N(bobby), “update”);

 

res = remove_i128128(CurrentCode(), N(table_name), &query, sizeof(test_model128x2));

ASSERT(res == 1, “remove”)

2.1.3.3 函数文档

load_primary_i128i128

int32_t     load_primary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code – 拥有该表的代码
  • table -要修改的范围/代码上下文中的表的ID /名称
  • data -复制记录的位置,应该用主键初始化来加载
  • len -要拷贝的数据的长度

返回值

读取的字节数,若未找到键则返回-1

前提

datalen >= sizeof(uint128_t)数据是一个有效的指针,指向至少datalen字节长((uint128_t)数据)的内存范围。主键范围是由当前交易声明的,该方法是从应用上下文调用的(非验证或前置条件)。

后置条件

数据将被初始化为与键值匹配记录的len字节长度。

异常

如果调用无效的前提条件,运行将会出现异常。

 

front_primary_i128i128

int32_t front_primary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制主键的前记录
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

back_primary_i128i128

int32_t back_primary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制主键的返回(back)记录
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

next_primary_i128i128

int32_t next_primary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制主键的下一个记录的位置,必须用一个键进行初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

previous_primary_i128i128

int32_t previous_primary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制主键的前一记录的位置,必须用一个键进行初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

upper_bound_primary_i128i128

int32_t upper_bound_primary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制主键的上界位置,必须用一个键进行初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

lower_bound_primary_i128i128

int32_t lower_bound_primary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制主键的下界位置,必须用一个键进行初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

load_secondary_i128i128

int32_t load_secondary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -拥有该表的代码
  • table – 在当前范围/代码上下文中修改表的id/名称
  • data -复制记录的位置,必须用一个辅助(secondary)键进行初始化
  • len -复制记录长度

返回值

读取的字节数,键不存在则返回-1

前提

len >= sizeof(uint128_t)数据是一个有效的指针,指向至少datalen字节长((uint128_t)数据)的内存范围。辅助键范围是由当前交易声明的,该方法是从应用上下文调用的(非验证或前置条件)。

后置条件

数据将用与键匹配的len字节记录初始化。

异常

如果调用无效的前提条件,运行将会出现异常。

 

front_secondary_i128i128

int32_t front_secondary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制辅助键的前记录的位置
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

back_secondary_i128i128

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制辅助键的返回(back)记录的位置
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

next_secondary_i128i128

int32_t next_secondary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制辅助键的下一条记录的位置,必须用一个键初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

previous_secondary_i128i128

int32_t previous_secondary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制辅助键的前一条记录的位置,必须用一个键初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

upper_bound_secondary_i128i128

int32_t upper_bound_secondary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制辅助键的上边界的位置,必须用一个键初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

lower_bound_secondary_i128i128

int32_t lower_bound_secondary_i128i128 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -复制辅助键的下边界的位置,必须用一个键初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,记录不存在则返回-1

 

remove_i128i128

int32_t remove_i128i128 (account_name scope, table_name table, constvoid *data)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -必须指向至少包含有32字节的{主键、辅助键}

返回值

记录成功移除返回1,未找到键值对应的记录则返回0

 

store_i128i128

int32_t store_i128i128 (account_name scope, table_name table, constvoid *data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -必须指向至少包含有32字节的{主键、辅助键}数据
  • len – 数据的长度

返回值

创建新纪录返回1,更新已存在的记录则返回0

 

update_i128i128

int32_t update_i128i128 (account_name scope, table_name table, constvoid *data, uint32_t len)

参数

  • scope -要读取的帐户范围,必须存在于交易范围列表中
  • table – 用于查询的范围/代码上下文中的表的id/名称
  • data -必须指向至少包含有32字节的{主键、辅助键}数据
  • len – 数据的长度

返回值

如果记录更新成功返回1,未找到键值对应的记录则返回0

2.1.4三位64bit索引表

带有64位主键、辅助键和任意二进制数据值的数据库表的接口。

描述

参数

  • scope -查找表数据的账户
  • code – 拥有该表的代码
  • table – 存储记录表的表名
  • data -一个至少32字节的内存指针
  • len – 数据的长度,必须大于或等于32字节

 

返回值

读取到的总字节数,当读取到的字节包含24个字节的键而出现”not found” 或 “end”时返回-1。 这些方法假设数据库中的记录有如下格式:

struct record { uint64 primary; uint64 secondary; uint64 tertiary; … arbitrary data … };

你可以迭代这些索引,通过 { 主键, 次键,三级键}实现主索引排序记录,通过{ 次键,三级键}实现次索引排序记录,通过{三级键}实现三级索引排序记录。

2.1.4.2示例

struct test_model3xi64 {

uint64_t a;

uint64_t b;

uint64_t c;

uint64_t name;

};

 

test_model3xi64 alice{ 0, 0, 0, N(alice) };

test_model3xi64 bob{ 1, 1, 1, N(bob) };

test_model3xi64 carol{ 2, 2, 2, N(carol) };

test_model3xi64 dave{ 3, 3, 3, N(dave) };

 

int32_t res = store_i64i64i64(CurrentCode(), N(table_name), &alice, sizeof(test_model3xi64));

res = store_i64i64i64(CurrentCode(), N(table_name), &bob, sizeof(test_model3xi64));

res = store_i64i64i64(CurrentCode(), N(table_name), &carol, sizeof(test_model3xi64));

res = store_i64i64i64(CurrentCode(), N(table_name), &dave, sizeof(test_model3xi64));

 

test_model3xi64 query;

a = 0;

res = load_primary_i64i64i64(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model3xi64));

ASSERT(res == sizeof(test_model3xi64) && query.name == N(alice), “load”);

 

res = front_primary_i64i64i64(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model3xi64));

ASSERT(res == size of(test_model3xi64) && query.name == N(dave), “front”);

 

res = back_primary_i64i64i64(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model3xi64));

ASSERT(res == size of(test_model3xi64) && query.name == N(alice), “back”);

 

res = previous_primary_i64i64i64(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model3xi64));

ASSERT(res == size of(test_model3xi64) && query.name == N(bob), “previous”);

 

res = next_primary_i64i64i64(CurrentCode(), CurrentCode(), N(table_name), &query, sizeof(test_model3xi64));

ASSERT(res == size of(test_model3xi64) && query.name == N(alice), “next”);*

2.1.4.3函数文档

load_primary_i64i64i64

int32_t load_primary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -拥有该表的代码
  • table – 用于修改的范围/代码上下文中的表的id/名称
  • data -复制记录的位置,加载时必须初始化为(一级、二级、三级)
  • len -复制记录的长度

返回值

读取的字节数,键值不存在则返回-1

前提

数据是一个有效的指针,指向至少len字节长度的内存((uint64_t)数据)存储主键范围是由当前交易声明的,这个方法是从应用上下文(不是验证或前提条件)中调用的。

后置条件

数据将被初始化为与键值匹配记录的len字节长度。

异常

如果调用无效的前提条件,运行将会出现异常。

 

front_primary_i64i64i64

int32_t front_primary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制主键的前记录位置
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

back_primary_i64i64i64

int32_t back_primary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 查询范围/代码上下文中表的id/名称
  • data -复制主键的后(back)记录位置
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

next_primary_i64i64i64

int32_t next_primary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 查询范围/代码上下文中表的id/名称
  • data -复制主键的下一个记录的位置,必须用一个键值初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

previous_primary_i64i64i64

int32_t previous_primary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 查询范围/代码上下文中表的id/名称
  • data -复制主键的上一个记录的位置,必须用一个键值初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

upper_bound_primary_i64i64i64

int32_t upper_bound_primary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 查询范围/代码上下文中表的id/名称
  • data -复制主键的上边界的位置,必须用一个键值初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

lower_bound_primary_i64i64i64

int32_t lower_bound_primary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 查询范围/代码上下文中表的id/名称
  • data -复制主键的下边界的位置,必须用一个键值初始化
  • len -要读取的数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

load_secondary_i64i64i64

int32_t load_secondary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -拥有该表的代码
  • table – 要修改范围/代码上下文中表的id/名称
  • data -复制记录的位置,必须用(次级,第三级)初始化加载
  • len -复制记录的长度

返回值

读取的字节数,未找到键则返回-1

前提

data是一个有效的指针,指向存储主键的至少len字节长度的内存((uint64_t)数据),范围是由当前交易声明的,这个方法是从应用上下文(不是验证或前提条件)中调用的。

后置条件

数据将被初始化为与键值匹配记录的len字节长度。

异常

如果调用无效的前提条件,运行将会出现异常。

 

front_secondary_i64i64i64

int32_t front_secondary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制第二键值的前(front)记录的位置
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

back_secondary_i64i64i64

int32_t back_secondary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制辅助键值后(back)记录的位置
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

next_secondary_i64i64i64

int32_t next_secondary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制下一个记录的位置,必须用键值初始化
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

previous_secondary_i64i64i64

int32_t previous_secondary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制先前记录的位置,必须用一个键值初始化
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

upper_bound_secondary_i64i64i64

int32_t upper_bound_secondary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将被读取的帐户范围,必须存在于交易范围列表中
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -要复制的第三个键的上边界位置,必须用一个键值初始化
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

lower_bound_secondary_i64i64i64

int32_t lower_bound_secondary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制的第二个键的下界位置,必须用一个键值初始化
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

load_tertiary_i64i64i64

int32_t load_tertiary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • code -拥有该表的代码
  • table – 要修改的范围/代码上下文中表的id/名称
  • data -复制记录的位置,必须用第三级初始化加载
  • len -复制记录的长度

返回值

读取的字节数,未找到键值则返回-1

前提

data是一个有效的指针,指向存储((uint64_t)数据)至少len字节长度的内存,第三键值范围是由当前交易声明的,这个方法是从应用上下文(不是验证或前提条件)中调用的。

后置条件

数据将用与键值相匹配的len字节长度的记录进行初始化。

异常

如果调用无效的前提条件,运行将会出现异常。

 

front_tertiary_i64i64i64

int32_t front_tertiary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制第三个键的前记录的位置
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

back_tertiary_i64i64i64

int32_t back_tertiary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制第三键的后记录的位置
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

next_tertiary_i64i64i64

int32_t next_tertiary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制下一个记录的位置,必须用一个键值初始化
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

previous_tertiary_i64i64i64

int32_t previous_tertiary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制前一个记录的位置,必须用一个键值初始化
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

upper_bound_tertiary_i64i64i64

int32_t upper_bound_tertiary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制第三位键的上界,必须用一个键值初始化
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

lower_bound_tertiary_i64i64i64

int32_t lower_bound_tertiary_i64i64i64 (account_name scope, account_name code, table_name table, void*data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • code -控制对数据写访问的标识代码
  • table – 要查询范围/代码上下文中表的id/名称
  • data -复制第三位键的下界,必须用一个键值初始化
  • len -要读取数据的最大长度,必须大于sizeof(uint64_t)

返回值

读取的字节数,未找到记录则返回-1

 

remove_i64i64i64

int32_t remove_i64i64i64 (account_name scope, table_name table, constvoid *data)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • table – 存储记录的表的名称
  • data -必须指向包含{主键,次键,第三键}至少24个字节的地址

返回值

删除记录成功返回1,未找到与键值匹配的记录则返回0

 

store_i64i64i64

int32_t store_i64i64i64 (account_name scope, table_name table, constvoid *data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • table – 存储记录的表的名称
  • data -必须指向包含{主键,次键,第三键}至少24个字节的地址
  • len -数据的长度

返回值

创建了一条新纪录返回1,更新了已存在的一条记录则返回0

 

update_i64i64i64

int32_t update_i64i64i64 (account_name scope, table_name table, constvoid *data, uint32_t len)

参数

  • scope -将要读取的帐户范围,必须要在交易范围列表中存在
  • table – 存储记录的表的名称
  • data -必须指向包含{主键,次键,第三键}至少24个字节的地址
  • len -数据的长度

返回值

记录更新成功返回1,未找到键值对应的记录返回0

 

 

 

 

 

2.2 数据库C++版本API

用于与数据库交互的c++ API。它提供了一个简单的接口,用于将任何固定大小的struct存储为数据库的一行。

2.2.1 单索引表

表的这种专业化是针对单索引表的

2.2.1.1 描述

struct table < scope, code, table, Record, PrimaryType, void >

struct primary_index

公共类型

Primary

typedef PrimaryType primary

typedef PrimaryType table < scope, code, table, Record, PrimaryType, void >::Primary

参数

  • scope – 包含此表在内的默认帐户名称范围
  • code – 对该表有写权限的代码帐户名称
  • table – 此表的唯一标识符(名称)
  • Record – 存储在每行中的数据类型
  • PrimaryType – 存储在记录中的第一个字段的类型

 

2.2.1.2 示例

struct MyModel {

uint128_t number;

uint64_t  name;

};

 

typedef table <N(myscope), N(mycode), N(mytable), MyModel, uint128_t> MyTable;

 

MyModel a { 1, N(one) };

MyModel b { 2, N(two) };

MyModel c { 3, N(three) };

MyModel d { 4, N(four) };

 

bool res = MyTable::store(a);

ASSERT(res, “store”);

 

res = MyTable::store(b);

ASSERT(res, “store”);

 

res = MyTable::store(c);

ASSERT(res, “store”);

 

res = MyTable::store(d);

ASSERT(res, “store”);

 

MyModel query;

res = MyTable::front(query);

ASSERT(res && query.number == 4 && query.name == N(four), “front”);

 

res = MyTable::back(query);

ASSERT(res && query.number == 1 && query.name == N(one), “back”);

 

res = MyTable::primary_index::previous(query);

ASSERT(res && query.number == 2 && query.name == N(two), “previous”);

 

res = MyTable::primary_index::next(query);

ASSERT(res && query.number == 1 && query.name == N(one), “next”);

 

number = 4;

res = MyTable::get(query);

ASSERT(res && query.number == 4 && query.name = N(four), “get”);

 

name = N(Four);

res = MyTable.update(query);

ASSERT(res && query.number == 4 && query.name == N(Four), “update”);

 

res = MyTable.remove(query);

ASSERT(res, “remove”);

 

res = MyTable.get(query);

ASSERT(!res, “get of removed record”);

2.2.1.4 静态公共成员函数

front (Record &r)

staticbool front (Record &r)

staticbool table< scope, code, table, Record, PrimaryType, void >::front (Record & r)

获取表的前部(front)

参数

  • r – 引用保存值

返回值

如果成功地检索到前部(front),则为真

 

back (Record &r)

staticbool back (Record &r)

staticbool table< scope, code, table, Record, PrimaryType, void >::back (Record & r)

获取表的后部(back)

参数

  • r – 引用保存值

返回值

如果成功地检索到后部(back),则为真

 

get (const PrimaryType &p, Record &r, uint64_t s=scope)

staticbool get (const PrimaryType &p, Record &r, uint64_t s=scope)

staticbool table< scope, code, table, Record, PrimaryType, void >::get   (const PrimaryType &p, Record &r, uint64_t s=scope)

检索指定主键的记录

参数

  • p – 需要获取的记录的主键
  • r -保存记录返回值的引用
  • s -范围,默认为类的范围

返回值

如果获取成功则返回true

 

get (Record &r, uint64_t s=scope)

staticbool get (Record &r, uint64_t s=scope)

staticbool table< scope, code, table, Record, PrimaryType, void >::get   (Record &   r, uint64_t s = scope)

获取基于初始化的主键值的记录

参数

  • r – 获取记录的主键,必须对要获取的主键进行初始化
  • s -范围,默认为类的范围

返回值

如果获取成功就返回true

 

store (const Record &r, uint64_t s=scope)

staticbool store (const Record &r, uint64_t s=scope)

staticbool table< scope, code, table, Record, PrimaryType, void >::store (const Record & r, uint64_t s = scope)

将记录存储在表中

参数

  • r -要存储的记录
  • s -范围,默认为类的范围

返回值

如果存储成功就返回true

 

update (const Record &r, uint64_t s=scope)

staticbool update (const Record &r, uint64_t s=scope)

staticbool table< scope, code, table, Record, PrimaryType, void >::store (const Record & r, uint64_t s = scope)

将记录存储在表中

参数

  • r -要存储的记录
  • s -范围,默认为类的范围

返回值

如果存储成功就返回true

 

static bool remove (const Record &r, uint64_t s=scope)

static bool remove (const Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, void >::remove (const Record & r, uint64_t    s = scope)

从表中删除记录

参数

  • r -要删除的记录
  • s -范围,默认为类的范围

返回值

如果删除成功就返回true

 

2.2.2 双重索引表

在数据库C API上定义一个类型安全的c++包装器(wrapper)

2.2.2.1 描述

class table< scope, code, table, Record, PrimaryType, SecondaryType >

struct primary_index

struct secondary_index

公共类型

Primary

typedef PrimaryType primary

typedef PrimaryType table< scope, code, table, Record, PrimaryType, SecondaryType >::Primary

Secondary

typedef SecondaryType secondary

typedef SecondaryType table< scope, code, table, Record, PrimaryType, SecondaryType >::Secondary

参数

  • scope – 包含此表在内的默认帐户名称/范围
  • code – 对该表有写权限的代码帐户名称
  • table – 此表的唯一标识符(名称)
  • Record – 存储在每行中的数据类型
  • PrimaryType – 存储在记录中的第一个字段的类型
  • SecondaryType- 存储在记录中的第二个字段的类型

 

主索引和二级索引是从最低到最高的n位无符号整数进行排序的。

 

2.2.2.2 示例

structModel {

uint64_t primary;

uint64_t secondary;

uint64_t value;

};

 

typedeftable <N(myscope), N(mycode), N(mytable), Model, uint64_t, uint64_t> MyTable;

Model a { 1, 11, N(first) };

Model b { 2, 22, N(second) };

Model c { 3, 33, N(third) };

Model d { 4, 44, N(fourth) };

 

boolres = MyTable::store(a);

ASSERT(res, “store”);

 

res = MyTable::store(b);

ASSERT(res, “store”);

 

res = MyTable::store(c);

ASSERT(res, “store”);

 

res = MyTable::store(d);

ASSERT(res, “store”);

 

Model query;

res = MyTable::primary_index::get(1, query);

ASSERT(res && query.primary == 1 && query.value == N(first), “first”);

 

res = MyTable::primary_index::front(query);

ASSERT(res && query.primary == 4 && query.value == N(fourth), “front”);

 

res = MyTable::primary_index::back(query);

ASSERT(res && query.primary == 1 && query.value == N(first), “back”);

 

res = MyTable::primary_index::previous(query);

ASSERT(res && query.primary == 2 && query.value == N(second), “previous”);

 

res = MyTable::primary_index::next(query);

ASSERT(res && query.primary == 1 && query.value == N(first), “first”);

 

res = MyTable::secondary_index::get(11, query);

ASSERT(res && query.primary == 11 && query.value == N(first), “first”);

 

res = MyTable::secondary_index::front(query);

ASSERT(res && query.secondary == 44 && query.value == N(fourth), “front”);

 

res = MyTable::secondary_index::back(query);

ASSERT(res && query.secondary == 11 && query.value == N(first), “back”);

 

res = MyTable::secondary_index::previous(query);

ASSERT(res && query.secondary == 22 && query.value == N(second), “previous”);

 

res = MyTable::secondary_index::next(query);

ASSERT(res && query.secondary == 11 && query.value == N(first), “first”);

 

res = MyTable::remove(query);

ASSERT(res, “remove”);

 

res = MyTable::get(query);

ASSERT(!res, “not found already removed”);

2.2.2.3 静态公共成员函数

get (const PrimaryType &p, Record &r, uint64_t s=scope)

static bool get (const PrimaryType &p, Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::get(const PrimaryType & p, Record & r, uint64_t s = scope)

参数

  • p – 用来检索的主键的引用
  • r -用来加载值的记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

store (const Record &r, uint64_t s=scope)

static bool store (const Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::store (const Record & r, uint64_t s = scope)

参数

  • r -要存储记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果存储成功返回true

 

update (const Record &r, uint64_t s=scope)

static bool update (const Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::update   (const Record & r, uint64_t s = scope)

参数

  • r -要更新记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果更新成功返回true

 

remove (const Record &r, uint64_t s=scope)

static bool remove (const Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::remove   (const Record & r, uint64_t s = scope)

参数

  • r -要删除记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果删除成功返回true

 

3.索引

3.1 主索引

3.1.1描述

主索引

table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index Struct Reference

3.1.2静态公共成员函数

front (Record &r, uint64_t s=scope)

static bool front (Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index::front (Record & r, uint64_t s = scope)

参数

  • r -引用一个记录,以存储基于主索引的前记录
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

back (Record &r, uint64_t s=scope)

static bool back (Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index::back (Record & r, uint64_t s = scope)

参数

  • r -引用一个记录以存储基于主索引的后记录
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

next (Record &r, uint64_t s=scope)

static bool next (Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index::next (Record & r, uint64_t s = scope)

参数

  • r -引用记录来存储下一个值,必须用当前值初始化。
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

previous (Record &r, uint64_t s=scope)

static bool previous (Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index::previous (Record & r, uint64_t s = scope)

参数

  • r -引用记录来存储以前的值,必须用当前值初始化。
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

get (const PrimaryType &p, Record &r, uint64_t s=scope)

static bool get (const PrimaryType &p, Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index::get (const PrimaryType & p, Record & r, uint64_t s = scope)

参数

  • p -引用主键来进行加载,必须用一个值初始化
  • r – 指向一个记录,以把值导入
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

lower_bound (const PrimaryType &p, Record &r)

static bool lower_bound (const PrimaryType &p, Record &r)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index::lower_bound (const PrimaryType & p, Record & r )

参数

  • p -能得到下界值的主键的引用,必须用一个值初始化
  • r -指向一个记录,以把值导入
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

upper_bound (const PrimaryType &p, Record &r)

static bool upper_bound (const PrimaryType &p, Record &r)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index::upper_bound (const PrimaryType & p, Record & r )

参数

  • p -能得到上界值的主键的引用,必须用一个值初始化
  • r -指向一个记录,以把值导入
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

remove (const Record &r, uint64_t s=scope)

static bool remove (const Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::primary_index::remove    (const Record & r, uint64_t s = scope)

参数

  • r – 将从表中删除的记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果删除成功返回true

 

3.2 二级索引

3.2.1描述

二级索引

table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index Struct Reference

3.2.2静态公共成员函数

front (Record &r, uint64_t s=scope)

static bool front (Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index::front (Record & r, uint64_t s = scope)

参数

  • r -引用一个记录,以存储基于二级索引的前记录
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

back (Record &r, uint64_t s=scope)

static bool back (Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index::back    (Record & r, uint64_t s = scope)

参数

  • r -引用一个记录,以存储基于二级索引的后记录
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

next (Record &r, uint64_t s=scope)

static bool next (Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index::next    (Record & r, uint64_t s = scope)

参数

  • r -引用记录以返回下一个记录
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

previous (Record &r, uint64_t s=scope)

static bool previous (Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index::previous    (Record & r, uint64_t s = scope)

参数

  • r -引用记录以返回以前的记录
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

get (const SecondaryType &p, Record &r, uint64_t s=scope)

static bool get (const SecondaryType &p, Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index::get (const SecondaryType & p, Record & r, uint64_t s = scope)

参数

  • p -二级索引键的引用
  • r – 保存值记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

lower_bound (const SecondaryType &p, Record &r, uint64_t s=scope)

static bool lower_bound (const SecondaryType &p, Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index::lower_bound (const SecondaryType & p, Record & r, uint64_t s = scope)

参数

  • p -对次键(secondary)的引用,以得到下界,必须用一个值初始化
  • r – 加载值记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

upper_bound (const SecondaryType &p, Record &r, uint64_t s=scope)

static bool upper_bound (const SecondaryType &p, Record &r, uint64_t s=scope)

static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index::upper_bound (const SecondaryType & p, Record & r, uint64_t s = scope)

参数

  • p -对次键的引用,以得到上界,必须用一个值初始化
  • r – 加载值记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果读取成功返回true

 

remove (const Record &r, uint64_t s=scope)

static bool remove (const Record &r, uint64_t s=scope)

 static bool table< scope, code, table, Record, PrimaryType, SecondaryType >::secondary_index::remove (const Record & r, uint64_t s = scope)

参数

  • r -要删除的记录的引用
  • s -账户范围,默认是当前类的范围

返回值

如果删除成功返回true