Descargar InfluxDB.Client - InfluxDB.Client Descargar código fuente

Cliente de InfluxDB para .NET

¡Esta biblioteca facilita ser un cliente para InfluxDB en .NET!

La idea básica detrás de la biblioteca es que debería poder convertir las consultas directamente en objetos de sus propias clases. Al igual que las micro-ormas como Dapper.

El objetivo es que queremos poder admitir la sintaxis LINQ en el futuro.

Instalación

Instálelo a través de Nuget con el siguiente comando.

 Install-Package Vibrant.InfluxDB.Client

El paquete se puede encontrar aquí.

O simplemente puede agarrarlo en uno de los lanzamientos de GitHub.

Lectura/escritura

La biblioteca expone todas las operaciones HTTP en InfluxDB (1.0+) y puede usarse para leer/escribir datos a/desde dos maneras principales:

Usando sus propias clases de Poco.
Uso de clases dinámicas.

Un ejemplo simple de cómo usar la biblioteca está disponible aquí.

Usando sus propias clases de Poco

Comience definiendo una clase que represente una fila en InfluxDB que desea almacenar.

 public class ComputerInfo
{
   [ InfluxTimestamp ]
   public DateTime Timestamp { get ; set ; }

   [ InfluxTag ( "host" ) ]
   public string Host { get ; set ; }

   [ InfluxTag ( "region" ) ]
   public string Region { get ; set ; }

   [ InfluxField ( "cpu" ) ]
   public double CPU { get ; set ; }

   [ InfluxField ( "ram" ) ]
   public long RAM { get ; set ; }
}

En su clase de Poco debe especificar estas cosas:

1 Propiedad con el tipo DateTime, DateTime?, DatetimeOffset o DateTimeOffset? Como la marca de tiempo utilizada en InfluxDB agregando el atributo [InfiflTimestamp].
0-* Propiedades con la cadena tipo, Long, Ulong, Int, Uint, Short, Ushort, Byte, SByte, Double, Float, Bool, DateTime, DateTimeOffset, Decimal o un enum de definido por el usuario (Nullables también) con el atributo [Inflyxtag] que InfluxDB usará como etiquetas indexadas. Tenga en cuenta que todas las etiquetas en InfluxDB todavía se almacenan una cadena. La biblioteca simplemente realizará la conversión al tipo especificado automáticamente.
1-* Propiedades con la cadena tipo, Long, Ulong, Int, Uint, Short, Ushort, Byte, SByte, Double, Float, Bool, DateTime, DateTimeOffset, Decimal o un enum definido por el usuario (también) con el atributo [Influxfield] que InfluxDB usará como campos.

Una vez que haya definido su clase, está listo para usar el InfluxClient, que es el punto de entrada principal a la API:

Aquí le mostramos cómo escribir en la base de datos:

 private ComputerInfo [ ] CreateTypedRowsStartingAt ( DateTime start , int rows )
{
   var rng = new Random ( ) ;
   var regions = new [ ] { "west-eu" , "north-eu" , "west-us" , "east-us" , "asia" } ;
   var hosts = new [ ] { "some-host" , "some-other-host" } ;

   var timestamp = start ;
   var infos = new ComputerInfo [ rows ] ;
   for ( int i = 0 ; i < rows ; i ++ )
   {
      long ram = rng . Next ( int . MaxValue ) ;
      double cpu = rng . NextDouble ( ) ;
      string region = regions [ rng . Next ( regions . Length ) ] ;
      string host = hosts [ rng . Next ( hosts . Length ) ] ;

      var info = new ComputerInfo { Timestamp = timestamp , CPU = cpu , RAM = ram , Host = host , Region = region } ;
      infos [ i ] = info ;

      timestamp = timestamp . AddSeconds ( 1 ) ;
   }

   return infos ;
}

public async Task Should_Write_Typed_Rows_To_Database ( )
{
   var client = new InfluxClient ( new Uri ( "http://localhost:8086" ) ) ;
   var infos = CreateTypedRowsStartingAt ( new DateTime ( 2010 , 1 , 1 , 1 , 1 , 1 , DateTimeKind . Utc ) , 500 ) ;
   await client . WriteAsync ( "mydb" , "myMeasurementName" , infos ) ;
}

Aquí está cómo consultar desde la base de datos:

 public async Task Should_Query_Typed_Data ( )
{
   var resultSet = await client . ReadAsync < ComputerInfo > ( "mydb" , "SELECT * FROM myMeasurementName" ) ;
   
   // resultSet will contain 1 result in the Results collection (or multiple if you execute multiple queries at once)
   var result = resultSet . Results [ 0 ] ;
   
   // result will contain 1 series in the Series collection (or potentially multiple if you specify a GROUP BY clause)
   var series = result . Series [ 0 ] ;
   
   // series.Rows will be the list of ComputerInfo that you queried for
   foreach ( var row in series . Rows )
   {
      Console . WriteLine ( "Timestamp: " + row . Timestamp ) ;
      Console . WriteLine ( "CPU: " + row . CPU ) ;
      Console . WriteLine ( "RAM: " + row . RAM ) ;
      // ...
   }
}

