Data Location Assignment [OLD]

Dimitar_Stefanov · April 6, 2020, 2:34pm

pragma solidity 0.5.1;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     users[id].balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

FuriousD · April 6, 2020, 2:56pm

user is destroyed after function is called so balance being updated is not persistent. Update balance in mapping instead.

function updateBalance(uint id, uint balance) public {
// User memory user = users[id];
users[id].balance = balance;
}

jon_m · April 8, 2020, 1:32am

I’m just posting my amended updateBalance function, as the rest of my contract remains unchanged.

Solution 1
The original version stops at line 2 of the function body, and saves the updated balance to user (the newly created instance of the User struct). However, as user is only saved locally to memory , it and all its properties (including the updated balance) are lost when the function is exited. This is resolved by adding line 3 to the function body, which assigns this locally created instance (together with all its properties, including the updated balance) to the mapping (users) before it is lost. The updated balance is now saved permanently (until it is updated again) because the mapping is saved in storage.

function updateBalance(uint id, uint balance) public {
    User memory user = users[id];
    user.balance = balance;        // original version stopped here
    users[id] = user;              // adding this line solves the problem
}

Solution 2 (my preferred solution)
This is a more concise version of solution 1. By combining lines 1 and 2 of the function body, it avoids the unnecessary step of creating the temporary instance (user), and instead directly assigns the updated balance to the mapping. The additional line 3 in solution 1 is also therefore no longer needed.

function updateBalance(uint id, uint balance) public {
    users[id].balance = balance;
}

Gab · April 8, 2020, 11:48am

i had to change some variable names to not get stupid with small u big U, singular and plural, solved, took me an ungodly amount of time to find the correct syntax but the error was clear pretty soon actually.

pragma solidity 0.5.1;
contract MemoryAndStorage {

mapping(uint => person)private users;

struct person{
    uint id;
    uint balance;
}


function addUser(uint id, uint balance) public {
    users[id] = person(id, balance);
}

function updateBalance(uint id, uint balance) public {
     users[id].balance = balance;

}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

creatiiive · April 8, 2020, 12:46pm

function updateBalace (uint id, uint balance) public{users[id].balance = balance;}
enough said.

gdoujaiji1 · April 8, 2020, 1:16pm

Change memory to storage:
function updateBalance(uint id, uint balance) public {
User storage user = users[id];
user.balance = balance;
}

abuga · April 8, 2020, 7:18pm

pragma solidity 0.5.12;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     User storage user = users[id];
     user.balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

Gab · April 12, 2020, 2:46pm

so the correction that I have made is this:

......
function updateBalance(uint id, uint balance) public {
         User storage user = users[id];
         user.balance = balance;
.....

or simpler:

......
function updateBalance(uint id, uint balance) public {
         users[id].balance = balance;
.....

ibourn · April 12, 2020, 6:37pm

function updateBalance(uint id, uint balance) public {
    // User memory user = users[id];
    // user.balance = balance;
   //CORRECTION :
    users[id].balance = balance;
}

in the first code, we used ‘memory’ for user so the balance can’t be stored more than the life time of the function.
even if we don’t use ‘memory’, balance is stored in the user Struct but we didn’t affect this user to the mapping

andersbraath1 · April 14, 2020, 6:47pm

pragma solidity 0.5.1;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     User storage user = users[id];
     user.balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

bl0ckchain_br0thaman · April 14, 2020, 8:59pm

The new balance value should be stored as storage value, not in memory.

Brian_Lenertz · April 15, 2020, 5:57pm

swapped out memory for storage in the updateBalance function. memory variables don’t hold values outside of a function.

ivga80 · April 15, 2020, 11:10pm

What happened to your code?
Ivo

ivga80 · April 15, 2020, 11:11pm

Don’t you want to post it here?

Ivo

Adi · April 17, 2020, 12:33pm

I changed the memory to storage as storage is saved permanently therefore fixing the bug.

pragma solidity 0.5.1;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     User **storage** user = users[id];
     user.balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

Toby_K · April 19, 2020, 11:21am

I changed the compiler version from 0.5.1 to 0.5.12 to be consistent with the course.
Testing the contract it is clear that the updateBalance function has an issue with permanent storage of the new balance. The function parameter ‘uint balance’ can not be modified in terms of data location. Uint will always remain in stack.
As a solution I modified the function so that both id and new balance are stored permanently in the mapping. It seemed the most simplistic answer to me. I tested my solution and it worked.
Another (less elegant) way would have been to assign ‘storage’ data location to the User struct inside the updateBalance function.

pragma solidity 0.5.12;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

dinucci · April 19, 2020, 10:20pm

`I changed memory for storage and seemed to work, will move on to the solution and see the explanation

++++++++++++++++++++++++++++++++++

pragma solidity 0.5.1;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
         User storage user = users[id];
         user.balance = balance;
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

ajcapo90 · April 21, 2020, 12:18pm

In updateBalance function, the variable user is just executed inside the function and it will not save outside it, because of memory statement.

The fastest solution to solve this problem is to change the data location from memory to storage, to save it permanently.

pragma solidity 0.5.12;

contract MemoryAndStorage{
    
    mapping(uint => User) users;
    
    struct User{
        uint id;
        uint balance;
    }
    
    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }
    
    function updateBalance(uint id, uint balance) public {
        User storage user = users[id];
        user.balance = balance;
    }
    
    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }
}

The cheapest solution will be to rewrite the function whit the same body as addUser function. In this way there isn’t any extra data stored permanently (eg. into variable user).

pragma solidity 0.5.12;

contract MemoryAndStorage{
    
    mapping(uint => User) users;
    
    struct User{
        uint id;
        uint balance;
    }
    
    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }
    
    function updateBalance(uint id, uint balance) public {
        users[id] = User(id, balance);
    }
    
    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }
}

Dejan · April 21, 2020, 7:29pm

I changed memory to storage so that the update data will be available outside the update function too.

And this works, however the update and the add user functions now do the exact same thing. If I re-add a user with the same ID but with a new balance, the data is updated as well. So do we actually need an update function at all?

Jego · April 22, 2020, 9:00am

pragma solidity 0.5.1;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     //User memory user = users[id];
     users[id].balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}