influxdb 1.5.2 → 1.6.0

raw patch · 7 files changed

+321/−88 lines, 7 filesdep +taggedPVP ok

version bump matches the API change (PVP)

Dependencies added: tagged

API changes (from Hackage documentation)

Files

• CHANGELOG.md +9/−0
• influxdb.cabal +3/−2
• src/Database/InfluxDB.hs +36/−8
• src/Database/InfluxDB/JSON.hs +4/−0
• src/Database/InfluxDB/Manage.hs +2/−2
• src/Database/InfluxDB/Query.hs +174/−75
• src/Database/InfluxDB/Types.hs +93/−1

@@ -1,5 +1,14 @@ # Revision history for influxdb +## v1.6.0 - 2018-04-14++This release includes a few significant breaking changes.++* Deprecate the confusing parseQueryField and re-export parseJSON instead+* Rewrite the QueryResults instances for tuples+* Add Timestamp instance for TimeSpec (#59)+* Extend haddock comments+ ## v1.5.2 - 2018-04-11  * Export parseResultsWithDecoder, Decoder, lenientDecoder and strictDecoder from Database.InfluxDB

@@ -1,5 +1,5 @@ name: influxdb-version: 1.5.2+version: 1.6.0 synopsis: Haskell client library for InfluxDB description:   @influxdb@ is a Haskell client library for InfluxDB.@@ -13,7 +13,7 @@ copyright: Copyright (C) 2014-2018 Mitsutoshi Aoe category: Database build-type: Custom-cabal-version: >= 1.24+cabal-version: 1.24 tested-with:   GHC == 7.10.3   GHC == 8.0.2@@ -85,6 +85,7 @@     , network >= 2.6 && < 2.7     , optional-args >= 1.0 && < 1.1     , scientific >= 0.3.3 && < 0.4+    , tagged >= 0.1 && < 0.9     , text < 1.3     , time >= 1.5 && < 1.10     , unordered-containers < 0.3