Usando clases dinámicas

Las clases de POCO no se ajustan a todos los casos de uso. Esto se vuelve obvio una vez que está implementando un sistema y no sabe cuáles serán los campos/etiquetas en el momento de la compilación. En este caso debe usar clases dinámicas.

Para que esto funcione, debe usar la interfaz iinFluxRow que especifica métodos de lectura/escritura para etiquetas y campos. Esta biblioteca ya incluye una implementación de estas interfaces que utiliza diccionarios y tiene soporte básico para el DLR. Esta clase se llama DynamicInFluxRow.

Aquí le mostramos cómo escribir usando clases dinámicas.

 private DynamicInfluxRow [ ] CreateDynamicRowsStartingAt ( DateTime start , int rows )
{
   var rng = new Random ( ) ;
   var regions = new [ ] { "west-eu" , "north-eu" , "west-us" , "east-us" , "asia" } ;
   var hosts = new [ ] { "some-host" , "some-other-host" } ;
   
   var timestamp = start ;
   var infos = new DynamicInfluxRow [ rows ] ;
   for ( int i = 0 ; i < rows ; i ++ )
   {
      long ram = rng . Next ( int . MaxValue ) ;
      double cpu = rng . NextDouble ( ) ;
      string region = regions [ rng . Next ( regions . Length ) ] ;
      string host = hosts [ rng . Next ( hosts . Length ) ] ;

      var info = new DynamicInfluxRow ( ) ;
      info . Fields . Add ( "cpu" , cpu ) ;
      info . Fields . Add ( "ram" , ram ) ;
      info . Tags . Add ( "host" , host ) ;
      info . Tags . Add ( "region" , region ) ;
      info . Timestamp = timestamp ;

      infos [ i ] = info ;

      timestamp = timestamp . AddSeconds ( 1 ) ;
   }
   return infos ;
}

public async Task Should_Write_Dynamic_Rows_To_Database ( )
{
   var client = new InfluxClient ( new Uri ( "http://localhost:8086" ) ) ;
   var infos = CreateDynamicRowsStartingAt ( new DateTime ( 2010 , 1 , 1 , 1 , 1 , 1 , DateTimeKind . Utc ) , 500 ) ;
   await client . WriteAsync ( "mydb" , "myMeasurementName" , infos ) ;
}

Tenga en cuenta que si usa clases dinámicas, enums definidos por el usuario y a veces, ya que los campos/etiquetas no son compatibles, ya que no hay forma de diferenciar entre una cadena y un enum/enumero.

También tenga en cuenta que si desea utilizar el tipo de marca de tiempo personalizado o DateTimeOffset con esta interfaz, puede usar la interfaz genérica IinFluxRow o la clase DynamicInFluxRow.

Aquí está cómo consultar desde la base de datos:

 public async Task Should_Query_Dynamic_Data ( )
{
   var resultSet = await client . ReadAsync < DynamicInfluxRow > ( "mydb" , "SELECT * FROM myMeasurementName" ) ;
   
   // resultSet will contain 1 result in the Results collection (or multiple if you execute multiple queries at once)
   var result = resultSet . Results [ 0 ] ;
   
   // result will contain 1 series in the Series collection (or potentially multiple if you specify a GROUP BY clause)
   var series = result . Series [ 0 ] ;
   
   // series.Rows will be the list of DynamicInfluxRow that you queried for (which can be cast to dynamic)
   foreach ( dynamic row in series . Rows )
   {
      Console . WriteLine ( "Timestamp: " + row . time ) ; // Can also access row.Timestamp
      Console . WriteLine ( "CPU: " + row . cpu ) ;
      Console . WriteLine ( "RAM: " + row . ram ) ;
      // ...
   }
}

Leer OPERACIONES SOLO

A menudo, es posible que no seleccione la estructura exacta que también está insertando. Tal vez esté haciendo una agregación o cálculos sobre los datos que está recuperando que cambia el nombre de las columnas devueltas.

En este caso, simplemente puede definir una nueva clase y usar el InfluxComputedAttribute. Cualquier columna que coincida con el nombre especificado en el atributo (etiqueta o campo, agregado o no) irá a la propiedad con este atributo.

 [ InfluxComputedAttribute ]

Las clases con este atributo no deben usarse para la inserción, ya que no hay forma de que el cliente sepa si es un campo o etiqueta.

