InfluxDB.Client
4.0.3
هذه المكتبة تجعل من السهل أن تكون عميلًا لـ InfluxDB على .NET!
الفكرة الأساسية وراء المكتبة هي أنها يجب أن تكون قادرة على تحويل الاستعلامات مباشرة إلى كائنات من الفصول الدراسية الخاصة بك. يشبه إلى حد كبير النمور الصغيرة مثل dapper.
الهدف هو أننا نريد أن نكون قادرين على دعم بناء جملة LINQ في المستقبل.
تثبيته من خلال Nuget مع الأمر التالي.
Install-Package Vibrant.InfluxDB.Client
يمكن العثور على الحزمة هنا.
أو يمكنك ببساطة الاستيلاء عليها في أحد إصدارات جيثب.
تكشف المكتبة جميع عمليات HTTP على influxdb (1.0+) ويمكن استخدامها لقراءة/كتابة بيانات من/إلى طريقتين أساسيتين:
مثال بسيط على كيفية استخدام المكتبة متاح هنا.
ابدأ بتحديد فصل يمثل صفًا في influxdb تريد تخزينه.
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 ; }
}في فصل POCO الخاص بك ، يجب عليك تحديد هذه الأشياء:
بمجرد تحديد فصلك ، تكون مستعدًا لاستخدام التدفق ، وهي نقطة الدخول الرئيسية إلى واجهة برمجة التطبيقات:
إليك كيفية الكتابة إلى قاعدة البيانات:
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 ) ;
}إليك كيفية الاستعلام من قاعدة البيانات:
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 ) ;
// ...
}
}فئات POCO لا تتناسب مع كل حالة استخدام. يصبح هذا واضحًا بمجرد تنفيذ نظام ولا تعرف ما الذي ستكون الحقول/العلامات في وقت الترجمة. في هذه الحالة ، يجب عليك استخدام الفئات الديناميكية.
لكي يعمل هذا ، يجب عليك استخدام واجهة iinfluxrow التي تحدد طرق القراءة/الكتابة للعلامات والحقول. تتضمن هذه المكتبة بالفعل تطبيقًا واحدًا من هذه الواجهات التي تستخدم القواميس ولديها دعم أساسي لـ DLR. يسمى هذا الفئة DynamicinFluxrow.
إليك كيفية الكتابة باستخدام الفصول الديناميكية.
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 ) ;
}لاحظ أنه إذا كنت تستخدم الفئات الديناميكية ، والتعداد المعرفة من قبل المستخدم وأخصائيات البيانات ، حيث لا يتم دعم الحقول/العلامات ، حيث لا توجد وسيلة للتمييز بين السلسلة والتعداد/DateTime.
لاحظ أيضًا ، إذا كنت ترغب في استخدام نوع Timestamp المخصص أو DateTimeOffset مع هذه الواجهة ، فيمكنك استخدام واجهة iinfluxrow العامة أو فئة DynamicInfluxrow.
إليك كيفية الاستعلام من قاعدة البيانات:
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 ) ;
// ...
}
} في كثير من الأحيان ، قد لا تختار الهيكل الدقيق الذي تقوم به أيضًا. ربما تقوم ببعض التجميع أو الحسابات على البيانات التي تسترجعها والتي تغير اسم الأعمدة التي تم إرجاعها.
في هذه الحالة ، يمكنك ببساطة تحديد فئة جديدة واستخدام influxComputEdattribute. أي أعمدة تتطابق مع الاسم المحدد في السمة (العلامة أو الحقل ، المجمعة أو لا) ستذهب إلى الخاصية مع هذه السمة.
[ InfluxComputedAttribute ]لا ينبغي استخدام الفصول التي تحتوي على هذه السمة للإدراج ، حيث لا توجد طريقة للعميل لمعرفة ما إذا كان حقلًا أو علامة.
إذا كنت تستخدم واجهة iinfluxrow (DynamicinFluxRow ، على سبيل المثال) ، فإن مجموعة "الحقول" مليئة بجميع الأعمدة التي لا تتطابق مع علامة معروفة للقياس المحدد.
في بعض الأحيان ، يمكنك استرداد كمية هائلة من البيانات من قاعدة البيانات ، في الواقع ، لدرجة أن الحفاظ على كل شيء في الذاكرة في أي وقت غير ممكن. في هذه الحالة ، تحتاج إلى ميزة chunking التي توفرها influxDB. يمكنك الاستفادة من هذه الميزة من خلال تمكين التقطيع من خلال فئة التدفق. عند تمكين العميل ، سيقدم العميل خيارات التضخيم إلى efferuxdb عند استرداد البيانات.
ومع ذلك ، فإن عمليات ReadAsync الافتراضية ستقرأ ببساطة جميع القطع قبل إرجاع التحكم إلى المستخدم. لدعم السيناريوهات التي تريد قراءة قطعة البيانات عن طريق قطعة ، يمكنك بدلاً من ذلك استخدام Method REATHUNKEDASYNC. سيؤدي ذلك إلى إرجاع نوع مختلف من مجموعة النتائج التي تتيح لك التكرار بشكل غير متزامن على جميع القطع (مع الحفاظ على بنية الاستعلامات التي قمت بها في البداية). إليك مثال مأخوذ من اختبارات الوحدة:
[ 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 ) ;
}في الإصدارات القادمة من C# ، ستكون هناك القدرة على التكرار على العدوى غير المتزامنة ، وبمجرد وصول هذه الميزة ، سأدعم ذلك أيضًا. انظر الفيديو أدناه:
https://channel9.msdn.com/blogs/seth-juarez/a-preview-of-c-8-with-mads-torgersen#time=16m30s
عند تحديد شرط المنطقة الزمنية ، سيعود influxDB الطوابع الزمنية مع إزاحةها. يمكنك الحفاظ على هذا الإزاحة في الطابع الزمني الذي تم إرجاعه باستخدام إما dateTimeOffset أو Nullable كنوع الطابع الزمني. إذا كنت تستخدم DateTime أو Nullable كنوع الطابع الزمني ، فسيتم دائمًا تحويل الطابع الزمني إلى UTC.
بدلاً من ذلك ، يمكنك تنفيذ Itimestampparser الخاص بك لدعم الأنواع المخصصة ، على سبيل المثال العقيدة. بمجرد تنفيذها ، يمكنك التسجيل على التدفق. ما عليك سوى تنفيذ الواجهة التالية:
/// <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 ) ;
} غالبًا ما ترغب في الكتابة إلى قياسات متعددة بأسماء قياس مختلفة عن طريق تنفيذ مكالمة واحدة.
يمكن تحقيق ذلك إما عن طريق تنفيذ الواجهة التالية على فئات 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 ; }
}
أو عن طريق وضع سمة [التدفق] على صفك أو تعريفات خاصية فئة POCO الخاصة بك.
عند استخدامه في الفصل الدراسي ، يجب عليك تحديد اسم ، مثل ذلك:
[ InfluxMeasurement ( "MyTableName" ) ]
public class ClassWithMeasurementName
{
[ InfluxTimestamp ]
internal DateTime Timestamp { get ; set ; }
[ InfluxField ( "cpu" ) ]
internal double ? CPU { get ; set ; }
}عند استخدامها على خاصية ، لا تحدد اسمًا. سوف تستخدم قيمة الخاصية (والتي يجب أن تكون سلسلة):
public class ClassWithMeasurementName
{
[ InfluxTimestamp ]
internal DateTime Timestamp { get ; set ; }
[ InfluxField ( "cpu" ) ]
internal double ? CPU { get ; set ; }
[ InfluxMeasurement ]
public string TableName { get ; set ; }
}عند استخدام أحد هذه الأساليب ، يمكنك بعد ذلك استخدام طريقة Writeasync الزائدة التالية ، والتي لا تأخذ اسم القياس كوسيطة:
public Task WriteAsync < TInfluxRow > ( string db , IEnumerable < TInfluxRow > rows )
public Task WriteAsync < TInfluxRow > ( string db , IEnumerable < TInfluxRow > rows , InfluxWriteOptions options )
في حال كنت ترغب في القيام بذلك مع فئات ديناميكية ، يمكنك ببساطة استخدام NameDynamicinFluxrow (الذي ينفذ واجهة ihavemeasurementName).
يتم استخدام الأولوية التالية عند تحديد أي قياس لكتابة سجل في حالة استخدام طرق متعددة:
في حال كنت تستخدم ihavemeAsurementName أو خاصية مع تدفقات التدفق ، سيتم كتابة اسم القياس إلى تلك الخاصية أثناء عمليات القراءة.
يدعم التدفق أيضًا ربط المعلمة لدعم الوقاية من حقن SQL.
لاستخدام هذا ، ما عليك سوى استخدام الطرق التي تأخذ المعلمة "معلمات الكائن". يمكن أن يكون هذا كائنًا مجهولًا أو قاموسًا أو أي كائن يدعم تسلسل JSON من خلال newtonsoft.json.
عند تحديد المعلمة في الكائن أو القاموس ، لا تقم ببادئة الأسماء باستخدام $ ، مثل الأسماء في الاستعلام الفعلي.
إليك مثال على ما قد يبدو عليه:
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 ) } ) ;يمكن استخدام أي نوع تستخدمه عادة من خلال مكتبة العميل كمعلمة.
يمكن رؤية الواجهة الرئيسية للتفاعل مع influxDB أدناه.
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 ) ;
}بالإضافة إلى هذه الواجهة ، يتم توفير الكثير من طرق التمديد التي تبني فوقها:
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
}للحصول على مؤشر دقيق لما تشير إليه كل من المعلمات إلى صفحة الوثائق التي توفرها influxDB:
