InfluxDB.Client Download - InfluxDB.Client Download Kode Sumber

Klien influxdb untuk .net

Perpustakaan ini memudahkan menjadi klien untuk influxdb di .net!

Ide dasar di balik perpustakaan adalah bahwa ia harus dapat mengubah kueri langsung menjadi objek kelas Anda sendiri. Sama seperti mikro aktor seperti necis.

Tujuannya adalah kami ingin dapat mendukung sintaks LINQ di masa depan.

Instalasi

Instal melalui Nuget dengan perintah berikut.

 Install-Package Vibrant.InfluxDB.Client

Paket dapat ditemukan di sini.

Atau Anda bisa mengambilnya di salah satu rilis GitHub.

Membaca/Menulis

Perpustakaan memaparkan semua operasi HTTP pada influxdb (1.0+) dan dapat digunakan untuk membaca/menulis data ke/dari dua cara utama:

Menggunakan kelas POCO Anda sendiri.
Menggunakan kelas dinamis.

Contoh sederhana tentang cara menggunakan perpustakaan tersedia di sini.

Menggunakan kelas POCO Anda sendiri

Mulailah dengan mendefinisikan kelas yang mewakili baris dalam influxdb yang ingin Anda simpan.

 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 ; }
}

Di kelas POCO Anda, Anda harus menentukan hal -hal ini:

1 Properti dengan tipe datetime, datetime?, DateTimeOffset atau DateTimeOffset? sebagai cap waktu yang digunakan dalam influxdb dengan menambahkan atribut [InfluxTimestamp].
0-* Properti dengan string tipe, panjang, ulong, int, uint, pendek, ushort, byte, sbyte, double, float, bool, datetime, datetimeOffset, desimal atau enum yang ditentukan pengguna (nullables juga) dengan atribut [influxtag] bahwa influxdb akan digunakan sebagai tag yang diindeks. Perhatikan bahwa semua tag dalam influxdb masih disimpan string. Perpustakaan hanya akan membuat konversi ke jenis yang ditentukan secara otomatis.
1-* Properti dengan string tipe, panjang, ulong, int, uint, pendek, ushort, byte, sbyte, double, float, bool, datetime, datetimeOffset, desimal atau enum yang ditentukan pengguna (nullables juga) dengan atribut [influxfield] yang akan digunakan oleh influxdb sebagai fields.

Setelah Anda mendefinisikan kelas Anda, Anda siap menggunakan influxclient, yang merupakan titik masuk utama ke API:

Inilah cara menulis ke database:

 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 ) ;
}

Inilah cara meminta permintaan dari database:

 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 ) ;
      // ...
   }
}

Menggunakan kelas dinamis

Kelas POCO tidak sesuai dengan setiap kasus penggunaan. Ini menjadi jelas setelah Anda menerapkan suatu sistem dan Anda tidak tahu apa bidang/tag pada waktu kompilasi. Dalam hal ini Anda harus menggunakan kelas dinamis.

Agar ini berfungsi, Anda harus menggunakan antarmuka iinfluxrow yang menentukan metode membaca/menulis untuk tag dan bidang. Perpustakaan ini sudah mencakup satu implementasi dari antarmuka ini yang menggunakan kamus dan memiliki dukungan dasar untuk DLR. Kelas ini disebut DynamicInfluxrow.

Inilah cara menulis menggunakan kelas dinamis.

 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 ) ;
}

Perhatikan, bahwa jika Anda menggunakan kelas dinamis, enum yang ditentukan pengguna dan datetimes karena bidang/tag tidak didukung, karena tidak ada cara untuk membedakan antara string dan enum/datetime.

Juga perhatikan, jika Anda ingin menggunakan tipe timestamp khusus atau DateTimeOffset dengan antarmuka ini, Anda dapat menggunakan antarmuka IInfluxrow generik atau kelas DynamicInfluxrow.

Inilah cara meminta permintaan dari database:

 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 ) ;
      // ...
   }
}

Baca Operasi Hanya

Seringkali, Anda mungkin tidak memilih struktur yang tepat yang juga Anda masukkan. Mungkin Anda melakukan beberapa agregasi atau perhitungan pada data yang Anda ambil yang mengubah nama kolom yang dikembalikan.

Dalam hal ini, Anda cukup mendefinisikan kelas baru dan menggunakan influxcomputedAttribute. Setiap kolom yang cocok dengan nama yang ditentukan dalam atribut (tag atau bidang, dikumpulkan atau tidak) akan masuk ke properti dengan atribut ini.

 [ InfluxComputedAttribute ]

Kelas dengan atribut ini tidak boleh digunakan untuk dimasukkan, karena tidak ada cara bagi klien untuk mengetahui apakah itu bidang atau tag.

Jika Anda menggunakan antarmuka iinfluxrow (DynamicInfluxrow, misalnya), maka koleksi "bidang" diisi dengan semua kolom yang tidak cocok dengan tag yang diketahui untuk pengukuran spesifik.

