/// <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="entitiesToUpsert">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 async static Task <int> UpsertBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToUpsert,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null
) where T : class
{
var typeMeta = TypeMeta.Get <T>();
return(await connection.MergeBulkAsync <T>(
entitiesToUpsert,
transaction,
commandTimeout,
sqlBulkCopy : sqlBulkCopy,
matched =>
{
matched.Action = MergeAction.Update;
matched.Condition = typeMeta.PropertiesExceptKeyAndComputed.ColumnListDifferenceCheck();
},
notMatchedByTarget =>
{
notMatchedByTarget.Action = MergeAction.Insert;
}
));
}
static AssetObject LoadObject(EndianStream es, int format, TypeMeta types)
{
var obj = new AssetObject();
obj.PathId = es.ReadUInt64();
obj.DataOfs = es.ReadUInt32();
obj.Size = es.ReadUInt32();
if (format < 17)
{
obj.TypeId = es.ReadInt32();
obj.ClassId = es.ReadInt16();
}
else
{
obj.TypeId = es.ReadInt32();
obj.ClassId = types.ClassIds[obj.TypeId];
}
if (format <= 16)
{
es.ReadInt16();
}
if (format == 15 || format == 16)
{
es.ReadByte();
}
return(obj);
}
public void Insert <T>(T item)
{
if (ConnectionData == null)
{
return;
}
try
{
using (var command = DbConnection.CreateCommand())
{
var meta = new TypeMeta(typeof(T));
var properties = meta.Properties.Where(p => p.HasGetter).ToList();
foreach (var property in properties)
{
var parameterName = string.Format("@{0}", property.Name);
var value = property.GetValue(item) ?? DBNull.Value;
command.Parameters.Add(new SqlParameter(parameterName, value));
}
var insert = new StringBuilder("insert into ").AppendFormat(meta.Type.Name)
.AppendFormat(" ({0})", string.Join(", ", properties.Select(p => p.Name)))
.Append(" values ")
.AppendFormat(" ({0})", string.Join(", ", command.Parameters.Cast <SqlParameter>().Select(p => p.ParameterName)));
command.CommandText = insert.ToString();
DbConnection.Open();
command.ExecuteNonQuery();
}
}
finally
{
DbConnection.Close();
}
}
private static string NicifyNamespaceQualifiedInstallerTitle(Type installerType)
{
return(TypeMeta.NicifyNamespaceQualifiedName(
installerType.Namespace,
NicifyInstallerTitle(installerType)
));
}
/// <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="entitiesToInsert">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 async static Task <int> InsertBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToInsert,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null
) where T : class
{
var meta = TypeMeta.Get <T>();
var wasClosed = connection.State == ConnectionState.Closed;
if (wasClosed)
{
connection.Open();
}
var insertedTableName = await connection.TransferBulkAsync(entitiesToInsert, transaction : transaction, sqlBulkCopy : sqlBulkCopy);
var columnList = meta.PropertiesExceptKeyAndComputed.ColumnList();
var query = $@"
INSERT INTO {meta.TableName} ({columnList})
SELECT {columnList} FROM {insertedTableName};
" ;
var inserted = await connection.ExecuteAsync(query, commandTimeout, transaction);
if (wasClosed)
{
connection.Close();
}
return(inserted);
}
/// <summary>
/// Gets an array of all the instantiatable <see cref="IElementAdderMenuCommand{TContext}"/>
/// implementations that are annotated with <see cref="ElementAdderMenuCommandAttribute"/>.
private static IEnumerable <Type> GetAnnotatedCommandTypes <TContext>()
{
return
(from type in TypeMeta.DiscoverImplementations <IElementAdderMenuCommand <TContext> >()
where type.IsClass && type.IsDefined(typeof(ElementAdderMenuCommandAttribute), false)
select type);
}
TreeNode CreateTreeNode(TypeMeta tm)
{
var children = tm.Properties.Select(p =>
new TreeNode(p.Name, new[]
{
new TreeNode("Type:" + p.BaseType.ToString())
{
Tag = p.BaseType
},
new TreeNode("IsOptional:" + p.IsOptional.ToString())
{
Tag = p.IsOptional
}
})
{
Tag = p
})
.ToArray();
var tn = new TreeNode(tm.Name, children)
{
Tag = tm
};
return(tn);
}
/// <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="entitiesToDelete">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 async static Task <int> DeleteBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToDelete,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null
) where T : class
{
var entityCount = entitiesToDelete.Count();
if (entityCount == 0)
{
return(0);
}
if (entityCount == 1)
{
return(await connection.DeleteAsync(entitiesToDelete.First(), transaction : transaction, commandTimeout : commandTimeout) ? 1 : 0);
}
var typeMeta = TypeMeta.Get <T>();
if (typeMeta.PropertiesKey.Count == 0 && typeMeta.PropertiesExplicit.Count == 0)
{
throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
}
var wasClosed = connection.State == ConnectionState.Closed;
if (wasClosed)
{
connection.Open();
}
var insertedTableName = await connection.TransferBulkAsync(
entitiesToDelete,
typeMeta.TableName,
typeMeta.PropertiesKeyAndExplicit,
transaction : transaction,
sqlBulkCopy : sqlBulkCopy
);
var query = $@"
DELETE Target
FROM
{ insertedTableName } AS Source
INNER JOIN { typeMeta.TableName } AS Target
ON { typeMeta.PropertiesKeyAndExplicit.ColumnListEquals(" AND ") };
" ;
var deleted = await connection.ExecuteAsync(query, commandTimeout : commandTimeout, transaction : transaction);
if (wasClosed)
{
connection.Close();
}
return(deleted);
}
private string FormatTypeDisplayName(Type type)
{
var formatter = this.TypeDisplayNameFormatter;
return(formatter != null
? formatter.Invoke(type)
: TypeMeta.NicifyName(type.Name));
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceDescriptor"/> class.
/// </summary>
/// <param name="serviceType">The type representing the service.</param>
public ServiceDescriptor(Type serviceType)
{
this.ServiceType = serviceType;
this.dependencies = ForDependenciesOf(serviceType).ToArray();
this.Title = TypeMeta.NicifyCompoundName(this.ServiceType.Name, unwantedSuffix: "_Service");
this.TitleWithNamespace = TypeMeta.NicifyNamespaceQualifiedName(this.ServiceType.Namespace, this.Title);
}
public ProxyTypeDescriptor(Type type)
{
Meta = TypeMeta.Get(type);
ProxyType = typeof(PlatformProxy <>).MakeGenericType(type);
_properties = Meta.Members.Select(m => new ProxyPropertyDescriptor(this, m)).ToArray();
_propertyCollection = new PropertyDescriptorCollection(_properties);
_events = new EventDescriptorCollection(type.GetEvents().Select(e => new ProxyEventDescriptor(e)).ToArray());
}
public MergeActionOptions <T> Insert()
{
var typeMeta = TypeMeta.Get <T>();
Action = MergeAction.Insert;
ColumnsByPropertyInfo(typeMeta.PropertiesExceptKeyAndComputed);
return(this);
}
/// <summary>
/// Merges 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="entitiesToMerge">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 async static Task <int> MergeBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToMerge,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null,
Action <MergeKeyOptions> key = null,
Action <MergeActionOptions <T> > matched = null,
Action <MergeActionOptions <T> > notMatchedByTarget = null,
Action <MergeActionOptions <T> > notMatchedBySource = null
) where T : class
{
if (entitiesToMerge == null)
{
throw new ArgumentNullException(nameof(entitiesToMerge));
}
var entityCount = entitiesToMerge.Count();
if (entityCount == 0)
{
return(0);
}
var typeMeta = TypeMeta.Get <T>();
if (typeMeta.PropertiesKey.Count == 0 && typeMeta.PropertiesExplicit.Count == 0)
{
throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
}
var result = await connection.Execute(
entitiesToMerge,
typeMeta.PropertiesExceptComputed,
async (connection, transaction, source, parameters, properties) =>
{
var sb = new StringBuilder($@"
MERGE INTO {typeMeta.TableName} AS Target
USING {source} AS Source
ON ({OnColumns(typeMeta, keyAction: key).ColumnListEquals(" AND ")})"
);
sb.AppendLine();
MergeMatchResult.Matched.Format(typeMeta, matched, sb);
MergeMatchResult.NotMatchedBySource.Format(typeMeta, notMatchedBySource, sb);
MergeMatchResult.NotMatchedByTarget.Format(typeMeta, notMatchedByTarget, sb);
//MergeOutputFormat(typeMeta.PropertiesKey.Union(typeMeta.PropertiesComputed).ToList(), sb);
sb.Append(";");
return(await connection.ExecuteAsync(sb.ToString(), param: parameters, commandTimeout: commandTimeout, transaction: transaction));
},
transaction : transaction
);
return(result.Sum());
}
public MergeActionOptions <T> Update()
{
var typeMeta = TypeMeta.Get <T>();
Action = MergeAction.Update;
ColumnsByPropertyInfo(typeMeta.PropertiesExceptKeyAndComputed);
CheckConditionOnColumns();
return(this);
}
/// <summary>
/// Merges 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="entitiesToMerge">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 async static Task <int> MergeBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToMerge,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null,
Action <MergeActionOptions> matched = null,
Action <MergeActionOptions> notMatchedByTarget = null,
Action <MergeActionOptions> notMatchedBySource = null
) where T : class
{
var typeMeta = TypeMeta.Get <T>();
if (typeMeta.PropertiesKey.Count == 0 && typeMeta.PropertiesExplicit.Count == 0)
{
throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
}
var wasClosed = connection.State == System.Data.ConnectionState.Closed;
if (wasClosed)
{
connection.Open();
}
var insertedTableName = await connection.TransferBulkAsync(
entitiesToMerge,
typeMeta.TableName,
typeMeta.Properties,
transaction : transaction,
sqlBulkCopy : sqlBulkCopy
);
var sb = new StringBuilder($@"
MERGE INTO {typeMeta.TableName} AS Target
USING {insertedTableName} AS Source
ON ({typeMeta.PropertiesKeyAndExplicit.ColumnListEquals(" AND ")})"
);
MergeMatchResult.Matched.Format(typeMeta, matched, sb);
MergeMatchResult.NotMatchedBySource.Format(typeMeta, notMatchedBySource, sb);
MergeMatchResult.NotMatchedByTarget.Format(typeMeta, notMatchedByTarget, sb);
sb.Append(";");
var merged = await connection.ExecuteAsync(sb.ToString(), commandTimeout : commandTimeout, transaction : transaction);
if (wasClosed)
{
connection.Close();
}
return(merged);
}
/// <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="entitiesToUpdate">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 async static Task <int> UpdateBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToUpdate,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null
) where T : class
{
entitiesToUpdate = entitiesToUpdate.Where(x => (x is SqlMapperExtensions.IProxy proxy && !proxy.IsDirty) || !(x is SqlMapperExtensions.IProxy));
var entityCount = entitiesToUpdate.Count();
if (entityCount == 0)
{
return(0);
}
if (entityCount == 1)
{
return(await connection.UpdateAsync(entitiesToUpdate.First(), transaction : transaction, commandTimeout : commandTimeout) ? 1 : 0);
}
var typeMeta = TypeMeta.Get <T>();
if (typeMeta.PropertiesKey.Count == 0 && typeMeta.PropertiesExplicit.Count == 0)
{
throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
}
var result = await connection.Execute(
entitiesToUpdate,
typeMeta.PropertiesExceptComputed,
async (connection, transaction, source, parameters, properties) =>
{
var query = $@"
UPDATE Target
SET
{ typeMeta.PropertiesExceptKeyAndComputed.ColumnListEquals(", ") }
FROM
{ source } AS Source
INNER JOIN { typeMeta.TableName } AS Target
ON { typeMeta.PropertiesKeyAndExplicit.ColumnListEquals(" AND ") };
" ;
return(await connection.ExecuteAsync(query, param: parameters, commandTimeout: commandTimeout, transaction: transaction));
},
transaction : transaction
);
return(result.Sum());
}
/// <summary>
/// Discovers all of the available installer types for a given service.
/// </summary>
/// <param name="service">The service.</param>
/// <returns>
/// An array of zero-or-more non-abstract installer types.
/// </returns>
public static Type[] DiscoverInstallerTypes(IServiceDescriptor service)
{
if (s_ServiceInstallerTypes == null)
{
s_ServiceInstallerTypes = TypeMeta.DiscoverImplementations <ZenjectServiceInstaller>();
}
var genericInstallerType = typeof(ZenjectServiceInstaller <>).MakeGenericType(service.ServiceType);
return(s_ServiceInstallerTypes
.Where(installerType => genericInstallerType.IsAssignableFrom(installerType))
.Where(installerType => !installerType.IsAbstract && installerType.IsClass)
.ToArray());
}
public static ProxyXamlType Get(Type type)
{
var meta = TypeMeta.Get(type);
lock (_cache)
{
ProxyXamlType result;
if (!_cache.TryGetValue(type, out result))
{
_cache[type] = result = new ProxyXamlType(meta);
}
return(result);
}
}
/// <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="entitiesToUpdate">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 async static Task <bool> UpdateBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToUpdate,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null
) where T : class
{
entitiesToUpdate = entitiesToUpdate.Where(x => x is SqlMapperExtensions.IProxy proxy && !proxy.IsDirty);
if (!entitiesToUpdate.Any())
{
return(false);
}
var typeMeta = TypeMeta.Get <T>();
if (typeMeta.PropertiesKey.Count == 0 && typeMeta.PropertiesExplicit.Count == 0)
{
throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
}
var wasClosed = connection.State == ConnectionState.Closed;
if (wasClosed)
{
connection.Open();
}
var insertedTableName = await connection.TransferBulkAsync(entitiesToUpdate, transaction : transaction, sqlBulkCopy : sqlBulkCopy);
var query = $@"
UPDATE Target
SET
{ typeMeta.PropertiesExceptKeyAndComputed.ColumnListEquals(", ") }
FROM
{ insertedTableName } AS Source
INNER JOIN { typeMeta.TableName } AS Target
ON { typeMeta.PropertiesKeyAndExplicit.ColumnListEquals(" AND ") };
" ;
var updated = await connection.ExecuteAsync(query, commandTimeout : commandTimeout, transaction : transaction);
if (wasClosed)
{
connection.Close();
}
return(updated > 0);
}
public static IEnumerable <string> OnColumns(TypeMeta typeMeta, Action <MergeKeyOptions> keyAction = null)
{
var options = new MergeKeyOptions();
if (keyAction == null)
{
options.ColumnsByPropertyInfo(typeMeta.PropertiesKeyAndExplicit);
}
else
{
keyAction(options);
}
return(options.Columns);
}
public static Type Build(TypeMeta meta)
{
TypeBuilder builder = moduleBuilder.DefineType(meta.TypeName, TypeAttributes.Public);
CustomAttributeBuilder tableAttributeBuilder = new CustomAttributeBuilder(typeof(TableAttribute).GetConstructor(new Type[1] {
typeof(string)
}), new object[] { "RuntimeModel_" + meta.TypeName });
builder.SetParent(meta.BaseType);
builder.SetCustomAttribute(tableAttributeBuilder);
foreach (var item in meta.PropertyMetas)
{
AddProperty(item, builder, meta.BaseType);
}
return(builder.CreateTypeInfo().UnderlyingSystemType);
}
public async static Task <IEnumerable <T> > GetBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToGet,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null
)
{
var typeMeta = TypeMeta.Get <T>();
if (typeMeta.PropertiesKey.Count == 0 && typeMeta.PropertiesExplicit.Count == 0)
{
throw new ArgumentException("Entity must have at least one [Key] or [ExplicitKey] property");
}
var wasClosed = connection.State == ConnectionState.Closed;
if (wasClosed)
{
connection.Open();
}
var insertedTableName = await connection.TransferBulkAsync(
entitiesToGet,
typeMeta.TableName,
typeMeta.PropertiesKeyAndExplicit,
transaction : transaction,
sqlBulkCopy : sqlBulkCopy
);
var query = $@"
SELECT *
FROM
{ insertedTableName } AS Source
INNER JOIN { typeMeta.TableName } AS Target
ON { typeMeta.PropertiesKeyAndExplicit.ColumnListEquals(" AND ") };
" ;
var enities = await connection.QueryAsync <T>(query, commandTimeout : commandTimeout, transaction : transaction);
if (wasClosed)
{
connection.Close();
}
return(enities);
}
public static async Task <string> TransferBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToInsert,
SqlTransaction transaction = null,
Action <SqlBulkCopy> sqlBulkCopy = null
)
{
var meta = TypeMeta.Get <T>();
return(await connection.TransferBulkAsync(
entitiesToInsert,
meta.TableName,
meta.Properties,
transaction : transaction,
sqlBulkCopy : sqlBulkCopy
));
}
/// <summary>
/// Populates a menu with concrete element types.
/// </summary>
/// <param name="menu">Editor menu.</param>
/// <exception cref="System.ArgumentNullException">
/// If <paramref name="menu"/> is <c>null</c>.
/// </exception>
public void PopulateWithConcreteTypes(EditorMenu menu)
{
ExceptionUtility.CheckArgumentNotNull(menu, "menu");
menu.AddSeparator();
foreach (var concreteType in ApplyTypeFilter(TypeMeta.DiscoverImplementations(this.ElementContractType)))
{
menu.AddCommand(this.FormatTypeDisplayName(concreteType))
.Enabled(this.ElementAdder != null && this.ElementAdder.CanAddElement(concreteType))
.Action(() => {
if (this.ElementAdder.CanAddElement(concreteType))
{
this.ElementAdder.AddElement(concreteType);
}
});
}
}
private static void Format(this MergeMatchResult result, TypeMeta typeMeta, Action <MergeActionOptions> optionsAction, StringBuilder sb)
{
if (optionsAction == null)
{
return;
}
var options = new MergeActionOptions();
optionsAction(options);
if (options.Action == MergeAction.None)
{
return;
}
if (options.Columns == null)
{
options.Columns = typeMeta.PropertiesExceptKeyAndComputed;
}
switch (result)
{
case MergeMatchResult.Matched:
sb.Append("WHEN MATCHED");
break;
case MergeMatchResult.NotMatchedBySource:
sb.AppendLine("WHEN NOT MATCHED BY SOURCE");
break;
case MergeMatchResult.NotMatchedByTarget:
sb.AppendLine("WHEN NOT MATCHED BY TARGET");
break;
}
if (!string.IsNullOrEmpty(options.Condition))
{
sb.AppendFormat(" AND ({0})", options.Condition);
}
sb.AppendLine(" THEN");
MergeActionFormat(options, sb);
}
protected virtual void AddEntry(SerializedProperty entries, int index, TypeMeta typeMeta)
{
if (index < 0 || index > entries.arraySize)
{
return;
}
entries.serializedObject.Update();
entries.InsertArrayElementAtIndex(index);
SerializedProperty entryProperty = entries.GetArrayElementAtIndex(index);
entryProperty.FindPropertyRelative("TypeName").stringValue = typeMeta.Type.FullName;
entryProperty.FindPropertyRelative("PropertyName").stringValue = typeMeta.Members[0];
entryProperty.FindPropertyRelative("Key").stringValue = "";
entryProperty.FindPropertyRelative("Mode").enumValueIndex = (int)BindingMode.OneWay;
entries.serializedObject.ApplyModifiedProperties();
GUI.FocusControl(null);
}
/// <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="entitiesToInsert">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 async static Task <int> InsertBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToInsert,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null
) where T : class
{
var entityCount = entitiesToInsert.Count();
if (entityCount == 0)
{
return(0);
}
if (entityCount == 1)
{
return(await connection.InsertAsync(entitiesToInsert, transaction : transaction, commandTimeout : commandTimeout));
}
var typeMeta = TypeMeta.Get <T>();
var result = await connection.Execute(
entitiesToInsert,
typeMeta.PropertiesExceptKeyAndComputed,
async (connection, transaction, source, parameters, properties) =>
{
var columnList = properties.ColumnList();
var query = $@"
INSERT INTO {typeMeta.TableName} ({columnList})
SELECT {columnList} FROM {source} AS Source;
" ;
return(await connection.ExecuteAsync(query, param: parameters, commandTimeout: commandTimeout, transaction: transaction));
},
transaction : transaction
);
return(result.Sum());
}
private ITypeMap CreateMap(Type sourceType, Type targetType)
{
var target = new TypeMeta(targetType);
if (target.IsSimple)
{
return(new SimpleTypeMap(sourceType, targetType, this));
}
if (target.IsDictionary)
{
}
if (target.IsCollection)
{
return(new CollectionTypeMap(sourceType, targetType, this));
}
if (target.IsComplex)
{
return(new TypeMap(sourceType, targetType, this));
}
throw new Tantrum(string.Format("Don't know how to map {0}", targetType));
}
public override object Map(object source)
{
if (source == null)
{
return(null);
}
var target = TypeMeta.New(TargetType.Type);
foreach (var propertyMap in _propertyMaps)
{
try
{
propertyMap.Map(source, target);
}
catch (Exception ex)
{
throw new MappingException(string.Format("Could not map property {0}", propertyMap.FullName), ex);
}
}
return(target);
}
/// <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="entitiesToUpsert">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 async static Task <int> UpsertBulkAsync <T>(
this SqlConnection connection,
IEnumerable <T> entitiesToUpsert,
SqlTransaction transaction = null,
int?commandTimeout = null,
Action <SqlBulkCopy> sqlBulkCopy = null,
Action <MergeKeyOptions> key = null
) where T : class
{
var typeMeta = TypeMeta.Get <T>();
return(await connection.MergeBulkAsync <T>(
entitiesToUpsert,
transaction,
commandTimeout,
sqlBulkCopy : sqlBulkCopy,
key : key,
matched : options => options.Update(),
notMatchedByTarget : options => options.Insert()
));
}
public InstructionType(InstructionKindEnum aKind, int aIndex, TypeMeta aType)
: base(aKind, aIndex)
{
Type = aType;
}
