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 工具类实例来调用。在每个方法中，都需要先获取正确的表格实例，并根据需要创建、设置和读取数据记录实例。最后，再将数据记录实例作为参数，调用相应的方法进行数据操作。