Table合约

这是一个关于Table的 Solidity 智能合约。该智能合约定义了一些重要的实体和方法，可以用于创建、操作和管理表格数据。

首先是 TableFactory 合约，用于创建和打开表格。其中包含：

openTable(string) 方法用于打开一个已经存在的表格并返回该表格实例 Table
createTable(string, string, string) 方法用于创建一个新的表格，并需要传入三个参数：表格名、主键名、存储引擎类型

接下来是一个 Condition 合约，用于设置查询条件。其中包含：

等于（Equal）
不等于（Not Equal）
大于（Greater Than）
大于等于（Greater or Equal）
小于（Less Than）
小于等于（Less or Equal）
限制返回记录数（limit）

然后是一个 Entry 合约，代表表格中的一行数据记录。它提供了获取和设置各种类型的数据值的方法，如整数、无符号整数、地址、字符串等。

最后是一个 Table 合约，包括以下方法：

select(string, Condition) 方法用于根据查询条件选择表格中的数据记录
insert(string, Entry) 方法用于往表格中插入一条新的数据记录
update(string, Entry, Condition) 方法用于根据给定的查询条件更新表格中的数据记录
remove(string, Condition) 方法用于根据给定的查询条件删除表格中的数据记录
newEntry() 方法用于创建一个新的数据记录实例
newCondition() 方法用于创建一个新的查询条件实例

另外还有一个 KVTableFactory 合约，用于创建和打开键值表。其中包含：

openTable(string) 方法用于打开一个已经存在的键值表并返回该表格实例 KVTable
createTable(string, string, string) 方法用于创建一个新的键值表，并需要传入三个参数：表格名、主键名、存储引擎类型

最后是一个 KVTable 合约，代表键值表中的一行数据记录。它提供了获取和设置键值对数据的方法，其中 key 的类型为字符串，value 的类型为 Entry。

pragma solidity ^0.4.24;

contract TableFactory {
    
    
    function openTable(string) public view returns (Table); //open table
    function createTable(string, string, string) public returns (int256); //create table
}

//select condition
contract Condition {
    
    
    function EQ(string, int256) public view;
    function EQ(string, string) public view;
    function EQ(string, address) public view;

    function NE(string, int256) public view;
    function NE(string, string) public view;

    function GT(string, int256) public view;
    function GE(string, int256) public view;

    function LT(string, int256) public view;
    function LE(string, int256) public view;

    function limit(int256) public view;
    function limit(int256, int256) public view;
}

//one record
contract Entry {
    
    
    function getInt(string) public view returns (int256);
    function getUInt(string) public view returns (uint256);
    function getAddress(string) public view returns (address);
    function getBytes64(string) public view returns (bytes1[64]);
    function getBytes32(string) public view returns (bytes32);
    function getString(string) public view returns (string);

    function set(string, int256) public;
    function set(string, uint256) public;
    function set(string, string) public;
    function set(string, address) public;
}

//record sets
contract Entries {
    
    
    function get(int256) public view returns (Entry);
    function size() public view returns (int256);
}

//Table main contract
contract Table {
    
    
    function select(string, Condition) public view returns (Entries);
    function insert(string, Entry) public returns (int256);
    function update(string, Entry, Condition) public returns (int256);
    function remove(string, Condition) public returns (int256);

    function newEntry() public view returns (Entry);
    function newCondition() public view returns (Condition);
}

contract KVTableFactory {
    
    
    function openTable(string) public view returns (KVTable);
    function createTable(string, string, string) public returns (int256);
}

//KVTable per permiary key has only one Entry
contract KVTable {
    
    
    function get(string) public view returns (bool, Entry);
    function set(string, Entry) public returns (int256);
    function newEntry() public view returns (Entry);
}

编写Table合约工具类

使用 Solidity 语言编写的工具类，基于给出的 Table 合约，可以进行数据操作，包括对表格中数据的 CRUD 操作。

该工具类包含以下方法：

constructor: 构造函数，用于初始化工具类实例，需要传入 TableFactory 实例、表格名和主键名。通过表格名和主键名打开表格实例。
createTable: 创建新表格，在当前数据库中创建一张新表格，需要传入存储引擎类型，返回新建表的 ID。
selectByID: 根据给定的主键 ID 查询表格数据，返回查询结果的第一行数据记录。
selectByCondition: 根据给定的查询条件查询表格数据，返回符合条件的所有数据记录。
insertEntry: 向表格中插入一条新的数据记录，需要传入数据记录实例，返回新增记录的 ID。
updateByID: 根据给定的主键 ID 更新表格中的数据记录，需要传入需要更新的数据记录实例，返回影响的记录数。
removeByID: 根据给定的主键 ID 删除表格中的数据记录，返回影响的记录数。

需要注意的是，在方法调用前，需要确保已经打开了正确的表格实例，并且已经传入正确的表格名和主键名。

pragma solidity ^0.8.0;

import "./Table.sol";

