智能合约的编写增删改查

没有什么参考价值

---

Table.sol内容

pragma solidity ^0.4.24;

contract TableFactory {
        /**
         * @brief 打开表，返回Table合约地址
         * @param tableName 表的名称
         * @return 返回Table的地址，当表不存在时，将会返回空地址即address(0x0)
         */
        function openTable(string tableName) public constant returns (Table);

        /**
         * @brief 创建表，返回是否成功
         * @param tableName 表的名称
         * @param key 表的主键名
         * @param valueFields 表的字段名，多个字段名以英文逗号分隔
         * @return 返回错误码，成功为0，错误则为负数
         */
        function createTable(string tableName,int key,string valueFields) public         
        returns(int);
}

// 查询条件
contract Condition {
 //等于
    function EQ(string, int) public;
    function EQ(string, string) public;

//不等于
    function NE(string, int) public;
    function NE(string, string)  public;

//大于
    function GT(string, int) public;
//大于或等于
    function GE(string, int) public;

//小于
    function LT(string, int) public;
//小于或等于
    function LE(string, int) public;

//限制返回记录条数
    function limit(int) public;
    function limit(int, int) public;
}

// 单条数据记录
        contract Entry {
        function getInt(string) public constant returns(int);
        function getAddress(string) public constant returns(address);
        function getBytes64(string) public constant returns(byte[64]);
        function getBytes32(string) public constant returns(bytes32);
        function getString(string) public constant returns(string);

        function set(string, int) public;
        function set(string, string) public;
        function set(string, address) public;
}

// 数据记录集
        contract Entries {
        function get(int) public constant returns(Entry);
        function size() public constant returns(int);
        }

// Table主类
contract Table {
        /**
         * @brief 查询接口
         * @param key 查询主键值
         * @param cond 查询条件
         * @return Entries合约地址，合约地址一定存在
         */
        function select(int key, Condition cond) public constant returns(Entries);
        /**
         * @brief 插入接口
         * @param key 插入主键值
         * @param entry 插入字段值
         * @return 插入影响的行数
         */
        function insert(int key, Entry entry) public returns(int);
        /**
         * @brief 更新接口
         * @param key 更新主键值
         * @param entry 更新字段值
         * @param cond 更新条件
         * @return 更新影响的行数
         */
        function update(int key, Entry entry, Condition cond) public returns(int);
        /**
         * @brief 删除接口
         * @param key 删除的主键值
         * @param cond 删除条件
         * @return 删除影响的行数
         */
        function remove(int key, Condition cond) public returns(int);

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

任务分配表合约的内容：

pragma solidity >=0.6.10 <0.8.20;
        pragma experimental ABIEncoderV2;

        import "./Table.sol";

        contract TableTest {
        event CreateResult(int256 count);
        event InsertResult(int256 count);
        event UpdateResult(int256 count);
        event RemoveResult(int256 count);

        TableFactory tableFactory;
        string constant TABLE_NAME = "task";
        constructor() public {
        tableFactory = TableFactory(0x1001); //The fixed address is 0x1001 for TableFactory
        // the parameters of createTable are tableName,keyField,"vlaueFiled1,vlaueFiled2,vlaueFiled3,..."
        tableFactory.createTable(TABLE_NAME, "id", "employer_id,task_desc,employee_id,task_price,task_status");
        }
   //新建一个任务表 表中内容：主键为任务id 任务发布者ID 任务描述 任务接受者ID 任务成交金额 任务状态
        //select records
        function select(int memory id) public view
            returns (int256[] memory,int256[] memory, string[] memory,int256[] memory, int256[] memory,int[]memory)
            {
            Table table = tableFactory.openTable(TABLE_NAME);

            Condition condition = table.newCondition();

            Entries entries = table.select(id, condition);
            //返回任务id
            int256[] memory id_list = new int256[](uint256(entries.size()));
            //返回任务发布者ID
            int256[] memory employer_id_list = new int256[](uint256(entries.size()));
            //返回任务内容
            string[] memory task_desc_list = new string[](uint256(entries.size()));
            //返回任务接受者ID
            int256[] memory employee_id_list = new int256[](uint256(entries.size()));
            //返回任务成交金额
            int256[] memory task_price_list = new int256[](uint256(entries.size()));
            //返回任务状态
            int256[] memory task_status_list = new int256[](uint256(entries.size()));

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

        id_list[uint256(i)] = entry.getInt("id");
        employer_id_list[uint256(i)] = entry.getInt("employer_id");
        task_desc_list[uint256(i)] = entry.getString("task_desc");
        employee_id_list[uint256(i)] = entry.getInt("employee_id");
        task_price_list[uint256(i)] = entry.getInt("task_price");
        task_status_list[uint256(i)] = entry.getInt("task_status");

        }

        return (id_list,employer_id_list,task_desc_list,employee_id_list,task_price_list,task_status_list);
        }


        //插入任务的记录 根据任务的id
        function insert(int256 id,int256 employer_id, string memory task_desc,int256 employee_id, int256 task_price,int task_status)
            public returns (int256)
            {
            Table table = tableFactory.openTable(TABLE_NAME);

            Entry entry = table.newEntry();
            entry.set("id", id);
            entry.set("employer_id", employer_id);
            entry.set("task_desc", task_desc);
            entry.set("employee_id", employee_id);
            entry.set("task_price", task_price);
            entry.set("task_status", task_status);

            int256 count = table.insert(id, entry);
            emit InsertResult(count);

            return count;
            }
            //update records
            function update(int256 id,int task_status)
            public returns (int256)
            {
            Table table = tableFactory.openTable(TABLE_NAME);

            Entry entry = table.newEntry();
            //entry.set("task_desc", task_desc);//更新任务的内容
            //entry.set("task_price", task_price);//更改任务的奖励
            entry.set("task_status", task_status);//更新任务的状态
            Condition condition = table.newCondition();
            condition.EQ("id", id);//根据任务的id进行更新

            int256 count = table.update(id,task_status);
            emit UpdateResult(count);

            return count;
            }

            //删除任务的记录信息
            function remove(int256 id) public returns (int256) {
            Table table = tableFactory.openTable(TABLE_NAME);

            Condition condition = table.newCondition();
            condition.EQ("id", id);

            int256 count = table.remove(id, condition);
            emit RemoveResult(count);

        return count;
        }
        }