Si está utilizando la interfaz IinFluxRow (DynamicInFluxRow, por ejemplo), entonces la colección "Fields" se llena con todas las columnas que no coinciden con una etiqueta conocida para la medición específica.

Fragmento

A veces puede recuperar una cantidad masiva de datos de la base de datos, tanto de hecho, que no es posible mantener todo en la memoria en cualquier momento. En este caso, necesita la función de fragmentación proporcionada por InfluxDB. Puede aprovechar esta característica permitiendo fragmentos a través de la clase de InfluxyerPions. Cuando se habilita, el cliente proporcionará las opciones de fragmentación a InfluxDB cuando recupere datos.

Sin embargo, las operaciones predeterminadas de ReadAsync simplemente leerán todos los fragmentos antes de devolver el control al usuario. Para admitir escenarios en los que desea leer el fragmento de datos de Chunk, puede usar el método ReadChunkedasync. Esto devolverá un tipo diferente de conjunto de resultados que le permite iterar asinconalmente sobre todos los fragmentos (mientras mantiene la estructura de las consultas que inicialmente hizo). Aquí hay un ejemplo tomado de las pruebas unitarias:

 [ Fact ]
public async Task Should_Write_And_Query_Deferred_Grouped_Data_With_Multi_Query ( )
{
   var start = new DateTime ( 2011 , 1 , 1 , 1 , 1 , 1 , DateTimeKind . Utc ) ;
   var infos = InfluxClientFixture . CreateTypedRowsStartingAt ( start , 5000 , false ) ;
   await client . WriteAsync ( InfluxClientFixture . DatabaseName , "groupedComputerInfo4" , infos ) ;
   await client . WriteAsync ( InfluxClientFixture . DatabaseName , "groupedComputerInfo5" , infos ) ;

   var chunkedResultSet = await client . ReadChunkedAsync < ComputerInfo > ( 
      InfluxClientFixture . DatabaseName , 
      $ "SELECT * FROM groupedComputerInfo4 GROUP BY region;SELECT * FROM groupedComputerInfo5 GROUP BY region" , 
      new InfluxQueryOptions { ChunkSize = 200 } ) ;

   InfluxChunkedResult < ComputerInfo > currentResult ;
   InfluxChunkedSeries < ComputerInfo > currentSerie ;
   InfluxChunk < ComputerInfo > currentChunk ;
   int resultCount = 0 ;
   int serieCount = 0 ;
   int rowCount = 0 ;

   using ( chunkedResultSet )
   {
      while ( ( currentResult = await chunkedResultSet . GetNextResultAsync ( ) ) != null )
      {
         while ( ( currentSerie = await currentResult . GetNextSeriesAsync ( ) ) != null )
         {
            while ( ( currentChunk = await currentSerie . GetNextChunkAsync ( ) ) != null )
            {
               rowCount += currentChunk . Rows . Count ;
            }
            serieCount ++ ;
         }
         resultCount ++ ;
      }
   }

   Assert . Equal ( 1 * 2 , resultCount ) ;
   Assert . Equal ( InfluxClientFixture . Regions . Length * 2 , serieCount ) ;
   Assert . Equal ( 5000 * 2 , rowCount ) ;
}

En las próximas versiones de C# habrá la capacidad de iterar sobre Async Enumerables, y una vez que esta característica llegue, también lo admitiré. Vea el video a continuación:

https://channel9.msdn.com/blogs/seth-juarez/a-preview-of-c-8-with-mads-torgersen#time=16m30ss

Preservar compensaciones de zona horaria

Al especificar la cláusula de zona horaria, InfluxDB devolverá las marcas de tiempo con sus compensaciones. Puede preservar este desplazamiento en la marca de tiempo devuelta utilizando un DateTimeOffset o anulable como el tipo de marca de tiempo. Si usa DateTime o Nullable como el tipo de marca de tiempo, la marca de tiempo siempre se convertirá a UTC.

Tipo de marca de tiempo personalizado

Alternativamente, puede implementar su propio ITIMESTAMPPARSER para admitir tipos personalizados, por ejemplo, Nodatime. Una vez implementado, puede registrarse en InfluxClient. Simplemente implementa la siguiente interfaz:

 /// <summary>
/// ITimestampParser is responsible for parsing the 'time' column
/// of data returned, allowing use of custom DateTime types.
/// </summary>
/// <typeparam name="TTimestamp"></typeparam>
public interface ITimestampParser < TTimestamp >
{
   /// <summary>
   /// Parses a epoch time (UTC) or ISO8601-timestamp (potentially with offset) to a date and time.
   /// This is used when reading data from influxdb.
   /// </summary>
   /// <param name="precision">TimestampPrecision provided by the current InfluxQueryOptions.</param>
   /// <param name="epochTimeLongOrIsoTimestampString">The raw value returned by the query.</param>
   /// <returns>The parsed timestamp.</returns>
   TTimestamp ToTimestamp ( TimestampPrecision ? precision , object epochTimeLongOrIsoTimestampString ) ;

