diff --git a/CHANGELOG.md b/CHANGELOG.md
index e9f9ca3..2cf705a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,8 +3,9 @@
 ### Features
  - [167](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/167) - Added `InfluxDBClient::writeRecord(const char *record)`.
  - [167](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/167) - Added possibility to disable retrying by setting `maxRetryAttempts` to zero: `client.setWriteOptions(WriteOptions().maxRetryAttempts(0));` 
- - [172](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/170) - Added directly streaming batch for write. It can be enable by `InfluxDBClient::setStreamWrite(bool enable = true)`. Writing by streaming lines of batch saves RAM as it sends data without allocating a buffer. On the other hand, this way of writing is about half times slower than the classic way, when allocating the buffer for writing the whole batch. 
-  - [172](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/170) - Allowing larger batch size, > 255.
+ - [172](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/172) - Added directly streaming batch for write. It can be enable by `InfluxDBClient::setStreamWrite(bool enable = true)`. Writing by streaming lines of batch saves RAM as it sends data without allocating a buffer. On the other hand, this way of writing is about half times slower than the classic way, when allocating the buffer for writing the whole batch. 
+  - [172](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/172) - Allowing larger batch size, > 255.
+  - [173](https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino/pull/173) - Added Flux query parameters. Now supported by InfluxDB Cloud only.
 
 ## 3.9.0 [2021-09-17]
 ### Features
