Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (1)

467-467: Remove unnecessary assignment to next variable

The variable next is assigned but not used beyond the null check. Simplify the condition to improve readability.

Apply this diff to simplify the code:

- if ((next = actionClient.ScannerGetNextAsync(scanInfo, requestOption).Result) != null)
+ if (actionClient.ScannerGetNextAsync(scanInfo, requestOption).Result != null)

🧰 Tools

🪛 GitHub Check: Codacy Static Code Analysis

[warning] 467-467: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs#L467
Remove this useless assignment to local variable 'next'.

Configuration used: CodeRabbit UI
Review profile: CHILL

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (3)

454-471: Optimize column family iteration

The current implementation iterates through all column families sequentially until finding data. Consider:

1. Implementing parallel scanning of column families
2. Caching frequently used column families

// Example of parallel implementation
var tasks = familyNameList.Select(async i => {
    var familyName = i.name;
    var scanner = getScanner(wherepart, familyName);
    var scanInfo = await actionClient.CreateScannerAsync(table, scanner, requestOption);
    return await actionClient.ScannerGetNextAsync(scanInfo, requestOption);
});
var results = await Task.WhenAll(tasks);
var firstResult = results.FirstOrDefault(r => r != null);

---

Line range hint 588-619: Add documentation for type inference logic

The complex type inference logic needs documentation to explain:

1. The purpose of all-zero byte array handling
2. The conditions for switching between Double and Long types
3. The rationale behind the length checks

Add XML documentation:

/// <summary>
/// Displays the inferred type and value from a byte array.
/// </summary>
/// <param name="byteArray">The byte array to analyze</param>
/// <returns>A string representation of the inferred value</returns>
/// <remarks>
/// The method uses the following rules for type inference:
/// - All-zero arrays return "0"
/// - Arrays of length 8 are checked for both Double and Long representation
/// - NaN and Infinity values in Double format are handled specially
/// </remarks>

---

653-657: Use constants for byte array lengths

Define constants for commonly used byte array lengths to improve code maintainability.