   /// <summary>
   /// Converts the timestamp to epoch time (UTC). This is used when writing data to influxdb.
   /// </summary>
   /// <param name="precision">TimestampPrecision provided by the current InfluxWriteOptions.</param>
   /// <param name="timestamp">The timestamp to convert.</param>
   /// <returns>The UTC epoch time.</returns>
   long ToEpoch ( TimestampPrecision precision , TTimestamp timestamp ) ;
}

Escribir a diferentes nombres de medición en una sola llamada

A menudo, es posible que desee escribir en múltiples mediciones con diferentes nombres de medidas ejecutando una sola llamada.

Esto se puede lograr implementando la siguiente interfaz en sus clases de POCO:

   /// <summary>
   /// Interface that can be used to specify a per-row measurement name.
   /// </summary>
   public interface IHaveMeasurementName
   {
      /// <summary>
      /// Gets or sets the measurement name.
      /// </summary>
      string MeasurementName { get ; set ; }
   }

O colocando el atributo [InfluxMeice] en su clase o definiciones de propiedad de su clase POCO.

Al usarlo en una clase, debe especificar un nombre, así:

   [ InfluxMeasurement ( "MyTableName" ) ]
   public class ClassWithMeasurementName
   {
      [ InfluxTimestamp ]
      internal DateTime Timestamp { get ; set ; }

      [ InfluxField ( "cpu" ) ]
      internal double ? CPU { get ; set ; }
   }

Cuando lo use en una propiedad, no especifique un nombre. Utilizará el valor de la propiedad (que debe ser una cadena):

   public class ClassWithMeasurementName
   {
      [ InfluxTimestamp ]
      internal DateTime Timestamp { get ; set ; }

      [ InfluxField ( "cpu" ) ]
      internal double ? CPU { get ; set ; }

      [ InfluxMeasurement ]
      public string TableName { get ; set ; }
   }

Al usar uno de estos enfoques, puede usar el siguiente método WriteAsync de sobrecargas, que no toma un nombre de medición como argumento:

      public Task WriteAsync < TInfluxRow > ( string db , IEnumerable < TInfluxRow > rows )
      
      public Task WriteAsync < TInfluxRow > ( string db , IEnumerable < TInfluxRow > rows , InfluxWriteOptions options )

En caso de que desee hacer esto con clases dinámicas, simplemente puede usar el nombre de DynamicInFluxRow (que implementa la interfaz ihaveMeAsurementName).

Se utiliza la siguiente prioridad cuando determine a qué medición escribir un registro en caso de que se usen múltiples enfoques:

El nombre proporcionado en el método WRITEASYNC.
El nombre proporcionado por la interfaz ihaveMeAseMementName
El nombre proporcionado por la propiedad anotada con el InfluxMeaceRentAttribute.
El nombre proporcionado en la clase anotado con el InfluxMeaceRentAttribute.

En caso de que use el nombre ihaveMeAseMementNe o una propiedad con el InfluxMeaseSeMementTribute, el nombre de medición se escribirá en esa propiedad durante las operaciones de lectura.

Unión de parámetros y prevención de inyección SQL

El InfluxClient también admite la unión de parámetros para respaldar la prevención de la inyección de SQL.

Para usar esto, simplemente use los métodos que toman el parámetro "Parámetros del objeto". Este puede ser un objeto anónimo, un diccionario o cualquier objeto que admita la serialización JSON a través de Newtonsoft.json.

Al parametrizar los valores en el objeto o el diccionario, no prefije los nombres con $, como los nombres están en la consulta real.

Aquí hay un ejemplo de cómo se vería:

 var resultSet = await client . ReadAsync < ComputerInfo > ( 
   db ,
   "SELECT * FROM myMeasurementName WHERE time >= $myParam" , 
   new { myParam = new DateTime ( 2010 , 1 , 1 , 1 , 1 , 3 , DateTimeKind . Utc ) } ) ;

Cualquier tipo que use generalmente a través de esta biblioteca de clientes se puede usar como parámetro.

Otras operaciones

La interfaz principal para interactuar con InfluxDB se puede ver a continuación.

 public interface IInfluxClient
{
   /// <summary>
   /// Gets the default query optionns.
   /// </summary>
   InfluxQueryOptions DefaultQueryOptions { get ; }
   /// <summary>
   /// Gets the default write options.
   /// </summary>
   InfluxWriteOptions DefaultWriteOptions { get ; }
   /// <summary>
   /// Gets or sets the timeout for all requests made.
   /// </summary>
   TimeSpan Timeout { get ; set ; }
   /// <summary>
   /// Gets the timestamp parser registry.
   /// </summary>
   ITimestampParserRegistry TimestampParserRegistry { get ; }
      
