From 6b6713534272d18e846b149178caa59c66649687 Mon Sep 17 00:00:00 2001
From: Andrea Cattaneo <andrea.cattaneo@infoesse.it>
Date: Fri, 23 Sep 2022 10:21:52 +0200
Subject: [PATCH] code refactor

---
 ACUtils.SqlDb/SqlDb.cs                        | 614 ++----------------
 ACUtils.SqlDb/SqlDb_BulkInsert.cs             |  35 +
 ACUtils.SqlDb/SqlDb_Execute.cs                | 108 +++
 ACUtils.SqlDb/SqlDb_QueryDataRow.cs           |  50 ++
 ACUtils.SqlDb/SqlDb_QueryDataSet.cs           | 121 ++++
 ACUtils.SqlDb/SqlDb_QueryDataTable.cs         |  55 ++
 ACUtils.SqlDb/SqlDb_QueryMany.cs              |  30 +
 .../SqlDb_QueryNullableSingleValue.cs         |  32 +
 ACUtils.SqlDb/SqlDb_QueryOne.cs               |  30 +
 ACUtils.SqlDb/SqlDb_QuerySingleValue.cs       | 122 ++++
 10 files changed, 635 insertions(+), 562 deletions(-)
 create mode 100644 ACUtils.SqlDb/SqlDb_BulkInsert.cs
 create mode 100644 ACUtils.SqlDb/SqlDb_Execute.cs
 create mode 100644 ACUtils.SqlDb/SqlDb_QueryDataRow.cs
 create mode 100644 ACUtils.SqlDb/SqlDb_QueryDataSet.cs
 create mode 100644 ACUtils.SqlDb/SqlDb_QueryDataTable.cs
 create mode 100644 ACUtils.SqlDb/SqlDb_QueryMany.cs
 create mode 100644 ACUtils.SqlDb/SqlDb_QueryNullableSingleValue.cs
 create mode 100644 ACUtils.SqlDb/SqlDb_QueryOne.cs
 create mode 100644 ACUtils.SqlDb/SqlDb_QuerySingleValue.cs

diff --git a/ACUtils.SqlDb/SqlDb.cs b/ACUtils.SqlDb/SqlDb.cs
index 0a57f2f..f7ea2f6 100644
--- a/ACUtils.SqlDb/SqlDb.cs
+++ b/ACUtils.SqlDb/SqlDb.cs
@@ -16,6 +16,8 @@ public class SqlDb : IDisposable
 
         private static MissingSchemaAction? missingSchemaAction;
 
+        private bool _persistentConnection = false;
+
         public static MissingSchemaAction MissingSchemaAction
         {
             get
@@ -29,553 +31,39 @@ public static MissingSchemaAction MissingSchemaAction
             set => missingSchemaAction = value;
         }
 
-        #region costructor
-        public SqlDb(string connectionString, ILogger logger)
+        #region constructor
+        public SqlDb(string connectionString, ILogger logger, bool persistentConnection = false)
         {
             this.ConnectionString = connectionString;
             this.logger = logger;
             scope = null;
+            this._persistentConnection = persistentConnection;
         }
 
-        public SqlDb(string connectionString, Serilog.ILogger logger)
+        public SqlDb(string connectionString, Serilog.ILogger logger, bool persistentConnection = false)
         {
             this.ConnectionString = connectionString;
             this.logger = new SerilogWrapper(logger);
             scope = null;
+            this._persistentConnection = persistentConnection;
         }
 
-        public SqlDb(string connectionString)
+        public SqlDb(string connectionString, bool persistentConnection = false)
         {
             this.ConnectionString = connectionString;
             this.logger = null;
             scope = null;
+            this._persistentConnection = persistentConnection;
         }
         #endregion
 
