Correction of the return values of the DatabaseInfo methods for determining the insert, read and delete operations

src/FirebirdSql.Data.FirebirdClient.Tests/FbDatabaseInfoTests.cs

@@ -16,6 +16,7 @@
 //$Authors = Carlos Guzman Alvarez, Jiri Cincura (jiri@cincura.net)
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Threading;
@@ -61,4 +62,124 @@ public void CompleteDatabaseInfoTest()
  Assert.DoesNotThrowAsync(() => (Task)m.Invoke(dbInfo, new object[] { CancellationToken.None }), m.Name);
  }
 	}
+
+	[Test]
+	public async Task PerformanceAnalysis_SELECT_Test()
+	{
+ var tableNameList = await GetTableNameList();
+ var tableIdTest = tableNameList["TEST"];
+
+ var dbInfo = new FbDatabaseInfo(Connection);
+ var insertCount = await dbInfo.GetInsertCountAsync();
+ var updateCount = await dbInfo.GetUpdateCountAsync();
+ var readSeqCount = await dbInfo.GetReadSeqCountAsync();
+ var readIdxCount = await dbInfo.GetReadIdxCountAsync();
+
+ var fbCommand = new FbCommand("SELECT MAX(INT_FIELD) FROM TEST", Connection);
+ var maxIntField = await fbCommand.ExecuteScalarAsync() as int?;
+
+ insertCount = await GetAffectedTables(insertCount, await dbInfo.GetInsertCountAsync());
+ updateCount = await GetAffectedTables(updateCount, await dbInfo.GetUpdateCountAsync());
+ readSeqCount = await GetAffectedTables(readSeqCount, await dbInfo.GetReadSeqCountAsync());
+ readIdxCount = await GetAffectedTables(readIdxCount, await dbInfo.GetReadIdxCountAsync());
+
+ Assert.That(insertCount.ContainsKey(tableIdTest), Is.False);
+ Assert.That(updateCount.ContainsKey(tableIdTest), Is.False);
+ Assert.That(readSeqCount.ContainsKey(tableIdTest), Is.True);
+ Assert.That(readSeqCount[tableIdTest], Is.EqualTo(maxIntField + 1));
+ Assert.That(readIdxCount.ContainsKey(tableIdTest), Is.False);
+	}
+
+	[Test]
+	public async Task PerformanceAnalysis_INSERT_Test()
+	{
+ var tableNameList = await GetTableNameList();
+ var tableIdTest = tableNameList["TEST"];
+
+ var dbInfo = new FbDatabaseInfo(Connection);
+ var insertCount = await dbInfo.GetInsertCountAsync();
+ var updateCount = await dbInfo.GetUpdateCountAsync();
+ var readSeqCount = await dbInfo.GetReadSeqCountAsync();
+ var readIdxCount = await dbInfo.GetReadIdxCountAsync();
+
+ var fbCommand = new FbCommand("INSERT INTO TEST (INT_FIELD) VALUES (900)", Connection);
+ await fbCommand.ExecuteNonQueryAsync();
+
+ insertCount = await GetAffectedTables(insertCount, await dbInfo.GetInsertCountAsync());
+ updateCount = await GetAffectedTables(updateCount, await dbInfo.GetUpdateCountAsync());
+ readSeqCount = await GetAffectedTables(readSeqCount, await dbInfo.GetReadSeqCountAsync());
+ readIdxCount = await GetAffectedTables(readIdxCount, await dbInfo.GetReadIdxCountAsync());
+
+ Assert.That(insertCount.ContainsKey(tableIdTest), Is.True);
+ Assert.That(insertCount[tableIdTest], Is.EqualTo(1));
+ Assert.That(updateCount.ContainsKey(tableIdTest), Is.False);
+ Assert.That(readSeqCount.ContainsKey(tableIdTest), Is.False);
+ Assert.That(readIdxCount.ContainsKey(tableIdTest), Is.False);
+	}
+
+	[Test]
+	public async Task PerformanceAnalysis_UPDATE_Test()
+	{
+ var tableNameList = await GetTableNameList();
+ var tableIdTest = tableNameList["TEST"];
+
+ var fbCommand = new FbCommand("INSERT INTO TEST (INT_FIELD) VALUES (900)", Connection);
+ await fbCommand.ExecuteNonQueryAsync();
+
+ var dbInfo = new FbDatabaseInfo(Connection);
+ var insertCount = await dbInfo.GetInsertCountAsync();
+ var updateCount = await dbInfo.GetUpdateCountAsync();
+ var readSeqCount = await dbInfo.GetReadSeqCountAsync();
+ var readIdxCount = await dbInfo.GetReadIdxCountAsync();
+
+ fbCommand.CommandText = "UPDATE TEST SET SMALLINT_FIELD = 900 WHERE (INT_FIELD = 900)";
+ await fbCommand.ExecuteNonQueryAsync();
+
+ insertCount = await GetAffectedTables(insertCount, await dbInfo.GetInsertCountAsync());
+ updateCount = await GetAffectedTables(updateCount, await dbInfo.GetUpdateCountAsync());
+ readSeqCount = await GetAffectedTables(readSeqCount, await dbInfo.GetReadSeqCountAsync());
+ readIdxCount = await GetAffectedTables(readIdxCount, await dbInfo.GetReadIdxCountAsync());
+
+ Assert.That(insertCount.ContainsKey(tableIdTest), Is.False);
+ Assert.That(updateCount.ContainsKey(tableIdTest), Is.True);
+ Assert.That(updateCount[tableIdTest], Is.EqualTo(1));
+ Assert.That(readSeqCount.ContainsKey(tableIdTest), Is.False);
+ Assert.That(readIdxCount.ContainsKey(tableIdTest), Is.True);
+ Assert.That(readIdxCount[tableIdTest], Is.EqualTo(1));
+	}
+
+	async Task<IDictionary<short, ulong>> GetAffectedTables(IDictionary<short, ulong> statisticInfoBefore, IDictionary<short, ulong> statisticInfoAfter)
+	{
+ var result = new Dictionary<short, ulong>();
+ foreach (var keyValuePair in statisticInfoAfter)
+ {
+ if (statisticInfoBefore.TryGetValue(keyValuePair.Key, out var value))
+ {
+ var counter = keyValuePair.Value - value;
+ if (counter > 0)
+ {
+ result.Add(keyValuePair.Key, counter);
+ }
+ }
+ else
+ result.Add(keyValuePair.Key, keyValuePair.Value);
+ }
+ return await Task.FromResult(result);
+	}
+
+	async Task<IDictionary<string, short>> GetTableNameList()
+	{
+ IDictionary<string, short> result = new Dictionary<string, short>();
+ await using (var command = new FbCommand("select R.RDB$RELATION_ID, TRIM(R.RDB$RELATION_NAME) from RDB$RELATIONS R WHERE RDB$SYSTEM_FLAG = 0", Connection))
+ {
+ await using (var reader = await command.ExecuteReaderAsync())
+ {
+ while (await reader.ReadAsync())
+ {
+ result.Add(reader.GetString(1), reader.GetInt16(0));
+ }
+ }
+ }
+ return result;
+	}
 }

