What is the scope of State Variables and Storage?

Question

I refer to this - http://solidity.readthedocs.io/en/develop/introduction-to-smart-contracts.html

pragma solidity ^0.4.0;

contract SimpleStorage {
    uint storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public constant returns (uint) {
        return storedData;
    } }

It states:

Of course, anyone could just call set again with a different value and overwrite your number, but the number will still be stored in the history of the blockchain

I understood the state variables are stored in contract storage which is persistent. Are their previous values stored in the blockchain itself?

My question is really what happens if someone is storing db keys, and they have a lot of them in an array - thousands or millions.

How exactly would the array be stored when one element is changed? Does the historical storage hold only the changed array element and an index or is the whole array stored?

If I have say -

Student {
 uint age;
 uint studentId;
 uint studentScore;
 uint studentCourseFee;
}

Student[] public students;

Then I have 40,000 students so Student[] has 40K elements, and then I change one entry. What happens to the whole array? If I change entry 22,045 in the array (eg delete it), how does the historical storage record that and how does the new array get stored, now it is one entry shorter?

I can foresee scaling problems with am approach under any design here.

Answer 1

The blockchain itself doesn't store the state. It stores the block headers, transactions, and transaction receipts. The state is constructed by applying the transactions in the correct order.

Moreover, every contract has a storage consisting of virtual 2^256 256-bit slots. How datatypes are mapped to these slots is language/compiler dependent. Here you can read how it works in Solidity: http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage. You'll see that arrays in Solidity do not follow the layout, which you would expect in C/C++ for instance.

Finally, every storage slot is stored by the node in a data structure called merkle-patricia-tree (trie). When the state changes, only the delta of the change is appended to the trie. See https://blog.ethereum.org/2015/11/15/merkling-in-ethereum/

Changes to the storage are very expensive in Ethereum (20,000 gas / 32-byte slot). Maximum capacity of a block is around 8Mil gas. This means, in theory, you could store some 12-13Kb of data every 15s. Hence, it doesn't make sense to use Ethereum for storing large data. The design goal is: store as less as necessary. move everything else to an off-chain database or a distributed filesystem (swarm/ipfs/...).