-        #region QueryDataTable
-        /// <summary>
-        /// Esegue la query e restituisce il DataTable del risultato
-        /// </summary>
-        /// <example>
-        /// db.QueryDataTable("SELECT * FROM A WHERE B = @B", "@B".WithValue("1"));
-        /// </example>
-        /// <param name="queryString">stringa contenente la stringa di interrogazione SQL</param>
-        /// <param name="queryParams">nomi dei parametri associati a i loro valori. utilizzare <see cref="KeyValuePairExt"/> come helper </param>
-        /// <returns></returns>
-        public DataTable QueryDataTable(string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            DataSet ds = QueryDataSet(queryString, queryParams);
-            return ds.Tables[0];
-        }
-
-        public static DataTable QueryDataTable(SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            DataSet ds = QueryDataSet(connection, queryString, queryParams);
-            return ds.Tables[0];
-        }
-
-        public DataTable QueryDataTable(string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
-        {
-            DataSet ds = QueryDataSet(queryString, queryParams);
-            return ds.Tables[0];
-        }
-
-        public static DataTable QueryDataTable(SqlConnection connection, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
-        {
-            DataSet ds = QueryDataSet(connection, queryString, queryParams);
-            return ds.Tables[0];
-        }
-
-        public DataTable QueryDataTable(string queryString)
-        {
-            DataSet ds = QueryDataSet(queryString);
-            return ds.Tables[0];
-        }
-
-        public static DataTable QueryDataTable(SqlConnection connection, string queryString)
-        {
-            DataSet ds = QueryDataSet(connection, queryString);
-            return ds.Tables[0];
-        }
-
-        public List<T> QueryMany<T>(string sql, params KeyValuePair<string, object>[] queryParams) where T : ACUtils.DBModel<T>, new()
-        {
-            var dt = QueryDataTable(sql, queryParams);
-            return ACUtils.DBModel<T>.Idrate(dt);
-        }
-
-        public async IAsyncEnumerable<T> QueryManyAsync<T>(string sql, params KeyValuePair<string, object>[] queryParams) where T : ACUtils.DBModel<T>, new()
-        {
-            var dt = QueryDataTable(sql, queryParams);
-            await foreach (var q in ACUtils.DBModel<T>.IdrateAsyncGenerator(dt))
-            {
-                yield return q;
-            }
-        }
-
-        public static List<T> QueryMany<T>(SqlConnection connection, string sql, params KeyValuePair<string, object>[] queryParams) where T : ACUtils.DBModel<T>, new()
-        {
-            var dt = QueryDataTable(connection, sql, queryParams);
-            return ACUtils.DBModel<T>.Idrate(dt);
-        }
-
-        #endregion
-
-        #region QueryDataSet
-        public DataSet QueryDataSet(string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    WriteLog(queryString, queryParams);
-                    var ds = QueryDataSet(connection, queryString, queryParams);
-                    return ds;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString, queryParams);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-        public static DataSet QueryDataSet(SqlConnection connection, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString, queryParams))
-            {
-                using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand))
-                {
-                    DataSet ds = new DataSet();
-                    adapter.MissingSchemaAction = MissingSchemaAction;
-                    adapter.Fill(ds);
-                    return ds;
-                }
-            }
-        }
-
-        public DataSet QueryDataSet(string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    WriteLog(queryString, queryParams);
-                    var ds = QueryDataSet(connection, queryString, queryParams);
-                    return ds;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString, queryParams);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-        public static DataSet QueryDataSet(SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString, queryParams))
-            {
-                using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand))
-                {
-                    DataSet ds = new DataSet();
-                    adapter.MissingSchemaAction = MissingSchemaAction;
-                    adapter.Fill(ds);
-                    return ds;
-                }
-            }
-        }
-
-        public DataSet QueryDataSet(string queryString)
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    WriteLog(queryString);
-                    var ds = QueryDataSet(connection, queryString);
-                    return ds;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-        public static DataSet QueryDataSet(SqlConnection connection, string queryString)
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString))
-            {
-                using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand))
-                {
-                    DataSet ds = new DataSet();
-                    adapter.MissingSchemaAction = MissingSchemaAction;
-                    adapter.Fill(ds);
-                    return ds;
-                }
-            }
-        }
-
-        #endregion
-
-        #region QueryDataRow
-        public DataRow QueryDataRow(string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            DataTable dt = QueryDataTable(
-                queryString,
-                queryParams
-            );
-
-            if (dt.Rows.Count == 0)
-            {
-                throw new Exceptions.NotFoundException("nessun risultato ottenuto");
-            }
-
-            if (dt.Rows.Count > 1)
-            {
-                throw new Exceptions.TooMuchResultsException("ottenuto più valori");
-            }
-            return dt.Rows[0];
-        }
-
-        public static DataRow QueryDataRow(SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            DataTable dt = QueryDataTable(
-                connection,
-                queryString,
-                queryParams
-            );
-
-            if (dt.Rows.Count == 0)
-            {
-                throw new Exceptions.NotFoundException("nessun risultato ottenuto");
-            }
-
-            if (dt.Rows.Count > 1)
-            {
-                throw new Exceptions.TooMuchResultsException("ottenuto più valori");
-            }
-
-            return dt.Rows[0];
-        }
-
-        public T QueryOne<T>(
-            string sql,
-            params KeyValuePair<string, object>[] queryParams
-        ) where T : ACUtils.DBModel<T>, new()
-        {
-            var dr = QueryDataRow(sql, queryParams);
-            return ACUtils.DBModel<T>.Idrate(dr);
-        }
-
-
-        public static T QueryOne<T>(
-            SqlConnection connection,
-            string sql,
-            params KeyValuePair<string, object>[] queryParams
-        ) where T : ACUtils.DBModel<T>, new()
-        {
-            var dr = QueryDataRow(connection, sql, queryParams);
-            return ACUtils.DBModel<T>.Idrate(dr);
-        }
-
-        #endregion
-
-        #region QuerySingleValue
-
-        public T QuerySingleValue<T>(string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    WriteLog(queryString, queryParams);
-                    var value = QuerySingleValue<T>(connection, queryString, queryParams);
-                    return value;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString, queryParams);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-        public static T QuerySingleValue<T>(SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString, queryParams))
-            {
-                object value = selectCommand.ExecuteScalar();
-                return _changeType<T>(value);
-            }
-        }
-
-        public static Nullable<T> QueryNullableSingleValue<T>(SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams) where T : struct
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString, queryParams))
-            {
-                object value = selectCommand.ExecuteScalar();
-                if (value == null || value == DBNull.Value || value is DBNull)
-                {
-                    return null;
-                }
-                // conversione variabile da object a type specificato
-                //return (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value);
-                return _changeType<T?>(value);
-            }
-        }
-
-        public T QuerySingleValue<T>(string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    WriteLog(queryString, queryParams);
-                    var value = QuerySingleValue<T>(connection, queryString, queryParams);
-                    return value;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString, queryParams);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-        public static T QuerySingleValue<T>(SqlConnection connection, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString, queryParams))
-            {
-                object value = selectCommand.ExecuteScalar();
-                return _changeType<T>(value);
-            }
-        }
-
-
-        public T QuerySingleValue<T>(string queryString)
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    var value = QuerySingleValue<T>(connection, queryString);
-                    return _changeType<T>(value);
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-
-        public static T QuerySingleValue<T>(SqlConnection connection, string queryString)
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString))
-            {
-                object value = selectCommand.ExecuteScalar();
-                return _changeType<T>(value);
-            }
-        }
-
-
-        public Nullable<T> QueryNullableSingleValue<T>(string queryString, params KeyValuePair<string, object>[] queryParams) where T : struct
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    WriteLog(queryString, queryParams);
-                    var value = QueryNullableSingleValue<T>(connection, queryString, queryParams);
-                    return value;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString, queryParams);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-        #endregion
-
-        #region Execute
-        public bool Execute(string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            //queryString = queryString.Trim().Replace(System.Environment.NewLine, " ");
-            //queryString = System.Text.RegularExpressions.Regex.Replace(queryString, @"\s+", " ");
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    var value = Execute(connection, queryString, queryParams);
-                    return value;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString, queryParams);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-        public static bool Execute(SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
-        {
-            //queryString = queryString.Trim().Replace(System.Environment.NewLine, " ");
-            //queryString = System.Text.RegularExpressions.Regex.Replace(queryString, @"\s+", " ");
-            using (SqlCommand selectCommand = generateCommand(connection, queryString, queryParams))
-            {
-                var value = selectCommand.ExecuteNonQuery() > 0;
-                return value;
-            }
-        }
-
-        public bool Execute(string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    var value = Execute(connection, queryString, queryParams);
-                    return value;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString, queryParams);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-        public bool Execute(SqlConnection connection, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString, queryParams))
-            {
-                var value = selectCommand.ExecuteNonQuery() > 0;
-                return value;
-            }
-        }
-
-        public bool Execute(string queryString)
-        {
-            using (SqlConnection connection = new SqlConnection(ConnectionString))
-            {
-                try
-                {
-                    connection.Open();
-                    WriteLog(queryString);
-                    var value = Execute(connection, queryString);
-                    return value;
-                }
-                catch (Exception ex)
-                {
-                    WriteLog(ex, queryString);
-                    throw;
-                }
-                finally
-                {
-                    try { connection.Close(); } catch { }
-                }
-            }
-        }
-
-        public static bool Execute(SqlConnection connection, string queryString)
-        {
-            using (SqlCommand selectCommand = generateCommand(connection, queryString))
-            {
-                return selectCommand.ExecuteNonQuery() > 0;
-            }
-        }
-
-        #endregion
-
-        public static T GetColVal<T>(DataRow dataRow, string columnName)
-        {
-            // dataRow.Field<T>(columnName)
-            object val = dataRow[columnName];
-            switch (val.GetType().Name)
-            {
-                case "DBNull":
-                    return default(T);
-            }
-            switch (typeof(T).Name)
-            {
-                case "String":
-                case "string":
-                    return (T)(object)val.ToString().Trim(); // OMFG!
-                case "Int32":
-                    if (val.GetType().Name.Equals("Decimal"))
-                    {
-                        return (T)(object)decimal.ToInt32((decimal)val);
-                    }
-                    return (T)val;
-                case "Int64":
-                    if (val.GetType().Name == "Int32")
-                    {
-                        return (T)(object)(int)val;
-                    }
-
-                    return (T)val;
-                default:
-                    return (T)val;
-            }
-        }
-
         #region generateCommand
