Is this API too simple?

Question

There are a multitude of key-value stores available. Currently you need to choose one and stick with it. I believe an independent open API, not made by a key-value store vendor would make switching between stores much easier.

Therefore I'm building a datastore abstraction layer (like ODBC but focused on simpler key value stores) so that someone build an app once, and change key-value stores if necessary. Is this API too simple?

get(Key)
set(Key, Value)
exists(Key)
delete(Key)

As all the APIs I have seen so far seem to add so much I was wondering how many additional methods were necessary?

I have received some replies saying that set(null) could be used to delete an item and if get returns null then this means that an item doesn't exist. This is bad for two reasons. Firstly, is it not good to mix return types and statuses, and secondly, not all languages have the concept of null. See:

http://stackoverflow.com/questions/2324337/do-all-programming-languages-have-a-clear-concept-of-nil-null-or-undefined

I do want to be able to perform many types of operation on the data, but as I understand it everything can be built up on top of a key value store. Is this correct? And should I provide these value added functions too? e.g: like mapreduce, or indexes

Internally we already have a basic version of this in Erlang and Ruby and it has saved us alot of time, and also enabled us to test performance for specific use cases of different key value stores

Answer 1

If all you are doing is getting, setting, and deleting keys, this is fine.

Answer 2

Do only what is absolute necessary, instead of asking if it is too simple, ask if it is too much, even if it only has one method.

Answer 3

There is no such thing as "too simple" for an API. The simpler the better! If it solves the need the way it is, then leave it.

Answer 4

The delete method is unnecessary. You can just pass null to set.

Edited to add:

I'm only kidding! I would keep delete, and probably add Count, Contains, and maybe an enumerator (or two).

Answer 5

I am all for simplifying an interface to its bare minimum but without having more details about the requirements of the system, it is tough to tell if this interface is sufficient. Sure looks concise enough though.

Don't forget to document the semantics for "key non-existent" as it isn't clear from reading your API definition above. updated: I see you have added the exists method: is this necessary? you could use the get method and define a NIL of some sort, no?

Maybe worth thinking about: how about considering "freshness" of a value? i.e. an associated "last-modified" timestamp? Of course, it depends on your system requirements.

What about access control? Is it within scope of the API definition?

What about iterating through the keys? If there is a possibility of a large set, you might want to include some pagination semantics.

Answer 6

Your API lacks some useful functions like "hasKey" and "clear". You might want to look at, say, Python's hack at it, http://docs.python.org/tutorial/datastructures.html#dictionaries, and pick and choose additional functions.

Everyone is saying, "simple is good" and that's true until "simple is too simple."

Answer 7

As mentioned, the simpler the better, but a simple iterator or key-listing method could be of use. I always end up needing to iterate through the set. A "size()" method too, if not taken care of by the iterator. It obviously depends on your usage, though.

Answer 8

When creating an API, you need to ask yourself, what does my API provide the user. If your API is so simplistic that it is faster and easier for your client to write their own app, then your API has failed. Ask yourself, does my functionality give them specific benefits. If the answer is no, it is too simplistic and generic.

Answer 9

It's not too simple, it's beautiful. If "exists(key)" is just a convenient shorthand for "get(Key) != null", you should consider removing it. I guess that depends on how large or complex the value you get() is.