src/FirebirdSql.Data.FirebirdClient/Common/Extensions.cs

@@ -51,6 +51,20 @@ public static string ToHexString(this byte[] b)
  return BitConverter.ToString(b).Replace("-", string.Empty);
 	}
 
+	public static IDictionary<short, ulong> GetTableStatistics(this byte[] b, int length)
+	{
+ var capacity = length > 3 ? (length - 3) / 6 + 1 : 0;
+
+ var tableStatistics = new Dictionary<short, ulong>(capacity);
+ for (var i = 3; i < length; i += 6)
+ {
+ var tableId = (short)IscHelper.VaxInteger(b, i, 2);
+ var count = (ulong)IscHelper.VaxInteger(b, i + 2, 4);
+ tableStatistics.Add(tableId, count);
+ }
+ return tableStatistics;
+	}
+
 	public static IEnumerable<IEnumerable<T>> Split<T>(this T[] array, int size)
 	{
  for (var i = 0; i < (float)array.Length / size; i++)

src/FirebirdSql.Data.FirebirdClient/Common/IscHelper.cs

@@ -54,14 +54,6 @@ public static List<object> ParseDatabaseInfo(byte[] buffer, Charset charset)
  case IscCodes.isc_info_marks:
  case IscCodes.isc_info_reads:
  case IscCodes.isc_info_writes:
- case IscCodes.isc_info_backout_count:
- case IscCodes.isc_info_delete_count:
- case IscCodes.isc_info_expunge_count:
- case IscCodes.isc_info_insert_count:
- case IscCodes.isc_info_purge_count:
- case IscCodes.isc_info_read_idx_count:
- case IscCodes.isc_info_read_seq_count:
- case IscCodes.isc_info_update_count:
  case IscCodes.isc_info_db_size_in_pages:
  case IscCodes.isc_info_oldest_transaction:
  case IscCodes.isc_info_oldest_active:
@@ -77,6 +69,17 @@ public static List<object> ParseDatabaseInfo(byte[] buffer, Charset charset)
  info.Add(VaxInteger(buffer, pos, length));
  break;
 
+ case IscCodes.isc_info_backout_count:
+ case IscCodes.isc_info_delete_count:
+ case IscCodes.isc_info_expunge_count:
+ case IscCodes.isc_info_insert_count:
+ case IscCodes.isc_info_purge_count:
+ case IscCodes.isc_info_update_count:
+ case IscCodes.isc_info_read_seq_count:
+ case IscCodes.isc_info_read_idx_count:
+ info.Add(buffer.GetTableStatistics(length));
+ break;
+
  case IscCodes.isc_info_no_reserve:
  case IscCodes.isc_info_forced_writes:
  case IscCodes.isc_info_db_read_only:

src/FirebirdSql.Data.FirebirdClient/FirebirdClient/FbDatabaseInfo.cs

@@ -17,7 +17,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Data;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -225,76 +224,141 @@ public Task<int> GetWritesAsync(CancellationToken cancellationToken = default)
  return GetValueAsync<int>(IscCodes.isc_info_writes, cancellationToken);
 	}
 
