Driver Haskell Riak: fare una semplice operazione "put"

Question

Sto cercando di presentarmi a Riak con Haskell driver e sono bloccato con una semplice operazione put. Sono confuso con la firma della funzione put. e non c'è un solo esempio da nessuna parte là fuori.

Quindi, con questa firma:

put :: (FromJSON c, ToJSON c, Resolvable c) => Connection -> Bucket 
     -> Key -> Maybe VClock -> c -> W -> DW -> IO (c, VClock) 

Ho un paio di domande.

Che cos'è un Forse VClock? Devo generarlo in qualche modo o è sufficiente specificare solo nulla lì? E perché restituisco questa VClock nella tupla restituita?

Devo scrivere istanze FromJSON e ToJSON per ogni semplice valore che ho inserito anche se si tratta di un valore stringa semplice? Come se volessi mettere un valore "Stitch" con il tasto "Name", come lo faccio?

Che cos'è l'istanza Resolvable? Come posso risolvere un valore di testo o stringa risolvibile? Capisco che devo definire la funzione resolve ma non capisco cosa significa e come farlo.

Answer 1

spero seguente codice di semplice put e ottenere operazione può aiutare a:

{-# LANGUAGE DeriveGeneriC#-} 
{-# LANGUAGE UndecidableInstances #-} 

module Main where 
import Data.Aeson 
import qualified Network.Riak as Riak 
import Network.Riak.Types 
import Data.ByteString.Char8 hiding (putStrLn) 
import Data.ByteString.Lazy as L hiding (pack,putStrLn) 
import GHC.Generics hiding (R) 

-- convert String to lazy ByteString 
toBS :: String -> L.ByteString 
toBS str = L.fromChunks (pack (str):[]) 

putBucket :: Bucket 
putBucket = toBS "Bucket" 

putKey :: Key 
putKey = toBS "key" 

r :: R 
r = Default 

w :: W 
w = Default 

dw :: DW 
dw = Default 

rw :: RW 
rw = Default 

-- declare a data and create its instances 
data Coord = Coord { x :: Double, y :: Double } deriving (Generic, Show) 

instance FromJSON Coord 

instance ToJSON Coord 

instance (Show Coord) => Riak.Resolvable Coord where 
    resolve a b = a 

value :: Coord 
value = Coord { 
    x = 2.2, 
    y = 3.3 
} 


main :: IO() 
main = do 
    -- establish a connection 
    let client = Riak.defaultClient 
    con <- Riak.connect client 
    -- simple put operation 
    put_ret <- (Riak.put con putBucket putKey Nothing value w dw) 
    putStrLn (show put_ret) 
    buckets <- Riak.listBuckets con 
    print buckets 
    -- simple get operation 
    get_ret <- (Riak.get con putBucket putKey r) :: IO (Maybe (Coord, VClock)) 
    putStrLn (show get_ret) 
    -- delete a value 
    Riak.delete con putBucket putKey rw 
    -- if try to get that value we will find "Nothing" 
    get_ret <- (Riak.get con putBucket putKey r) :: IO (Maybe (Coord, VClock)) 
    putStrLn (show get_ret) 
    -- print the final bucket list 
    buckets <- Riak.listBuckets con 
    print buckets 

Answer 2

Maybe VClock è il VClock dell'oggetto che si sta aggiornando (Just vclock) o Nothing. È possibile specificare Nothing qui se non ci sono oggetti per questa chiave già nel database.

Il VClock avvolto in IO (IO (c, VClock)) è il VClock dell'oggetto inserito, restituito dal database.

Il tipo di dati sarà necessario un ToJSON e un'istanza FromJSON per utilizzare quella funzione put. Aeson contiene istruzioni per la scrittura automatica. È possibile memorizzare dati non JSON utilizzando i moduli Network.Riak.Value, ma questo è più complicato.

risolvibile viene utilizzato per risolvere i due fratelli e si presenta come questo, dove a e b sono MyDataType s:

instance Resolvable MyDataType where resolve a b = a

Idealmente la vostra funzione decisione fa qualcosa di più intelligente di una semplice raccolta a o b come l'ordinamento è non garantito e può essere chiamato più volte se ci sono più fratelli.

here è un codice per creare un pool di connessioni Riak che potrebbe risultare utile.

Vi ritroverete con qualcosa che assomiglia a questo:

put conn bucket key Nothing value Quorum Quorum

dove value è i dati. Altro su Quorumhere.