   /// <summary>
   /// Executes an arbitrary command that does not return a table.
   /// </summary>
   /// <param name="commandOrQuery"></param>
   /// <param name="db"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   Task < InfluxResultSet > ExecuteOperationAsync ( string commandOrQuery , string db , object parameters ) ;
   /// <summary>
   /// Executes an arbitrary command that returns a table as a result.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="commandOrQuery"></param>
   /// <param name="db"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   Task < InfluxResultSet < TInfluxRow > > ExecuteOperationAsync < TInfluxRow > ( string commandOrQuery , string db , object parameters ) where TInfluxRow : new ( ) ;

   /// <summary>
   /// Executes a ping and waits for the leader to respond.
   /// </summary>
   /// <param name="secondsToWaitForLeader"></param>
   /// <returns></returns>
   Task < InfluxPingResult > PingAsync ( int ? secondsToWaitForLeader ) ;

   /// <summary>
   /// Executes the query and returns the result with the specified query options.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="query"></param>
   /// <param name="db"></param>
   /// <param name="options"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   Task < InfluxResultSet < TInfluxRow > > ReadAsync < TInfluxRow > ( string db , string query , object parameters , InfluxQueryOptions options ) where TInfluxRow : new ( ) ;
   /// <summary>
   /// Executes the query and returns a deferred result that can be iterated over as they
   /// are returned by the database.
   /// 
   /// It does not make sense to use this method unless you are returning a big payload and
   /// have enabled chunking through InfluxQueryOptions.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="db"></param>
   /// <param name="query"></param>
   /// <param name="options"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   Task < InfluxChunkedResultSet < TInfluxRow > > ReadChunkedAsync < TInfluxRow > ( string db , string query , object parameters , InfluxQueryOptions options ) where TInfluxRow : new ( ) ;
   /// <summary>
   /// Writes the rows with the specified write options.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <param name="rows"></param>
   /// <param name="options"></param>
   /// <returns></returns>
   Task WriteAsync < TInfluxRow > ( string db , string measurementName , IEnumerable < TInfluxRow > rows , InfluxWriteOptions options ) where TInfluxRow : new ( ) ;
   /// <summary>
   /// Deletes data in accordance with the specified query
   /// </summary>
   /// <param name="db"></param>
   /// <param name="deleteQuery"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   Task < InfluxResult > DeleteAsync ( string db , string deleteQuery , object parameters ) ;
}

Además de esta interfaz, se proporciona muchos métodos de extensión que se basan en la parte superior:

 public static class InfluxClientExtensions
{
   #region Raw Operations

   /// <summary>
   /// Executes an arbitrary command that returns a table as a result.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="commandOrQuery"></param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet < TInfluxRow > > ExecuteOperationAsync < TInfluxRow > ( this IInfluxClient client , string commandOrQuery , string db ) ;

   /// <summary>
   /// Executes an arbitrary command or query that returns a table as a result.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="commandOrQuery"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet < TInfluxRow > > ExecuteOperationAsync < TInfluxRow > ( this IInfluxClient client , string commandOrQuery ) ;

   /// <summary>
   /// Executes an arbitrary command or query that returns a table as a result.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="commandOrQuery"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet < TInfluxRow > > ExecuteOperationAsync < TInfluxRow > ( this IInfluxClient client , string commandOrQuery , object parameters ) ;

   /// <summary>
   /// Executes an arbitrary command that does not return a table.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="commandOrQuery"></param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet > ExecuteOperationAsync ( this IInfluxClient client , string commandOrQuery , string db ) ;

   /// <summary>
   /// Executes an arbitrary command that does not return a table.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="commandOrQuery"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet > ExecuteOperationAsync ( this IInfluxClient client , string commandOrQuery ) ;

   /// <summary>
   /// Executes an arbitrary command that does not return a table.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="commandOrQuery"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet > ExecuteOperationAsync ( this IInfluxClient client , string commandOrQuery , object parameters ) ;

   #endregion

   #region System Monitoring

   /// <summary>
   /// Shows InfluxDB stats.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <returns></returns>
   public static async Task < InfluxResult < TInfluxRow > > ShowStatsAsync < TInfluxRow > ( this IInfluxClient client ) ;

   /// <summary>
   /// Shows InfluxDB diagnostics.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <returns></returns>
   public static async Task < InfluxResult < TInfluxRow > > ShowDiagnosticsAsync < TInfluxRow > ( this IInfluxClient client ) ;

   /// <summary>
   /// Shows Shards.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <returns></returns>
   public static async Task < InfluxResult < ShardRow > > ShowShards ( this IInfluxClient client ) ;

   #endregion

