| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Database.InfluxDB.Query
Synopsis
- data Query
- query :: QueryResults a => QueryParams -> Query -> IO (Vector a)
- queryChunked :: QueryResults a => QueryParams -> Optional Int -> Query -> FoldM IO (Vector a) r -> IO r
- data QueryParams
- queryParams :: Database -> QueryParams
- server :: HasServer a => Lens' a Server
- database :: HasDatabase a => Lens' a Database
- precision :: HasPrecision ty a => Lens' a (Precision ty)
- manager :: HasManager a => Lens' a (Either ManagerSettings Manager)
- class QueryResults a where
- parseResults :: Precision QueryRequest -> Value -> Parser (Vector a)
- parseResultsWith :: (Maybe Text -> HashMap Text Text -> Vector Text -> Array -> Parser a) -> Value -> Parser (Vector a)
- withQueryResponse :: QueryParams -> Maybe (Optional Int) -> Query -> (Request -> Response BodyReader -> IO r) -> IO r
- newtype Tagged (s :: k) b :: forall k. k -> Type -> Type = Tagged {
- unTagged :: b
- untag :: Tagged s b -> b
Query interface
An InfluxDB query.
A spec of the format is available at https://docs.influxdata.com/influxdb/v1.7/query_language/spec/.
A Query can be constructed using either
- the
IsStringinstance with-XOverloadedStrings - or
formatQuery.
>>>:set -XOverloadedStrings>>>"SELECT * FROM series" :: Query"SELECT * FROM series">>>import qualified Database.InfluxDB.Format as F>>>formatQuery ("SELECT * FROM "%F.key) "series""SELECT * FROM \"series\""
NOTE: Currently this library doesn't support type-safe query construction.
query :: QueryResults a => QueryParams -> Query -> IO (Vector a) Source #
Query data from InfluxDB.
It may throw InfluxException.
If you need a lower-level interface (e.g. to bypass the QueryResults
constraint etc), see withQueryResponse.
Arguments
| :: QueryResults a | |
| => QueryParams | |
| -> Optional Int | Chunk size By |
| -> Query | |
| -> FoldM IO (Vector a) r | |
| -> IO r |
Same as query but it instructs InfluxDB to stream chunked responses
rather than returning a huge JSON object. This can be lot more efficient than
query if the result is huge.
It may throw InfluxException.
If you need a lower-level interface (e.g. to bypass the QueryResults
constraint etc), see withQueryResponse.
Query parameters
data QueryParams Source #
The full set of parameters for the query API
Following lenses are available to access its fields:
Instances
| HasCredentials QueryParams Source # | Authentication info for the query
|
Defined in Database.InfluxDB.Query Methods authentication :: Lens' QueryParams (Maybe Credentials) Source # | |
| HasManager QueryParams Source # |
|
Defined in Database.InfluxDB.Query Methods manager :: Lens' QueryParams (Either ManagerSettings Manager) Source # | |
| HasDatabase QueryParams Source # |
|
Defined in Database.InfluxDB.Query | |
| HasServer QueryParams Source # |
|
Defined in Database.InfluxDB.Query | |
| HasPrecision QueryRequest QueryParams Source # | Returning JSON responses contain timestamps in the specified precision/format.
|
Defined in Database.InfluxDB.Query Methods precision :: Lens' QueryParams (Precision QueryRequest) Source # | |
queryParams :: Database -> QueryParams Source #
Smart constructor for QueryParams
Default parameters:
server :: HasServer a => Lens' a Server Source #
InfluxDB server address and port that to interact with.
manager :: HasManager a => Lens' a (Either ManagerSettings Manager) Source #
HTTP manager settings or a manager itself.
If it's set to ManagerSettings, the library will create a Manager from
the settings for you.
Parsing results
class QueryResults a where Source #
Types that can be converted from an JSON object returned by InfluxDB.
For example the h2o_feet series in
the official document
can be encoded as follows:
>>>:{data H2OFeet = H2OFeet { time :: UTCTime , levelDesc :: T.Text , location :: T.Text , waterLevel :: Double } instance QueryResults H2OFeet where parseResults prec = parseResultsWith $ \_ _ columns fields -> do time <- getField "time" columns fields >>= parseUTCTime prec levelDesc <- getField "level_description" columns fields >>= parseJSON location <- getField "location" columns fields >>= parseJSON waterLevel <- getField "water_level" columns fields >>= parseJSON return H2OFeet {..} :}
Methods
parseResults :: Precision QueryRequest -> Value -> Parser (Vector a) Source #
Parse a JSON object as an array of values of expected type.
Instances
Arguments
| :: (Maybe Text -> HashMap Text Text -> Vector Text -> Array -> Parser a) | A parser that takes
to construct a value. |
| -> Value | |
| -> Parser (Vector a) |
Parse a JSON response with the lenientDecoder. This can be useful to
implement the parseResults method.
Low-level functions
Arguments
| :: QueryParams | |
| -> Maybe (Optional Int) | Chunk size By |
| -> Query | |
| -> (Request -> Response BodyReader -> IO r) | |
| -> IO r |
Lower-level interface to query data.
Re-exports from tagged
newtype Tagged (s :: k) b :: forall k. k -> Type -> Type #
A Tagged s bb with an attached phantom type s.
This can be used in place of the more traditional but less safe idiom of
passing in an undefined value with the type, because unlike an (s -> b),
a Tagged s bs as a real value.
Moreover, you don't have to rely on the compiler to inline away the extra argument, because the newtype is "free"
Tagged has kind k -> * -> * if the compiler supports PolyKinds, therefore
there is an extra k showing in the instance haddocks that may cause confusion.