palmik / data-store

Multi-key multi-value store for Haskell native data types with type safe interface.

Data.Store is pure, in-memory dictionary written in Haskell that supports multidimensional keys.

See:

• Documentation
• Examples

data-store's Issues

Make the lens based interface in Data.Store.Lens work with lists instead of stores.

We will gain performance on par with regular lookup but we will lose the ability to chain the lenses (this should not matter since we can create 'composite' query in one go unlike in tables where chaining of the lenses is used to create 'composite' queries).

API documentation update

Hi,
data-store seems a very interesting library for databases, but could you improve the documentation?
Explain, for example, what is the role of tag in

data Store tag krs irs ts v

it seems that there is a mistake with the later example

...
type ContentStore = Store ContentStoreKRS ContentStoreIRS ContentStoreTS Content

Also, it is not clear how the O and M specifications affect the operations that I can run on a Store.

Thanks

Data.Store.map fails to update index.

I haven't yet produced a minimal test case as my application is fairly complex, but here's the gist:

I'm using Storable to create a table for a record I have. The record has a field watchWState that is essentially defined as Active Int | Notifying.

If I do a map to update the state to Notifying from Active, if I do a query like S.lookup (sWatchWState .== Notifying) table, it comes back with nothing. Showing the raw table shows that the value of the row has Notifying, but the key portion still has the original value.

I can't imagine this is expected behavior. Maps by definition will update the records, so its weird that you cannot query the new table by the new values. It seems like the code https://github.com/Palmik/data-store/blob/master/src/Data/Store.hs#L445 just passes the key straight through.

In the mean time i guess I can do something like (S.fromList . Data.List.map . S.toList).

Ordered lookups.

Add ordered lookups. The function signatures should look like this (here I assume that (tag, n) denotes dimension of type one-to-one, but it could be extended to one-to-many dimensions as well):

lookupOrderByA :: IsSelection sel => sel tag krs irs ts -> (tag, n) -> I.Store tag krs irs ts v -> [(I.RawKey krs ts, v)]
lookupOrderByD :: IsSelection sel => sel tag krs irs ts -> (tag, n) -> I.Store tag krs irs ts v -> [(I.RawKey krs ts, v)]
lookupMap :: IsSelection sel => sel tag krs irs ts -> (tag, n) -> I.Store tag krs irs ts v -> Data.Map.Map (DimensionType krs irs n) (I.RawKey krs ts, v)

MySQL implements this (in the most general case) by sorting the result of the query afterwards [1]. I know we can do better at least in the case where the selection is simply (SelectionDimension n) and we want to order the results by (tag, n).