Chunking

Kadang -kadang Anda dapat mengambil sejumlah besar data dari database, begitu banyak pada kenyataannya, sehingga menjaga semuanya dalam memori pada satu waktu tidak mungkin. Dalam hal ini Anda memerlukan fitur chunking yang disediakan oleh influxdb. Anda dapat memanfaatkan fitur ini dengan mengaktifkan chunking melalui kelas InfluxQueryOptions. Saat diaktifkan, klien akan memberikan opsi chunking untuk masuk ketika mengambil data.

Namun, operasi ReadAsync default akan cukup membaca semua potongan sebelum mengembalikan kontrol ke pengguna. Untuk mendukung skenario di mana Anda ingin membaca chunk data dengan chunk, Anda malah dapat menggunakan metode readchunkedAsync. Ini akan mengembalikan jenis set hasil yang berbeda yang memungkinkan Anda untuk mengulangi semua potongan (sambil tetap mempertahankan struktur kueri yang awalnya Anda buat). Berikut contoh yang diambil dari tes unit:

 [ 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 ) ;
}

Dalam versi C# mendatang akan ada kemampuan untuk mengulangi overync enumerables, dan begitu fitur ini menghantam, saya akan mendukungnya juga. Lihat video di bawah ini:

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

Melestarikan offsete TimeZone

Saat menentukan klausa zona waktu, InfluxDB akan mengembalikan cap waktu dengan offset mereka. Anda dapat mempertahankan offset ini di cap waktu yang dikembalikan dengan menggunakan DatetimeOffset atau nullable sebagai tipe timestamp. Jika Anda menggunakan datetime atau nullable sebagai jenis waktu, cap waktu akan selalu dikonversi ke UTC.

Jenis Timestamp Kustom

Atau, Anda dapat mengimplementasikan itimestampParser Anda sendiri untuk mendukung tipe khusus, misalnya nodatime. Setelah diterapkan, Anda dapat mendaftar pada influxclient. Cukup terapkan antarmuka berikut:

 /// <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 ) ;
}

Menulis ke berbagai nama pengukuran dalam panggilan tunggal

Seringkali Anda mungkin ingin menulis ke beberapa pengukuran dengan nama pengukuran yang berbeda dengan menjalankan satu panggilan.

Ini dapat dicapai dengan mengimplementasikan antarmuka berikut di kelas POCO Anda:

   /// <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 ; }
   }

Atau dengan meletakkan atribut [masuknya pengukuran] pada kelas atau definisi properti Anda dari kelas POCO Anda.

Saat menggunakannya di kelas, Anda harus menentukan nama, seperti itu:

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

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

Saat menggunakannya di properti, jangan tentukan nama. Itu akan menggunakan nilai properti (yang harus berupa string):

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

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

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

Saat menggunakan salah satu dari pendekatan ini, Anda kemudian dapat menggunakan metode WriteAsync Overloads berikut, yang tidak mengambil nama pengukuran sebagai argumen:

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

Jika Anda ingin melakukan ini dengan kelas -kelas dinamis, Anda dapat menggunakan nameddynamicinfluxrow (yang mengimplementasikan antarmuka IhaveAmeArtName).

Prioritas berikut digunakan ketika menentukan pengukuran mana yang akan menulis catatan dalam kasus beberapa pendekatan digunakan:

Nama yang disediakan dalam metode WriteAsync.
Nama yang disediakan oleh antarmuka ihavemeasurementname
Nama yang disediakan oleh properti yang dianotasi dengan InfluxMeArtArtAttribute.
Nama yang disediakan di kelas dianotasi dengan InfluxMeaseSurementAttribute.

Jika Anda menggunakan IHAVEMEASUREMENTNAME atau properti dengan InfluxMeAdeArtAttribute, nama pengukuran akan ditulis ke properti itu selama operasi baca.

Parameter Ikatan dan Pencegahan Injeksi SQL

Influxclient juga mendukung pengikatan parameter untuk mendukung pencegahan injeksi SQL.

Untuk menggunakan ini, cukup gunakan metode yang mengambil parameter "parameter objek". Ini bisa menjadi objek anonim, kamus atau objek apa pun yang mendukung serialisasi JSON melalui newtonsoft.json.

Saat parameterisasi nilai dalam objek atau kamus, jangan awalkan nama dengan $, seperti nama -nama dalam kueri yang sebenarnya.

Berikut adalah contoh dari apa yang mungkin terlihat:

 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 ) } ) ;

Jenis apa pun yang biasanya Anda gunakan melalui pustaka klien ini dapat digunakan sebagai parameter.

Operasi Lainnya

Antarmuka utama untuk berinteraksi dengan influxdb dapat dilihat di bawah ini.

 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 ) ;
}

Selain antarmuka ini, banyak metode ekstensi yang dibangun di atasnya disediakan:

 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
}