   #region Authentication and Authorization

   /// <summary>
   /// CREATE a new admin user.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="username"></param>
   /// <param name="password"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet > CreateAdminUserAsync ( this IInfluxClient client , string username , string password ) ;

   /// <summary>
   /// CREATE a new non-admin user.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="username"></param>
   /// <param name="password"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > CreateUserAsync ( this IInfluxClient client , string username , string password ) ;

   /// <summary>
   /// GRANT administrative privileges to an existing user.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="username"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > GrantAdminPrivilegesAsync ( this IInfluxClient client , string username ) ;

   /// <summary>
   /// GRANT READ, WRITE or ALL database privileges to an existing user.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="privilege"></param>
   /// <param name="db"></param>
   /// <param name="username"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > GrantPrivilegeAsync ( this IInfluxClient client , string db , DatabasePriviledge privilege , string username ) ;

   /// <summary>
   /// REVOKE administrative privileges from an admin user
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="username"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > RevokeAdminPrivilegesAsync ( this IInfluxClient client , string username ) ;

   /// <summary>
   /// REVOKE READ, WRITE, or ALL database privileges from an existing user.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="privilege"></param>
   /// <param name="db"></param>
   /// <param name="username"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > RevokePrivilegeAsync ( this IInfluxClient client , string db , DatabasePriviledge privilege , string username ) ;

   /// <summary>
   /// SET a user’s password.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="username"></param>
   /// <param name="password"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > SetPasswordAsync ( this IInfluxClient client , string username , string password ) ;

   /// <summary>
   /// DROP a user.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="username"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > DropUserAsync ( this IInfluxClient client , string username ) ;

   /// <summary>
   /// SHOW all existing users and their admin status.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <returns></returns>
   public static async Task < InfluxResult < UserRow > > ShowUsersAsync ( this IInfluxClient client ) ;

   /// <summary>
   /// SHOW a user’s database privileges.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="username"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < GrantsRow > > ShowGrantsAsync ( this IInfluxClient client , string username ) ;

   #endregion

   #region Database Management

   /// <summary>
   /// Create a database with CREATE DATABASE.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > CreateDatabaseAsync ( this IInfluxClient client , string db ) ;

   /// <summary>
   /// Delete a database with DROP DATABASE
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > DropDatabaseAsync ( this IInfluxClient client , string db ) ;

   /// <summary>
   /// Delete series with DROP SERIES
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > DropSeries ( this IInfluxClient client , string db , string measurementName ) ;

   /// <summary>
   /// Delete series with DROP SERIES
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <param name="where"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > DropSeries ( this IInfluxClient client , string db , string measurementName , string where ) ;

   /// <summary>
   /// Delete measurements with DROP MEASUREMENT
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="measurementName"></param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > DropMeasurementAsync ( this IInfluxClient client , string db , string measurementName ) ;

   /// <summary>
   /// Create retention policies with CREATE RETENTION POLICY
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="policyName"></param>
   /// <param name="db"></param>
   /// <param name="duration"></param>
   /// <param name="replicationLevel"></param>
   /// <param name="isDefault"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > CreateRetentionPolicyAsync ( this IInfluxClient client , string db , string policyName , string duration , int replicationLevel , bool isDefault ) ;

   /// <summary>
   /// Create retention policies with CREATE RETENTION POLICY
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="policyName"></param>
   /// <param name="db"></param>
   /// <param name="duration"></param>
   /// <param name="replicationLevel"></param>
   /// <param name="shardGroupDuration"></param>
   /// <param name="isDefault"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > CreateRetentionPolicyAsync ( this IInfluxClient client , string db , string policyName , string duration , int replicationLevel , string shardGroupDuration , bool isDefault ) ;

   /// <summary>
   /// Modify retention policies with ALTER RETENTION POLICY
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="policyName"></param>
   /// <param name="db"></param>
   /// <param name="duration"></param>
   /// <param name="replicationLevel"></param>
   /// <param name="isDefault"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > AlterRetentionPolicyAsync ( this IInfluxClient client , string db , string policyName , string duration , int replicationLevel , bool isDefault ) ;

   /// <summary>
   /// Modify retention policies with ALTER RETENTION POLICY
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="policyName"></param>
   /// <param name="db"></param>
   /// <param name="duration"></param>
   /// <param name="replicationLevel"></param>
   /// <param name="shardGroupDuration"></param>
   /// <param name="isDefault"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > AlterRetentionPolicyAsync ( this IInfluxClient client , string db , string policyName , string duration , int replicationLevel , string shardGroupDuration , bool isDefault ) ;

   /// <summary>
   /// Delete retention policies with DROP RETENTION POLICY
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="policyName"></param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > DropRetentionPolicyAsync ( this IInfluxClient client , string db , string policyName ) ;

