Solidity – How to Filter Through an Array of Structs?

arrayscontract-developmentsoliditystructtransactions

I want a way to store an array of structs. And then I want the ability to filter through this array and pick out a subset of items where a certain struct parameter named foo == bar for example.

Is this possible in solidity? Are there any limitations on how large my original my array is and the number of returned items?

Lastly, because this would only read from the ledger, it should not cost any gas to execute correct?

Thank you.

Best Answer

As I understand its possible with followings,

Are there any limitations on how large my original my array

The limitation to contracts' storage is the limitation for this as well - i.e. 2^261 bytes. You may refer this question for contract storage limitation.

number of returned items?

There are two limitations; what solidity has allowed to return from a function which has a good read here and what your client machine used to connect to the ethereum network can handle in it's memory.

because this would only read from the ledger, it should not cost any gas to execute correct

This depends on your requirement. If what you want is just to read without a transaction involved (to display locally or so) it won't cost gas. But although the function is constant, if you need it to be used within a transaction (let's say you call non-constant function and within that function you use this constan function to verify something ) this may still cost gas. A good read regarding this can be found in this question.

code would look like something similar to this, depending on your requirement it may change

MyStruct[] myStructArray;

function checkArray() constant returns(bool[]){ // change on what you need to return

    bool[] checker; // change on what you need to return

    for(uint i = 0; i<myStructArray.length; i++){
        if(myStructArray[i].foo == bar){
            checker[i]=true; //or whatever you want to do if it matches
        }
        else{
            checker[i]=false;
        }
    }
    return checker;
}

Related Solutions

Solidity Memory Management – Does ‘Delete’ Free Mapping Space

Based on my Debug observation:

I have tested that:

Firstly I insert data into my map data-structure as I explained in my question.
Secondly, I have returned the address of first mapped index, which is 0, this could be done for other indexes as well (0:10).
Without a delete operation I can retrieve the data perfectly fine from the address of mapped Foo[]. But if I did the delete operation, Solidity gives an error.

This debug result: leads me to conclude that memory is freed or address does not contain any valid information.

Test code:

set_txn_hash     = my_contract.transact().map_insert();
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)

for x in range(0, 9):
   for y in range(0, 9):
         output           = my_contract.call().get_(x, y);
         print(output);  //returns correct value.

set_txn_hash     = my_contract.transact().map_remove_map();                                             
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)                                      

set_txn_hash     = my_contract.transact().get_map_address(0);
contract_address = unmigrated_chain.wait.for_receipt(set_txn_hash)

output           = my_contract.call().get_map();
print(output);

output           = my_contract.call().try_();
print(output);  //Solidity gives error if delete map_remove_map() is called

Additional functions inside my Contract:

  function map_insert(){
    for(uint i = 0; i < 10; i++)
      for(uint j = 0; j < 10; j++)
        add(i, i*10 + j);
  }

  function map_remove_map(){
    for(uint i = 0; i < 10; i++)
      delete_(i);
  }

  function map_remove_map_item(){
    for(uint i = 0; i < 10; i++)
      for(uint j = 0; j < 10; j++)
        delete_items(i, j);
  }

  function get_map_address(uint id) {
    uint addr;
    Foo[] a = foo[id];

    assembly{
    addr := a
        }
    map_address = addr;
  }

  function get_map() constant returns (uint){
    return map_address;
  }

  function try_() constant returns (uint ){
    uint addr = map_address;
    Foo[] a;
    assembly{
    a := addr
        }
    return a[1].x;  
  }

Solidity Arrays – Storing a Dynamic Array of Structs Containing Dynamic Array of Structs

It worked a lot better using a mapping to store the struct.

I used user-supplied keys for random access to the mapped structs and added a list of the keys in case iteration is important.

pragma solidity 0.4.24;

contract Bounties {

    // an unordered list of keys

    bytes32[] public bountyList;

    struct Bounty {
        bool isBounty; // simple collision check
        address issuer;
        uint256 fulfillmentAmount;
        uint256 balance;
        bool bountyOpen;
        Fulfillment[] fulfillments;
        mapping (bytes32 => bool) used;
    }

    struct Fulfillment {
        uint256 fulfillmentAmount;
        address fulfiller;
    }

    // a mapping to the Bounty structs
    mapping(bytes32 => Bounty) public bountyStructs;

    function isBounty(bytes32 key) public view returns(bool isIndeed) {
        return bountyStructs[key].isBounty;
    }

    function newBounty(bytes32 key, address _issuer, uint amount) public payable returns(bool success) {
        require(!isBounty(key)); // no duplicates
        bountyList.push(key);
        bountyStructs[key].isBounty = true;
        bountyStructs[key].issuer = _issuer;
        bountyStructs[key].fulfillmentAmount = amount;
        bountyStructs[key].balance = msg.value;
        bountyStructs[key].bountyOpen = true;
        // no need to initialize the mapping
        // should emit an event here
        return true;
    }

    function appendFulfillment(bytes32 bountyKey) public payable returns(bool success) {
        require(isBounty(bountyKey));
        Fulfillment memory f;
        f.fulfillmentAmount = msg.value;
        f.fulfiller = msg.sender;
        bountyStructs[bountyKey].fulfillments.push(f);
        // should emit an event here.
        return true;
    }

}

Hope it helps.

Best Answer

Related Solutions

Solidity Memory Management – Does ‘Delete’ Free Mapping Space

Solidity Arrays – Storing a Dynamic Array of Structs Containing Dynamic Array of Structs

Related Topic