@@ -56,10 +56,15 @@   , strictDecoder   , getField   , getTag+  , parseJSON   , parseUTCTime   , parsePOSIXTime   , parseQueryField +  -- *** Re-exports from tagged+  , Tagged(..)+  , untag+   -- * Database management   , manage @@ -160,10 +165,35 @@  == Querying data -First we define a placeholder data type called 'CPUUsage' and a 'QueryResults'-instance. 'getField', 'parseUTCTime' and 'parseQueryField' etc are avilable to-make JSON decoding easier.+=== Using an one-off tuple +If all the field types are an instance of 'FromJSON', we can use a tuple to store+the results.++>>> :set -XDataKinds -XOverloadedStrings+>>> type CPUUsage = (Tagged "time" UTCTime, Tagged "idle" Double, Tagged "system" Double, Tagged "user" Double)+>>> v <- query p $ formatQuery ("SELECT * FROM "%F.measurement) cpuUsage :: IO (V.Vector CPUUsage)+>>> v+[(Tagged 2017-06-17 15:41:40 UTC,Tagged 10.1,Tagged 53.3,Tagged 46.6)]++Note that the type signature on query here is also necessary to type check.+We can remove the tags using 'untag':++>>> V.map (\(a, b, c, d) -> (untag a, untag b, untag c, untag d)) v :: V.Vector (UTCTime, Double, Double, Double)+[(2017-06-17 15:41:40 UTC,10.1,53.3,46.6)]++Or even using 'Data.Coerce.coerce':++>>> import Data.Coerce+>>> coerce v :: V.Vector (UTCTime, Double, Double, Double)+[(2017-06-17 15:41:40 UTC,10.1,53.3,46.6)]++=== Using a custom data type++We can define our custom data type and write a 'QueryResults' instance+instead. 'getField', 'parseUTCTime' and 'parseQueryField' etc are avilable to+make it easier to write a JSON decoder.+ >>> :{ data CPUUsage = CPUUsage   { time :: UTCTime@@ -172,16 +202,14 @@ instance QueryResults CPUUsage where   parseResults prec = parseResultsWithDecoder strictDecoder $ \_ _ columns fields -> do     time <- getField "time" columns fields >>= parseUTCTime prec-    FieldFloat cpuIdle <- getField "idle" columns fields >>= parseQueryField-    FieldFloat cpuSystem <- getField "system" columns fields >>= parseQueryField-    FieldFloat cpuUser <- getField "user" columns fields >>= parseQueryField+    cpuIdle <- getField "idle" columns fields >>= parseJSON+    cpuSystem <- getField "system" columns fields >>= parseJSON+    cpuUser <- getField "user" columns fields >>= parseJSON     return CPUUsage {..} :}  >>> query p $ formatQuery ("SELECT * FROM "%F.measurement) cpuUsage :: IO (V.Vector CPUUsage) [CPUUsage {time = 2017-06-17 15:41:40 UTC, cpuIdle = 10.1, cpuSystem = 53.3, cpuUser = 46.6}]--Note that the type signature on query here is also necessary to type check. -}  {- $write

@@ -20,6 +20,7 @@   , getTag    -- * Common JSON object parsers+  , A.parseJSON   , parseUTCTime   , parsePOSIXTime   , parseRFC3339@@ -219,3 +220,6 @@     return FieldNull   _ -> fail $ "parseQueryField: expected a flat data structure, but got "     ++ show val+{-# DEPRECATED parseQueryField+  "This function parses numbers in a misleading way. Use 'parseJSON' instead."+  #-}

@@ -51,7 +51,7 @@ import qualified Network.HTTP.Client as HC import qualified Network.HTTP.Types as HT -import Database.InfluxDB.JSON (getField, parseQueryField)+import Database.InfluxDB.JSON (getField) import Database.InfluxDB.Types as Types import Database.InfluxDB.Query hiding (query) import qualified Database.InfluxDB.Format as F@@ -148,7 +148,7 @@  instance QueryResults ShowSeries where   parseResults _ = parseResultsWith $ \_ _ columns fields -> do-    FieldString name <- getField "key" columns fields >>= parseQueryField+    name <- getField "key" columns fields >>= parseJSON     return $ ShowSeries $ F.formatKey F.text name  makeLensesWith

@@ -7,6 +7,7 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE RecordWildCards #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE ViewPatterns #-} module Database.InfluxDB.Query@@ -30,15 +31,22 @@    -- * Low-level functions   , withQueryResponse++  -- * Re-exports from tagged+  , Tagged(..)+  , untag   ) where import Control.Exception import Control.Monad import Data.Char import Data.List+import Data.Proxy+import GHC.TypeLits  import Control.Lens import Data.Aeson import Data.Optional (Optional(..), optional)+import Data.Tagged import Data.Vector (Vector) import Data.Void import qualified Control.Foldl as L@@ -79,10 +87,9 @@ -- instance QueryResults H2OFeet where --   parseResults prec = parseResultsWith $ \_ _ columns fields -> do --     time <- getField "time" columns fields >>= parseUTCTime prec---     String levelDesc <- getField "level_description" columns fields---     String location <- getField "location" columns fields---     FieldFloat waterLevel <----       getField "water_level" columns fields >>= parseQueryField+--     levelDesc <- getField "level_description" columns fields >>= parseJSON+--     location <- getField "location" columns fields >>= parseJSON+--     waterLevel <- getField "water_level" columns fields >>= parseJSON --     return H2OFeet {..} -- :} class QueryResults a where@@ -96,85 +103,177 @@   parseResults _ = A.withObject "error" $ \obj -> obj .:? "error"     >>= maybe (pure V.empty) (withText "error" $ fail . T.unpack) -instance (a ~ Value, b ~ Value) => QueryResults (a, b) where-  parseResults _ = parseResultsWith $ \_ _ _ fields ->-    maybe (fail $ "invalid fields: " ++ show fields) return $ do-      a <- fields V.!? 0-      b <- fields V.!? 1-      return (a, b)+fieldName :: KnownSymbol k => proxy k -> T.Text+fieldName = T.pack . symbolVal -instance (a ~ Value, b ~ Value, c ~ Value)-  => QueryResults (a, b, c) where-    parseResults _ = parseResultsWith $ \_ _ _ fields ->-      maybe (fail $ "invalid fields: " ++ show fields) return $ do-        a <- fields V.!? 0-        b <- fields V.!? 1-        c <- fields V.!? 2-        return (a, b, c)+-- | One-off type for non-timestamped measurements+--+-- >>> let p = queryParams "_internal"+-- >>> dbs <- query p "SHOW DATABASES" :: IO (V.Vector (Tagged "name" T.Text))+-- >>> find ((== "_internal") . untag) dbs+-- Just (Tagged "_internal")+instance (KnownSymbol k, FromJSON v) => QueryResults (Tagged k v) where+  parseResults _ = parseResultsWith $ \_ _ columns fields ->+    getField (fieldName (Proxy :: Proxy k)) columns fields >>= parseJSON -instance (a ~ Value, b ~ Value, c ~ Value, d ~ Value)-  => QueryResults (a, b, c, d) where-    parseResults _ = parseResultsWith $ \_ _ _ fields ->-      maybe (fail $ "invalid fields: " ++ show fields) return $ do-        a <- fields V.!? 0-        b <- fields V.!? 1-        c <- fields V.!? 2-        d <- fields V.!? 3-        return (a, b, c, d)+-- | One-off tuple for sigle-field measurements+instance+  ( KnownSymbol k1, FromJSON v1+  , KnownSymbol k2, FromJSON v2 )+  => QueryResults (Tagged k1 v1, Tagged k2 v2) where+    parseResults _ = parseResultsWith $ \_ _ columns fields -> do+      v1 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k1)) columns fields+      v2 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k2)) columns fields+      return (v1, v2) -instance (a ~ Value, b ~ Value, c ~ Value, d ~ Value, e ~ Value)-  => QueryResults (a, b, c, d, e) where-    parseResults _ = parseResultsWith $ \_ _ _ fields ->-      maybe (fail $ "invalid fields: " ++ show fields) return $ do-        a <- fields V.!? 0-        b <- fields V.!? 1-        c <- fields V.!? 2-        d <- fields V.!? 3-        e <- fields V.!? 4-        return (a, b, c, d, e)+-- | One-off tuple for two-field measurements+instance+  ( KnownSymbol k1, FromJSON v1+  , KnownSymbol k2, FromJSON v2+  , KnownSymbol k3, FromJSON v3 )+  => QueryResults (Tagged k1 v1, Tagged k2 v2, Tagged k3 v3) where+    parseResults _ = parseResultsWith $ \_ _ columns fields -> do+      v1 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k1)) columns fields+      v2 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k2)) columns fields+      v3 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k3)) columns fields+      return (v1, v2, v3) -instance (a ~ Value, b ~ Value, c ~ Value, d ~ Value, e ~ Value, f ~ Value)-  => QueryResults (a, b, c, d, e, f) where-    parseResults _ = parseResultsWith $ \_ _ _ fields ->-      maybe (fail $ "invalid fields: " ++ show fields) return $ do-        a <- fields V.!? 0-        b <- fields V.!? 1-        c <- fields V.!? 2-        d <- fields V.!? 3-        e <- fields V.!? 4-        f <- fields V.!? 5-        return (a, b, c, d, e, f)+-- | One-off tuple for three-field measurements+instance+  ( KnownSymbol k1, FromJSON v1+  , KnownSymbol k2, FromJSON v2+  , KnownSymbol k3, FromJSON v3+  , KnownSymbol k4, FromJSON v4 )+  => QueryResults (Tagged k1 v1, Tagged k2 v2, Tagged k3 v3, Tagged k4 v4) where+    parseResults _ = parseResultsWith $ \_ _ columns fields -> do+      v1 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k1)) columns fields+      v2 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k2)) columns fields+      v3 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k3)) columns fields+      v4 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k4)) columns fields+      return (v1, v2, v3, v4) +-- | One-off tuple for four-field measurements instance-  ( a ~ Value, b ~ Value, c ~ Value, d ~ Value, e ~ Value, f ~ Value-  , g ~ Value )-  => QueryResults (a, b, c, d, e, f, g) where-    parseResults _ = parseResultsWith $ \_ _ _ fields ->-      maybe (fail $ "invalid fields: " ++ show fields) return $ do-        a <- fields V.!? 0-        b <- fields V.!? 1-        c <- fields V.!? 2-        d <- fields V.!? 3-        e <- fields V.!? 4-        f <- fields V.!? 5-        g <- fields V.!? 6-        return (a, b, c, d, e, f, g)+  ( KnownSymbol k1, FromJSON v1+  , KnownSymbol k2, FromJSON v2+  , KnownSymbol k3, FromJSON v3+  , KnownSymbol k4, FromJSON v4+  , KnownSymbol k5, FromJSON v5 )+  => QueryResults+    ( Tagged k1 v1, Tagged k2 v2, Tagged k3 v3, Tagged k4 v4+    , Tagged k5 v5+    ) where+    parseResults _ = parseResultsWith $ \_ _ columns fields -> do+      v1 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k1)) columns fields+      v2 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k2)) columns fields+      v3 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k3)) columns fields+      v4 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k4)) columns fields+      v5 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k5)) columns fields+      return (v1, v2, v3, v4, v5) +-- | One-off tuple for five-field measurements instance-  ( a ~ Value, b ~ Value, c ~ Value, d ~ Value, e ~ Value, f ~ Value-  , g ~ Value, h ~ Value )-  => QueryResults (a, b, c, d, e, f, g, h) where-    parseResults _ = parseResultsWith $ \_ _ _ fields ->-      maybe (fail $ "invalid fields: " ++ show fields) return $ do-        a <- fields V.!? 0-        b <- fields V.!? 1-        c <- fields V.!? 2-        d <- fields V.!? 3-        e <- fields V.!? 4-        f <- fields V.!? 5-        g <- fields V.!? 6-        h <- fields V.!? 7-        return (a, b, c, d, e, f, g, h)+  ( KnownSymbol k1, FromJSON v1+  , KnownSymbol k2, FromJSON v2+  , KnownSymbol k3, FromJSON v3+  , KnownSymbol k4, FromJSON v4+  , KnownSymbol k5, FromJSON v5+  , KnownSymbol k6, FromJSON v6 )+  => QueryResults+    ( Tagged k1 v1, Tagged k2 v2, Tagged k3 v3, Tagged k4 v4+    , Tagged k5 v5, Tagged k6 v6+    ) where+    parseResults _ = parseResultsWith $ \_ _ columns fields -> do+      v1 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k1)) columns fields+      v2 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k2)) columns fields+      v3 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k3)) columns fields+      v4 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k4)) columns fields+      v5 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k5)) columns fields+      v6 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k6)) columns fields+      return (v1, v2, v3, v4, v5, v6)++-- | One-off tuple for six-field measurement+instance+  ( KnownSymbol k1, FromJSON v1+  , KnownSymbol k2, FromJSON v2+  , KnownSymbol k3, FromJSON v3+  , KnownSymbol k4, FromJSON v4+  , KnownSymbol k5, FromJSON v5+  , KnownSymbol k6, FromJSON v6+  , KnownSymbol k7, FromJSON v7 )+  => QueryResults+    ( Tagged k1 v1, Tagged k2 v2, Tagged k3 v3, Tagged k4 v4+    , Tagged k5 v5, Tagged k6 v6, Tagged k7 v7+    ) where+    parseResults _ = parseResultsWith $ \_ _ columns fields -> do+      v1 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k1)) columns fields+      v2 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k2)) columns fields+      v3 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k3)) columns fields+      v4 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k4)) columns fields+      v5 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k5)) columns fields+      v6 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k6)) columns fields+      v7 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k7)) columns fields+      return (v1, v2, v3, v4, v5, v6, v7)++-- | One-off tuple for seven-field measurements+instance+  ( KnownSymbol k1, FromJSON v1+  , KnownSymbol k2, FromJSON v2+  , KnownSymbol k3, FromJSON v3+  , KnownSymbol k4, FromJSON v4+  , KnownSymbol k5, FromJSON v5+  , KnownSymbol k6, FromJSON v6+  , KnownSymbol k7, FromJSON v7+  , KnownSymbol k8, FromJSON v8 )+  => QueryResults+    ( Tagged k1 v1, Tagged k2 v2, Tagged k3 v3, Tagged k4 v4+    , Tagged k5 v5, Tagged k6 v6, Tagged k7 v7, Tagged k8 v8+    ) where+    parseResults _ = parseResultsWith $ \_ _ columns fields -> do+      v1 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k1)) columns fields+      v2 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k2)) columns fields+      v3 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k3)) columns fields+      v4 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k4)) columns fields+      v5 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k5)) columns fields+      v6 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k6)) columns fields+      v7 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k7)) columns fields+      v8 <- parseJSON+        =<< getField (fieldName (Proxy :: Proxy k8)) columns fields+      return (v1, v2, v3, v4, v5, v6, v7, v8)  -- | The full set of parameters for the query API data QueryParams = QueryParams

@@ -8,6 +8,7 @@ {-# LANGUAGE KindSignatures #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}@@ -23,6 +24,7 @@ import Data.Time.Clock import Data.Time.Clock.POSIX import Network.HTTP.Client (Manager, ManagerSettings, Request)+import System.Clock (TimeSpec(..)) import qualified Data.ByteString.Lazy as BL import qualified Data.Text as T import qualified Network.HTTP.Client as HC@@ -226,7 +228,7 @@   scaleTo :: Precision 'WriteRequest -> time -> Int64  roundAt :: RealFrac a => a -> a -> a-roundAt scale x = fromIntegral (round (x / scale) :: Int) * scale+roundAt scale x = fromIntegral (round (x / scale) :: Int64) * scale  -- | Scale of the type precision. --@@ -244,14 +246,104 @@   Minute -> 60   Hour ->   60 * 60 +-- |+-- >>> import Data.Time.Calendar+-- >>> let t = UTCTime (fromGregorian 2018 04 14) 123.123456789+-- >>> t+-- 2018-04-14 00:02:03.123456789 UTC+-- >>> roundTo Nanosecond t+-- 1523664123123456789+-- >>> roundTo Microsecond t+-- 1523664123123457000+-- >>> roundTo Millisecond t+-- 1523664123123000000+-- >>> roundTo Second t+-- 1523664123000000000+-- >>> roundTo Minute t+-- 1523664120000000000+-- >>> roundTo Hour t+-- 1523664000000000000+-- >>> scaleTo Nanosecond t+-- 1523664123123456789+-- >>> scaleTo Microsecond t+-- 1523664123123457+-- >>> scaleTo Millisecond t+-- 1523664123123+-- >>> scaleTo Second t+-- 1523664123+-- >>> scaleTo Minute t+-- 25394402+-- >>> scaleTo Hour t+-- 423240 instance Timestamp UTCTime where   roundTo prec = roundTo prec . utcTimeToPOSIXSeconds   scaleTo prec = scaleTo prec . utcTimeToPOSIXSeconds +-- |+-- >>> let dt = 123.123456789 :: NominalDiffTime+-- >>> roundTo Nanosecond dt+-- 123123456789+-- >>> roundTo Microsecond dt+-- 123123457000+-- >>> roundTo Millisecond dt+-- 123123000000+-- >>> roundTo Second dt+-- 123000000000+-- >>> roundTo Minute dt+-- 120000000000+-- >>> roundTo Hour dt+-- 0+-- >>> scaleTo Nanosecond dt+-- 123123456789+-- >>> scaleTo Microsecond dt+-- 123123457+-- >>> scaleTo Millisecond dt+-- 123123+-- >>> scaleTo Second dt+-- 123+-- >>> scaleTo Minute dt+-- 2+-- >>> scaleTo Hour dt+-- 0 instance Timestamp NominalDiffTime where   roundTo prec time =     round $ 10^(9 :: Int) * roundAt (precisionScale prec) time   scaleTo prec time = round $ time / precisionScale prec++-- |+-- >>> let timespec = TimeSpec 123 123456789+-- >>> roundTo Nanosecond timespec+-- 123123456789+-- >>> roundTo Microsecond timespec+-- 123123457000+-- >>> roundTo Millisecond timespec+-- 123123000000+-- >>> roundTo Second timespec+-- 123000000000+-- >>> roundTo Minute timespec+-- 120000000000+-- >>> roundTo Hour timespec+-- 0+-- >>> scaleTo Nanosecond timespec+-- 123123456789+-- >>> scaleTo Microsecond timespec+-- 123123457+-- >>> scaleTo Millisecond timespec+-- 123123+-- >>> scaleTo Second timespec+-- 123+-- >>> scaleTo Minute timespec+-- 2+-- >>> scaleTo Hour timespec+-- 0+instance Timestamp TimeSpec where+  roundTo prec t =+    round $ 10^(9 :: Int) * roundAt (precisionScale prec) (timeSpecToSeconds t)+  scaleTo prec t = round $ timeSpecToSeconds t / precisionScale prec++timeSpecToSeconds :: TimeSpec -> Double+timeSpecToSeconds TimeSpec { sec, nsec } =+  fromIntegral sec + fromIntegral nsec * 10^^(-9 :: Int)  -- | Exceptions used in this library. --