contract TableUtils {
    
    
    TableFactory private tableFactory;
    Table private table;
    string private tableName;
    string private primaryKey;

    // 构造函数，用于初始化工具类实例
    constructor(TableFactory factory, string memory name, string memory key) {
    
    
        tableFactory = factory;
        tableName = name;
        primaryKey = key;

        // 打开表格实例
        table = tableFactory.openTable(tableName);
    }

    // 获取当前打开的表格实例
    function getTable() external view returns (Table) {
    
    
        return table;
    }

    // 在当前数据库中创建一张新表格
    function createTable(string memory engineType) external returns (int256) {
    
    
        return tableFactory.createTable(tableName, primaryKey, engineType);
    }

    // 根据给定的主键 ID 查询表格数据，返回查询结果的第一行数据记录
    function selectByID(int256 id) external view returns (Entry memory) {
    
    
        Condition condition = table.newCondition();
        condition.EQ(primaryKey, id);

        Entries entries = table.select("", condition);
        require(entries.size() == 1, "Record not found");

        return entries.get(0);
    }

    // 根据给定的查询条件查询表格数据，返回符合条件的所有数据记录
    function selectByCondition(Condition condition) external view returns (Entries memory) {
    
    
        return table.select("", condition);
    }

    // 向表格中插入一条新的数据记录，需要传入数据记录实例，返回新增记录的 ID
    function insertEntry(Entry memory entry) external returns (int256) {
    
    
        return table.insert("", entry);
    }

    // 根据给定的主键 ID 更新表格中的数据记录，需要传入需要更新的数据记录实例，返回影响的记录数
    function updateByID(int256 id, Entry memory entry) external returns (int256) {
    
    
        Condition condition = table.newCondition();
        condition.EQ(primaryKey, id);

        return table.update("", entry, condition);
    }

    // 根据给定的主键 ID 删除表格中的数据记录，返回影响的记录数
    function removeByID(int256 id) external returns (int256) {
    
    
        Condition condition = table.newCondition();
        condition.EQ(primaryKey, id);

        return table.remove("", condition);
    }
}

TableUtils使用

使用 TableUtils 工具类的示例。首先，需要在合约中进行实例化，并传入正确的参数：

pragma solidity ^0.8.0;

import "./TableFactory.sol";
import "./TableUtils.sol";

contract MyContract {
    
    
    TableFactory private tableFactory;
    TableUtils private utils;

    // 构造函数，用于初始化合约实例和工具类实例
    constructor(TableFactory factory) {
    
    
        tableFactory = factory;
        utils = new TableUtils(tableFactory, "my_table", "id");
    }

    // 创建新表格，并返回新建表的 ID
    function createTable() external returns (int256) {
    
    
        return utils.createTable("BASIC");
    }

    // 向表格中插入一条新的数据记录，并返回新增记录的 ID
    function insertData(string memory name, uint256 value) external returns (int256) {
    
    
        Entry memory entry = utils.getTable().newEntry();

        entry.set("name", name);
        entry.set("value", int256(value));

        return utils.insertEntry(entry);
    }

    // 根据给定的主键 ID 更新表格中的数据记录，需要传入需要更新的数据记录实例，返回影响的记录数
    function updateData(int256 id, string memory name, uint256 value) external returns (int256) {
    
    
        Entry memory entry = utils.getTable().newEntry();

        entry.set("name", name);
        entry.set("value", int256(value));

        return utils.updateByID(id, entry);
    }

    // 根据给定的主键 ID 删除表格中的数据记录，返回影响的记录数
    function removeData(int256 id) external returns (int256) {
    
    
        return utils.removeByID(id);
    }

    // 根据给定的主键 ID 查询表格中的数据记录，并返回查询结果
    function getDataByID(int256 id) external view returns (string memory, uint256) {
    
    
        Entry memory entry = utils.selectByID(id);

        return (entry.getString("name"), uint256(entry.getInt("value")));
    }

    // 根据给定的查询条件查询表格中的数据记录，并返回查询结果
    function getDataByCondition() external view returns (string[] memory, uint256[] memory) {
    
    
        Condition condition = utils.getTable().newCondition();
        Entries entries = utils.selectByCondition(condition);

        string[] memory names = new string[](uint256(entries.size()));
        uint256[] memory values = new uint256[](uint256(entries.size()));

        for (int256 i = 0; i < entries.size(); i++) {
    
    
            Entry memory entry = entries.get(i);

            names[uint256(i)] = entry.getString("name");
            values[uint256(i)] = uint256(entry.getInt("value"));
        }

        return (names, values);
    }
}

在这个示例中，我们首先创建了一个名为 MyContract 的合约，在构造函数中初始化并传入了一个 TableFactory 实例。然后，使用该工厂实例创建了一个名为 my_table 的表格，并指定主键名为 id。

接下来定义了一些方法，用于对表格数据进行 CRUD 操作。例如，insertData 方法可以向表格中插入一条新的数据记录，并返回新增数据的 ID；getDataByID 方法可以根据给定的主键 ID 查询表格中的数据记录，并返回查询结果。

需要注意的是，所有涉及到对表格数据进行操作的方法，都需要通过 TableUtils 工具类实例来调用。在每个方法中，都需要先获取正确的表格实例，并根据需要创建、设置和读取数据记录实例。最后，再将数据记录实例作为参数，调用相应的方法进行数据操作。

Table合约自写工具类详解

Table合约

编写Table合约工具类

TableUtils使用

猜你喜欢