5 Data Persistence

Search…
5 Data Persistence
This section provides instructions for creating and setting up a table for user data, creating an instance of the table, adding new rows as well as instructions for adjusting and deleting them. In addition, there are instructions for setting up an ABI file and testing the installed contract.
To store user data, a contract can be created to be used as an address book. Despite the fact that this use of data is not very practical this operation illustrates a method of storing data in CyberWay without any distortion of business logic.
5.1 Create a new directory for the address book contract
1
cd CONTRACTS_DIR
2
mkdir addressbook
3
cd addressbook
Copied!
5.2 Create file
1
touch addressbook.cpp
Copied!
Fill the file with the following content:
1
#include <eosiolib/eosio.hpp>
2
​
3
using namespace eosio;
4
​
5
class [[eosio::contract("addressbook")]] addressbook : public eosio::contract {
6
    public:
7
​
8
    private: 
9
​
10
};
Copied!
5.3 Create address book data structure
Before a table can be configured and created, it is necessary to create an address book data structure. Since this is an address book, the table must contain information about people, and the contract itself must store some important data for each record or person. A possible person structure is the following:
1
struct person {
2
    name key;
3
    std::string first_name;
4
    std::string last_name;
5
    std::string street;
6
    std::string city;
7
    std::string state
8
};
Copied!
The structure of the table cannot be changed as long as it is filled out with data. If necessary, change data structure of the table. For that you must first delete all its rows.
5.4 Configure table indexes
The table has to be configured after determining its data structure. The first step is to define eosio::multi_index constructor to use the table data structure. Add the following line to the created class:
1
typedef eosio::multi_index<"people"_n, person> address_index;
Copied!
This definition of multi_index creates a table called people, which allows the following:
to use the _n operator to determine the type of eosio::name and also to use this name for the table. This table will contain several descriptions of individual «person»s, so you can assign the name «people» to the table;  
to transfer the structure for an individual defined in the previous step;  
to declare the type of this particular table. This type will be used to create instances of this table;  
to configure and accommodate the table indexes, which are to be mentioned later.  
At this stage the file should have the following form:
1
#include <eosiolib/eosio.hpp>
2
​
3
using namespace eosio;
4
​
5
class [[eosio::contract("addressbook")]] addressbook : public eosio::contract {
6
​
7
  public:
8
​
9
  private:
10
    struct [[eosio::table]] person {
11
      name key;
12
      std::string first_name;
13
      std::string last_name;
14
      std::string street;
15
      std::string city;
16
      std::string state
17
    };
18
​
19
    typedef eosio::multi_index<"people"_n, person> address_index;
20
  public:
21
​
22
};
Copied!
5.5 Create class constructor
When working with C++ classes, the first open method to be created is the constructor. The constructor determines the initial setting of the contract. The contracts allow you to expand the class. To do this, you need to initialize the parent class of the contract with the code name of the contract and the recipient.
1
addressbook(name receiver, name code, datastream<const char*> ds):contract(receiver, code, ds) {}
Copied!
Параметр:
name code — a contract account name.
5.6 Create table entries
5.6.1 The following conditions must be met:
Any changes are added to the address book by the user himself only.  
For the ease of use, the contract should provide an ability to create or modify a row of table in one action.  
5.6.2 Define the user action to add a record or modify a table. This action should take any values ​​necessary to create or edit an entry in the table.
Format the method. For further convenience and simplicity of the interface, the same method will perform both the creation and the modification of lines. It is given the name «upsert» (as a combination of «update» and «insert»).
Only the user has the right to control his own entry in the table. To perform this, use the require_auth method provided by eosio.cdt. This method takes one argument — the name of the account performing the transaction. The upsert method is:
1
void upsert(
2
    name user, 
3
    std::string first_name, 
4
    std::string last_name, 
5
    std::string street, 
6
    std::string city, 
7
    std::string state
8
) {
9
  require_auth( user );
10
}
Copied!
5.6.3 Create a table. The multi_index table is configured and declared as address_index. Creating an instance of a table requires two arguments:
contract account code;  
scope of the contract.  
You also need to set an iterator for a frequent use. 
The table will be the following:
1
void upsert(
2
    name user, 
3
    std::string first_name, 
4
    std::string last_name, 
5
    std::string street, 
6
    std::string city, 
7
    std::string state) {
8
        require_auth( user );
9
        address_index addresses(_code, _code.value);
10
        auto iterator = addresses.find(user.value);
11
}
Copied!
5.6.4 Write the logic for creating or modifying a table, the logic for determining the existence of a user. To do this, you can use the table's method called find, passing the user parameter. The find method returns a table iterator.
1
void upsert(
2
… 
3
) {
4
    require_auth( user );
5
    address_index addresses(_code, _code.value);
6
    auto iterator = addresses.find(user.value);
7
    if( iterator == addresses.end() )
8
      {
9
            //The user isn't in the table
10
     }
11
      else {
12
         //The user is in the table
13
      }
14
}
Copied!
5.6.5 Create an entry in the table using the emplace method. This method takes two arguments: the «payer» of this record, which pays for the use of storage and the callback function.
The callback function for the emplace method should use lambda to create a link. Inside a body, assign values to the rows for the upsert.
1
void upsert(
2
…
3
) {
4
    require_auth( user );
5
    address_index addresses(_code, _code.value);
6
    auto iterator = addresses.find(user.value);
7
    if( iterator == addresses.end() )
8
    {
9
        addresses.emplace(user, [&]( auto& row ) {
10
        row.key = user;
11
        row.first_name = first_name;
12
        row.last_name = last_name;
13
        row.street = street;
14
        row.city = city;
15
        row.state = state;});
16
    }
17
    else {
18
        //The user is in the table
19
    }
20
}
Copied!
5.6.6 To modify an entry in a table, you can use the modify method with the following arguments:
iterator — an iterator (previously defined);  
user — a user who is the payer;  
a function to handle the table modification.
1
...
2
if( iterator == addresses.end() )
3
{
4
...
5
}
6
else {
7
std::string changes;
8
addresses.modify(iterator, user, [&]( auto& row ) {
9
    row.key = user;
10
    row.first_name = first_name;
11
    row.last_name = last_name;
12
    row.street = street;
13
    row.city = city;
14
    row.state = state;
15
});
16
}
17
...
Copied!
Upon completion of the instructions in this clause, the address book contract will have a functional action that will allow the user to create or modify a row in the table.  
5.7 Deleting records from the table
Create a public method in your address book and make sure that it includes ABI-ads. Also create require_auth to check the user's right to perform the action. Only the owner of the record can change his account. In the address book, each account has only one entry.
To delete a record, you need to set an iterator using find and call the erase method
1
...
2
void erase(name user) {
3
    require_auth(user);
4
    address_index addresses(_code, _code.value);
5
    auto iterator = addresses.find(user.value);
6
    eosio_assert(iterator != addresses.end(), "Record does not exist");
7
    addresses.erase(iterator);
8
}
9
...
Copied!
Upon completion of the instructions in this clause, the address book contract will have a functional action that will allow the user to create, modify or delete any entry in the table. However, the contract is not yet ready for compilation.
5.8 Edit the ABI file
Before you compile the contract you need to edit the addressbook.cpp file.
5.8.1 At the end of the file, place the macro EOSIO_DISPATCH, specifying the name of the contract, as well as the «upsert» and «erase» actions.
This macro sends calls to specific methods in this contract. The macro ensures the compatibility of the cpp-file with the wasm EOSIO interpreter. Failure to include this declaration may lead to an error in the deployment of the contract.
1
EOSIO_DISPATCH( addressbook, (upsert)(erase) )
Copied!
5.8.2 Declare actions in the ABI file.
Although eosio.cdt includes an ABI generator, you also need to manually modify the generated ABI file. At the top of the description of the functions upsert and erase add a declaration in the following form:
1
[[eosio::action]]
Copied!
This declaration allows you to extract action arguments and to create the necessary ABI structure descriptions in the generated ABI file.
5.8.3 Declare tables in an ABI file.
Matching the previous paragraph instructions change the declaration for the table:
1
struct [[eosio::table]] person {
Copied!
The final state of the contract with the address book before compilation is the following:
1
#include <eosiolib/eosio.hpp>
2
​
3
using namespace eosio;
4
​
5
class [[eosio::contract("addressbook")]] addressbook : public eosio::contract {
6
​
7
private:
8
  struct [[eosio::table]] person {
9
    name key;
10
    std::string first_name;
11
    std::string last_name;
12
    std::string street;
13
    std::string city;
14
    std::string state;
15
​
16
    uint64_t primary_key() const {return key.value;}
17
  };
18
  typedef eosio::multi_index<"person"_n, person> address_index;
19
​
20
public:
21
  using contract::contract;
22
​
23
addressbook(name receiver, name code,  datastream<const char*> ds): contract(receiver, code, ds) {}
24
​
25
  [[eosio::action]]
26
  void upsert(name user, std::string first_name, std::string last_name, std::string street,std::string city, std::string state) {
27
        require_auth( user );
28
        address_index addresses(_self, _self.value);
29
        auto iterator = addresses.find(user.value);
30
        if( iterator == addresses.end() )
31
        {
32
            addresses.emplace(user, [&]( auto& row ) {
33
                row.key = user;
34
                row.first_name = first_name;
35
                row.last_name = last_name;
36
                row.street = street;
37
                row.city = city;
38
                row.state = state;
39
            });
40
        }
41
        else {
42
                std::string changes;
43
                addresses.modify(iterator, user, [&]( auto& row ) {
44
                row.key = user;
45
                row.first_name = first_name;
46
                row.last_name = last_name;
47
                row.street = street;
48
                row.city = city;
49
                row.state = state;
50
        });
51
      }
52
  }
53
​
54
  [[eosio::action]]
55
  void erase(name user) {
56
    require_auth(user);
57
​
58
    address_index addresses(_self, _self.value);
59
​
60
    auto iterator = addresses.find(user.value);
61
    eosio_assert(iterator != addresses.end(), "Record does not exist");
62
    addresses.erase(iterator);
63
  }
64
​
65
};
66
​
67
EOSIO_DISPATCH( addressbook, (upsert)(erase))
Copied!
5.9 Compile a contract
1
eosio-cpp -o addressbook.wasm addressbook.cpp --abigen
Copied!
5.10 Describe the index of the primary key of the table in the ABI file
The generator creates a table without indices during the compilation of the ABI file:
1
  ...
2
  "tables": [
3
  {
4
      "name": "person",
5
      "type": "person",
6
      "index_type": "i64",
7
      "key_names": [],
8
      "key_types": []
9
  }],
10
  …
Copied!
You must edit the table in the ABI file, keeping only the name and type unchanged and replacing the remaining fields with the following description of the primary key index:
1
  …
2
    "indexes": [
3
    {
4
        "name": "primary",
5
        "unique": "true",
6
        "orders": [
7
        {"field": "key", "order": "asc"}
8
   ]}
9
  …
Copied!
5.11 Install a contract
5.11.1 Create an account for the contract by executing:
1
cleos create account olga addressbook <public key>
Copied!
5.11.2 Set an addressbook contract by executing:
1
cleos set contract addressbook CONTRACTS_DIR/addressbook -p [email protected]
Copied!
5.12 Test an established contract
5.12.1 Check an addition of a row to a table for a user named alice.
1
cleos push action addressbook upsert '["alice", "alice", "liddell", "123 drink me way", "wonderland", "amsterdam"]' -p [email protected]
Copied!
As an output the following information should appear:
1
executed transaction: ...
2
#   addressbook <= addressbook::upsert          {"user":"alice","first_name":"alice","last_name":"liddell","street":"123 drink me way","city":"wonde...
Copied!
5.12.2 Verify that the alice user cannot create an entry for another user by running:
1
cleos push action addressbook upsert '["bob", "bob", "is a loser", "doesnt exist", "somewhere", "someplace"]' -p [email protected]
Copied!
The require_auth method in a contract should not allow another user to create (or modify) strings. As a result, you should receive an error message:
1
Error 3090004: Missing required authority
2
Ensure that you have the related authority inside your transaction!;
3
If you are currently using 'cleos push action' command, try to add the relevant authority using -p option.
Copied!
5.12.3 Get a user record with the alice name.
1
cleos get table addressbook addressbook people --lower alice --limit 1
Copied!
As an output the following information should appear:
1
{
2
  "rows": [{
3
      "key": "3773036822876127232",
4
      "first_name": "alice",
5
      "last_name": "liddell",
6
      "street": "123 drink me way",
7
      "city": "wonderland",
8
      "state": "amsterdam"
9
    }
10
  ],
11
  "more": false
12
}
Copied!
5.12.4 Verify that the user with the name alice can delete the record from the table by executing::
1
cleos push action addressbook erase '["alice"]' -p [email protected]
Copied!
As an output the following information should appear:
1
executed transaction: … 
2
#   addressbook <= addressbook::erase           {"user":"alice"}
3
warning: transaction executed locally, but may not be confirmed by the network yet    ]
Copied!
Check for no record by running:
1
cleos get table addressbook addressbook people --lower alice --limit 1
Copied!
The following Information should appear:
1
{
2
  "rows": [],
3
  "more": false
4
}
Copied!
4 Understanding ABI Files
6 Secondary Indexes
Last modified 3yr ago
Copy link
Contents
5.1 Create a new directory for the address book contract
5.2 Create file
5.3 Create address book data structure
5.4 Configure table indexes
5.5 Create class constructor
5.6 Create table entries
5.7 Deleting records from the table
5.8 Edit the ABI file
5.9 Compile a contract
5.10 Describe the index of the primary key of the table in the ABI file
5.11 Install a contract
5.12 Test an established contract