You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1266 lines
52 KiB
1266 lines
52 KiB
using Dapper;
|
|
using StackExchange.Profiling.Data;
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.ComponentModel.DataAnnotations.Schema;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Text;
|
|
|
|
#if NETSTANDARD1_3
|
|
using DataException = System.InvalidOperationException;
|
|
#endif
|
|
|
|
namespace Dapper.Contrib.Extensions
|
|
{
|
|
/// <summary>
|
|
/// The Dapper.Contrib extensions for Dapper
|
|
/// </summary>
|
|
public static partial class SqlMapperExtensions
|
|
{
|
|
/// <summary>
|
|
/// The function to get a database type from the given <see cref="IDbConnection" />.
|
|
/// </summary>
|
|
/// <param name="connection">The connection to get a database type name from.</param>
|
|
public delegate string GetDatabaseTypeDelegate(IDbConnection connection);
|
|
|
|
/// <summary>
|
|
/// The function to get a a table name from a given <see cref="Type" />
|
|
/// </summary>
|
|
/// <param name="type">The <see cref="Type" /> to get a table name for.</param>
|
|
public delegate string TableNameMapperDelegate(Type type);
|
|
|
|
private static readonly ConcurrentDictionary<RuntimeTypeHandle, IEnumerable<PropertyInfo>> KeyProperties =
|
|
new();
|
|
|
|
private static readonly ConcurrentDictionary<RuntimeTypeHandle, IEnumerable<PropertyInfo>> ExplicitKeyProperties
|
|
= new();
|
|
|
|
private static readonly ConcurrentDictionary<RuntimeTypeHandle, IEnumerable<PropertyInfo>> TypeProperties =
|
|
new();
|
|
|
|
private static readonly ConcurrentDictionary<RuntimeTypeHandle, IEnumerable<PropertyInfo>> ComputedProperties =
|
|
new();
|
|
|
|
private static readonly ConcurrentDictionary<RuntimeTypeHandle, string> GetQueries =
|
|
new();
|
|
|
|
private static readonly ConcurrentDictionary<RuntimeTypeHandle, string> TypeTableName =
|
|
new();
|
|
|
|
private static readonly ISqlAdapter DefaultAdapter = new SqlServerAdapter();
|
|
|
|
private static readonly Dictionary<string, ISqlAdapter> AdapterDictionary
|
|
= new()
|
|
{
|
|
["sqlconnection"] = new SqlServerAdapter(),
|
|
["sqlceconnection"] = new SqlCeServerAdapter(),
|
|
["npgsqlconnection"] = new PostgresAdapter(),
|
|
["sqliteconnection"] = new SQLiteAdapter(),
|
|
["mysqlconnection"] = new MySqlAdapter(),
|
|
["fbconnection"] = new FbAdapter()
|
|
};
|
|
|
|
/// <summary>
|
|
/// Specify a custom table name mapper based on the POCO type name
|
|
/// </summary>
|
|
public static TableNameMapperDelegate TableNameMapper;
|
|
|
|
/// <summary>
|
|
/// Specifies a custom callback that detects the database type instead of relying on the default strategy (the name of
|
|
/// the connection type object).
|
|
/// Please note that this callback is global and will be used by all the calls that require a database specific
|
|
/// adapter.
|
|
/// </summary>
|
|
public static GetDatabaseTypeDelegate GetDatabaseType;
|
|
|
|
private static List<PropertyInfo> ComputedPropertiesCache(Type type)
|
|
{
|
|
if (ComputedProperties.TryGetValue(type.TypeHandle, out IEnumerable<PropertyInfo> pi))
|
|
{
|
|
return pi.ToList();
|
|
}
|
|
|
|
List<PropertyInfo> computedProperties = TypePropertiesCache(type)
|
|
.Where(p => p.GetCustomAttributes(true).Any(a => a is ComputedAttribute)).ToList();
|
|
|
|
ComputedProperties[type.TypeHandle] = computedProperties;
|
|
return computedProperties;
|
|
}
|
|
|
|
private static List<PropertyInfo> ExplicitKeyPropertiesCache(Type type)
|
|
{
|
|
if (ExplicitKeyProperties.TryGetValue(type.TypeHandle, out IEnumerable<PropertyInfo> pi))
|
|
{
|
|
return pi.ToList();
|
|
}
|
|
|
|
List<PropertyInfo> explicitKeyProperties = TypePropertiesCache(type)
|
|
.Where(p => p.GetCustomAttributes(true).Any(a => a is ExplicitKeyAttribute)).ToList();
|
|
|
|
ExplicitKeyProperties[type.TypeHandle] = explicitKeyProperties;
|
|
return explicitKeyProperties;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 查询主键,属性加了Key标签
|
|
/// </summary>
|
|
/// <param name="type"></param>
|
|
/// <returns></returns>
|
|
private static List<PropertyInfo> KeyPropertiesCache(Type type)
|
|
{
|
|
if (KeyProperties.TryGetValue(type.TypeHandle, out IEnumerable<PropertyInfo> pi))
|
|
{
|
|
return pi.ToList();
|
|
}
|
|
|
|
List<PropertyInfo> allProperties = TypePropertiesCache(type);
|
|
List<PropertyInfo> keyProperties = allProperties.Where(p => p.GetCustomAttributes(true).Any(a => a is KeyAttribute))
|
|
.ToList();
|
|
|
|
if (keyProperties.Count == 0)
|
|
{
|
|
PropertyInfo idProp = allProperties.Find(p =>
|
|
string.Equals(p.Name, "Id", StringComparison.CurrentCultureIgnoreCase));
|
|
if (idProp != null && !idProp.GetCustomAttributes(true).Any(a => a is ExplicitKeyAttribute))
|
|
{
|
|
keyProperties.Add(idProp);
|
|
}
|
|
}
|
|
|
|
KeyProperties[type.TypeHandle] = keyProperties;
|
|
return keyProperties;
|
|
}
|
|
|
|
private static List<PropertyInfo> TypePropertiesCache(Type type)
|
|
{
|
|
if (TypeProperties.TryGetValue(type.TypeHandle, out IEnumerable<PropertyInfo> pis))
|
|
{
|
|
return pis.ToList();
|
|
}
|
|
|
|
PropertyInfo[] properties = type.GetProperties().Where(IsWriteable).ToArray();
|
|
TypeProperties[type.TypeHandle] = properties;
|
|
return properties.ToList();
|
|
}
|
|
|
|
private static bool IsWriteable(PropertyInfo pi)
|
|
{
|
|
List<object> attributes = pi.GetCustomAttributes(typeof(WriteAttribute), false).AsList();
|
|
if (attributes.Count != 1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
WriteAttribute writeAttribute = (WriteAttribute)attributes[0];
|
|
return writeAttribute.Write;
|
|
}
|
|
|
|
private static PropertyInfo GetSingleKey<T>(string method)
|
|
{
|
|
Type type = typeof(T);
|
|
List<PropertyInfo> keys = KeyPropertiesCache(type);
|
|
//var explicitKeys = ExplicitKeyPropertiesCache(type);
|
|
int keyCount = keys.Count; // + explicitKeys.Count;
|
|
if (keyCount > 1)
|
|
{
|
|
throw new DataException(
|
|
$"{method}<T> only supports an entity with a single [Key] property. [Key] Count: {keys.Count}");
|
|
}
|
|
|
|
if (keyCount == 0)
|
|
{
|
|
throw new DataException($"{method}<T> only supports an entity with a [Key] property");
|
|
}
|
|
|
|
return keys[0];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a single entity by a single id from table "Ts".
|
|
/// Id must be marked with [Key] attribute.
|
|
/// Entities created from interfaces are tracked/intercepted for changes and used by the Update() extension
|
|
/// for optimal performance.
|
|
/// </summary>
|
|
/// <typeparam name="T">Interface or type to create and populate</typeparam>
|
|
/// <param name="connection">Open SqlConnection</param>
|
|
/// <param name="id">Id of the entity to get, must be marked with [Key] attribute</param>
|
|
/// <param name="transaction">The transaction to run under, null (the default) if none</param>
|
|
/// <param name="commandTimeout">Number of seconds before command execution timeout</param>
|
|
/// <returns>Entity of T</returns>
|
|
public static T Get<T>(this IDbConnection connection, dynamic id, IDbTransaction transaction = null,
|
|
int? commandTimeout = null) where T : class
|
|
{
|
|
Type type = typeof(T);
|
|
|
|
if (!GetQueries.TryGetValue(type.TypeHandle, out string sql))
|
|
{
|
|
PropertyInfo key = GetSingleKey<T>(nameof(Get));
|
|
string name = GetTableName(type);
|
|
|
|
sql = $"select * from {name} where {key.Name} = @KeyName";
|
|
GetQueries[type.TypeHandle] = sql;
|
|
}
|
|
|
|
DynamicParameters dynParms = new DynamicParameters();
|
|
dynParms.Add("@KeyName", id);
|
|
|
|
T obj;
|
|
|
|
if (type.IsInterface)
|
|
{
|
|
IDictionary<string, object> res = connection.Query(sql, dynParms).FirstOrDefault() as IDictionary<string, object>;
|
|
|
|
if (res == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
obj = ProxyGenerator.GetInterfaceProxy<T>();
|
|
|
|
foreach (PropertyInfo property in TypePropertiesCache(type))
|
|
{
|
|
object val = res[property.Name];
|
|
if (val == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (property.PropertyType.IsGenericType &&
|
|
property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
|
|
{
|
|
Type genericType = Nullable.GetUnderlyingType(property.PropertyType);
|
|
if (genericType != null)
|
|
{
|
|
property.SetValue(obj, Convert.ChangeType(val, genericType), null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
property.SetValue(obj, Convert.ChangeType(val, property.PropertyType), null);
|
|
}
|
|
}
|
|
|
|
((IProxy)obj).IsDirty = false; //reset change tracking and return
|
|
}
|
|
else
|
|
{
|
|
obj = connection.Query<T>(sql, dynParms, transaction, commandTimeout: commandTimeout).FirstOrDefault();
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a list of entites from table "Ts".
|
|
/// Id of T must be marked with [Key] attribute.
|
|
/// Entities created from interfaces are tracked/intercepted for changes and used by the Update() extension
|
|
/// for optimal performance.
|
|
/// </summary>
|
|
/// <typeparam name="T">Interface or type to create and populate</typeparam>
|
|
/// <param name="connection">Open SqlConnection</param>
|
|
/// <param name="transaction">The transaction to run under, null (the default) if none</param>
|
|
/// <param name="commandTimeout">Number of seconds before command execution timeout</param>
|
|
/// <returns>Entity of T</returns>
|
|
public static IEnumerable<T> GetAll<T>(this IDbConnection connection, IDbTransaction transaction = null,
|
|
int? commandTimeout = null) where T : class
|
|
{
|
|
Type type = typeof(T);
|
|
Type cacheType = typeof(List<T>);
|
|
|
|
if (!GetQueries.TryGetValue(cacheType.TypeHandle, out string sql))
|
|
{
|
|
GetSingleKey<T>(nameof(GetAll));
|
|
string name = GetTableName(type);
|
|
|
|
sql = "select * from " + name;
|
|
GetQueries[cacheType.TypeHandle] = sql;
|
|
}
|
|
|
|
if (!type.IsInterface)
|
|
{
|
|
return connection.Query<T>(sql, null, transaction, commandTimeout: commandTimeout);
|
|
}
|
|
|
|
IEnumerable<dynamic> result = connection.Query(sql);
|
|
List<T> list = new List<T>();
|
|
foreach (IDictionary<string, object> res in result)
|
|
{
|
|
T obj = ProxyGenerator.GetInterfaceProxy<T>();
|
|
foreach (PropertyInfo property in TypePropertiesCache(type))
|
|
{
|
|
object val = res[property.Name];
|
|
if (val == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (property.PropertyType.IsGenericType &&
|
|
property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
|
|
{
|
|
Type genericType = Nullable.GetUnderlyingType(property.PropertyType);
|
|
if (genericType != null)
|
|
{
|
|
property.SetValue(obj, Convert.ChangeType(val, genericType), null);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
property.SetValue(obj, Convert.ChangeType(val, property.PropertyType), null);
|
|
}
|
|
}
|
|
|
|
((IProxy)obj).IsDirty = false; //reset change tracking and return
|
|
list.Add(obj);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
private static string GetTableName(Type type)
|
|
{
|
|
if (TypeTableName.TryGetValue(type.TypeHandle, out string name))
|
|
{
|
|
return name;
|
|
}
|
|
|
|
if (TableNameMapper != null)
|
|
{
|
|
name = TableNameMapper(type);
|
|
}
|
|
else
|
|
{
|
|
#if NETSTANDARD1_3
|
|
var info = type.GetTypeInfo();
|
|
#else
|
|
Type info = type;
|
|
#endif
|
|
//NOTE: This as dynamic trick falls back to handle both our own Table-attribute as well as the one in EntityFramework
|
|
dynamic tableAttrName =
|
|
info.GetCustomAttribute<TableAttribute>(false)?.Name
|
|
?? (info.GetCustomAttributes(false)
|
|
.FirstOrDefault(attr => attr.GetType().Name == "TableAttribute") as dynamic)?.Name;
|
|
|
|
if (tableAttrName != null)
|
|
{
|
|
name = tableAttrName;
|
|
}
|
|
else
|
|
{
|
|
name = type.Name + "s";
|
|
if (type.IsInterface && name.StartsWith("I"))
|
|
{
|
|
name = name.Substring(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
TypeTableName[type.TypeHandle] = name;
|
|
return name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inserts an entity into table "Ts" and returns identity id or number of inserted rows if inserting a list.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type to insert.</typeparam>
|
|
/// <param name="connection">Open SqlConnection</param>
|
|
/// <param name="entityToInsert">Entity to insert, can be list of entities</param>
|
|
/// <param name="transaction">The transaction to run under, null (the default) if none</param>
|
|
/// <param name="commandTimeout">Number of seconds before command execution timeout</param>
|
|
/// <returns>Identity of inserted entity, or number of inserted rows if inserting a list</returns>
|
|
public static long Insert<T>(this IDbConnection connection, T entityToInsert, IDbTransaction transaction = null,
|
|
int? commandTimeout = null) where T : class
|
|
{
|
|
bool isList = false;
|
|
Type type = typeof(T);
|
|
|
|
if (type.IsArray)
|
|
{
|
|
isList = true;
|
|
type = type.GetElementType();
|
|
}
|
|
else if (type.IsGenericType)
|
|
{
|
|
TypeInfo typeInfo = type.GetTypeInfo();
|
|
bool implementsGenericIEnumerableOrIsGenericIEnumerable =
|
|
typeInfo.ImplementedInterfaces.Any(ti =>
|
|
ti.IsGenericType && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>)) ||
|
|
typeInfo.GetGenericTypeDefinition() == typeof(IEnumerable<>);
|
|
|
|
if (implementsGenericIEnumerableOrIsGenericIEnumerable)
|
|
{
|
|
isList = true;
|
|
type = type.GetGenericArguments()[0];
|
|
}
|
|
}
|
|
|
|
string name = GetTableName(type);
|
|
StringBuilder sbColumnList = new StringBuilder(null);
|
|
List<PropertyInfo> allProperties = TypePropertiesCache(type);
|
|
List<PropertyInfo> keyProperties = KeyPropertiesCache(type);
|
|
List<PropertyInfo> computedProperties = ComputedPropertiesCache(type);
|
|
List<PropertyInfo> allPropertiesExceptKeyAndComputed =
|
|
allProperties.ToList(); //.Except(keyProperties.Union(computedProperties)).ToList();
|
|
|
|
ISqlAdapter adapter = GetFormatter(connection);
|
|
|
|
for (int i = 0; i < allPropertiesExceptKeyAndComputed.Count; i++)
|
|
{
|
|
PropertyInfo property = allPropertiesExceptKeyAndComputed[i];
|
|
adapter.AppendColumnName(sbColumnList, property.Name); //fix for issue #336
|
|
if (i < allPropertiesExceptKeyAndComputed.Count - 1)
|
|
{
|
|
sbColumnList.Append(", ");
|
|
}
|
|
}
|
|
|
|
StringBuilder sbParameterList = new StringBuilder(null);
|
|
for (int i = 0; i < allPropertiesExceptKeyAndComputed.Count; i++)
|
|
{
|
|
PropertyInfo property = allPropertiesExceptKeyAndComputed[i];
|
|
sbParameterList.AppendFormat("@{0}", property.Name);
|
|
if (i < allPropertiesExceptKeyAndComputed.Count - 1)
|
|
{
|
|
sbParameterList.Append(", ");
|
|
}
|
|
}
|
|
|
|
int returnVal;
|
|
bool wasClosed = connection.State == ConnectionState.Closed;
|
|
if (wasClosed)
|
|
{
|
|
connection.Open();
|
|
}
|
|
|
|
if (!isList) //single entity
|
|
{
|
|
returnVal = adapter.Insert(connection, transaction, commandTimeout, name, sbColumnList.ToString(),
|
|
sbParameterList.ToString(), keyProperties, entityToInsert);
|
|
}
|
|
else
|
|
{
|
|
//insert list of entities
|
|
string cmd = $"insert into {name} ({sbColumnList}) values ({sbParameterList})";
|
|
returnVal = connection.Execute(cmd, entityToInsert, transaction, commandTimeout);
|
|
}
|
|
|
|
if (wasClosed)
|
|
{
|
|
connection.Close();
|
|
}
|
|
|
|
return returnVal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Updates entity in table "Ts", checks if the entity is modified if the entity is tracked by the Get() extension.
|
|
/// </summary>
|
|
/// <typeparam name="T">Type to be updated</typeparam>
|
|
/// <param name="connection">Open SqlConnection</param>
|
|
/// <param name="entityToUpdate">Entity to be updated</param>
|
|
/// <param name="transaction">The transaction to run under, null (the default) if none</param>
|
|
/// <param name="commandTimeout">Number of seconds before command execution timeout</param>
|
|
/// <returns>true if updated, false if not found or not modified (tracked entities)</returns>
|
|
public static bool Update<T>(this IDbConnection connection, T entityToUpdate, IDbTransaction transaction = null,
|
|
int? commandTimeout = null) where T : class
|
|
{
|
|
if (entityToUpdate is IProxy proxy && !proxy.IsDirty)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Type type = typeof(T);
|
|
|
|
if (type.IsArray)
|
|
{
|
|
type = type.GetElementType();
|
|
}
|
|
else if (type.IsGenericType)
|
|
{
|
|
TypeInfo typeInfo = type.GetTypeInfo();
|
|
bool implementsGenericIEnumerableOrIsGenericIEnumerable =
|
|
typeInfo.ImplementedInterfaces.Any(ti =>
|
|
ti.IsGenericType && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>)) ||
|
|
typeInfo.GetGenericTypeDefinition() == typeof(IEnumerable<>);
|
|
|
|
if (implementsGenericIEnumerableOrIsGenericIEnumerable)
|
|
{
|
|
type = type.GetGenericArguments()[0];
|
|
}
|
|
}
|
|
|
|
List<PropertyInfo> keyProperties =
|
|
KeyPropertiesCache(type).ToList(); //added ToList() due to issue #418, must work on a list copy
|
|
List<PropertyInfo> explicitKeyProperties = ExplicitKeyPropertiesCache(type);
|
|
if (keyProperties.Count == 0 && explicitKeyProperties.Count == 0)
|
|
{
|
|
throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
|
|
}
|
|
|
|
string name = GetTableName(type);
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendFormat("update {0} set ", name);
|
|
|
|
List<PropertyInfo> allProperties = TypePropertiesCache(type);
|
|
keyProperties.AddRange(explicitKeyProperties);
|
|
List<PropertyInfo> computedProperties = ComputedPropertiesCache(type);
|
|
List<PropertyInfo> nonIdProps = allProperties.Except(keyProperties.Union(computedProperties)).ToList();
|
|
|
|
ISqlAdapter adapter = GetFormatter(connection);
|
|
|
|
for (int i = 0; i < nonIdProps.Count; i++)
|
|
{
|
|
PropertyInfo property = nonIdProps[i];
|
|
adapter.AppendColumnNameEqualsValue(sb, property.Name); //fix for issue #336
|
|
if (i < nonIdProps.Count - 1)
|
|
{
|
|
sb.Append(", ");
|
|
}
|
|
}
|
|
|
|
sb.Append(" where ");
|
|
for (int i = 0; i < keyProperties.Count; i++)
|
|
{
|
|
PropertyInfo property = keyProperties[i];
|
|
adapter.AppendColumnNameEqualsValue(sb, property.Name); //fix for issue #336
|
|
if (i < keyProperties.Count - 1)
|
|
{
|
|
sb.Append(" and ");
|
|
}
|
|
}
|
|
|
|
int updated = connection.Execute(sb.ToString(), entityToUpdate, commandTimeout: commandTimeout,
|
|
transaction: transaction);
|
|
return updated > 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete entity in table "Ts".
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of entity</typeparam>
|
|
/// <param name="connection">Open SqlConnection</param>
|
|
/// <param name="entityToDelete">Entity to delete</param>
|
|
/// <param name="transaction">The transaction to run under, null (the default) if none</param>
|
|
/// <param name="commandTimeout">Number of seconds before command execution timeout</param>
|
|
/// <returns>true if deleted, false if not found</returns>
|
|
public static bool Delete<T>(this IDbConnection connection, T entityToDelete, IDbTransaction transaction = null,
|
|
int? commandTimeout = null) where T : class
|
|
{
|
|
if (entityToDelete == null)
|
|
{
|
|
throw new ArgumentException("Cannot Delete null Object", nameof(entityToDelete));
|
|
}
|
|
|
|
Type type = typeof(T);
|
|
|
|
if (type.IsArray)
|
|
{
|
|
type = type.GetElementType();
|
|
}
|
|
else if (type.IsGenericType)
|
|
{
|
|
TypeInfo typeInfo = type.GetTypeInfo();
|
|
bool implementsGenericIEnumerableOrIsGenericIEnumerable =
|
|
typeInfo.ImplementedInterfaces.Any(ti =>
|
|
ti.IsGenericType && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>)) ||
|
|
typeInfo.GetGenericTypeDefinition() == typeof(IEnumerable<>);
|
|
|
|
if (implementsGenericIEnumerableOrIsGenericIEnumerable)
|
|
{
|
|
type = type.GetGenericArguments()[0];
|
|
}
|
|
}
|
|
|
|
List<PropertyInfo> keyProperties =
|
|
KeyPropertiesCache(type).ToList(); //added ToList() due to issue #418, must work on a list copy
|
|
List<PropertyInfo> explicitKeyProperties = ExplicitKeyPropertiesCache(type);
|
|
if (keyProperties.Count == 0 && explicitKeyProperties.Count == 0)
|
|
{
|
|
throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
|
|
}
|
|
|
|
string name = GetTableName(type);
|
|
keyProperties.AddRange(explicitKeyProperties);
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendFormat("delete from {0} where ", name);
|
|
|
|
ISqlAdapter adapter = GetFormatter(connection);
|
|
|
|
for (int i = 0; i < keyProperties.Count; i++)
|
|
{
|
|
PropertyInfo property = keyProperties[i];
|
|
adapter.AppendColumnNameEqualsValue(sb, property.Name); //fix for issue #336
|
|
if (i < keyProperties.Count - 1)
|
|
{
|
|
sb.Append(" and ");
|
|
}
|
|
}
|
|
|
|
int deleted = connection.Execute(sb.ToString(), entityToDelete, transaction, commandTimeout);
|
|
return deleted > 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Delete all entities in the table related to the type T.
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of entity</typeparam>
|
|
/// <param name="connection">Open SqlConnection</param>
|
|
/// <param name="transaction">The transaction to run under, null (the default) if none</param>
|
|
/// <param name="commandTimeout">Number of seconds before command execution timeout</param>
|
|
/// <returns>true if deleted, false if none found</returns>
|
|
public static bool DeleteAll<T>(this IDbConnection connection, IDbTransaction transaction = null,
|
|
int? commandTimeout = null) where T : class
|
|
{
|
|
Type type = typeof(T);
|
|
string name = GetTableName(type);
|
|
string statement = $"delete from {name}";
|
|
int deleted = connection.Execute(statement, null, transaction, commandTimeout);
|
|
return deleted > 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 适配数据类型
|
|
/// 2020-11-09 集成MiniProfiler
|
|
/// </summary>
|
|
/// <param name="connection"></param>
|
|
/// <returns></returns>
|
|
private static ISqlAdapter GetFormatter(IDbConnection connection)
|
|
{
|
|
string name = GetDatabaseType?.Invoke(connection).ToLower()
|
|
?? connection.GetType().Name.ToLower();
|
|
if (name == "profileddbconnection")
|
|
{
|
|
ProfiledDbConnection pconn = (ProfiledDbConnection)connection;
|
|
name = pconn.WrappedConnection.GetType().Name.ToLower();
|
|
}
|
|
|
|
return !AdapterDictionary.ContainsKey(name)
|
|
? DefaultAdapter
|
|
: AdapterDictionary[name];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defined a proxy object with a possibly dirty state.
|
|
/// </summary>
|
|
public interface IProxy //must be kept public
|
|
{
|
|
/// <summary>
|
|
/// Whether the object has been changed.
|
|
/// </summary>
|
|
bool IsDirty { get; set; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines a table name mapper for getting table names from types.
|
|
/// </summary>
|
|
public interface ITableNameMapper
|
|
{
|
|
/// <summary>
|
|
/// Gets a table name from a given <see cref="Type" />.
|
|
/// </summary>
|
|
/// <param name="type">The <see cref="Type" /> to get a name from.</param>
|
|
/// <returns>The table name for the given <paramref name="type" />.</returns>
|
|
string GetTableName(Type type);
|
|
}
|
|
|
|
private static class ProxyGenerator
|
|
{
|
|
private static readonly Dictionary<Type, Type> TypeCache = new();
|
|
|
|
private static AssemblyBuilder GetAsmBuilder(string name)
|
|
{
|
|
return AssemblyBuilder.DefineDynamicAssembly(new AssemblyName { Name = name }, AssemblyBuilderAccess.Run);
|
|
}
|
|
|
|
public static T GetInterfaceProxy<T>()
|
|
{
|
|
Type typeOfT = typeof(T);
|
|
|
|
if (TypeCache.TryGetValue(typeOfT, out Type k))
|
|
{
|
|
return (T)Activator.CreateInstance(k);
|
|
}
|
|
|
|
AssemblyBuilder assemblyBuilder = GetAsmBuilder(typeOfT.Name);
|
|
|
|
ModuleBuilder moduleBuilder =
|
|
assemblyBuilder.DefineDynamicModule("SqlMapperExtensions." +
|
|
typeOfT.Name); //NOTE: to save, add "asdasd.dll" parameter
|
|
|
|
Type interfaceType = typeof(IProxy);
|
|
TypeBuilder typeBuilder = moduleBuilder.DefineType(typeOfT.Name + "_" + Guid.NewGuid(),
|
|
TypeAttributes.Public | TypeAttributes.Class);
|
|
typeBuilder.AddInterfaceImplementation(typeOfT);
|
|
typeBuilder.AddInterfaceImplementation(interfaceType);
|
|
|
|
//create our _isDirty field, which implements IProxy
|
|
MethodInfo setIsDirtyMethod = CreateIsDirtyProperty(typeBuilder);
|
|
|
|
// Generate a field for each property, which implements the T
|
|
foreach (PropertyInfo property in typeof(T).GetProperties())
|
|
{
|
|
bool isId = property.GetCustomAttributes(true).Any(a => a is KeyAttribute);
|
|
CreateProperty<T>(typeBuilder, property.Name, property.PropertyType, setIsDirtyMethod, isId);
|
|
}
|
|
|
|
#if NETSTANDARD1_3 || NETSTANDARD2_0
|
|
var generatedType = typeBuilder.CreateTypeInfo().AsType();
|
|
#else
|
|
Type generatedType = typeBuilder.CreateType();
|
|
#endif
|
|
|
|
TypeCache.Add(typeOfT, generatedType);
|
|
return (T)Activator.CreateInstance(generatedType);
|
|
}
|
|
|
|
private static MethodInfo CreateIsDirtyProperty(TypeBuilder typeBuilder)
|
|
{
|
|
Type propType = typeof(bool);
|
|
FieldBuilder field = typeBuilder.DefineField("_" + nameof(IProxy.IsDirty), propType, FieldAttributes.Private);
|
|
PropertyBuilder property = typeBuilder.DefineProperty(nameof(IProxy.IsDirty),
|
|
PropertyAttributes.None,
|
|
propType,
|
|
new[] { propType });
|
|
|
|
const MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.NewSlot |
|
|
MethodAttributes.SpecialName
|
|
| MethodAttributes.Final | MethodAttributes.Virtual |
|
|
MethodAttributes.HideBySig;
|
|
|
|
// Define the "get" and "set" accessor methods
|
|
MethodBuilder currGetPropMthdBldr = typeBuilder.DefineMethod("get_" + nameof(IProxy.IsDirty),
|
|
getSetAttr,
|
|
propType,
|
|
Type.EmptyTypes);
|
|
ILGenerator currGetIl = currGetPropMthdBldr.GetILGenerator();
|
|
currGetIl.Emit(OpCodes.Ldarg_0);
|
|
currGetIl.Emit(OpCodes.Ldfld, field);
|
|
currGetIl.Emit(OpCodes.Ret);
|
|
MethodBuilder currSetPropMthdBldr = typeBuilder.DefineMethod("set_" + nameof(IProxy.IsDirty),
|
|
getSetAttr,
|
|
null,
|
|
new[] { propType });
|
|
ILGenerator currSetIl = currSetPropMthdBldr.GetILGenerator();
|
|
currSetIl.Emit(OpCodes.Ldarg_0);
|
|
currSetIl.Emit(OpCodes.Ldarg_1);
|
|
currSetIl.Emit(OpCodes.Stfld, field);
|
|
currSetIl.Emit(OpCodes.Ret);
|
|
|
|
property.SetGetMethod(currGetPropMthdBldr);
|
|
property.SetSetMethod(currSetPropMthdBldr);
|
|
MethodInfo getMethod = typeof(IProxy).GetMethod("get_" + nameof(IProxy.IsDirty));
|
|
MethodInfo setMethod = typeof(IProxy).GetMethod("set_" + nameof(IProxy.IsDirty));
|
|
typeBuilder.DefineMethodOverride(currGetPropMthdBldr, getMethod);
|
|
typeBuilder.DefineMethodOverride(currSetPropMthdBldr, setMethod);
|
|
|
|
return currSetPropMthdBldr;
|
|
}
|
|
|
|
private static void CreateProperty<T>(TypeBuilder typeBuilder, string propertyName, Type propType,
|
|
MethodInfo setIsDirtyMethod, bool isIdentity)
|
|
{
|
|
//Define the field and the property
|
|
FieldBuilder field = typeBuilder.DefineField("_" + propertyName, propType, FieldAttributes.Private);
|
|
PropertyBuilder property = typeBuilder.DefineProperty(propertyName,
|
|
PropertyAttributes.None,
|
|
propType,
|
|
new[] { propType });
|
|
|
|
const MethodAttributes getSetAttr = MethodAttributes.Public
|
|
| MethodAttributes.Virtual
|
|
| MethodAttributes.HideBySig;
|
|
|
|
// Define the "get" and "set" accessor methods
|
|
MethodBuilder currGetPropMthdBldr = typeBuilder.DefineMethod("get_" + propertyName,
|
|
getSetAttr,
|
|
propType,
|
|
Type.EmptyTypes);
|
|
|
|
ILGenerator currGetIl = currGetPropMthdBldr.GetILGenerator();
|
|
currGetIl.Emit(OpCodes.Ldarg_0);
|
|
currGetIl.Emit(OpCodes.Ldfld, field);
|
|
currGetIl.Emit(OpCodes.Ret);
|
|
|
|
MethodBuilder currSetPropMthdBldr = typeBuilder.DefineMethod("set_" + propertyName,
|
|
getSetAttr,
|
|
null,
|
|
new[] { propType });
|
|
|
|
//store value in private field and set the isdirty flag
|
|
ILGenerator currSetIl = currSetPropMthdBldr.GetILGenerator();
|
|
currSetIl.Emit(OpCodes.Ldarg_0);
|
|
currSetIl.Emit(OpCodes.Ldarg_1);
|
|
currSetIl.Emit(OpCodes.Stfld, field);
|
|
currSetIl.Emit(OpCodes.Ldarg_0);
|
|
currSetIl.Emit(OpCodes.Ldc_I4_1);
|
|
currSetIl.Emit(OpCodes.Call, setIsDirtyMethod);
|
|
currSetIl.Emit(OpCodes.Ret);
|
|
|
|
//TODO: Should copy all attributes defined by the interface?
|
|
if (isIdentity)
|
|
{
|
|
Type keyAttribute = typeof(KeyAttribute);
|
|
ConstructorInfo myConstructorInfo = keyAttribute.GetConstructor(new Type[] { });
|
|
CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder(myConstructorInfo, new object[] { });
|
|
property.SetCustomAttribute(attributeBuilder);
|
|
}
|
|
|
|
property.SetGetMethod(currGetPropMthdBldr);
|
|
property.SetSetMethod(currSetPropMthdBldr);
|
|
MethodInfo getMethod = typeof(T).GetMethod("get_" + propertyName);
|
|
MethodInfo setMethod = typeof(T).GetMethod("set_" + propertyName);
|
|
typeBuilder.DefineMethodOverride(currGetPropMthdBldr, getMethod);
|
|
typeBuilder.DefineMethodOverride(currSetPropMthdBldr, setMethod);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies that this field is a explicitly set primary key in the database
|
|
/// </summary>
|
|
[AttributeUsage(AttributeTargets.Property)]
|
|
public class ExplicitKeyAttribute : Attribute
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies whether a field is writable in the database.
|
|
/// </summary>
|
|
[AttributeUsage(AttributeTargets.Property)]
|
|
public class WriteAttribute : Attribute
|
|
{
|
|
/// <summary>
|
|
/// Specifies whether a field is writable in the database.
|
|
/// </summary>
|
|
/// <param name="write">Whether a field is writable in the database.</param>
|
|
public WriteAttribute(bool write)
|
|
{
|
|
Write = write;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether a field is writable in the database.
|
|
/// </summary>
|
|
public bool Write { get; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies that this is a computed column.
|
|
/// </summary>
|
|
[AttributeUsage(AttributeTargets.Property)]
|
|
public class ComputedAttribute : Attribute
|
|
{
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The interface for all Dapper.Contrib database operations
|
|
/// Implementing this is each provider's model.
|
|
/// </summary>
|
|
public partial interface ISqlAdapter
|
|
{
|
|
/// <summary>
|
|
/// Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
|
|
/// </summary>
|
|
/// <param name="connection">The connection to use.</param>
|
|
/// <param name="transaction">The transaction to use.</param>
|
|
/// <param name="commandTimeout">The command timeout to use.</param>
|
|
/// <param name="tableName">The table to insert into.</param>
|
|
/// <param name="columnList">The columns to set with this insert.</param>
|
|
/// <param name="parameterList">The parameters to set for this insert.</param>
|
|
/// <param name="keyProperties">The key columns in this table.</param>
|
|
/// <param name="entityToInsert">The entity to insert.</param>
|
|
/// <returns>The Id of the row created.</returns>
|
|
int Insert(IDbConnection connection, IDbTransaction transaction, int? commandTimeout, string tableName,
|
|
string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert);
|
|
|
|
/// <summary>
|
|
/// Adds the name of a column.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
void AppendColumnName(StringBuilder sb, string columnName);
|
|
|
|
/// <summary>
|
|
/// Adds a column equality to a parameter.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
void AppendColumnNameEqualsValue(StringBuilder sb, string columnName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The SQL Server database adapter.
|
|
/// </summary>
|
|
public partial class SqlServerAdapter : ISqlAdapter
|
|
{
|
|
/// <summary>
|
|
/// Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
|
|
/// </summary>
|
|
/// <param name="connection">The connection to use.</param>
|
|
/// <param name="transaction">The transaction to use.</param>
|
|
/// <param name="commandTimeout">The command timeout to use.</param>
|
|
/// <param name="tableName">The table to insert into.</param>
|
|
/// <param name="columnList">The columns to set with this insert.</param>
|
|
/// <param name="parameterList">The parameters to set for this insert.</param>
|
|
/// <param name="keyProperties">The key columns in this table.</param>
|
|
/// <param name="entityToInsert">The entity to insert.</param>
|
|
/// <returns>The Id of the row created.</returns>
|
|
public int Insert(IDbConnection connection, IDbTransaction transaction, int? commandTimeout, string tableName,
|
|
string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert)
|
|
{
|
|
string cmd = $"insert into `{tableName}` ({columnList}) values ({parameterList}); select @@ROWCOUNT num";
|
|
SqlMapper.GridReader multi = connection.QueryMultiple(cmd, entityToInsert, transaction, commandTimeout);
|
|
|
|
dynamic first = multi.Read().FirstOrDefault();
|
|
if (first == null || first.num == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int num = (int)first.num;
|
|
return num;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the name of a column.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnName(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("[{0}]", columnName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a column equality to a parameter.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnNameEqualsValue(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("[{0}] = @{1}", columnName, columnName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The SQL Server Compact Edition database adapter.
|
|
/// </summary>
|
|
public partial class SqlCeServerAdapter : ISqlAdapter
|
|
{
|
|
/// <summary>
|
|
/// Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
|
|
/// </summary>
|
|
/// <param name="connection">The connection to use.</param>
|
|
/// <param name="transaction">The transaction to use.</param>
|
|
/// <param name="commandTimeout">The command timeout to use.</param>
|
|
/// <param name="tableName">The table to insert into.</param>
|
|
/// <param name="columnList">The columns to set with this insert.</param>
|
|
/// <param name="parameterList">The parameters to set for this insert.</param>
|
|
/// <param name="keyProperties">The key columns in this table.</param>
|
|
/// <param name="entityToInsert">The entity to insert.</param>
|
|
/// <returns>The Id of the row created.</returns>
|
|
public int Insert(IDbConnection connection, IDbTransaction transaction, int? commandTimeout, string tableName,
|
|
string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert)
|
|
{
|
|
string cmd = $"insert into `{tableName}` ({columnList}) values ({parameterList}); select @@ROWCOUNT num";
|
|
SqlMapper.GridReader multi = connection.QueryMultiple(cmd, entityToInsert, transaction, commandTimeout);
|
|
|
|
dynamic first = multi.Read().FirstOrDefault();
|
|
if (first == null || first.num == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int num = (int)first.num;
|
|
return num;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the name of a column.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnName(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("[{0}]", columnName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a column equality to a parameter.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnNameEqualsValue(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("[{0}] = @{1}", columnName, columnName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The MySQL database adapter.
|
|
/// </summary>
|
|
public partial class MySqlAdapter : ISqlAdapter
|
|
{
|
|
/// <summary>
|
|
/// Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
|
|
/// 2020-11-09 影响行数改为Select ROW_COUNT()
|
|
/// </summary>
|
|
/// <param name="connection">The connection to use.</param>
|
|
/// <param name="transaction">The transaction to use.</param>
|
|
/// <param name="commandTimeout">The command timeout to use.</param>
|
|
/// <param name="tableName">The table to insert into.</param>
|
|
/// <param name="columnList">The columns to set with this insert.</param>
|
|
/// <param name="parameterList">The parameters to set for this insert.</param>
|
|
/// <param name="keyProperties">The key columns in this table.</param>
|
|
/// <param name="entityToInsert">The entity to insert.</param>
|
|
/// <returns>The Id of the row created.</returns>
|
|
public int Insert(IDbConnection connection, IDbTransaction transaction, int? commandTimeout, string tableName,
|
|
string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert)
|
|
{
|
|
string cmd = $"insert into `{tableName}` ({columnList}) values ({parameterList}); select ROW_COUNT() num";
|
|
SqlMapper.GridReader multi = connection.QueryMultiple(cmd, entityToInsert, transaction, commandTimeout);
|
|
|
|
dynamic first = multi.Read().FirstOrDefault();
|
|
if (first == null || first.num == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int num = (int)first.num;
|
|
return num;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the name of a column.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnName(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("`{0}`", columnName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a column equality to a parameter.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnNameEqualsValue(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("`{0}` = @{1}", columnName, columnName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The Postgres database adapter.
|
|
/// </summary>
|
|
public partial class PostgresAdapter : ISqlAdapter
|
|
{
|
|
/// <summary>
|
|
/// Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
|
|
/// </summary>
|
|
/// <param name="connection">The connection to use.</param>
|
|
/// <param name="transaction">The transaction to use.</param>
|
|
/// <param name="commandTimeout">The command timeout to use.</param>
|
|
/// <param name="tableName">The table to insert into.</param>
|
|
/// <param name="columnList">The columns to set with this insert.</param>
|
|
/// <param name="parameterList">The parameters to set for this insert.</param>
|
|
/// <param name="keyProperties">The key columns in this table.</param>
|
|
/// <param name="entityToInsert">The entity to insert.</param>
|
|
/// <returns>The Id of the row created.</returns>
|
|
public int Insert(IDbConnection connection, IDbTransaction transaction, int? commandTimeout, string tableName,
|
|
string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendFormat("insert into {0} ({1}) values ({2})", tableName, columnList, parameterList);
|
|
|
|
// If no primary key then safe to assume a join table with not too much data to return
|
|
PropertyInfo[] propertyInfos = keyProperties as PropertyInfo[] ?? keyProperties.ToArray();
|
|
if (propertyInfos.Length == 0)
|
|
{
|
|
sb.Append(" RETURNING *");
|
|
}
|
|
else
|
|
{
|
|
sb.Append(" RETURNING ");
|
|
bool first = true;
|
|
foreach (PropertyInfo property in propertyInfos)
|
|
{
|
|
if (!first)
|
|
{
|
|
sb.Append(", ");
|
|
}
|
|
|
|
first = false;
|
|
sb.Append(property.Name);
|
|
}
|
|
}
|
|
|
|
List<dynamic> results = connection.Query(sb.ToString(), entityToInsert, transaction, commandTimeout: commandTimeout)
|
|
.ToList();
|
|
|
|
// Return the key by assinging the corresponding property in the object - by product is that it supports compound primary keys
|
|
int id = 0;
|
|
foreach (PropertyInfo p in propertyInfos)
|
|
{
|
|
object value = ((IDictionary<string, object>)results[0])[p.Name.ToLower()];
|
|
p.SetValue(entityToInsert, value, null);
|
|
if (id == 0)
|
|
{
|
|
id = Convert.ToInt32(value);
|
|
}
|
|
}
|
|
|
|
return id;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the name of a column.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnName(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("\"{0}\"", columnName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a column equality to a parameter.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnNameEqualsValue(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("\"{0}\" = @{1}", columnName, columnName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The SQLite database adapter.
|
|
/// </summary>
|
|
public partial class SQLiteAdapter : ISqlAdapter
|
|
{
|
|
/// <summary>
|
|
/// Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
|
|
/// </summary>
|
|
/// <param name="connection">The connection to use.</param>
|
|
/// <param name="transaction">The transaction to use.</param>
|
|
/// <param name="commandTimeout">The command timeout to use.</param>
|
|
/// <param name="tableName">The table to insert into.</param>
|
|
/// <param name="columnList">The columns to set with this insert.</param>
|
|
/// <param name="parameterList">The parameters to set for this insert.</param>
|
|
/// <param name="keyProperties">The key columns in this table.</param>
|
|
/// <param name="entityToInsert">The entity to insert.</param>
|
|
/// <returns>The Id of the row created.</returns>
|
|
public int Insert(IDbConnection connection, IDbTransaction transaction, int? commandTimeout, string tableName,
|
|
string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert)
|
|
{
|
|
string cmd = $"INSERT INTO `{tableName}` ({columnList}) VALUES ({parameterList}); SELECT last_insert_rowid() id";
|
|
SqlMapper.GridReader multi = connection.QueryMultiple(cmd, entityToInsert, transaction, commandTimeout);
|
|
|
|
int id = (int)multi.Read().First().id;
|
|
PropertyInfo[] propertyInfos = keyProperties as PropertyInfo[] ?? keyProperties.ToArray();
|
|
if (propertyInfos.Length == 0)
|
|
{
|
|
return id;
|
|
}
|
|
|
|
PropertyInfo idProperty = propertyInfos[0];
|
|
idProperty.SetValue(entityToInsert, Convert.ChangeType(id, idProperty.PropertyType), null);
|
|
|
|
return id;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the name of a column.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnName(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("\"{0}\"", columnName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a column equality to a parameter.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnNameEqualsValue(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("\"{0}\" = @{1}", columnName, columnName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The Firebase SQL adapeter.
|
|
/// </summary>
|
|
public partial class FbAdapter : ISqlAdapter
|
|
{
|
|
/// <summary>
|
|
/// Inserts <paramref name="entityToInsert" /> into the database, returning the Id of the row created.
|
|
/// </summary>
|
|
/// <param name="connection">The connection to use.</param>
|
|
/// <param name="transaction">The transaction to use.</param>
|
|
/// <param name="commandTimeout">The command timeout to use.</param>
|
|
/// <param name="tableName">The table to insert into.</param>
|
|
/// <param name="columnList">The columns to set with this insert.</param>
|
|
/// <param name="parameterList">The parameters to set for this insert.</param>
|
|
/// <param name="keyProperties">The key columns in this table.</param>
|
|
/// <param name="entityToInsert">The entity to insert.</param>
|
|
/// <returns>The Id of the row created.</returns>
|
|
public int Insert(IDbConnection connection, IDbTransaction transaction, int? commandTimeout, string tableName,
|
|
string columnList, string parameterList, IEnumerable<PropertyInfo> keyProperties, object entityToInsert)
|
|
{
|
|
string cmd = $"insert into `{tableName}` ({columnList}) values ({parameterList})";
|
|
connection.Execute(cmd, entityToInsert, transaction, commandTimeout);
|
|
|
|
PropertyInfo[] propertyInfos = keyProperties as PropertyInfo[] ?? keyProperties.ToArray();
|
|
string keyName = propertyInfos[0].Name;
|
|
IEnumerable<dynamic> r = connection.Query($"SELECT FIRST 1 {keyName} ID FROM `{tableName}` ORDER BY {keyName} DESC",
|
|
transaction: transaction, commandTimeout: commandTimeout);
|
|
|
|
dynamic id = r.First().ID;
|
|
if (id == null)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (propertyInfos.Length == 0)
|
|
{
|
|
return Convert.ToInt32(id);
|
|
}
|
|
|
|
PropertyInfo idp = propertyInfos[0];
|
|
idp.SetValue(entityToInsert, Convert.ChangeType(id, idp.PropertyType), null);
|
|
|
|
return Convert.ToInt32(id);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds the name of a column.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnName(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("{0}", columnName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a column equality to a parameter.
|
|
/// </summary>
|
|
/// <param name="sb">The string builder to append to.</param>
|
|
/// <param name="columnName">The column name.</param>
|
|
public void AppendColumnNameEqualsValue(StringBuilder sb, string columnName)
|
|
{
|
|
sb.AppendFormat("{0} = @{1}", columnName, columnName);
|
|
}
|
|
}
|