Careful with transformations between ints and strings when serializing about aiocache HOT 5 CLOSED

aioredis behaves like this by default:

In [5]: import asyncio
   ...: import aioredis
   ...: 
   ...: loop = asyncio.get_event_loop()
   ...: 
   ...: @asyncio.coroutine
   ...: def go():
   ...:     redis = yield from aioredis.create_redis(
   ...:         ('localhost', 6379), loop=loop)
   ...:     yield from redis.set('my-key', 1)
   ...:     val = yield from redis.get('my-key', encoding="utf-8")
   ...:     print(val)
   ...:     print(type(val))
   ...:     redis.close()
   ...: loop.run_until_complete(go())
   ...: 
1
<class 'str'>

Reducing priority since its the behavior of the default client.

Anyway, the solution that could be implemented is to save the type of the key and make the cast when it is retrieved. This type saving should be optional since it will use extra space... An example flow:

1. set("my-key", 1, save_type=True) # this will create both the my-key: 1 and my-key-type: int keys.
2. When retrieving, it will do a my-key-type(retrieved_value).

If save_type is not passed, client default behavior is implemented. This behavior should only be for built int python types?? For advanced python objects pickle and custom serializer strategies can be followed. Need to think about it and see if this case is worth it to implement

from aiocache.

Where this logic will reside is yet to decide (serializers or backend).

from aiocache.

Add an example of how to solve this using marshmallow. Once its well explained issue can be closed (and reopen another one in case the saving type functionality is asked

from aiocache.

Problem is deeper, with defaultserializer, memorycache can store any object and will retrieve it correctly. with memcached and redis this is not possible. Behavior should be the same for the different caches but then we will be cutting functionality from the memory one...

from aiocache.

Lets follow redis-py approach of converting the values transparently instead of limiting the behavior.

This will introduce the following behavior with the default serializer:

await cache.set("key", 1)
await cache.get("key")
>>>> '1'

await cache.set("key", {"a": 1, "b": []})
await cache.get("key")
>>>> '{"a": 1, "b": []}'

Documentation must be clear and warn the user about that.

Each backend must be responsible of converting to the needed datatype. I've tried to do this in the serializer layer but then the user must change existing serializers to return bytes or something supported by the user. Lets allow this "incorrect" type propagation until the backend itself and then deal with it there.

from aiocache.