[Ethereum] Searching data on a smart contract

contract-designcontract-developmentmappingsoliditystruct

I have a smart contract which contains some article data stored inside a struct, which is mapped with an id which uniquely identifies it with a mapping, like this:

struct Foo {
    string a;
    string b;
}

mapping (uint64 => Foo) public articles;

(Obviously the above code is simplied, but the structure is the same, although the real struct has 7 variables instead of 2).

Now I have to be able to search using any of the 7 attributes. The blockchain is going to be private, so gas usage is not a concern.

My first solution was to add a search method to the smart contract and, within it, traverse the entire mapping and check which items satisfy the condition. Obviously this is O(n) and it was taking around 8 seconds for 2000 elements, which although isn't bad, I hope for a better solution.

Then I thought about having 7 more mappings which would act as search indexes, mapping each attribute value to the index of the article that satisfies it, such as:

mapping (string => uint64) public searchIndex;

(Note that right now it isn't required to check substrings, only equality)

And finally, I was thinking about if it would be good to do keep these indexes on Elastic Search rather than on the blockchain itself, although I would prefer a pure blockchain-based solution if possible.

So, what of these options (of any other better you know) do you think is more adequate?

Thank you.

Best Answer

It is clear you can't directly get the object you want without knowing it's key. The idea of the 7 mappings is actually the most obvious and the least complicated one and it works in most cases not only yours.

The most useful idea I can come up with is that you look for patterns in your struct attributes, patterns that help you organize a search schema in case you have 10 or 20 thousand elements. e.g. ; if string a values are linked to a known timeline like a == "X12" for today and the next day another entry would havea == "X13". So when you want to search for structs with a == X32 you will have better understanding of where could that struct be and what are the search index limits.

Thus making searching in 20 thousand elements a search in only 2 thousand.

hope it was clear.

Related Solutions

Solidity Smart Contract – How to Access External Data and Knowledge

The common pattern is called an oracle.

Ethereum contracts cannot communicate directly with the outside world, so they must rely on the outside world pushing information into the network.

You have 2 choices:

Use an oracle: Services like Oraclize are formal implementations where you pay to poke their services for oracle data that they provide.
Write an oracle: If the data you require is not already oracle-ized, but you have the savvy to do so, you can write your own external service that periodically pokes data into your own oracle contract. Then your application contract just requests it when it needs it.

solidity – How to Push and Pull Data from a Storage Contract?

I started with your example and adapted it until it works. A few pointers I noticed while doing it.

struct defines a Type. You have to cast a Variable with that Type to storage values. mapping is the tool for organizing instances by unique key.

I changed the Type of name to bytes32 because it's not possible to pass strings between contracts at this time.

E will need knowledge of the ABI for D so it can make calls. D is in the same source file, so the compiler can "see" it when it encounters this line that casts a variable as type "D".

D d;

E will also need to know the address of "the" D instance it should be talking to. The constructor for E expects an address passed in when it gets deployed.

I made the mapping public so there's a "free" getter function called documentStructs() and it expects only the key passed in. It returns the two values stored.

pragma solidity ^0.4.6;

contract D {

  // This is a Type
  struct DocumentStruct{
    // Not possible to pass strings between contracts at this time
    bytes32 name;
    uint value;
  }

  // This is a namespace where we will store docs of Type DocumentStruct
  mapping(bytes32 => DocumentStruct) public documentStructs;

  // Set values in storage
  function StoreDocument(bytes32 key, bytes32 name, uint value) returns (bool success) {
   documentStructs[key].name  = name;
   documentStructs[key].value = value;
   return true;
  }

}

contract E {

  // "d" is of type "D" which is a contract ^
  D d;

  // Define the Type in this context
  struct DocumentStruct{
    bytes32 name;
    uint value;
  }    

  // For this to work, pass in D's address to E's constructor
  function E(address DContractAddress) {
    d = D(DContractAddress);
  }

  function RetrieveData(bytes32 key) 
    public
    constant
    returns(bytes32, uint) 
  {
    // Declare a temporary "doc" to hold a DocumentStruct
    DocumentStruct memory doc;
    // Get it from the "public" mapping's free getter.
    (doc.name, doc.value) = d.documentStructs(key);
    // return values with a fixed sized layout
    return(doc.name, doc.value);
  }
}

There are all sorts of non-obvious data organization considerations that can be a bit of a struggle in the early stages. It may be helpful to look at the strengths and weaknesses of different patterns unfolded over here: Are there well-solved and simple storage patterns for Solidity?

Here is the above in Remix to show it working.

Hope it helps.

Best Answer

Related Solutions

Solidity Smart Contract – How to Access External Data and Knowledge

solidity – How to Push and Pull Data from a Storage Contract?

Related Topic