Data Location Assignment [OLD]

vnaysngh · September 27, 2020, 11:52am

Well, here’s my solution

pragma solidity 0.5.12;

contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

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

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

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

}

jon_m · September 27, 2020, 10:22pm

Hi @sajede.k,

Ok, so is your solution just the 3rd line in the updateBalance function body? i.e.

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

Also, please don’t post screen shots of your assignment solution code, because the code can’t be copied and pasted into a text editor for executing and testing purposes. Thanks

sajede.k · September 28, 2020, 4:23am

Hi
Yes i suppose that worked.
I thought this is more obvious and clear this way, but you’re right.Ok

Warphine · September 28, 2020, 5:48pm

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

Agent989 · September 28, 2020, 9:14pm

in updateBalance the following is taking place.

the user is being retreived from the mapping (storage) and then stored into a memory variable called user.
The memory variable is being updated.

The data should be written back to the mapping but this is not being done. The memory variable (user) is erased after the function call.

A solution is to add the statement:

users[id] = user;

jon_m · September 28, 2020, 10:26pm

You should be deploying your solutions yourself to test whether they work… no supposing then

connerkup · September 29, 2020, 7:10am

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;
}

}

oneworldcoder · September 29, 2020, 9:32am

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;
    }

}

or

ThisIsNotStefan · September 29, 2020, 3:02pm

From my point of view, the easiest fix would be to assign the new balance to the instance that is already stored in storage.

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

mat.rhombus · October 1, 2020, 1:56am

This was my first solution, but after reviewing the communities responses, it seems like mine works but wasn’t dry enough

Realized I could have just updated “User memory user = users[id];” to “User storage user = users[id];” which would have cancelled out the need to add “users[id] = User(id, balance);” to the updateBalance function.


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];
         user.balance = balance;
         users[id] = User(id, balance);
    }

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

}

enrico · October 2, 2020, 1:59pm

I’ve missed this replay! sorry for the late answer and thanks for it! I did the solution to the assignment right and I did the previous post just as an exercise. That is clear to me.

I’ve still some doubt about this code:

User storage user = users[id]; 
        user.id = id;
        user.balance = balance;

doing so I assign users[id] to user and the problem is that user is empty (because the function didn’t assign id and balance yet to it) ?

Also I don’t understand why it works if it is wrong.

Sorry for the long reply and thanks for your patience!

jon_m · October 3, 2020, 4:54pm

Hey @enrico,

Great!

enrico:

I’ve still some doubt about this code:
User storage user = users[id]; 
        user.id = id;
        user.balance = balance;
doing so I assign users[id] to user and the problem is that user is empty (because the function didn’t assign id and balance yet to it) ?

Assigning users[id] to user isn’t wrong, it’s just unnecessary/superfluous if user is defined as a local variable in memory (instead of storage). This is because, whether this is a new person or an update to an existing person, this new or updated User instance still needs to be saved to the mapping located in storage after the ID and balance data have been assigned in the 2nd and 3rd lines, as follows:

users[id] = user;

In summary: this is one possible solution

function updateBalance(uint id, uint balance) public {
        User memory user;
        // User memory user = users[id];
        // this still works ok, but it's unnecessary/superfluous
   
        user.balance = balance;
        users[id] = user;
    }

If we change memory to storage, then assigning users[id] to user isn’t wrong at all, in fact it’s necessary in order to establish user as a “pointer” to the users mapping i.e. whatever is assigned to user within the function is automatically stored within the users mapping.

In summary: this is another possible solution:

function updateBalance(uint id, uint balance) public {
    User storage user = users[id];
    user.balance = balance;
    // users[id] = user;
    // this last line now isn't needed as the 1st line performs this assignment
}

So, hopefully, you can also now see that in this second solution, if user now points to the same User instance in the mapping as users[id], then adding a user variable is actually an unnecessary intermediary step, which we can cut out, and we can just combine the first two lines as follows:

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

I hope that helps to clarify things for you. But just let us know if you have any further questions

moonman · October 4, 2020, 6:59pm

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;
    }
}

my solution

freddythebee · October 5, 2020, 2:25pm

Changes made below

pragma solidity 0.5.12; // Updated the soldity version
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];
         // user.balance = balance;
         
         // As data in 'memory' is lost after function is exited, the data will not update global 
         // mapping, so to update the mapping, I added the following line:
         
         // users[id] = user;
         
         
        // However I noticed that the Gas cost with this change, was quite high, so I decided
        // to update the global mapping directly, which brought the Gas cost down.
        
        users[id].balance = balance;
    }

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

}

jon_m · October 5, 2020, 8:15pm

Hi @freddythebee,

Good to see you back here in the forum!

Excellent analysis of the assignment solution, and spot on regarding the gas costs

SiAdams · October 5, 2020, 8:36pm

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;
}

}

gmarcotte · October 6, 2020, 3:01am

pragma solidity 0.5.1;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    require(id > 0);  // added to check input because we dont want any zero ids
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
    require(id > 0);                // added to check input because we dont want any zero ids
    require(users[id].id > 0);      // added this to make sure user exists -- This code will prevent user from creating a new user, must use addUser for that.
    //User memory user = users[id];
    //users[id].balance = balance;  // this is the problem right here - this var is not in storage area.
    users[id].balance = balance;    // added this to fix the problem:  update the persistant storage
}


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

}

nicolasgarcia214 · October 6, 2020, 4:27pm

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;
}

}

biokillos · October 7, 2020, 8:38am

Just simplifying the updateBalance function did the trick.

pragma solidity 0.6.6;

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;
    }
}

Afronizer · October 8, 2020, 1:54pm

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;
}

}