Fix stupid bug in Sqlite Wrapper

Author: LoneWandererProductions

SQLiteHelper/SqliteExecute.cs

@@ -917,10 +917,10 @@ private bool ExecuteNonQuery(string sqlQuery, bool suppress)
         /// <param name="checking">Shall we check the input</param>
         /// <returns>Success Status</returns>
         private bool ExecuteInsertQuery(
-            string sqlQuery,
-            IReadOnlyCollection<TableSet> table,
-            Dictionary<string, TableColumns> tableInfo,
-            bool checking)
+                    string sqlQuery,
+                    IReadOnlyCollection<TableSet> table,
+                    Dictionary<string, TableColumns> tableInfo,
+                    bool checking)
         {
             // Establish connection
             using var conn = GetConn();
@@ -932,50 +932,49 @@ private bool ExecuteInsertQuery(
             // Begin transaction
             using var tr = conn.BeginTransaction();
 
-
             try
             {
                 using var cmd = conn.CreateCommand();
                 cmd.Transaction = tr;
                 cmd.CommandTimeout = SqliteConnectionConfig.TimeOut;
                 cmd.CommandText = sqlQuery;
 
-                var checkCount = 0;
-                var paramCache = new Dictionary<int, SQLiteParameter>();
-
+                // Syntax Checker initialization
                 var syntax = new SqliteSyntax(SetMessage);
 
+                // Cache parameters to reuse objects (Optimization)
+                var paramCache = new Dictionary<int, SQLiteParameter>();
+
                 foreach (var row in table)
                 {
+                    // Syntax Check Logic
                     if (checking)
                     {
-                        if (checkCount >= tableInfo.Count)
-                        {
-                            checkCount = 0;
-                        }
-
-                        var convert = tableInfo.ElementAt(checkCount).Value;
-                        if (!syntax.AdvancedSyntaxCheck(tableInfo, table, row, convert))
+                        // Pass the full schema (tableInfo) and the full batch (table)
+                        // The Syntax class now handles the column iteration internally.
+                        if (!syntax.AdvancedSyntaxCheck(tableInfo, row, table))
                         {
                             return false;
                         }
-
-                        checkCount++;
                     }
 
-                    cmd.Parameters.Clear(); // Ensure no leftover parameters
+                    // Clear parameters for the new row
+                    cmd.Parameters.Clear();
 
                     for (var i = 0; i < row.Row.Count; i++)
                     {
                         if (!paramCache.TryGetValue(i, out var param))
                         {
+                            // Create parameter if it doesn't exist
                             param = new SQLiteParameter($"{SqliteHelperResources.Param}{i}", row.Row[i]);
                             cmd.Parameters.Add(param);
                             paramCache[i] = param;
                         }
                         else
                         {
+                            // Reuse parameter object, just update value and re-add to command
                             param.Value = row.Row[i];
+                            cmd.Parameters.Add(param);
                         }
                     }
 
@@ -986,7 +985,8 @@ private bool ExecuteInsertQuery(
 
                 _message = new MessageItem
                 {
-                    Message = $"{SqliteHelperResources.SuccessExecutedLog}{sqlQuery}", Level = 2
+                    Message = $"{SqliteHelperResources.SuccessExecutedLog}{sqlQuery}",
+                    Level = 2
                 };
                 OnError(_message);
 
@@ -1003,7 +1003,6 @@ private bool ExecuteInsertQuery(
             return false;
         }
 
-
         /// <summary>
         ///     Update Table
         /// </summary>

SqliteHelper/SqliteSyntax.cs

@@ -2,17 +2,19 @@
  * COPYRIGHT:   See COPYING in the top level directory
  * PROJECT:     SqliteHelper
  * FILE:        SqliteHelper/SqLiteDataTypes.cs
- * PURPOSE:     Enums of Types Sqlite Supports
+ * PURPOSE:     Enums of Types Sqlite Supports and Syntax Checking
  * PROGRAMER:   Peter Geinitz (Wayfarer)
  */
 
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace SqliteHelper
 {
+    /// <summary>
+    ///     Handles syntax checking and data validation for SQLite operations
+    /// </summary>
     internal sealed class SqliteSyntax
     {
         /// <summary>
@@ -35,35 +37,49 @@ public SqliteSyntax(EventHandler<MessageItem> setMessage = null)
         }
 
         /// <summary>
-        ///     Basic sanity checks
+        ///     Basic sanity checks.
+        ///     Refactored to check the Entire Row against the Entire Schema.
         /// </summary>
         /// <param name="tableInfo">Headers, Data Type and Constraints of the table</param>
-        /// <param name="table">Table Collection</param>
-        /// <param name="row">Table Collection</param>
-        /// <param name="convert">Table Collection</param>
+        /// <param name="row">The specific Row we are checking</param>
+        /// <param name="batch">The full batch of rows (needed for uniqueness checks within the batch)</param>
         /// <returns>true if no errors were found</returns>
-        internal bool AdvancedSyntaxCheck(ICollection tableInfo, IEnumerable<TableSet> table, TableSet row,
-            TableColumns convert)
+        internal bool AdvancedSyntaxCheck(
+            Dictionary<string, TableColumns> tableInfo,
+            TableSet row,
+            IEnumerable<TableSet> batch)
         {
-            if (tableInfo.Count != table.First().Row.Count)
+            // Sanity Check: Do the column counts match?
+            if (tableInfo.Count != row.Row.Count)
             {
                 LogError(SqliteHelperResources.ErrorMoreElementsToAddThanRows);
                 return false;
             }
 
-            foreach (var rows in row.Row)
+            // Convert dictionary values to a list to access by index 
+            // (Assuming order matches Insert logic)
+            var schemaColumns = tableInfo.Values.ToList();
+
+            // Loop through each column in the row
+            for (int i = 0; i < row.Row.Count; i++)
             {
-                if (!CheckNullability(rows, convert))
+                var value = row.Row[i];
+                var definition = schemaColumns[i];
+
+                // Check Nullability
+                if (!CheckNullability(value, definition))
                 {
                     return false;
                 }
 
-                if (!CheckTypeCompatibility(rows, convert))
+                // Check Data Type
+                if (!CheckTypeCompatibility(value, definition))
                 {
                     return false;
                 }
 
-                if (!CheckUniqueness(row, convert))
+                // Check Uniqueness (Primary Key / Unique Constraint)
+                if (!CheckBatchUniqueness(value, i, definition, batch))
                 {
                     return false;
                 }
@@ -75,58 +91,68 @@ internal bool AdvancedSyntaxCheck(ICollection tableInfo, IEnumerable<TableSet> t
         /// <summary>
         ///     Checks the nullability.
         /// </summary>
-        /// <param name="rows">The rows.</param>
-        /// <param name="convert">The convert.</param>
+        /// <param name="value">The value to check.</param>
+        /// <param name="convert">The column definition.</param>
         /// <returns>Condition fulfilled</returns>
-        private bool CheckNullability(object rows, TableColumns convert)
+        private bool CheckNullability(string value, TableColumns convert)
         {
-            if (rows != null || convert.NotNull)
+            // Logic Fix: Valid if value exists OR if the column allows nulls (NOT NotNull).
+            if (!string.IsNullOrEmpty(value) || !convert.NotNull)
             {
                 return true;
             }
 
-            LogError(SqliteHelperResources.ErrorNotNullAble);
+            LogError($"{SqliteHelperResources.ErrorNotNullAble} (Column: {convert.RowId})");
             return false;
         }
 
         /// <summary>
         ///     Checks the type compatibility.
         /// </summary>
-        /// <param name="rows">The rows.</param>
-        /// <param name="convert">The convert.</param>
+        /// <param name="value">The value string.</param>
+        /// <param name="convert">The column definition.</param>
         /// <returns>Condition fulfilled</returns>
-        private bool CheckTypeCompatibility(string rows, TableColumns convert)
+        private bool CheckTypeCompatibility(string value, TableColumns convert)
         {
-            var check = SqliteProcessing.CheckConvert(convert.DataType, rows);
+            // If empty and nullable, skip type check
+            if (string.IsNullOrEmpty(value)) return true;
+
+            var check = SqliteProcessing.CheckConvert(convert.DataType, value);
             if (check)
             {
                 return true;
             }
 
-            LogError($"{SqliteHelperResources.ErrorWrongType} - Value: {rows}, Expected Type: {convert.DataType}");
+            LogError($"{SqliteHelperResources.ErrorWrongType} - Value: {value}, Expected Type: {convert.DataType}");
             return false;
         }
 
         /// <summary>
-        ///     Checks the uniqueness.
+        ///     Checks the uniqueness within the current batch.
         /// </summary>
-        /// <param name="row">The row.</param>
-        /// <param name="convert">The convert.</param>
-        /// <returns></returns>
-        private bool CheckUniqueness(TableSet row, TableColumns convert)
+        /// <param name="value">The value to check.</param>
+        /// <param name="columnIndex">Index of the column.</param>
+        /// <param name="convert">The column definition.</param>
+        /// <param name="batch">The full batch of rows.</param>
+        /// <returns>True if unique in batch</returns>
+        private bool CheckBatchUniqueness(string value, int columnIndex, TableColumns convert, IEnumerable<TableSet> batch)
         {
+            // Only check if it is a Primary Key or explicitly Unique
             if (!convert.PrimaryKey && !convert.Unique)
             {
                 return true;
             }
 
-            var isUnique = row.Row.Distinct().Count() == row.Row.Count;
-            if (isUnique)
+            // Check if this value appears more than once in this specific column index across the batch
+            // Note: This does not check the Database itself, only the data we are about to insert.
+            int count = batch.Count(r => r.Row.Count > columnIndex && r.Row[columnIndex] == value);
+
+            if (count <= 1)
             {
                 return true;
             }
 
-            LogError(SqliteHelperResources.ErrorNotUnique);
+            LogError($"{SqliteHelperResources.ErrorNotUnique} (Duplicate found in batch: {value})");
             return false;
         }