mysql数据库中表的信息：

CREATE TABLE `task`  (
  `id` bigint(0) NOT NULL COMMENT '任务ID',
  `category_id` bigint(0) NULL DEFAULT NULL COMMENT '任务分类ID',
  `employer_id` bigint(0) NULL DEFAULT NULL COMMENT '任务发布者ID',
  `task_title` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '任务标题',
  `task_profile` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '任务简介',
  `task_desc` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL COMMENT '任务描述',
  `fees_low` double NULL DEFAULT NULL COMMENT '最低预算奖励',
  `fees_high` double NULL DEFAULT NULL COMMENT '最高预算奖励',
  `fees_file` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '任务附件地址',
  `filename` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '附件文件名称',
  `employee_id` bigint(0) NULL DEFAULT NULL COMMENT '完成任务任务接受者ID',
  `task_price` double NULL DEFAULT NULL COMMENT '任务成交奖励',
  `task_status` tinyint(0) NULL DEFAULT NULL COMMENT '任务状态',
  `close_time` timestamp(0) NULL DEFAULT NULL COMMENT '成交时间',
  `bid_time` timestamp(0) NULL DEFAULT NULL COMMENT '任务申请成功时间',
  `create_time` timestamp(0) NULL DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

今天先写到这里明天再看

添加了hash匿名性之后:

/**
 * ClassName:qvkuail
 * Package:PACKAGE_NAME
 *
 * @Data:2023/05/08 16:23
 * @Author:灿灿睡醒了
 */
public class qvkuail {

    pragma solidity >=0.6.10 <0.8.20;
    pragma experimental ABIEncoderV2;

    import"./Table.sol";
//在Solidity代码中添加SHA256库，这将使您能够使用SHA256哈希函数对主键id进行哈希处理
    import"./SHA256.sol";  // 添加SHA256库
    contract TableTest

    {
        event CreateResult (int256 count);
        event InsertResult (int256 count);
        event UpdateResult (int256 count);
        event RemoveResult (int256 count);

        TableFactory tableFactory;
        string constant TABLE_NAME = "task";
        constructor() public {
        tableFactory = TableFactory(0x1001); //The fixed address is 0x1001 for TableFactory
        // the parameters of createTable are tableName,keyField,"vlaueFiled1,vlaueFiled2,vlaueFiled3,..."
        tableFactory.createTable(TABLE_NAME, "id", "employer_id,task_desc,employee_id,task_price,task_status");
    }
        //新建一个任务表 表中内容：主键为任务id 任务发布者ID 任务描述 任务接受者ID 任务成交金额 任务状态
        //select records
        function select ( int id)public view
//        function select(bytes32 id_hash) public view
        returns(int256[]memory, int256[]memory, string[]memory, int256[]memory, int256[]memory,int[] memory)
        {


            Table table = tableFactory.openTable(TABLE_NAME);

            Condition condition = table.newCondition();
            //Entries entries = table.select(id_hash, condition);  // 使用哈希值而不是原始id查询表
            Entries entries = table.select(id, condition);

            //返回任务id
            int256[] memory id_list = new int256[] (uint256(entries.size()));
            //返回任务发布者ID
            int256[] memory employer_id_list = new int256[] (uint256(entries.size()));
            //返回任务内容
            string[] memory task_desc_list = new string[] (uint256(entries.size()));
            //返回任务接受者ID
            int256[] memory employee_id_list = new int256[] (uint256(entries.size()));
            //返回任务成交金额
            int256[] memory task_price_list = new int256[] (uint256(entries.size()));
            //返回任务状态
            int256[] memory task_status_list = new int256[] (uint256(entries.size()));

            for (int256 i = 0; i < entries.size(); ++i) {
                Entry entry = entries.get(i);
                //bytes32 id_hash_temp = bytes32(entry.getInt("id"));
                //int256 id = int256(id_hash_temp);  // 将哈希值转换为原始id
                //id_list[uint256(i)] = id;
                id_list[uint256(i)] = entry.getInt("id");
                employer_id_list[uint256(i)] = entry.getInt("employer_id");
                task_desc_list[uint256(i)] = entry.getString("task_desc");
                employee_id_list[uint256(i)] = entry.getInt("employee_id");
                task_price_list[uint256(i)] = entry.getInt("task_price");
                task_status_list[uint256(i)] = entry.getInt("task_status");

            }

            return (id_list,employer_id_list, task_desc_list, employee_id_list, task_price_list, task_status_list);
        }


        //插入任务的记录 根据任务的id
        function insert (int256 id, int256 employer_id, string task_desc, int256 employee_id, int256 task_price,
        int task_status)
public returns(int256)
        {
            Table table = tableFactory.openTable(TABLE_NAME);

            Entry entry = table.newEntry();
            //bytes32 id_hash = SHA256.hash(bytes32(id));  // 将id哈希化
            //entry.set("id", int256(id_hash));  // 将哈希后的id插入到表中
            entry.set("id", id);
            entry.set("employer_id", employer_id);
            entry.set("task_desc", task_desc);
            entry.set("employee_id", employee_id);
            entry.set("task_price", task_price);
            entry.set("task_status", task_status);

            int256 count = table.insert(id, entry);
            //int256 count = table.insert(id_hash, entry);  // 将哈希后的id插入到表中
            emit InsertResult (count);

            return count;
        }

        //更新任务的交易记录
        function update (int256 id,int task_status)
public returns(int256)
        {
            Table table = tableFactory.openTable(TABLE_NAME);

            Entry entry = table.newEntry();
            //entry.set("task_desc", task_desc);//更新任务的内容
            //entry.set("task_price", task_price);//更改任务的奖励
            entry.set("task_status", task_status);//更新任务的状态
            Condition condition = table.newCondition();

            condition.EQ("id", id);//根据任务的id进行更新

            int256 count = table.update(id, task_status);
            emit UpdateResult (count);

            return count;
        }

        //删除任务的记录信息
        function remove (int256 id) public returns(int256) {
        Table table = tableFactory.openTable(TABLE_NAME);

        Condition condition = table.newCondition();
        condition.EQ("id", id);

        int256 count = table.remove(id, condition);
        emit RemoveResult (count);

        return count;
    }
    }
}