   #endregion

   #region Continous Queries

   /// <summary>
   /// To see the continuous queries you have defined, query SHOW CONTINUOUS QUERIES and InfluxDB will return the name and query for each continuous query in the database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < ContinuousQueryRow > > ShowContinuousQueries ( this IInfluxClient client , string db ) ;

   /// <summary>
   /// Creates a continuous query.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="name"></param>
   /// <param name="db"></param>
   /// <param name="continuousQuery"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > CreateContinuousQuery ( this IInfluxClient client , string db , string name , string continuousQuery ) ;

   /// <summary>
   /// Drops a continuous query.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="name"></param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult > DropContinuousQuery ( this IInfluxClient client , string db , string name ) ;

   #endregion

   #region Schema Exploration

   /// <summary>
   /// Get a list of all the databases in your system.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <returns></returns>
   public static async Task < InfluxResult < DatabaseRow > > ShowDatabasesAsync ( this IInfluxClient client ) ;

   /// <summary>
   /// The SHOW RETENTION POLICIES query lists the existing retention policies on a given database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < RetentionPolicyRow > > ShowRetentionPoliciesAsync ( this IInfluxClient client , string db ) ;

   /// <summary>
   /// The SHOW SERIES query returns the distinct series in your database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < ShowSeriesRow > > ShowSeriesAsync ( this IInfluxClient client , string db ) ;

   /// <summary>
   /// The SHOW SERIES query returns the distinct series in your database.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < ShowSeriesRow > > ShowSeriesAsync ( this IInfluxClient client , string db , string measurementName ) ;

   /// <summary>
   /// The SHOW SERIES query returns the distinct series in your database.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <param name="where"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < ShowSeriesRow > > ShowSeriesAsync ( this IInfluxClient client , string db , string measurementName , string where ) ;

   /// <summary>
   /// The SHOW MEASUREMENTS query returns the measurements in your database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < MeasurementRow > > ShowMeasurementsAsync ( this IInfluxClient client , string db ) ;

   /// <summary>
   /// The SHOW MEASUREMENTS query returns the measurements in your database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="where"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < MeasurementRow > > ShowMeasurementsAsync ( this IInfluxClient client , string db , string where ) ;

   /// <summary>
   /// The SHOW MEASUREMENTS query returns the measurements in your database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementRegex"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < MeasurementRow > > ShowMeasurementsWithMeasurementAsync ( this IInfluxClient client , string db , string measurementRegex ) ;

   /// <summary>
   /// The SHOW MEASUREMENTS query returns the measurements in your database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementRegex"></param>
   /// <param name="where"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < MeasurementRow > > ShowMeasurementsWithMeasurementAsync ( this IInfluxClient client , string db , string measurementRegex , string where ) ;

   /// <summary>
   /// SHOW TAG KEYS returns the tag keys associated with each measurement.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < TagKeyRow > > ShowTagKeysAsync ( this IInfluxClient client , string db ) ;

   /// <summary>
   /// SHOW TAG KEYS returns the tag keys associated with each measurement.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < TagKeyRow > > ShowTagKeysAsync ( this IInfluxClient client , string db , string measurementName ) ;

   /// <summary>
   /// The SHOW TAG VALUES query returns the set of tag values for a specific tag key across all measurements in the database.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <typeparam name="TValue"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="tagKey"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < TInfluxRow > > ShowTagValuesAsAsync < TInfluxRow , TValue > ( this IInfluxClient client , string db , string tagKey ) ;

   /// <summary>
   /// The SHOW TAG VALUES query returns the set of tag values for a specific tag key across all measurements in the database.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <typeparam name="TValue"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="tagKey"></param>
   /// <param name="measurementName"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < TInfluxRow > > ShowTagValuesAsAsync < TInfluxRow , TValue > ( this IInfluxClient client , string db , string tagKey , string measurementName ) ;

   /// <summary>
   /// The SHOW TAG VALUES query returns the set of tag values for a specific tag key across all measurements in the database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="tagKey"></param>
   /// <returns></returns>
   public static Task < InfluxResult < TagValueRow > > ShowTagValuesAsync ( this IInfluxClient client , string db , string tagKey ) ;

   /// <summary>
   /// The SHOW TAG VALUES query returns the set of tag values for a specific tag key across all measurements in the database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="tagKey"></param>
   /// <param name="measurementName"></param>
   /// <returns></returns>
   public static Task < InfluxResult < TagValueRow > > ShowTagValuesAsync ( this IInfluxClient client , string db , string tagKey , string measurementName ) ;


   /// <summary>
   /// The SHOW FIELD KEYS query returns the field keys across each measurement in the database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < FieldKeyRow > > ShowFieldKeysAsync ( this IInfluxClient client , string db ) ;