-	public int GetBackoutCount()
+	/// <summary>
+	/// Returns the number of removals of a version of a record of the affected tables.
+	/// </summary>
+	/// <returns>Dictionary with the number of removals, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public IDictionary<short, ulong> GetBackoutCount()
 	{
- return GetValue<int>(IscCodes.isc_info_backout_count);
+ return GetValue<IDictionary<short, ulong>>(IscCodes.isc_info_backout_count);
 	}
-	public Task<int> GetBackoutCountAsync(CancellationToken cancellationToken = default)
+	/// <summary>
+	/// Returns the number of removals of a version of a record of the affected tables.
+	/// </summary>
+	/// <returns>Dictionary with the number of removals, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public Task<IDictionary<short, ulong>> GetBackoutCountAsync(CancellationToken cancellationToken = default)
 	{
- return GetValueAsync<int>(IscCodes.isc_info_backout_count, cancellationToken);
+ return GetValueAsync<IDictionary<short, ulong>>(IscCodes.isc_info_backout_count, cancellationToken);
 	}
 
-	public int GetDeleteCount()
+	/// <summary>
+	/// Returns the number of database deletes of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of deletes, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public IDictionary<short, ulong> GetDeleteCount()
 	{
- return GetValue<int>(IscCodes.isc_info_delete_count);
+ return GetValue<IDictionary<short, ulong>>(IscCodes.isc_info_delete_count);
 	}
-	public Task<int> GetDeleteCountAsync(CancellationToken cancellationToken = default)
+	/// <summary>
+	/// Returns the number of database deletes of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of deletes, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public Task<IDictionary<short, ulong>> GetDeleteCountAsync(CancellationToken cancellationToken = default)
 	{
- return GetValueAsync<int>(IscCodes.isc_info_delete_count, cancellationToken);
+ return GetValueAsync<IDictionary<short, ulong>>(IscCodes.isc_info_delete_count, cancellationToken);
 	}
 
-	public int GetExpungeCount()
+	/// <summary>
+	/// Returns the number of removals of a record and all of its ancestors, for records whose deletions have been committed of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of removals, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public IDictionary<short, ulong> GetExpungeCount()
 	{
- return GetValue<int>(IscCodes.isc_info_expunge_count);
+ return GetValue<IDictionary<short, ulong>>(IscCodes.isc_info_expunge_count);
 	}
-	public Task<int> GetExpungeCountAsync(CancellationToken cancellationToken = default)
+
+	/// <summary>
+	/// Returns the number of removals of a record and all of its ancestors, for records whose deletions have been committed of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of removals, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public Task<IDictionary<short, ulong>> GetExpungeCountAsync(CancellationToken cancellationToken = default)
 	{
- return GetValueAsync<int>(IscCodes.isc_info_expunge_count, cancellationToken);
+ return GetValueAsync<IDictionary<short, ulong>>(IscCodes.isc_info_expunge_count, cancellationToken);
 	}
 
-	public int GetInsertCount()
+	/// <summary>
+	/// Returns the number of inserts into the database of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of inserts, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public IDictionary<short, ulong> GetInsertCount()
 	{
- return GetValue<int>(IscCodes.isc_info_insert_count);
+ return GetValue<IDictionary<short, ulong>>(IscCodes.isc_info_insert_count);
 	}