diff --git a/README.md b/README.md
index 7ecb434..833ec82 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,7 @@ This library doesn't support using those devices as a peripheral.
     - [InfluxDb 1](#influxdb-1)
     - [Skipping certificate validation](#skipping-certificate-validation)
   - [Querying](#querying)
+    - [Parametrized Queries](#parametrized-queries)
   - [Original API](#original-api)
     - [Initialization](#initialization)
     - [Sending a single measurement](#sending-a-single-measurement)
@@ -524,6 +525,87 @@ if(result.getError() != "") {
 ```
 Complete source code is available in [QueryAggregated example](examples/QueryAggregated/QueryAggregated.ino).
 
+### Parametrized Queries
+InfluxDB Cloud supports [Parameterized Queries](https://docs.influxdata.com/influxdb/cloud/query-data/parameterized-queries/)
+that let you dynamically change values in a query using the InfluxDB API. Parameterized queries make Flux queries more
+reusable and can also be used to help prevent injection attacks.
+
+InfluxDB Cloud inserts the params object into the Flux query as a Flux record named `params`. Use dot or bracket
+notation to access parameters in the `params` record in your Flux query. Parameterized Flux queries support only `int`
+, `float`, and `string` data types. To convert the supported data types into
+other [Flux basic data types, use Flux type conversion functions](https://docs.influxdata.com/influxdb/cloud/query-data/parameterized-queries/#supported-parameter-data-types).
+
+Parameterized query example:
+> :warning: Parameterized Queries are supported only in InfluxDB Cloud, currently there is no support in InfluxDB OSS.
+
+```cpp
+// Prepare query parameters
+QueryParams params;
+params.add("bucket", INFLUXDB_BUCKET);
+params.add("since", "-5m");
+params.add("device", DEVICE);
+params.add("rssiThreshold", -50);
+
+// Construct a Flux query using parameters
+// Parameters are accessed via the 'params' Flux object
+// Flux only supports only string, float and int as parameters. Duration can be converted from string.
+// Query will find RSSI less than defined threshold
+String query = "from(bucket: params.bucket) |> range(start: duration(v: params.since)) \
+  |> filter(fn: (r) => r._measurement == \"wifi_status\") \
+  |> filter(fn: (r) => r._field == \"rssi\") \
+  |> filter(fn: (r) => r.device == params.device) \
+  |> filter(fn: (r) => r._value < params.rssiThreshold)";
+
+// Print ouput header
+// Print composed query
+Serial.print("Querying with: ");
+Serial.println(query);
+
+// Send query to the server and get result
+FluxQueryResult result = client.query(query, params);
+
+//Print header
+Serial.printf("%10s %20s %5s\n","Time","SSID","RSSI");
+
+for(int i=0;i<37;i++) {
+  Serial.print('-');
+}
+Serial.println();
+
+// Iterate over rows. Even there is just one row, next() must be called at least once.
+int c = 0;
+while (result.next()) {
+  // Get converted value for flux result column 'SSID'
+  String ssid = result.getValueByName("SSID").getString();
+  
+  // Get converted value for flux result column '_value' where there is RSSI value
+  long rssi = result.getValueByName("_value").getLong();
+
+  // Get converted value for the _time column
+  FluxDateTime time = result.getValueByName("_time").getDateTime();
+
+  // Format date-time for printing
+  // Format string according to http://www.cplusplus.com/reference/ctime/strftime/
+  String timeStr = time.format("%F %T");
+  // Print formatted row
+  Serial.printf("%20s %10s %5d\n", timeStr.c_str(), ssid.c_str() ,rssi);
+  c++;
+}
+if(!c) {
+  Serial.println(" No data found");
+}
+
+// Check if there was an error
+if(result.getError() != "") {
+  Serial.print("Query result error: ");
+  Serial.println(result.getError());
+}
+
+// Close the result
+result.close();
+```
+Complete source code is available in [QueryParams example](examples/QueryParams/QueryParams.ino).
+
 ## Original API
 
 ### Initialization
diff --git a/examples/QueryParams/QueryParams.ino b/examples/QueryParams/QueryParams.ino
new file mode 100644
index 0000000..eebb699
--- /dev/null
+++ b/examples/QueryParams/QueryParams.ino
@@ -0,0 +1,154 @@
+/**
+ * QueryParams Example code for InfluxDBClient library for Arduino.
+  * 
+ * This example demonstrates querying using parameters inserted into the Flux query. We select WiFi signal level values bellow a certain threshold. 
+ * WiFi signal is measured and stored in BasicWrite and SecureWrite examples.
+ * 
+ * Demonstrates connection to any InfluxDB instance accesible via:
+ *  - InfluxDB 2 Cloud at https://cloud2.influxdata.com/ (certificate is preconfigured)
+ * 
+ *  Enter WiFi and InfluxDB parameters below
+ **/
+
+#if defined(ESP32)
+#include <WiFiMulti.h>
+WiFiMulti wifiMulti;
+#define DEVICE "ESP32"
+#elif defined(ESP8266)
+#include <ESP8266WiFiMulti.h>
+ESP8266WiFiMulti wifiMulti;
+#define DEVICE "ESP8266"
+#endif
+
+#include <InfluxDbClient.h>
+#include <InfluxDbCloud.h>
+
+// WiFi AP SSID
+#define WIFI_SSID "SSID"
+// WiFi password
+#define WIFI_PASSWORD "PASSWORD"
+// InfluxDB v2 server url, e.g. https://eu-central-1-1.aws.cloud2.influxdata.com (Use: InfluxDB UI -> Load Data -> Client Libraries)
+// InfluxDB 1.8+  (v2 compatibility API) server url, e.g. http://192.168.1.48:8086
+#define INFLUXDB_URL "server-url"
+// InfluxDB v2 server or cloud API authentication token (Use: InfluxDB UI -> Load Data -> Tokens -> <select token>)
+// InfluxDB 1.8+ (v2 compatibility API) use form user:password, eg. admin:adminpass
+#define INFLUXDB_TOKEN "server token"
+// InfluxDB v2 organization name or id (Use: InfluxDB UI -> Settings -> Profile -> <name under tile> )
+// InfluxDB 1.8+ (v2 compatibility API) use any non empty string
+#define INFLUXDB_ORG "org name/id"
+// InfluxDB v2 bucket name (Use: InfluxDB UI -> Load Data -> Buckets)
+// InfluxDB 1.8+ (v2 compatibility API) use database name
+#define INFLUXDB_BUCKET "bucket name"
+
+// Set timezone string according to https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
+// Examples:
+//  Pacific Time: "PST8PDT"
+//  Eastern: "EST5EDT"
+//  Japanesse: "JST-9"
+//  Central Europe: "CET-1CEST,M3.5.0,M10.5.0/3"
+#define TZ_INFO "CET-1CEST,M3.5.0,M10.5.0/3"
+
+// InfluxDB client instance with preconfigured InfluxCloud certificate
+InfluxDBClient client(INFLUXDB_URL, INFLUXDB_ORG, INFLUXDB_BUCKET, INFLUXDB_TOKEN, InfluxDbCloud2CACert);
+
+void setup() {
+  Serial.begin(115200);
+
+  // Setup wifi
+  WiFi.mode(WIFI_STA);
+  wifiMulti.addAP(WIFI_SSID, WIFI_PASSWORD);
+
+  Serial.print("Connecting to wifi");
+  while (wifiMulti.run() != WL_CONNECTED) {
+    Serial.print(".");
+    delay(500);
+  }
+  Serial.println();
+
+  
+  // Accurate time is necessary for certificate validation
+  // For the fastest time sync find NTP servers in your area: https://www.pool.ntp.org/zone/
+  // Syncing progress and the time will be printed to Serial
+  timeSync(TZ_INFO, "pool.ntp.org", "time.nis.gov");
+
+  // Check server connection
+  if (client.validateConnection()) {
+    Serial.print("Connected to InfluxDB: ");
+    Serial.println(client.getServerUrl());
+  } else {
+    Serial.print("InfluxDB connection failed: ");
+    Serial.println(client.getLastErrorMessage());
+  }
+}
+
+
+// Queries WiFi signal level values bellow a certain threshold using parameters inserted into the Flux query
+// Prints composed query and the result values.
+void loop() {
+  // Prepare query parameters
+  QueryParams params;
+  params.add("bucket", INFLUXDB_BUCKET);
+  params.add("since", "-5m");
+  params.add("device", DEVICE);
+  params.add("rssiTreshold", -50);
+  
+  // Construct a Flux query using parameters
+  // Parameters are accessed via the 'params' Flux object
+  // Flux only supports only string, float and int as parameters. Duration can be converted from string.
+  // Query will find RSSI less than defined treshold
+  String query = "from(bucket: params.bucket) |> range(start: duration(v: params.since)) \
+    |> filter(fn: (r) => r._measurement == \"wifi_status\") \
+    |> filter(fn: (r) => r._field == \"rssi\") \
+    |> filter(fn: (r) => r.device == params.device) \
+    |> filter(fn: (r) => r._value < params.rssiTreshold)";
+
+  // Print ouput header
+  // Print composed query
+  Serial.print("Querying with: ");
+  Serial.println(query);
+
+  // Send query to the server and get result
+  FluxQueryResult result = client.query(query, params);
+
+  //Print header
+  Serial.printf("%10s %20s %5s\n","Time","SSID","RSSI");
+
+  for(int i=0;i<37;i++) {
+    Serial.print('-');
+  }
+  Serial.println();
+
+  // Iterate over rows. Even there is just one row, next() must be called at least once.
+  int c = 0;
+  while (result.next()) {
+    // Get converted value for flux result column 'SSID'
+    String ssid = result.getValueByName("SSID").getString();
+   
+    // Get converted value for flux result column '_value' where there is RSSI value
+    long rssi = result.getValueByName("_value").getLong();
+
+    // Get converted value for the _time column
+    FluxDateTime time = result.getValueByName("_time").getDateTime();
+
+    // Format date-time for printing
+    // Format string according to http://www.cplusplus.com/reference/ctime/strftime/
+    String timeStr = time.format("%F %T");
+    // Print formatted row
+    Serial.printf("%20s %10s %5d\n", timeStr.c_str(), ssid.c_str() ,rssi);
+    c++;
+  }
+  if(!c) {
+    Serial.println(" No data found");
+  }
+
+  // Check if there was an error
+  if(result.getError() != "") {
+    Serial.print("Query result error: ");
+    Serial.println(result.getError());
+  }
+
+  // Close the result
+  result.close();
+  // Wait 15s
+  delay(15000);
+}
diff --git a/src/InfluxDbClient.cpp b/src/InfluxDbClient.cpp
index 3b4cda8..046ba88 100644
--- a/src/InfluxDbClient.cpp
+++ b/src/InfluxDbClient.cpp
@@ -572,9 +572,16 @@ static const char QueryDialect[] PROGMEM = "\
 \"header\": true,\
 \"delimiter\": \",\",\
 \"commentPrefix\": \"#\"\
-}}";
+}";
+
+static const char Params[] PROGMEM = ",\
+\"params\": {";
 
 FluxQueryResult InfluxDBClient::query(String fluxQuery) {
+    return query(fluxQuery, QueryParams());
+}
+
+FluxQueryResult InfluxDBClient::query(String fluxQuery, QueryParams params) {
     uint32_t rwt = getRemainingRetryTime();
     if(rwt > 0) {
         INFLUXDB_CLIENT_DEBUG("[W] Cannot query yet, pause %ds, %ds yet\n", _retryTime, rwt);
@@ -590,12 +597,28 @@ FluxQueryResult InfluxDBClient::query(String fluxQuery) {
     INFLUXDB_CLIENT_DEBUG("[D] Query to %s\n", _queryUrl.c_str());
     INFLUXDB_CLIENT_DEBUG("[D] JSON query:\n%s\n", fluxQuery.c_str());
 
-    String body = F("{\"type\":\"flux\",\"query\":\"");
-    body += escapeJSONString(fluxQuery) + "\",";
+    String queryEsc = escapeJSONString(fluxQuery);
+    String body;
+    body.reserve(150 + queryEsc.length() + params.size()*30);
+    body = F("{\"type\":\"flux\",\"query\":\"");
+    body +=  queryEsc;
+    body += "\",";
     body += FPSTR(QueryDialect);
-
+    if(params.size()) {
+        body += FPSTR(Params);
+        body += params.jsonString(0);
+        for(int i=1;i<params.size();i++) {
+            body +=",";
+            char *js = params.jsonString(i);
+            body += js;
+            delete [] js;
+        }
+        body += '}';
+    }
+    body += '}';
     CsvReader *reader = nullptr;
     _retryTime = 0;
+    INFLUXDB_CLIENT_DEBUG("[D] Query: %s\n", body.c_str());
     if(_service->doPOST(_queryUrl.c_str(), body.c_str(), PSTR("application/json"), 200, [&](HTTPClient *httpClient){
         bool chunked = false;
         if(httpClient->hasHeader(TransferEncoding)) {
diff --git a/src/InfluxDbClient.h b/src/InfluxDbClient.h
index 68e8ba1..bb61023 100644
--- a/src/InfluxDbClient.h
+++ b/src/InfluxDbClient.h
@@ -32,6 +32,7 @@
 #include "Point.h"  
 #include "WritePrecision.h"
 #include "query/FluxParser.h"
+#include "query/Params.h"
 #include "util/helpers.h"
 #include "Options.h"
 #include "BucketsClient.h"
@@ -130,6 +131,10 @@ class InfluxDBClient {
     // Use FluxQueryResult::next() method to iterate over lines of the query result.
     // Always call of FluxQueryResult::close() when reading is finished. Check FluxQueryResult doc for more info.
     FluxQueryResult query(String fluxQuery);
+    // Sends Flux query with params and returns FluxQueryResult object for subsequently reading flux query response.
+    // Use FluxQueryResult::next() method to iterate over lines of the query result.
+    // Always call of FluxQueryResult::close() when reading is finished. Check FluxQueryResult doc for more info.
+    FluxQueryResult query(String fluxQuery, QueryParams params);
     // Forces writing of all points in buffer, even the batch is not full.
     // Returns true if successful, false in case of any error 
     bool flushBuffer();
diff --git a/src/query/FluxParser.cpp b/src/query/FluxParser.cpp
index fe1737d..de35bf5 100644
--- a/src/query/FluxParser.cpp
+++ b/src/query/FluxParser.cpp
@@ -202,7 +202,7 @@ bool FluxQueryResult::next() {
 	return true;
 }
 
-FluxDateTime *FluxQueryResult::convertRfc3339(String value, const char *type) {
+FluxDateTime *FluxQueryResult::convertRfc3339(String &value, const char *type) {
     tm t = {0,0,0,0,0,0,0,0,0};
     // has the time part
     int zet = value.indexOf('Z');
@@ -240,7 +240,7 @@ FluxDateTime *FluxQueryResult::convertRfc3339(String value, const char *type) {
     return new FluxDateTime(value, type, t, fracts);
 }
 
-FluxBase *FluxQueryResult::convertValue(String value, String dataType) {
+FluxBase *FluxQueryResult::convertValue(String &value, String &dataType) {
     FluxBase *ret = nullptr;
     if(dataType.equals(FluxDatatypeDatetimeRFC3339) || dataType.equals(FluxDatatypeDatetimeRFC3339Nano)) {
         const char *type = FluxDatatypeDatetimeRFC3339;
diff --git a/src/query/FluxParser.h b/src/query/FluxParser.h
index 84e1326..d7025b0 100644
--- a/src/query/FluxParser.h
+++ b/src/query/FluxParser.h
@@ -86,8 +86,8 @@ class FluxQueryResult {
     // Descructor
     ~FluxQueryResult();
 protected:
-    FluxBase *convertValue(String value, String dataType);
-    static FluxDateTime *convertRfc3339(String value, const char *type);
+    FluxBase *convertValue(String &value, String &dataType);
+    static FluxDateTime *convertRfc3339(String &value, const char *type);
     void clearValues();
     void clearColumns();
 private:
diff --git a/src/query/FluxTypes.cpp b/src/query/FluxTypes.cpp
index 2530c18..1befc27 100644
--- a/src/query/FluxTypes.cpp
+++ b/src/query/FluxTypes.cpp
@@ -26,6 +26,7 @@
 */
 
 #include "FluxTypes.h"
+#include "util/helpers.h"
 
 const char	*FluxDatatypeString     = "string";
 const char	*FluxDatatypeDouble     = "double";
@@ -53,6 +54,14 @@ const char *FluxLong::getType() {
     return FluxDatatypeLong;
 }
 
+char *FluxLong::jsonString() {
+    int len  =_rawValue.length()+3+getNumLength(value)+2;
+    char *json = new char[len+1];
+    snprintf_P(json, len, PSTR("\"%s\":%ld"), _rawValue.c_str(), value);
+    return json;
+}
+
+
 FluxUnsignedLong::FluxUnsignedLong(String rawValue, unsigned long value):FluxBase(rawValue),value(value) {
 }
 
@@ -60,14 +69,33 @@ const char *FluxUnsignedLong::getType() {
     return FluxDatatypeUnsignedLong;
 }
 
-FluxDouble::FluxDouble(String rawValue, double value):FluxBase(rawValue),value(value) {
+char *FluxUnsignedLong::jsonString() {
+  int len  =_rawValue.length()+3+getNumLength(value)+2;
+  char *json = new char[len+1];
+  snprintf_P(json,len, PSTR("\"%s\":%lu"), _rawValue.c_str(), value);
+  return json;
+}
+
+FluxDouble::FluxDouble(String rawValue, double value):FluxDouble(rawValue, value, 0) {
    
 }
 
+FluxDouble::FluxDouble(String rawValue, double value, int precision):FluxBase(rawValue),
+  value(value),precision(precision) {}
+
 const char *FluxDouble::getType() {
     return FluxDatatypeDouble;
 }
 
+char *FluxDouble::jsonString() {
+    int len = _rawValue.length()+3+getNumLength(value)+precision+2;
+    char *json = new char[len+1];
+    char format[10];
+    sprintf_P(format, PSTR("\"%%s\":%%.%df"), precision);
+    snprintf(json, len, format , _rawValue.c_str(), value);
+    return json;
+}
+
 FluxBool::FluxBool(String rawValue, bool value):FluxBase(rawValue),value(value) {   
 }
 
@@ -75,6 +103,13 @@ const char *FluxBool::getType() {
     return FluxDatatypeBool;
 }
 
+char *FluxBool::jsonString() {
+    int len = _rawValue.length()+9;
+    char *json = new char[len+1];
+    snprintf_P(json, len, PSTR("\"%s\":%s"), _rawValue.c_str(), bool2string(value));
+    return json;
+}
+
 
 FluxDateTime::FluxDateTime(String rawValue, const char *type, struct tm value, unsigned long microseconds):FluxBase(rawValue),_type(type),value(value), microseconds(microseconds) {
 
@@ -93,12 +128,36 @@ String FluxDateTime::format(String formatString) {
   return str;
 }
 
-FluxString::FluxString(String rawValue, const char *type):FluxBase(rawValue),_type(type),value(_rawValue) {
+char *FluxDateTime::jsonString() {
+  int len = _rawValue.length()+3+21+(microseconds?10:0); 
+  char *buff = new char[len+1];
+  snprintf_P(buff, len, PSTR("\"%s\":\""), _rawValue.c_str());
+  strftime(buff+strlen(buff), len-strlen(buff), "%FT%T",&value);
+  if(microseconds) {
+    snprintf_P(buff+strlen(buff), len - strlen(buff), PSTR(".%06luZ"), microseconds); 
+  }
+  strcat(buff+strlen(buff), "\""); 
+  return buff;
+}
+
+FluxString::FluxString(String rawValue, const char *type):FluxString(rawValue, rawValue, type) {
+
+}
+
+FluxString::FluxString(String rawValue, String value, const char *type):FluxBase(rawValue),value(value),_type(type)
+{
 
 }
 
 const char *FluxString::getType() {
-    return _type;
+  return _type;
+}
+
+char *FluxString::jsonString() {
+  int len = _rawValue.length()+value.length()+7;
+  char *buff = new char[len+1];
+  snprintf(buff, len, "\"%s\":\"%s\"", _rawValue.c_str(), value.c_str());
+  return buff;
 }
 
 
diff --git a/src/query/FluxTypes.h b/src/query/FluxTypes.h
index d2d254c..4c70bc9 100644
--- a/src/query/FluxTypes.h
+++ b/src/query/FluxTypes.h
@@ -59,6 +59,7 @@ class FluxBase {
     virtual ~FluxBase();
     String getRawValue() const { return _rawValue; }
     virtual const char *getType() = 0;
+    virtual char *jsonString() = 0;
 };
 
 // Represents flux long
@@ -67,6 +68,7 @@ class FluxLong : public FluxBase {
     FluxLong(String rawValue, long value);
     long value;
     virtual const char *getType() override;
+    virtual char *jsonString() override;
 };
 
 // Represents flux unsignedLong
@@ -75,14 +77,19 @@ class FluxUnsignedLong : public FluxBase {
     FluxUnsignedLong(String rawValue, unsigned long value);
     unsigned long value;
     virtual const char *getType() override;
+    virtual char *jsonString() override;
 };
 
 // Represents flux double
 class FluxDouble : public FluxBase {
 public:
     FluxDouble(String rawValue, double value);
+    FluxDouble(String rawValue, double value, int precision);
     double value;
+    // For JSON serialization
+    int precision;
     virtual const char *getType() override;
+    virtual char *jsonString() override;
 };
 
 // Represents flux bool
@@ -91,6 +98,7 @@ class FluxBool : public FluxBase {
     FluxBool(String rawValue, bool value);
     bool value;
     virtual const char *getType() override;
+    virtual char *jsonString() override;
 };
 
 // Represents flux dateTime:RFC3339 and dateTime:RFC3339Nano
@@ -110,6 +118,7 @@ class FluxDateTime : public FluxBase {
     // Format string must be compatible with the http://www.cplusplus.com/reference/ctime/strftime/
     String format(String formatString);
     virtual const char *getType() override;
+    virtual char *jsonString() override;
 };
 
 // Represents flux string, duration, base64binary
@@ -118,8 +127,10 @@ class FluxString : public FluxBase {
     const char *_type;
 public:
     FluxString(String rawValue, const char *type);
+    FluxString(String rawValue, String value, const char *type);
     String value;
     virtual const char *getType() override;
+    virtual char *jsonString() override;
 };
 
 /** 
@@ -133,7 +144,7 @@ class FluxString : public FluxBase {
  *  * getDouble() - double
  * 
  * Calling improper type getter will result in zero (empty) value.
- * Check for null value usig isNull().
+ * Check for null value using isNull().
  * Use getRawValue() for getting original string form.
  * 
  **/
diff --git a/src/query/Params.cpp b/src/query/Params.cpp
new file mode 100644
index 0000000..e4b06e0
--- /dev/null
+++ b/src/query/Params.cpp
@@ -0,0 +1,136 @@
+/**
+ * 
+ * Params.cpp: InfluxDB flux query param
+ * 
+ * MIT License
+ * 
+ * Copyright (c) 2020 InfluxData
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+*/
+
+#include "Params.h"
+#include <algorithm>
+
+QueryParams::QueryParams() {
+  _data = std::make_shared<ParamsList>();
+}
+
+
+QueryParams::QueryParams(const QueryParams& other) {
+  _data = other._data;
+}
+
+ QueryParams::~QueryParams() {
+   if(_data) {
+    std::for_each(_data->begin(), _data->end(), [](FluxBase *&value){ delete value; });
+    _data->clear();
+   }
+ }
+
+QueryParams &QueryParams::operator=(const QueryParams &other) {
+  if(this != &other) {
+    _data = other._data;
+  }
+  return *this;
+}
+
+QueryParams &QueryParams::add(const char *name, float value, int decimalPlaces) {
+  return add(name, (double)value);
+}
+
+QueryParams &QueryParams::add(const char *name, double value, int decimalPlaces) {
+  return add(new FluxDouble(name, value, decimalPlaces));
+}
+
+QueryParams &QueryParams::add(const char *name, char value) {
+  String s(value);
+  return add(name, s);
+}
+QueryParams &QueryParams::add(const char *name, unsigned char value) {
+  return add(name, (unsigned long)value);
+}
+QueryParams &QueryParams::add(const char *name, int value) {
+  return add(name,(long)value);
+}
+QueryParams &QueryParams::add(const char *name, unsigned int value) {
+  return add(name,(unsigned long)value);
+}
+QueryParams &QueryParams::add(const char *name, long value) {
+    return add(new FluxLong(name, value));
+}
+QueryParams &QueryParams::add(const char *name, unsigned long value) {
+  return add(new FluxUnsignedLong(name, value));
+}
+QueryParams &QueryParams::add(const char *name, bool value) {
+  return add(new FluxBool(name, value));
+}
+QueryParams &QueryParams::add(const char *name, String &value) {
+  return add(name, value.c_str());
+}
+QueryParams &QueryParams::add(const char *name, long long value)  {
+  return add(name,(long)value);
+}
+QueryParams &QueryParams::add(const char *name, unsigned long long value) {
+  return add(name,(unsigned long)value);
+}
+QueryParams &QueryParams::add(const char *name, const char *value) {
+  return add(new FluxString(name, value, FluxDatatypeString));
+}
+QueryParams &QueryParams::add(const char *name, struct tm tm, unsigned long micros ) {
+  return add(new FluxDateTime(name, FluxDatatypeDatetimeRFC3339Nano, tm, micros));
+}
+
+QueryParams &QueryParams::add(FluxBase *value) {
+ if(_data) {
+    _data->push_back(value);
+  }
+  return *this;
+}
+
+void QueryParams::remove(const char *name) {
+  if(_data) {
+    auto it = std::find_if(_data->begin(),_data->end(), [name](FluxBase *f){ return f->getRawValue() == name; } );
+    if(it != _data->end()) {
+      delete *it;
+      _data->erase(it);
+    }
+  }
+}
+// Copy constructor
+int QueryParams::size() {
+  if(_data) {
+    return _data->size();
+  }
+  return 0;
+}
+
+FluxBase *QueryParams::get(int i) {
+  if(_data) {
+    return _data->at(i);
+  }
+  return 0;
+}
+
+char *QueryParams::jsonString(int i) {
+  if(_data) {
+    return _data->at(i)->jsonString();
+  }
+  return nullptr;
+}
diff --git a/src/query/Params.h b/src/query/Params.h
new file mode 100644
index 0000000..ca31013
--- /dev/null
+++ b/src/query/Params.h
@@ -0,0 +1,93 @@
+/**
+ * 
+ * Prams.h: InfluxDB flux query param
+ * 
+ * MIT License
+ * 
+ * Copyright (c) 2020 InfluxData
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+*/
+#ifndef _QUERY_PARAM_H_
+#define _QUERY_PARAM_H_
+
+#include "FluxTypes.h"
+#include <memory>
+#include <vector>
+
+typedef std::vector<FluxBase *> ParamsList;
+/**
+ * QueryParams holds parameters for Flux query.
+ * Parameters are accessed via the 'params.' prefix: e.g. params.start
+ *
+ */ 
+class QueryParams {
+  public:
+    // Constructor
+    QueryParams();
+    // Copy constructor
+    QueryParams(const QueryParams& other);
+    // Assignment operator
+    QueryParams &operator=(const QueryParams &other);
+    // Descructor
+    ~QueryParams();
+    // Adds param with a float value. A number of decimal places can be optionally set.
+    QueryParams &add(const char *name, float value, int decimalPlaces = 2);
+    // Adds param with a double value. A number of decimal places can be optionally set.
+    QueryParams &add(const char *name, double value, int decimalPlaces = 2); 
+    // Adds param with a character value.
+    QueryParams &add(const char *name, char value);
+    // Adds param with an unsigned character value. It is added as a number.
+    QueryParams &add(const char *name, unsigned char value);
+    // Adds param with an integer value.
+    QueryParams &add(const char *name, int value);
+    // Adds param with an unsigned integer value.
+    QueryParams &add(const char *name, unsigned int value);
+    // Adds param with a long value.
+    QueryParams &add(const char *name, long value);
+    // Adds param with an unsigned long value.
+    QueryParams &add(const char *name, unsigned long value);
+    // Adds param with a boolen value.
+    QueryParams &add(const char *name, bool value);
+    // Adds param with a String value.
+    QueryParams &add(const char *name, String &value);
+    // Adds param with a long long value. It is converted to long.
+    QueryParams &add(const char *name, long long value);
+    // Adds param with an unsigned long long value. It is converted to long.
+    QueryParams &add(const char *name, unsigned long long value);
+    // Adds param with a string value.
+    QueryParams &add(const char *name, const char *value);
+    // Adds param as a string representation of date-time value in UTC timezone, e.g. "2022-01-12T23:12:30.124Z"
+    // Micros is fractional part of seconds up to microseconds precision. E.g. if millisecond are provided
+    // it must be converted to microseconds: micros = 1000*millis
+    QueryParams &add(const char *name, struct tm tm, unsigned long micros = 0);
+    // Removed a param
+    void remove(const char *name);
+    // Returns i-th param
+    FluxBase *get(int i);
+    // Returns params count
+    int size();
+    // Returns JSON representation of i-th param
+    char *jsonString(int i);
+  private:
+    QueryParams &add(FluxBase *value);
+    std::shared_ptr<ParamsList> _data;
+};
+
+#endif //_QUERY_PARAM_H_
diff --git a/src/util/helpers.cpp b/src/util/helpers.cpp
index dfb3f7f..6c0e286 100644
--- a/src/util/helpers.cpp
+++ b/src/util/helpers.cpp
@@ -164,3 +164,12 @@ bool isValidID(const char *idString) {
 const char *bool2string(bool val) {
     return (val?"true":"false");
 }
+
+uint8_t getNumLength(long long l) {
+    uint8_t c = 0;
+    do {
+        c++;
+        l /=10;
+    } while(l);
+    return c;
+}
diff --git a/src/util/helpers.h b/src/util/helpers.h
index 506369c..c26f5ee 100644
--- a/src/util/helpers.h
+++ b/src/util/helpers.h
@@ -50,7 +50,9 @@ String escapeValue(const char *value);
 String urlEncode(const char* src);
 // Returns true of string contains valid InfluxDB ID type
 bool isValidID(const char *idString);
-// Return "true" if val is true, otherwise "false"
+// Returns "true" if val is true, otherwise "false"
 const char *bool2string(bool val);
+// Returns number of digits
+uint8_t getNumLength(long long l);
 
 #endif //_INFLUXDB_CLIENT_HELPERS_H
\ No newline at end of file
diff --git a/test/Test.cpp b/test/Test.cpp
index c51407a..0fe5c9f 100644
--- a/test/Test.cpp
+++ b/test/Test.cpp
@@ -38,6 +38,7 @@ void Test::run() {
     failures = 0;
     Serial.println("Unit & Integration Tests");
     // Basic tests
+    testUtils();
     testOptions();
     testPoint();
     testBatch();
@@ -46,6 +47,7 @@ void Test::run() {
     testUrlEncode();
     testIsValidID();
     testFluxTypes();
+    testFluxTypesSerialization();
     testFluxParserEmpty();
     testFluxParserSingleTable();
     testFluxParserNilValue();
@@ -56,6 +58,7 @@ void Test::run() {
     testFluxParserInvalidDatatype();
     testFluxParserMissingDatatype();
     testFluxParserErrorInRow();
+    testQueryParams();
     testBasicFunction();
     testFlushing();
     testInit();
@@ -77,9 +80,21 @@ void Test::run() {
     testRetriesOnServerOverload();
     testRetryInterval();
     testBuckets(); 
+    testQueryWithParams();
     Serial.printf("Tests %s\n", failures ? "FAILED" : "SUCCEEDED");
 }
 
+void Test::testUtils() {
+    TEST_INIT("testUtils");
+    int d = getNumLength(12345678901);
+    TEST_ASSERTM(d == 11, String(d));
+    d = getNumLength(1);
+    TEST_ASSERTM(d == 1, String(d));
+    d = getNumLength(12);
+    TEST_ASSERTM(d == 2, String(d));
+    TEST_END();
+}
+
 void Test::testOptions() {
     TEST_INIT("testOptions");
     WriteOptions defWO;
@@ -617,7 +632,7 @@ void Test::testRepeatedInit() {
         InfluxDBClient client;
         for(int i = 0; i<20;i++) {
             client.setConnectionParams(Test::apiUrl, Test::orgName, Test::bucketName, Test::token);
-            TEST_ASSERT(client.validateConnection());
+            TEST_ASSERTM(client.validateConnection(),client.getLastErrorMessage());
         }
     } while(0);
     uint32_t endRAM = ESP.getFreeHeap();
@@ -1403,6 +1418,111 @@ void Test::testFluxTypes() {
     TEST_END();
 }
 
+void Test::testFluxTypesSerialization() {
+    TEST_INIT("testFluxTypesSerialization");
+
+    struct strTest {
+        FluxBase *fb;
+        const char *json;
+    };
+
+    strTest tests[] = {
+        { new FluxLong("long", -2020123456), "\"long\":-2020123456" },
+        { new FluxUnsignedLong("ulong", 2020123456), "\"ulong\":2020123456" },
+        { new FluxBool("bool", false),  "\"bool\":false"},
+        { new FluxDouble("double", 28.3, 1), "\"double\":28.3"},
+        { new FluxDateTime("dateTime", FluxDatatypeDatetimeRFC3339Nano, {15,34,9,22,4,120,0,0,0}, 123456), "\"dateTime\":\"2020-05-22T09:34:15.123456Z\""},
+        { new FluxString("string", "my text", FluxDatatypeString), "\"string\":\"my text\""},
+        { new FluxDouble("double", 21328.3132213,5), "\"double\":21328.31322"}
+    };
+
+    for(int i=0;i<7;i++) {
+        char *buff = tests[i].fb->jsonString();
+        delete tests[i].fb;
+        String json = buff;
+        delete [] buff;
+        TEST_ASSERTM(json == tests[i].json , json);
+    }
+
+    TEST_END();
+}
+
+void Test::testQueryParams() {
+    TEST_INIT("testQueryParams");
+    QueryParams params;
+    TEST_ASSERT(params.size() == 0);
+
+    params
+        .add("long", -2020123456l)
+        .add("ulong", 2020123456)
+        .add("bool", false)
+        .add("double", 28.3, 1)
+        .add("dateTime", {15,34,9,22,4,120,0,0,0}, 123456)
+        .add("string", "my text");
+    TEST_ASSERT(params.size() == 6);
+
+    const char *jsons[] = {
+        "\"long\":-2020123456",
+        "\"ulong\":2020123456",
+        "\"bool\":false",
+        "\"double\":28.3",
+        "\"dateTime\":\"2020-05-22T09:34:15.123456Z\"",
+        "\"string\":\"my text\""
+    };
+    for(int i=0;i<params.size();i++) {
+        char *buff = params.jsonString(i);
+        String json = buff;
+        delete [] buff;
+        TEST_ASSERTM(json == jsons[i], json);
+    }
+
+    params.remove("double");
+    TEST_ASSERT(params.size() == 5);
+
+    TEST_ASSERT(params.get(3)->getRawValue() == "dateTime");
+
+    QueryParams params2;
+    params2.add("char", '1');
+    params2.add("uchar", (unsigned char)1);
+    params2.add("int", -1);
+    params2.add("uint", 1u);
+    params2.add("long", -1l);
+    params2.add("ulong", 1lu);
+    params2.add("longlong", -1ll);
+    params2.add("ulonglong", 1llu);
+    params2.add("float", 1.1f);
+    params2.add("double", 1.1);
+    params2.add("bool", true);
+    params2.add("cstring", "text");
+    params2.add("dateTime", {15,34,9,22,4,120,0,0,0});
+    String s = "string";
+    params2.add("string", s);
+    TEST_ASSERT(params2.size() == 14);
+
+    const char *types[] = {
+        FluxDatatypeString,
+        FluxDatatypeUnsignedLong,
+        FluxDatatypeLong,
+        FluxDatatypeUnsignedLong,
+        FluxDatatypeLong,
+        FluxDatatypeUnsignedLong,
+        FluxDatatypeLong,
+        FluxDatatypeUnsignedLong,
+        FluxDatatypeDouble,
+        FluxDatatypeDouble,
+        FluxDatatypeBool,
+        FluxDatatypeString,
+        FluxDatatypeDatetimeRFC3339Nano,
+        FluxDatatypeString
+    };
+
+    for(int i=0;i<params2.size();i++) {
+        TEST_ASSERTM(params2.get(i)->getType() == types[i], String(i) + " " + types[i]);
+    }
+
+    TEST_END();
+}
+
 void Test::testFluxParserEmpty() {
     TEST_INIT("testFluxParserEmpty");
     FluxQueryResult flux("Error sss");
@@ -2252,7 +2372,7 @@ void Test::testLargeBatch() {
 #endif
     int len =strlen(line); 
     int points = free/len;
-    Serial.printf("Free ram: %lu, line len: %d, max points: %d\n", free, len, points);
+    Serial.printf("Free ram: %u, line len: %d, max points: %d\n", free, len, points);
     client.setWriteOptions(WriteOptions().batchSize(batchSize));
     WS_DEBUG_RAM("After options");
     TEST_ASSERT(client.validateConnection());
@@ -2278,6 +2398,25 @@ void Test::testLargeBatch() {
     deleteAll(Test::apiUrl);
 }
 
+void Test::testQueryWithParams() {
+    TEST_INIT("testQueryWithParams");
+    TEST_ASSERT(waitServer(Test::managementUrl, true));
+    InfluxDBClient client(Test::apiUrl, Test::orgName, Test::bucketName, Test::token);
+
+    QueryParams params;
+    params.add("long", -12345);
+    params.add("ulong", 12345);
+    params.add("bool", false);
+    params.add("string", "my text");
+    params.add("double", 12345.6789, 4);
+    params.add("dateTime", {15,34,9,22,4,120,0,0,0}, 12345);
+    FluxQueryResult q = client.query("echo", params);
+    TEST_ASSERT(!q.next());
+    TEST_ASSERTM(client.getLastStatusCode()==444,String(client.getLastStatusCode()));
+    TEST_ASSERTM(q.getError() == "{\"type\":\"flux\",\"query\":\"echo\",\"dialect\":{\"annotations\":[\"datatype\"],\"dateTimeFormat\":\"RFC3339\",\"header\":true,\"delimiter\":\",\",\"commentPrefix\":\"#\"},\"params\":{\"long\":-12345,\"ulong\":12345,\"bool\":false,\"string\":\"my text\",\"double\":12345.6789,\"dateTime\":\"2020-05-22T09:34:15.012345Z\"}}", q.getError());
+    TEST_END();
+}
+
 void Test::setServerUrl(InfluxDBClient &client, String serverUrl) {
     client._connInfo.serverUrl = serverUrl;
     client._service->_apiURL = serverUrl + "/api/v2/";
diff --git a/test/Test.h b/test/Test.h
index c782749..dfc6828 100644
--- a/test/Test.h
+++ b/test/Test.h
@@ -37,12 +37,14 @@ class Test : public  TestBase {
 private: //helpers
     static void setServerUrl(InfluxDBClient &client, String serverUrl);
 private: // tests
+    static void testUtils();
     static void testOptions();
     static void testEcaping();
     static void testPoint();
     static void testBatch();
     static void testLineProtocol();
     static void testFluxTypes();
+    static void testFluxTypesSerialization();
     static void testFluxParserEmpty();
     static void testFluxParserSingleTable();
     static void testFluxParserNilValue();
@@ -71,9 +73,11 @@ class Test : public  TestBase {
     static void testRepeatedInit();
     static void testIsValidID();
     static void testBuckets();
+    static void testQueryParams();
     static void testFlushing();
     static void testNonRetry();
     static void testLargeBatch();
+    static void testQueryWithParams();
 };
 
 #endif //_TEST_H_
\ No newline at end of file
diff --git a/test/server/server.js b/test/server/server.js
index 45cd3b5..a2cc377 100644
--- a/test/server/server.js
+++ b/test/server/server.js
@@ -313,6 +313,8 @@ var queryRes = {
 "empty":``
 };
 
+
+
 function sleep(milliseconds) {
     const date = Date.now();
     let currentDate = null;
@@ -334,6 +336,9 @@ app.post(prefix+'/api/v2/query', (req,res) => {
                 status = 400;
             }
             data = queryRes[qi];
+        } else if(queryObj["query"] === 'echo') {
+            status = 444;
+            data = JSON.stringify(queryObj);
         } else if(pointsdb.length > 0) {
             console.log('query: ' + pointsdb.length + ' points');
             data = convertToCSV(pointsdb);