-        private static SqlCommand generateCommand(SqlConnection connection, string queryString)
+        internal static SqlCommand generateCommand(SqlConnection connection, string queryString)
         {
             return new SqlCommand(queryString, connection);
         }
 
-        private static SqlCommand generateCommand(SqlConnection connection, string queryString, KeyValuePair<string, object>[] queryParams)
+        internal static SqlCommand generateCommand(SqlConnection connection, string queryString, KeyValuePair<string, object>[] queryParams)
         {
             SqlCommand command = new SqlCommand(queryString, connection);
             foreach (KeyValuePair<string, object> param in queryParams)
@@ -585,7 +73,7 @@ private static SqlCommand generateCommand(SqlConnection connection, string query
             return command;
         }
 
-        private static SqlCommand generateCommand(SqlConnection connection, string queryString, KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        internal static SqlCommand generateCommand(SqlConnection connection, string queryString, KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
         {
             SqlCommand command = new SqlCommand(queryString, connection);
             foreach (KeyValuePair<string, KeyValuePair<SqlDbType, object>> param in queryParams)
@@ -597,7 +85,7 @@ private static SqlCommand generateCommand(SqlConnection connection, string query
         #endregion
 
         #region log
-        private static string SqlTypeToString(SqlDbType type)
+        internal static string SqlTypeToString(SqlDbType type)
         {
             switch (type)
             {
@@ -632,7 +120,7 @@ public string Switch(object x)
             }
         }
 
-        private static string ValueToString(object obj)
+        internal static string ValueToString(object obj)
         {
             TypeSwitch ts = new TypeSwitch()
                 .Case((bool x) => x ? "1" : "0")
@@ -648,7 +136,7 @@ private static string ValueToString(object obj)
             return ts.Switch(obj);
         }
 
-        private void WriteLog(string queryString)
+        internal void WriteLog(string queryString)
         {
             if (logger == null)
             {
@@ -658,7 +146,7 @@ private void WriteLog(string queryString)
             logger.Debug($"SQL {callerStack}{Environment.NewLine}{queryString}");
         }
 
-        private void WriteLog(Exception exception, string queryString)
+        internal void WriteLog(Exception exception, string queryString)
         {
             if (logger == null)
             {
@@ -668,7 +156,7 @@ private void WriteLog(Exception exception, string queryString)
             logger.Error($"SQL {callerStack} : {exception}");
         }
 
-        private void WriteLog(string queryString, KeyValuePair<string, object>[] queryParams)
+        internal void WriteLog(string queryString, KeyValuePair<string, object>[] queryParams)
         {
             if (logger == null)
             {
@@ -682,7 +170,7 @@ private void WriteLog(string queryString, KeyValuePair<string, object>[] queryPa
             logger.Debug($"SQL {callerStack}{Environment.NewLine}{declares}{Environment.NewLine}{queryString}");
         }
 
-        private void WriteLog(Exception exception, string queryString, KeyValuePair<string, object>[] queryParams)
+        internal void WriteLog(Exception exception, string queryString, KeyValuePair<string, object>[] queryParams)
         {
             if (logger == null)
             {
@@ -692,7 +180,7 @@ private void WriteLog(Exception exception, string queryString, KeyValuePair<stri
             logger.Error($"SQL {callerStack} : {exception}");
         }
 
-        private void WriteLog(string queryString, KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        internal void WriteLog(string queryString, KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
         {
             if (logger == null)
             {
@@ -707,7 +195,7 @@ private void WriteLog(string queryString, KeyValuePair<string, KeyValuePair<SqlD
             logger.Debug($"SQL {callerStack}{Environment.NewLine}{declares}{Environment.NewLine}{queryString}");
         }
 
-        private void WriteLog(Exception exception, string queryString, KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        internal void WriteLog(Exception exception, string queryString, KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
         {
             if (logger == null)
             {
@@ -717,7 +205,7 @@ private void WriteLog(Exception exception, string queryString, KeyValuePair<stri
             logger.Error($"SQL {callerStack} : {exception}");
         }
 
-        private string GetCallerStack(int start, int count)
+        internal string GetCallerStack(int start, int count)
         {
             string callerStack = "";
 
@@ -760,34 +248,6 @@ public void AbortTransaction()
 
         #endregion
 
-        #region bulk insert
-        public void BulkInsert<T>(string tablename, IEnumerable<T> records)
-        {
-            using (var bc = new SqlBulkCopy(ConnectionString))
-            {
-                bc.WriteToServer(BulkInsertPrepare(bc, tablename, records));
-            }
-        }
-        public async System.Threading.Tasks.Task BulkInsertAsync<T>(string tablename, IEnumerable<T> records)
-        {
-            using (var bc = new SqlBulkCopy(ConnectionString))
-            {
-                await bc.WriteToServerAsync(BulkInsertPrepare(bc, tablename, records));
-            }
-        }
-
-        private DataTable BulkInsertPrepare<T>(SqlBulkCopy bc, string tablename, IEnumerable<T> records)
-        {
-            bc.DestinationTableName = tablename;
-            var properties = typeof(T).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
-            foreach (var property in properties)
-            {
-                bc.ColumnMappings.Add(property.Name, property.Name);
-            }
-            return ToDataTable(records);
-        }
-        #endregion
-
         #region datatable generation
         ///###############################################################
         /// <summary>
@@ -895,8 +355,38 @@ protected virtual void Dispose(bool disposing)
         }
         #endregion
 
+        public static T GetColVal<T>(DataRow dataRow, string columnName)
+        {
+            // dataRow.Field<T>(columnName)
+            object val = dataRow[columnName];
+            switch (val.GetType().Name)
+            {
+                case "DBNull":
+                    return default(T);
+            }
+            switch (typeof(T).Name)
+            {
+                case "String":
+                case "string":
+                    return (T)(object)val.ToString().Trim(); // OMFG!
+                case "Int32":
+                    if (val.GetType().Name.Equals("Decimal"))
+                    {
+                        return (T)(object)decimal.ToInt32((decimal)val);
+                    }
+                    return (T)val;
+                case "Int64":
+                    if (val.GetType().Name == "Int32")
+                    {
+                        return (T)(object)(int)val;
+                    }
 
-        private static T _changeType<T>(object value)
+                    return (T)val;
+                default:
+                    return (T)val;
+            }
+        }
+        internal static T _changeType<T>(object value)
         {
             // conversione variabile da object a type specificato
             //return (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value);
diff --git a/ACUtils.SqlDb/SqlDb_BulkInsert.cs b/ACUtils.SqlDb/SqlDb_BulkInsert.cs
new file mode 100644
index 0000000..635f5b9
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_BulkInsert.cs
@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+
+namespace ACUtils
+{
+    public static class SqlDb_BulkInsert
+    {
+        public static void BulkInsert<T>(this SqlDb self, string tablename, IEnumerable<T> records)
+        {
+            using (var bc = new SqlBulkCopy(self.ConnectionString))
+            {
+                bc.WriteToServer(self.BulkInsertPrepare(bc, tablename, records));
+            }
+        }
+        public static async System.Threading.Tasks.Task BulkInsertAsync<T>(this SqlDb self, string tablename, IEnumerable<T> records)
+        {
+            using (var bc = new SqlBulkCopy(self.ConnectionString))
+            {
+                await bc.WriteToServerAsync(self.BulkInsertPrepare(bc, tablename, records));
+            }
+        }
+
+        internal static DataTable BulkInsertPrepare<T>(this SqlDb self, SqlBulkCopy bc, string tablename, IEnumerable<T> records)
+        {
+            bc.DestinationTableName = tablename;
+            var properties = typeof(T).GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
+            foreach (var property in properties)
+            {
+                bc.ColumnMappings.Add(property.Name, property.Name);
+            }
+            return SqlDb.ToDataTable(records);
+        }
+    }
+}
diff --git a/ACUtils.SqlDb/SqlDb_Execute.cs b/ACUtils.SqlDb/SqlDb_Execute.cs
new file mode 100644
index 0000000..4b7f51b
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_Execute.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+
+
+namespace ACUtils
+{
+    public static class SqlDb_Execute
+    {
+        public static bool Execute(this SqlDb self, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            //queryString = queryString.Trim().Replace(System.Environment.NewLine, " ");
+            //queryString = System.Text.RegularExpressions.Regex.Replace(queryString, @"\s+", " ");
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    var value = self.Execute(connection, queryString, queryParams);
+                    return value;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString, queryParams);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+
+        public static bool Execute(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            //queryString = queryString.Trim().Replace(System.Environment.NewLine, " ");
+            //queryString = System.Text.RegularExpressions.Regex.Replace(queryString, @"\s+", " ");
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams))
+            {
+                var value = selectCommand.ExecuteNonQuery() > 0;
+                return value;
+            }
+        }
+
+        public static bool Execute(this SqlDb self, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    var value = self.Execute(connection, queryString, queryParams);
+                    return value;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString, queryParams);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+
+        public static bool Execute(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams))
+            {
+                var value = selectCommand.ExecuteNonQuery() > 0;
+                return value;
+            }
+        }
+
+        public static bool Execute(this SqlDb self, string queryString)
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    self.WriteLog(queryString);
+                    var value = self.Execute(connection, queryString);
+                    return value;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+
+        public static bool Execute(this SqlDb self, SqlConnection connection, string queryString)
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString))
+            {
+                return selectCommand.ExecuteNonQuery() > 0;
+            }
+        }
+    }
+}
diff --git a/ACUtils.SqlDb/SqlDb_QueryDataRow.cs b/ACUtils.SqlDb/SqlDb_QueryDataRow.cs
new file mode 100644
index 0000000..b7ced0e
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_QueryDataRow.cs
@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+
+namespace ACUtils
+{
+    public static class SqlDb_QueryDataRow
+    {
+        public static DataRow QueryDataRow(this SqlDb self, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            DataTable dt = self.QueryDataTable(
+                queryString,
+                queryParams
+            );
+
+            if (dt.Rows.Count == 0)
+            {
+                throw new Exceptions.NotFoundException("nessun risultato ottenuto");
+            }
+
+            if (dt.Rows.Count > 1)
+            {
+                throw new Exceptions.TooMuchResultsException("ottenuto più valori");
+            }
+            return dt.Rows[0];
+        }
+
+        public static DataRow QueryDataRow(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            DataTable dt = self.QueryDataTable(
+                connection,
+                queryString,
+                queryParams
+            );
+
+            if (dt.Rows.Count == 0)
+            {
+                throw new Exceptions.NotFoundException("nessun risultato ottenuto");
+            }
+
+            if (dt.Rows.Count > 1)
+            {
+                throw new Exceptions.TooMuchResultsException("ottenuto più valori");
+            }
+
+            return dt.Rows[0];
+        }
+
+    }
+}
diff --git a/ACUtils.SqlDb/SqlDb_QueryDataSet.cs b/ACUtils.SqlDb/SqlDb_QueryDataSet.cs
new file mode 100644
index 0000000..b0cfd2b
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_QueryDataSet.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+
+namespace ACUtils
+{
+    public static class SqlDb_QueryDataSet
+    {
+        public static DataSet QueryDataSet(this SqlDb self, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    self.WriteLog(queryString, queryParams);
+                    var ds = self.QueryDataSet(connection, queryString, queryParams);
+                    return ds;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString, queryParams);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+
+        public static DataSet QueryDataSet(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams))
+            {
+                using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand))
+                {
+                    DataSet ds = new DataSet();
+                    adapter.MissingSchemaAction = SqlDb.MissingSchemaAction;
+                    adapter.Fill(ds);
+                    return ds;
+                }
+            }
+        }
+
+        public static DataSet QueryDataSet(this SqlDb self, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    self.WriteLog(queryString, queryParams);
+                    var ds = self.QueryDataSet(connection, queryString, queryParams);
+                    return ds;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString, queryParams);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+
+        public static DataSet QueryDataSet(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams))
+            {
+                using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand))
+                {
+                    DataSet ds = new DataSet();
+                    adapter.MissingSchemaAction = SqlDb.MissingSchemaAction;
+                    adapter.Fill(ds);
+                    return ds;
+                }
+            }
+        }
+
+        public static DataSet QueryDataSet(this SqlDb self, string queryString)
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    self.WriteLog(queryString);
+                    var ds = self.QueryDataSet(connection, queryString);
+                    return ds;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+
+        public static DataSet QueryDataSet(this SqlDb self, SqlConnection connection, string queryString)
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString))
+            {
+                using (SqlDataAdapter adapter = new SqlDataAdapter(selectCommand))
+                {
+                    DataSet ds = new DataSet();
+                    adapter.MissingSchemaAction = SqlDb.MissingSchemaAction;
+                    adapter.Fill(ds);
+                    return ds;
+                }
+            }
+        }
+    }
+}
diff --git a/ACUtils.SqlDb/SqlDb_QueryDataTable.cs b/ACUtils.SqlDb/SqlDb_QueryDataTable.cs
new file mode 100644
index 0000000..f81ad6b
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_QueryDataTable.cs
@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+
+namespace ACUtils
+{
+    public static class SqlDb_QueryDataTable
+    {
+        /// <summary>
+        /// Esegue la query e restituisce il DataTable del risultato
+        /// </summary>
+        /// <example>
+        /// db.QueryDataTable("SELECT * FROM A WHERE B = @B", "@B".WithValue("1"));
+        /// </example>
+        /// <param name="queryString">stringa contenente la stringa di interrogazione SQL</param>
+        /// <param name="queryParams">nomi dei parametri associati a i loro valori. utilizzare <see cref="KeyValuePairExt"/> come helper </param>
+        /// <returns></returns>
+        public static DataTable QueryDataTable(this SqlDb self, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            DataSet ds = self.QueryDataSet(queryString, queryParams);
+            return ds.Tables[0];
+        }
+
+        public static DataTable QueryDataTable(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            DataSet ds = self.QueryDataSet(connection, queryString, queryParams);
+            return ds.Tables[0];
+        }
+
+        public static DataTable QueryDataTable(this SqlDb self, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        {
+            DataSet ds = self.QueryDataSet(queryString, queryParams);
+            return ds.Tables[0];
+        }
+
+        public static DataTable QueryDataTable(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        {
+            DataSet ds = self.QueryDataSet(connection, queryString, queryParams);
+            return ds.Tables[0];
+        }
+
+        public static DataTable QueryDataTable(this SqlDb self, string queryString)
+        {
+            DataSet ds = self.QueryDataSet(queryString);
+            return ds.Tables[0];
+        }
+
+        public static DataTable QueryDataTable(this SqlDb self, SqlConnection connection, string queryString)
+        {
+            DataSet ds = self.QueryDataSet(connection, queryString);
+            return ds.Tables[0];
+        }
+
+    }
+}
diff --git a/ACUtils.SqlDb/SqlDb_QueryMany.cs b/ACUtils.SqlDb/SqlDb_QueryMany.cs
new file mode 100644
index 0000000..f995820
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_QueryMany.cs
@@ -0,0 +1,30 @@
+
+using System.Collections.Generic;
+using System.Data.SqlClient;
+
+namespace ACUtils
+{
+    public static class SqlDb_QueryMany
+    {
+        public static List<T> QueryMany<T>(this SqlDb self, string sql, params KeyValuePair<string, object>[] queryParams) where T : ACUtils.DBModel<T>, new()
+        {
+            var dt = self.QueryDataTable(sql, queryParams);
+            return ACUtils.DBModel<T>.Idrate(dt);
+        }
+
+        public static async IAsyncEnumerable<T> QueryManyAsync<T>(this SqlDb self, string sql, params KeyValuePair<string, object>[] queryParams) where T : ACUtils.DBModel<T>, new()
+        {
+            var dt = self.QueryDataTable(sql, queryParams);
+            await foreach (var q in ACUtils.DBModel<T>.IdrateAsyncGenerator(dt))
+            {
+                yield return q;
+            }
+        }
+
+        public static List<T> QueryMany<T>(this SqlDb self, SqlConnection connection, string sql, params KeyValuePair<string, object>[] queryParams) where T : ACUtils.DBModel<T>, new()
+        {
+            var dt = self.QueryDataTable(connection, sql, queryParams);
+            return ACUtils.DBModel<T>.Idrate(dt);
+        }
+    }
+}
diff --git a/ACUtils.SqlDb/SqlDb_QueryNullableSingleValue.cs b/ACUtils.SqlDb/SqlDb_QueryNullableSingleValue.cs
new file mode 100644
index 0000000..88d595d
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_QueryNullableSingleValue.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+
+namespace ACUtils
+{
+    public static class SqlDb_QueryNullableSingleValue
+    {
+        public static T? QueryNullableSingleValue<T>(this SqlDb self, string queryString, params KeyValuePair<string, object>[] queryParams) where T : struct
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    self.WriteLog(queryString, queryParams);
+                    var value = self.QueryNullableSingleValue<T>(connection, queryString, queryParams);
+                    return value;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString, queryParams);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+    }
+}
diff --git a/ACUtils.SqlDb/SqlDb_QueryOne.cs b/ACUtils.SqlDb/SqlDb_QueryOne.cs
new file mode 100644
index 0000000..b06d8e0
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_QueryOne.cs
@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Data.SqlClient;
+
+namespace ACUtils
+{
+    public static class SqlDb_QueryOne
+    {
+        public static T QueryOne<T>(
+            this SqlDb self,
+            string sql,
+            params KeyValuePair<string, object>[] queryParams
+        ) where T : ACUtils.DBModel<T>, new()
+        {
+            var dr = self.QueryDataRow(sql, queryParams);
+            return ACUtils.DBModel<T>.Idrate(dr);
+        }
+
+
+        public static T QueryOne<T>(
+            this SqlDb self,
+            SqlConnection connection,
+            string sql,
+            params KeyValuePair<string, object>[] queryParams
+        ) where T : ACUtils.DBModel<T>, new()
+        {
+            var dr = self.QueryDataRow(connection, sql, queryParams);
+            return ACUtils.DBModel<T>.Idrate(dr);
+        }
+    }
+}
diff --git a/ACUtils.SqlDb/SqlDb_QuerySingleValue.cs b/ACUtils.SqlDb/SqlDb_QuerySingleValue.cs
new file mode 100644
index 0000000..e08862a
--- /dev/null
+++ b/ACUtils.SqlDb/SqlDb_QuerySingleValue.cs
@@ -0,0 +1,122 @@
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+
+namespace ACUtils
+{
+    public static class SqlDb_QuerySingleValue
+    {
+        public static T QuerySingleValue<T>(this SqlDb self, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    self.WriteLog(queryString, queryParams);
+                    var value = self.QuerySingleValue<T>(connection, queryString, queryParams);
+                    return value;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString, queryParams);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+        public static T QuerySingleValue<T>(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams)
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams))
+            {
+                object value = selectCommand.ExecuteScalar();
+                return SqlDb._changeType<T>(value);
+            }
+        }
+
+        public static Nullable<T> QueryNullableSingleValue<T>(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, object>[] queryParams) where T : struct
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams))
+            {
+                object value = selectCommand.ExecuteScalar();
+                if (value == null || value == DBNull.Value || value is DBNull)
+                {
+                    return null;
+                }
+                // conversione variabile da object a type specificato
+                //return (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value);
+                return SqlDb._changeType<T?>(value);
+            }
+        }
+
+        public static T QuerySingleValue<T>(this SqlDb self, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    self.WriteLog(queryString, queryParams);
+                    var value = self.QuerySingleValue<T>(connection, queryString, queryParams);
+                    return value;
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString, queryParams);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+
+        public static T QuerySingleValue<T>(this SqlDb self, SqlConnection connection, string queryString, params KeyValuePair<string, KeyValuePair<SqlDbType, object>>[] queryParams)
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString, queryParams))
+            {
+                object value = selectCommand.ExecuteScalar();
+                return SqlDb._changeType<T>(value);
+            }
+        }
+
+
+        public static T QuerySingleValue<T>(this SqlDb self, string queryString)
+        {
+            using (SqlConnection connection = new SqlConnection(self.ConnectionString))
+            {
+                try
+                {
+                    connection.Open();
+                    var value = self.QuerySingleValue<T>(connection, queryString);
+                    return SqlDb._changeType<T>(value);
+                }
+                catch (Exception ex)
+                {
+                    self.WriteLog(ex, queryString);
+                    throw;
+                }
+                finally
+                {
+                    try { connection.Close(); } catch { }
+                }
+            }
+        }
+
+
+        public static T QuerySingleValue<T>(this SqlDb self, SqlConnection connection, string queryString)
+        {
+            using (SqlCommand selectCommand = SqlDb.generateCommand(connection, queryString))
+            {
+                object value = selectCommand.ExecuteScalar();
+                return SqlDb._changeType<T>(value);
+            }
+        }
+    }
+}