+private const int INT_FLOAT_BYTE_LENGTH = 4;
+private const int LONG_DOUBLE_BYTE_LENGTH = 8;

 public static DataType InferDataType(byte[] byteArray)
 {
     switch (byteArray.Length)
     {
-        case 4:
+        case INT_FLOAT_BYTE_LENGTH:
             // ...
-        case 8:
+        case LONG_DOUBLE_BYTE_LENGTH:
             // ...
     }
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

Ginger/GingerCoreNET/GingerCoreNET.csproj (2)

1204-1206: Consider organizing screenshots in a versioned structure.

The screenshot is correctly configured with "CopyToOutputDirectory" set to "Always", but consider organizing screenshots in a versioned folder structure (e.g., /v1/screenshots/) to better manage updates and backwards compatibility.

-    <None Update="Reports\Ginger-Web-Client\assets\screenshots\ScreenShot_1_1.png">
+    <None Update="Reports\Ginger-Web-Client\assets\screenshots\v1\ScreenShot_1_1.png">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>

---

Line range hint 1204-1245: Consider implementing a static asset versioning strategy.

The project contains multiple versioned static assets (JS files with hashes, screenshots with numeric versions). Consider implementing a systematic versioning strategy:

1. Use semantic versioning for screenshots and other static assets
2. Document the versioning scheme in the project
3. Consider using a build-time asset pipeline to manage these versions

Ginger/GingerCoreNET/GingerCoreNET.csproj (1)

1243-1245: 💡 Codebase verification

Update the remaining reference to the old JavaScript file in GingerCoreNET.csproj

The old JavaScript file reference (main.2ad51ab896990d24.js) still exists in GingerCoreNET.csproj alongside the new one (main.50dca4a1d8ae08b9.js), which needs to be removed to avoid confusion and potential issues.

• Ginger/GingerCoreNET/GingerCoreNET.csproj: Remove the old reference to main.2ad51ab896990d24.js

The new JavaScript file is correctly referenced in the HTML template at Ginger/GingerCoreNET/Reports/Ginger-Web-Client/index.html.

🔗 Analysis chain

Verify the JavaScript file update across the application.

The main.js file has been updated with a new hash (50dca4a1d8ae08b9), replacing the old version (2ad51ab896990d24). Ensure all references to this file are updated in the HTML templates.

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Description: Check for any remaining references to the old JavaScript file

# Test: Search for references to the old JS file
rg "main\.2ad51ab896990d24\.js"

# Test: Verify the new JS file is properly referenced in HTML files
rg "main\.50dca4a1d8ae08b9\.js"

Length of output: 562

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (2)

515-518: Refactor duplicated data validation logic

The data validation check is duplicated in both the wildcard and specific column selection paths. Consider extracting this into a helper method.

Apply this refactor:

+private void ValidateDataLoaded(bool isDataLoaded)
+{
+    if (!isDataLoaded)
+    {
+        throw new Exception("Data not found, Please check query");
+    }
+}

// Then replace both validation blocks with:
-if (isDataLoaded != true)
-{
-    throw new Exception("Data not found, Please check query");
-}
+ValidateDataLoaded(isDataLoaded);

Also applies to: 553-556

---

614-629: Enhance documentation for type inference logic

The type conversion logic between Double and Long is complex and would benefit from more detailed documentation explaining the rationale behind each conversion case.

Add XML documentation to clarify the logic:

+/// <summary>
+/// Handles edge cases in type inference between Double and Long:
+/// 1. Converts Double to Long if the value is a valid integer number
+/// 2. Converts Long to Double if the value would overflow Long
+/// 3. Handles special cases like NaN and Infinity
+/// </summary>
 if (inferredType == DataType.Double && !(Double.IsNaN(double.Parse(value.ToString())) || Double.IsInfinity(double.Parse(value.ToString()))))
 {
-    //Not a double
+    // Convert to Long if the value is a valid integer number
     inferredType = DataType.Long;
     value = ConvertByteArrayToType(byteArray, inferredType);
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (4)

208-212: Use string literals for string comparisons

Replace char literals with string literals for string operations.

-if (fieldValue.StartsWith('\'') && fieldValue.EndsWith('\''))
+if (fieldValue.StartsWith("'") && fieldValue.EndsWith("'"))

---

448-465: Optimize family name scanning logic

The current implementation scans each family name sequentially. Consider adding early termination if data is found.

 foreach (var i in familyNameList)
 {
     familyName = i.name;
     scanner = getScanner(wherepart, familyName);
     scanInfo = actionClient.CreateScannerAsync(table, scanner, requestOption).Result;
-    if ((next = actionClient.ScannerGetNextAsync(scanInfo, requestOption).Result) != null)
+    next = actionClient.ScannerGetNextAsync(scanInfo, requestOption).Result;
+    if (next != null && next.rows.Count > 0)
     {
         break;
     }
 }

🧰 Tools

🪛 GitHub Check: Codacy Static Code Analysis

[warning] 460-460: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs#L460
Remove this useless assignment to local variable 'next'.

---

504-507: Improve error message for data not found

The error message could be more specific about why the data was not found.

-throw new DataException("Data not found, Please check query");
+throw new DataException($"No data found for table '{table}'. Please verify the query conditions and table name.");

Also applies to: 542-545

---

Line range hint 586-616: Add XML documentation for complex type inference logic

The type inference logic is complex and would benefit from detailed documentation explaining the conversion rules.

+/// <summary>
+/// Infers and converts byte array data to the appropriate type.
+/// </summary>
+/// <param name="byteArray">The byte array to convert</param>
+/// <returns>The converted value as a string</returns>
+/// <remarks>
+/// Type inference rules:
+/// 1. Empty or null arrays return empty string
+/// 2. Arrays of all zeros (length < 9) return "0"
+/// 3. Double values are checked for NaN and Infinity
+/// 4. Long values are checked for overflow conditions
+/// </remarks>
 public static string DisplayInferredTypeAndValue(byte[] byteArray)

Configuration used: CodeRabbit UI
Review profile: CHILL

Learnt from: GokulBothe99
PR: Ginger-Automation/Ginger#3999
File: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs:217-224
Timestamp: 2024-11-18T10:42:16.120Z
Learning: Input validation when parsing `fieldValue` in the `getFilter` method of `GingerHbase` in `Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs` is not required.

 else if (fieldValue.Contains('.'))
 {
-    return new SingleColumnValueFilter(Encoding.UTF8.GetBytes(family), Encoding.UTF8.GetBytes(fieldName), compareOp, System.BitConverter.GetBytes(double.Parse(fieldValue)), filterIfMissing: true);
+    if (double.TryParse(fieldValue, out double value))
+    {
+        return new SingleColumnValueFilter(Encoding.UTF8.GetBytes(family), Encoding.UTF8.GetBytes(fieldName), compareOp, System.BitConverter.GetBytes(value), filterIfMissing: true);
+    }
+    throw new ArgumentException($"Invalid double value: {fieldValue}");
 }
 else
 {
-    var longBytes = System.BitConverter.GetBytes(long.Parse(fieldValue));
+    if (!long.TryParse(fieldValue, out long value))
+    {
+        throw new ArgumentException($"Invalid long value: {fieldValue}");
+    }
+    var longBytes = System.BitConverter.GetBytes(value);
     Array.Reverse(longBytes);
     return new SingleColumnValueFilter(Encoding.UTF8.GetBytes(family), Encoding.UTF8.GetBytes(fieldName), compareOp, longBytes, filterIfMissing: true);
 }

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (2)

208-212: Use string literals instead of char literals for string operations

The StartsWith and EndsWith methods are designed to work with strings. Using char literals (''') instead of string literals ("'") is not idiomatic C#.

-if (fieldValue.StartsWith('\'') && fieldValue.EndsWith('\''))
+if (fieldValue.StartsWith("'") && fieldValue.EndsWith("'"))

---

586-589: Add XML documentation for complex type inference logic

The type inference logic is complex and handles multiple edge cases. Consider adding XML documentation to explain:

1. The purpose of the byte array length check
2. The conditions for type conversion between Double and Long
3. The handling of special cases (NaN, Infinity)

+    /// <summary>
+    /// Infers and converts byte array data to the appropriate type.
+    /// </summary>
+    /// <param name="byteArray">The byte array to convert</param>
+    /// <returns>The string representation of the inferred type's value</returns>
+    /// <remarks>
+    /// - For arrays shorter than 9 bytes containing all zeros, returns "0"
+    /// - Handles conversion between Double and Long based on value characteristics
+    /// - Special handling for NaN and Infinity values
+    /// </remarks>
     public static string DisplayInferredTypeAndValue(byte[] byteArray)

Also applies to: 601-616

Configuration used: CodeRabbit UI
Review profile: CHILL

Learnt from: GokulBothe99
PR: Ginger-Automation/Ginger#3999
File: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs:217-224
Timestamp: 2024-11-18T10:42:16.120Z
Learning: Input validation when parsing `fieldValue` in the `getFilter` method of `GingerHbase` in `Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs` is not required.

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (3)

606-624: Improve code style and readability in ExtractOrderByColumnName.

The method could benefit from better code style and simplified logic.

Apply these improvements:

 public string ExtractOrderByColumnName(string query)
 {
-    string orderByClause = "order by";
-    string orderByColumnName = "";
+    const string ORDER_BY_CLAUSE = "order by";
+    int orderByIndex = query.IndexOf(ORDER_BY_CLAUSE, StringComparison.OrdinalIgnoreCase);
+    if (orderByIndex < 0)
+    {
+        return string.Empty;
+    }
 
-    int orderByIndex = query.IndexOf(orderByClause, StringComparison.OrdinalIgnoreCase);
-    if (orderByIndex >= 0)
-    {
-        int startIndex = orderByIndex + orderByClause.Length + 1;
-        int endIndex = query.IndexOf(" ", startIndex);
-        if (endIndex == -1) endIndex = query.Length;
-        orderByColumnName = query.Substring(startIndex, endIndex - startIndex).Trim();
+    int startIndex = orderByIndex + ORDER_BY_CLAUSE.Length + 1;
+    int endIndex = query.IndexOf(" ", startIndex);
+    if (endIndex == -1) 
+    {
+        endIndex = query.Length;
+    }
 
-        // Remove any trailing "desc" or "asc" if present
-        orderByColumnName = orderByColumnName.Split(' ')[0];
-    }
+    string orderByColumnName = query.Substring(startIndex, endIndex - startIndex).Trim();
+    return orderByColumnName.Split(' ')[0];  // Remove any trailing "desc" or "asc"
-    return orderByColumnName;
 }

🧰 Tools

🪛 GitHub Check: Codacy Static Code Analysis

[failure] 616-616: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs#L616
Add curly braces around the nested statement(s) in this 'if' block.

---

Line range hint 690-721: Improve type inference logic organization.

The type inference logic is complex and could benefit from better organization and documentation. Consider extracting the type inference logic into separate methods for better maintainability.

Consider refactoring the type inference logic:

+private static bool IsValidDouble(double value) => !Double.IsNaN(value) && !Double.IsInfinity(value);
+
+private static DataType RefinePotentialDoubleType(byte[] byteArray, object value)
+{
+    if (value == null || !double.TryParse(value.ToString(), out double doubleValue))
+    {
+        return DataType.Unknown;
+    }
+    
+    return IsValidDouble(doubleValue) ? DataType.Long : DataType.Double;
+}
+
 if (byteArray.Length <= 8 && byteArray.All(y => y == 0))
 {
     return "0";
 }
-
-if (inferredType == DataType.Double && !(Double.IsNaN(double.Parse(value.ToString())) || Double.IsInfinity(double.Parse(value.ToString()))))
-{
-    inferredType = DataType.Long;
-    value = ConvertByteArrayToType(byteArray, inferredType);
-}
-
-if (inferredType == DataType.Long && (Double.IsNaN(double.Parse(value.ToString())) || Double.IsInfinity(double.Parse(value.ToString()))))
-{
-    inferredType = DataType.Double;
-    value = ConvertByteArrayToType(byteArray, inferredType);
-}
+
+inferredType = RefinePotentialDoubleType(byteArray, value);
+value = ConvertByteArrayToType(byteArray, inferredType);

---

926-1001: Add XML documentation and null checks to new classes.

The new classes would benefit from XML documentation and proper null handling.

Add documentation and null checks:

+/// <summary>
+/// Represents a row of data from HBase with its key and columns.
+/// </summary>
 public class RowData
 {
     public string RowKey { get; set; }
     public Dictionary<string, string> Columns { get; set; }
 }

+/// <summary>
+/// Compares RowData objects based on a specified column name.
+/// Supports comparison of string, long, and double values.
+/// </summary>
 public class RowDataComparer : IComparer<RowData>
 {
     private readonly string _colName;
     private readonly bool _desc;

     public int Compare(RowData x, RowData y)
     {
+        if (x == null && y == null) return 0;
+        if (x == null) return _desc ? 1 : -1;
+        if (y == null) return _desc ? -1 : 1;
+
         if (!x.Columns.TryGetValue(_colName, out string xVal))
         {
             xVal = string.Empty;
         }

Configuration used: CodeRabbit UI
Review profile: CHILL

Learnt from: GokulBothe99
PR: Ginger-Automation/Ginger#3999
File: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs:217-224
Timestamp: 2024-11-18T10:42:16.120Z
Learning: Input validation when parsing `fieldValue` in the `getFilter` method of `GingerHbase` in `Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs` is not required.

 else if (fieldValue.Contains('.'))
 {
-    return new SingleColumnValueFilter(Encoding.UTF8.GetBytes(family), Encoding.UTF8.GetBytes(fieldName), compareOp, System.BitConverter.GetBytes(double.Parse(fieldValue)), filterIfMissing: true);
+    if (double.TryParse(fieldValue, out double value) && !double.IsInfinity(value))
+    {
+        return new SingleColumnValueFilter(Encoding.UTF8.GetBytes(family), Encoding.UTF8.GetBytes(fieldName), compareOp, System.BitConverter.GetBytes(value), filterIfMissing: true);
+    }
+    throw new ArgumentException($"Value {fieldValue} is outside the valid range for double");
 }

#!/bin/bash
# Search for potential large numeric values in the codebase
rg -g '!*.{dll,exe}' '[0-9]{15,}' 

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (3)

457-479: Consider extracting scanner initialization logic

The scanner initialization logic is complex and could be moved to a separate method for better maintainability.

Consider extracting the scanner initialization logic into a separate method:

+private Scanner InitializeScanner(HBaseClient client, string table, string wherepart)
+{
+    var familyNameList = client.GetTableSchemaAsync(table, null).Result.columns.ToList();
+    if (!familyNameList.Any())
+    {
+        throw new InvalidOperationException($"No column families found for table {table}");
+    }
+
+    foreach (var family in familyNameList)
+    {
+        var scanner = getScanner(wherepart, family.name);
+        var scanInfo = client.CreateScannerAsync(table, scanner, requestOption).Result;
+        
+        if (client.ScannerGetNextAsync(scanInfo, requestOption).Result != null)
+        {
+            return scanner;
+        }
+    }
+    return new Scanner();
+}

---

657-658: Enhance table name extraction regex pattern

The current regex pattern might not handle all valid table name formats. Consider making it more robust.

Consider using a more comprehensive pattern:

-string pattern = @"FROM\s+([a-zA-Z0-9_]+)";
+string pattern = @"FROM\s+(?:(?:`|""|')?([a-zA-Z0-9_$.]+)(?:`|""|')?)|(?:\[([^\]]+)\])";

This pattern will handle:

• Quoted identifiers (backticks, double quotes, single quotes)
• Schema-qualified names (e.g., "schema.table")
• Square bracket delimited identifiers

---

924-928: Add XML documentation and null checks

The new classes would benefit from XML documentation and proper null handling.

Consider adding documentation and null checks:

+/// <summary>
+/// Represents a row of data from HBase with its key and column values.
+/// </summary>
 public class RowData
 {
+    /// <summary>
+    /// Gets or sets the row key.
+    /// </summary>
     public string RowKey { get; set; }
+    /// <summary>
+    /// Gets or sets the dictionary of column names to their values.
+    /// </summary>
     public Dictionary<string, string> Columns { get; set; }
 }

+/// <summary>
+/// Compares RowData objects based on a specified column for sorting.
+/// </summary>
 public class RowDataComparer : IComparer<RowData>
 {
     public int Compare(RowData x, RowData y)
     {
+        if (x == null && y == null) return 0;
+        if (x == null) return -1;
+        if (y == null) return 1;
+
         if (!x.Columns.TryGetValue(_colName, out string xVal))
         {
             xVal = string.Empty;
         }

Also applies to: 929-999

Configuration used: CodeRabbit UI
Review profile: CHILL

Learnt from: GokulBothe99
PR: Ginger-Automation/Ginger#3999
File: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs:217-224
Timestamp: 2024-11-18T10:42:16.120Z
Learning: Input validation when parsing `fieldValue` in the `getFilter` method of `GingerHbase` in `Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs` is not required.

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (3)

685-686: Enhance table name extraction regex pattern

The current regex pattern might not handle all valid table names, such as those with hyphens or dots.

Apply this diff:

-string pattern = @"FROM\s+([a-zA-Z0-9_]+)";
+string pattern = @"FROM\s+([a-zA-Z0-9_\-\.]+)";

---

619-640: Add support for multiple ORDER BY columns

The current implementation only handles a single ORDER BY column. Consider enhancing it to support multiple columns.

Would you like me to provide an implementation that supports multiple ORDER BY columns?

---

973-977: Add input validation to RowData class

The RowData class should validate its inputs to prevent potential issues.

Apply this diff:

 public class RowData
 {
-    public string RowKey { get; set; }
-    public Dictionary<string, string> Columns { get; set; }
+    private string _rowKey;
+    public string RowKey
+    {
+        get => _rowKey;
+        set => _rowKey = value ?? throw new ArgumentNullException(nameof(value));
+    }
+
+    private Dictionary<string, string> _columns;
+    public Dictionary<string, string> Columns
+    {
+        get => _columns;
+        set => _columns = value ?? throw new ArgumentNullException(nameof(value));
+    }
+
+    public RowData()
+    {
+        Columns = new Dictionary<string, string>();
+    }
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

Learnt from: GokulBothe99
PR: Ginger-Automation/Ginger#3999
File: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs:217-224
Timestamp: 2024-11-18T10:42:16.120Z
Learning: Input validation when parsing `fieldValue` in the `getFilter` method of `GingerHbase` in `Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs` is not required.

-scanner = null;
+scanner = new Scanner();

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (4)

Line range hint 28-45: Remove unused imports

The following imports appear to be unnecessary:

• Applitools.Utils
• MongoDB.Driver
• OctaneStdSDK.Entities.Base

-using Applitools.Utils;
using GingerCore.Actions;
-using MongoDB.Driver;
-using OctaneStdSDK.Entities.Base;

---

503-517: Remove commented-out test code

The commented-out test code block should be removed as it appears to be debugging code that's no longer needed.

-        /*       double[] array = { 829, 101, 1, 2830.862, 1, 1, 501, 1, 19.5, 96.5, 14999, 120, 1, 1, 329 };
-               foreach (double i in array)
-               {
-                   var v_lon = System.BitConverter.GetBytes(i);
-                   Array.Reverse(v_lon);
-                   string longValu112 = ExtractColumnValue(v_lon);
-                   if (i == double.Parse(longValu112))
-                   {
-
-                   }
-                   else
-                   {
-
-                   }
-               }*/

---

701-714: Enhance table name extraction regex pattern

The current regex pattern might not handle all valid table names. Consider using a more robust pattern that supports additional characters and quoted identifiers.

-            string pattern = @"FROM\s+([a-zA-Z0-9_]+)";
+            string pattern = @"FROM\s+(?:""([^""]+)""|'([^']+)'|([a-zA-Z0-9_\-\.]+))";

---

Line range hint 943-947: Improve error handling in GetColumnList

Instead of returning null on exception, consider returning an empty list or throwing a meaningful exception with the cause.

 catch (Exception ex)
 {
     Reporter.ToLog(eLogLevel.WARN, "Unable to connect to Hbase", ex);
-    return null;
+    return new List<string>();
     // Or throw a more specific exception:
     // throw new HBaseConnectionException("Unable to retrieve column list", ex);
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

Learnt from: GokulBothe99
PR: Ginger-Automation/Ginger#3999
File: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs:217-224
Timestamp: 2024-11-18T10:42:16.120Z
Learning: Input validation when parsing `fieldValue` in the `getFilter` method of `GingerHbase` in `Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs` is not required.

-if (fieldValue.StartsWith('\'') && fieldValue.EndsWith('\''))
+if (fieldValue.StartsWith("'") && fieldValue.EndsWith("'"))

 public int Compare(RowData x, RowData y)
 {
+    if (x == null && y == null) return 0;
+    if (x == null) return _desc ? 1 : -1;
+    if (y == null) return _desc ? -1 : 1;
+
     if (!x.Columns.TryGetValue(_colName, out string xVal))
     {
         xVal = string.Empty;
     }

Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs (1)

550-558: Consider handling edge cases in SQL parsing.

The current implementation might fail with malformed SQL queries. Consider:

1. Handling multiple spaces between keywords
2. Handling comments in SQL
3. Handling quoted column names

-string[] selectedcols = SQLCalculated.Trim().Substring(selectIndex + 8, fromIndex - selectIndex - 8).Split(",");
+// Use regex to handle edge cases
+string pattern = @"SELECT\s+(.*?)\s+FROM";
+Match match = Regex.Match(SQLCalculated, pattern, RegexOptions.IgnoreCase);
+string[] selectedcols = match.Success 
+    ? match.Groups[1].Value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+    : Array.Empty<string>();

Configuration used: CodeRabbit UI
Review profile: CHILL

Learnt from: GokulBothe99
PR: Ginger-Automation/Ginger#3999
File: Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs:217-224
Timestamp: 2024-11-18T10:42:16.120Z
Learning: Input validation when parsing `fieldValue` in the `getFilter` method of `GingerHbase` in `Ginger/GingerCoreNET/Database/NoSqlBase/GingerHbase.cs` is not required.

-if (fieldValue.StartsWith('\'') && fieldValue.EndsWith('\''))
+if (fieldValue.StartsWith("'") && fieldValue.EndsWith("'"))

 public int Compare(RowData x, RowData y)
 {
+    if (x == null && y == null) return 0;
+    if (x == null) return _desc ? 1 : -1;
+    if (y == null) return _desc ? -1 : 1;
+
     if (!x.Columns.TryGetValue(_colName, out string xVal))
     {
         xVal = string.Empty;
     }