-	public Task<int> GetInsertCountAsync(CancellationToken cancellationToken = default)
+	/// <summary>
+	/// Returns the number of inserts into the database of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of inserts, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public Task<IDictionary<short, ulong>> GetInsertCountAsync(CancellationToken cancellationToken = default)
 	{
- return GetValueAsync<int>(IscCodes.isc_info_insert_count, cancellationToken);
+ return GetValueAsync<IDictionary<short, ulong>>(IscCodes.isc_info_insert_count, cancellationToken);
 	}
 
-	public int GetPurgeCount()
+	/// <summary>
+	/// Returns the number of removals of old versions of fully mature records (records that are committed, so that older ancestor versions are no longer needed) of the affected tables.
+	/// </summary>
+	/// <returns>Dictionary with the number of removals, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public IDictionary<short, ulong> GetPurgeCount()
 	{
- return GetValue<int>(IscCodes.isc_info_purge_count);
+ return GetValue<IDictionary<short, ulong>>(IscCodes.isc_info_purge_count);
 	}
-	public Task<int> GetPurgeCountAsync(CancellationToken cancellationToken = default)
+	/// <summary>
+	/// Returns the number of removals of old versions of fully mature records (records that are committed, so that older ancestor versions are no longer needed) of the affected tables.
+	/// </summary>
+	/// <returns>Dictionary with the number of removals, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public Task<IDictionary<short, ulong>> GetPurgeCountAsync(CancellationToken cancellationToken = default)
 	{
- return GetValueAsync<int>(IscCodes.isc_info_purge_count, cancellationToken);
+ return GetValueAsync<IDictionary<short, ulong>>(IscCodes.isc_info_purge_count, cancellationToken);
 	}
 
-	public long GetReadIdxCount()
+	/// <summary>
+	/// Returns the number of reads done via an index of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of reads, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public IDictionary<short, ulong> GetReadIdxCount()
 	{
- return GetValue<long>(IscCodes.isc_info_read_idx_count);
+ return GetValue<IDictionary<short, ulong>>(IscCodes.isc_info_read_idx_count);
 	}
-	public Task<long> GetReadIdxCountAsync(CancellationToken cancellationToken = default)
+	/// <summary>
+	/// Returns the number of reads done via an index of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of reads, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public Task<IDictionary<short, ulong>> GetReadIdxCountAsync(CancellationToken cancellationToken = default)
 	{
- return GetValueAsync<long>(IscCodes.isc_info_read_idx_count, cancellationToken);
+ return GetValueAsync<IDictionary<short, ulong>>(IscCodes.isc_info_read_idx_count, cancellationToken);
 	}
 
-	public long GetReadSeqCount()
+	/// <summary>
+	/// Returns the number of sequential table scans (row reads) of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of reads, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public IDictionary<short, ulong> GetReadSeqCount()
 	{
- return GetValue<long>(IscCodes.isc_info_read_seq_count);
+ return GetValue<IDictionary<short, ulong>>(IscCodes.isc_info_read_seq_count);
 	}
-	public Task<long> GetReadSeqCountAsync(CancellationToken cancellationToken = default)
+	/// <summary>
+	/// Returns the number of sequential table scans (row reads) of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of reads, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public Task<IDictionary<short, ulong>> GetReadSeqCountAsync(CancellationToken cancellationToken = default)
 	{
- return GetValueAsync<long>(IscCodes.isc_info_read_seq_count, cancellationToken);
+ return GetValueAsync<IDictionary<short, ulong>>(IscCodes.isc_info_read_seq_count, cancellationToken);
 	}
 
-	public long GetUpdateCount()
+	/// <summary>
+	/// Returns the number of database updates of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of updates, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public IDictionary<short, ulong> GetUpdateCount()
 	{
- return GetValue<long>(IscCodes.isc_info_update_count);
+ return GetValue<IDictionary<short, ulong>>(IscCodes.isc_info_update_count);
 	}
-	public Task<long> GetUpdateCountAsync(CancellationToken cancellationToken = default)
+	/// <summary>
+	/// Returns the number of database updates of the affected tables since the database was last attached.
+	/// </summary>
+	/// <returns>Dictionary with the number of updates, with table id (field RDB$RELATION_ID of the system table RDB$RELATIONS) as key.</returns>
+	public Task<IDictionary<short, ulong>> GetUpdateCountAsync(CancellationToken cancellationToken = default)
 	{
- return GetValueAsync<long>(IscCodes.isc_info_update_count, cancellationToken);
+ return GetValueAsync<IDictionary<short, ulong>>(IscCodes.isc_info_update_count, cancellationToken);
 	}
 
 	public int GetDatabaseSizeInPages()