   /// <summary>
   /// The SHOW FIELD KEYS query returns the field keys across each measurement in the database.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <returns></returns>
   public static async Task < InfluxResult < FieldKeyRow > > ShowFieldKeysAsync ( this IInfluxClient client , string db , string measurementName ) ;

   #endregion

   #region Ping

   /// <summary>
   /// Executes a ping.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <returns></returns>
   public static Task < InfluxPingResult > PingAsync ( this IInfluxClient client ) ;

   #endregion

   #region Data Management

   /// <summary>
   /// Writes the rows with default write options.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <param name="rows"></param>
   /// <returns></returns>
   public static Task WriteAsync < TInfluxRow > ( this IInfluxClient client , string db , string measurementName , IEnumerable < TInfluxRow > rows ) ;

   /// <summary>
   /// Writes the rows with default write options.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="rows"></param>
   /// <returns></returns>
   public static Task WriteAsync < TInfluxRow > ( this IInfluxClient client , string db , IEnumerable < TInfluxRow > rows ) ;

   /// <summary>
   /// Writes the rows with the specified write options.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="rows"></param>
   /// <param name="options"></param>
   /// <returns></returns>
   public static Task WriteAsync < TInfluxRow > ( this IInfluxClient client , string db , IEnumerable < TInfluxRow > rows , InfluxWriteOptions options ) ;

   /// <summary>
   /// Executes the query and returns the result with the default query options.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="query"></param>
   /// <param name="db"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet < TInfluxRow > > ReadAsync < TInfluxRow > ( this IInfluxClient client , string db , string query ) ;

   /// <summary>
   /// Executes the query and returns the result with the default query options.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="query"></param>
   /// <param name="db"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet < TInfluxRow > > ReadAsync < TInfluxRow > ( this IInfluxClient client , string db , string query , object parameters ) ;

   /// <summary>
   /// Executes the query and returns the result with the specified query options.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="query"></param>
   /// <param name="db"></param>
   /// <param name="options"></param>
   /// <returns></returns>
   public static Task < InfluxResultSet < TInfluxRow > > ReadAsync < TInfluxRow > ( this IInfluxClient client , string db , string query , InfluxQueryOptions options ) ;

   /// <summary>
   /// Executes the query and returns a deferred result that can be iterated over as they
   /// are returned by the database.
   /// 
   /// It does not make sense to use this method unless you are returning a big payload and
   /// have enabled chunking through InfluxQueryOptions.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="query"></param>
   /// <returns></returns>
   public static Task < InfluxChunkedResultSet < TInfluxRow > > ReadChunkedAsync < TInfluxRow > ( this IInfluxClient client , string db , string query ) ;

   /// <summary>
   /// Executes the query and returns a deferred result that can be iterated over as they
   /// are returned by the database.
   /// 
   /// It does not make sense to use this method unless you are returning a big payload and
   /// have enabled chunking through InfluxQueryOptions.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="query"></param>
   /// <param name="parameters"></param>
   /// <returns></returns>
   public static Task < InfluxChunkedResultSet < TInfluxRow > > ReadChunkedAsync < TInfluxRow > ( this IInfluxClient client , string db , string query , object parameters ) ;

   /// <summary>
   /// Executes the query and returns a deferred result that can be iterated over as they
   /// are returned by the database.
   /// 
   /// It does not make sense to use this method unless you are returning a big payload and
   /// have enabled chunking through InfluxQueryOptions.
   /// </summary>
   /// <typeparam name="TInfluxRow"></typeparam>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="query"></param>
   /// <param name="options"></param>
   /// <returns></returns>
   public static Task < InfluxChunkedResultSet < TInfluxRow > > ReadChunkedAsync < TInfluxRow > ( this IInfluxClient client , string db , string query , InfluxQueryOptions options ) ;

   /// <summary>
   /// Deletes data in accordance with the specified query
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="deleteQuery"></param>
   /// <returns></returns>
   public static Task < InfluxResult > DeleteAsync ( this IInfluxClient client , string db , string deleteQuery ) ;

   /// <summary>
   /// Deletes all data older than the specified timestamp.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <param name="to"></param>
   /// <returns></returns>
   public static Task < InfluxResult > DeleteOlderThanAsync ( this IInfluxClient client , string db , string measurementName , DateTime to ) ;

   /// <summary>
   /// Deletes all data in the specified range.
   /// </summary>
   /// <param name="client">The IInfluxClient that performs operation.</param>
   /// <param name="db"></param>
   /// <param name="measurementName"></param>
   /// <param name="from"></param>
   /// <param name="to"></param>
   /// <returns></returns>
   public static Task < InfluxResult > DeleteRangeAsync ( this IInfluxClient client , string db , string measurementName , DateTime from , DateTime to ) ;

   #endregion
}