private void CommitData <TEntity>(InternalDbSet <TEntity> dbSet, TEntity rowInstance, bool forceCommit) where TEntity : class
{
if (dbSet == null)
{
return;
}
if (rowInstance != null)
{
_rowList.Add(rowInstance);
}
if (_rowList.Count > 0 && (forceCommit || _rowList.Count % 5000 == 0)) //Commit all 500 row
{
count += _rowList.Count;
_logger.LogInformation("Count : " + count);
List <TEntity> list = new List <TEntity>();
foreach (TEntity row in _rowList)
{
if (row != null)
{
list.Add(row);
}
}
_rowList.Clear();
if (list.Count > 0)
{
dbSet.AddRange(list);
_dbContext.SaveChanges();
}
}
}
public void With_valid_entity_returns_the_added_entity()
{
var set = new InternalDbSet <FakeEntity>(new Mock <InternalSetForMock <FakeEntity> >().Object);
var entity = new FakeEntity();
var retVal = set.Remove(entity);
Assert.Same(entity, retVal);
}
public void With_valid_entity_returns_the_added_entity()
{
var set = new InternalDbSet<FakeEntity>(new Mock<InternalSetForMock<FakeEntity>>().Object);
var entity = new FakeEntity();
var retVal = set.Add(entity);
Assert.Same(entity, retVal);
}
public void With_valid_arguments_doesnt_throw()
{
var set = new InternalDbSet <FakeEntity>(new Mock <InternalSetForMock <FakeEntity> >().Object);
var query = set.SqlQuery("query");
Assert.NotNull(query);
Assert.False(query.InternalQuery.Streaming);
}
public void Throw_if_collection_is_null()
{
var internalContext = new Mock <InternalContext>();
var internalSet = new Mock <InternalSetForMock <FakeEntity> >();
internalSet.Setup(i => i.InternalContext).Returns(internalContext.Object);
var set = new InternalDbSet <FakeEntity>(internalSet.Object);
Assert.Equal(
new ArgumentNullException("entities").Message,
Assert.Throws <ArgumentNullException>(() => set.RemoveRange(null)).Message);
}
public void With_same_type_returns_generic_DbSet()
{
var internalContextMock = new Mock <InternalContextForMock>
{
CallBase = true
};
var internalSetMock = new Mock <InternalSet <FakeEntity> >(internalContextMock.Object);
internalSetMock.Setup(m => m.InternalContext).Returns(internalContextMock.Object);
var set = new InternalDbSet <FakeEntity>(internalSetMock.Object);
Assert.IsType <DbSet <FakeEntity> >(set.Cast <FakeEntity>());
}
public void With_derived_type_returns_non_null_object()
{
var internalContextMock = new Mock <InternalContextForMock>
{
CallBase = true
};
internalContextMock.Setup(m => m.CreateObject <FakeDerivedEntity>()).Returns(new FakeDerivedEntity());
var internalSetMock = new Mock <InternalSet <FakeEntity> >(internalContextMock.Object);
internalSetMock.Setup(m => m.InternalContext).Returns(internalContextMock.Object);
var set = new InternalDbSet <FakeEntity>(internalSetMock.Object);
Assert.IsType <FakeDerivedEntity>(set.Create(typeof(FakeDerivedEntity)));
}
public void With_valid_entities_returns_the_removed_entities()
{
var internalContext = new Mock <InternalContext>();
var internalSet = new Mock <InternalSetForMock <FakeEntity> >();
internalSet.Setup(i => i.InternalContext).Returns(internalContext.Object);
var set = new InternalDbSet <FakeEntity>(internalSet.Object);
var entity1 = new FakeEntity();
var entity2 = new FakeEntity();
var retVal = (IEnumerable <FakeEntity>)set
.RemoveRange(new[] { entity1, entity2 });
Assert.True(retVal.Contains(entity1));
Assert.True(retVal.Contains(entity2));
}
public override IReadOnlyList <DbGeneratedColumn> GetDbGeneratedColumns()
{
SchemaContext schemaContext = base.SchemaContextPool.Rent();
try
{
var dbGeneratedColumns = new List <DbGeneratedColumn>();
var dbSet = new InternalDbSet <MySqlModelCustomizer.MySqlDbGeneratedColumn>(schemaContext);
foreach (MySqlModelCustomizer.MySqlDbGeneratedColumn column in
dbSet.FromSqlRaw("SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, EXTRA FROM INFORMATION_SCHEMA.COLUMNS WHERE EXTRA <> ''"))
{
var dbGeneratedColumn = new DbGeneratedColumn()
{
ColumnName = column.ColumnName,
TableName = column.TableName,
TableSchema = column.TableSchema
};
if (column.Extra == "auto_increment")
{
dbGeneratedColumn.IsIdentity = true;
}
else
{
dbGeneratedColumn.IsComputed = true;
}
dbGeneratedColumns.Add(dbGeneratedColumn);
}
return(dbGeneratedColumns);
}
finally
{
base.SchemaContextPool.Return(schemaContext);
}
}
private TEntity ImportDataInDbSet <TEntity>(InternalDbSet <TEntity> dbSet, string fieldValues, List <PropertyInfo> propertyInfoList) where TEntity : class
{
if (dbSet == null || propertyInfoList == null)
{
return(null);
}
string[] fieldValuesSplit = fieldValues.Split(_fieldSeparator);
if (fieldValuesSplit == null || fieldValuesSplit.Length == 0)
{
return(null);
}
if (!_insertOnly)
{
var entityType = _dbContext.Model.FindEntityType(typeof(TEntity));
var keys = entityType.GetKeys();
object convertedValue;
string fieldValue;
var entityParameter = Expression.Parameter(typeof(TEntity), "e");
Expression expression;
PropertyInfo propertyInfo;
List <Expression> expressionList = new List <Expression>();
foreach (var key in keys)
{
foreach (var keyProperty in key.Properties)
{
for (int i = 0; i < propertyInfoList.Count; i++)
{
fieldValue = fieldValuesSplit[i];
propertyInfo = propertyInfoList[i];
if (propertyInfo == null)
{
continue;
}
convertedValue = ConvertField(propertyInfo, fieldValue);
if (propertyInfo.Name == keyProperty.Name)
{
if (propertyInfo.PropertyType != typeof(string))
{
expressionList.Add(Expression.Equal(
Expression.Property(entityParameter, propertyInfo),
Expression.Constant(convertedValue)
));
}
else
{
MemberExpression m = Expression.MakeMemberAccess(entityParameter, propertyInfo);
ConstantExpression c = Expression.Constant(convertedValue, typeof(string));
MethodInfo mi = typeof(string).GetMethod("Equals", new Type[] { typeof(string), typeof(StringComparison) });
Expression expressionTmp = Expression.Call(m, mi, c, Expression.Constant(StringComparison.OrdinalIgnoreCase));
expressionList.Add(Expression.Equal(expressionTmp, Expression.Constant(true)));
}
}
}
}
}
expression = StackExpression(expressionList);
var lambda = Expression.Lambda(expression, entityParameter) as Expression <Func <TEntity, bool> >;
var row = dbSet.Where(lambda).FirstOrDefault();
if (row == null)
{
row = (TEntity)Activator.CreateInstance(typeof(TEntity));
ManageRow(row, fieldValuesSplit, propertyInfoList);
return(row);
}
else
{
ManageRow(row, fieldValuesSplit, propertyInfoList);
}
}
else
{
var row = (TEntity)Activator.CreateInstance(typeof(TEntity));
ManageRow(row, fieldValuesSplit, propertyInfoList);
return(row);
}
return(null);
}
public void With_derived_type_returns_non_null_object()
{
var internalContextMock = new Mock<InternalContextForMock>
{
CallBase = true
};
internalContextMock.Setup(m => m.CreateObject<FakeDerivedEntity>()).Returns(new FakeDerivedEntity());
var internalSetMock = new Mock<InternalSet<FakeEntity>>(internalContextMock.Object);
internalSetMock.Setup(m => m.InternalContext).Returns(internalContextMock.Object);
var set = new InternalDbSet<FakeEntity>(internalSetMock.Object);
Assert.IsType<FakeDerivedEntity>(set.Create(typeof(FakeDerivedEntity)));
}
public void With_same_type_returns_generic_DbSet()
{
var internalContextMock = new Mock<InternalContextForMock>
{
CallBase = true
};
var internalSetMock = new Mock<InternalSet<FakeEntity>>(internalContextMock.Object);
internalSetMock.Setup(m => m.InternalContext).Returns(internalContextMock.Object);
var set = new InternalDbSet<FakeEntity>(internalSetMock.Object);
Assert.IsType<DbSet<FakeEntity>>(set.Cast<FakeEntity>());
}
public void Passing_null_parameters_to_non_generic_entity_query_method_throws()
{
var set = new InternalDbSet<FakeEntity>(new Mock<InternalSetForMock<FakeEntity>>().Object);
Assert.Equal("parameters", Assert.Throws<ArgumentNullException>(() => set.SqlQuery("query", null)).ParamName);
}
public IQueryable FromSql(Object dataContext, String sql, Object?[] parameters)
{
var dbSet = new InternalDbSet <TEntity>((T)dataContext);
return(dbSet.FromSqlRaw(sql, parameters));
}
public void With_null_parameters_throws()
{
var set = new InternalDbSet <FakeEntity>(new Mock <InternalSetForMock <FakeEntity> >().Object);
Assert.Equal("parameters", Assert.Throws <ArgumentNullException>(() => set.SqlQuery("query", null)).ParamName);
}
public void With_null_SQL_string_throws()
{
var set = new InternalDbSet<FakeEntity>(new Mock<InternalSetForMock<FakeEntity>>().Object);
Assert.Equal(Strings.ArgumentIsNullOrWhitespace("sql"), Assert.Throws<ArgumentException>(() => set.SqlQuery(null)).Message);
}
public void With_valid_arguments_doesnt_throw()
{
var set = new InternalDbSet<FakeEntity>(new Mock<InternalSetForMock<FakeEntity>>().Object);
Assert.NotNull(set.SqlQuery("query"));
}
public void With_null_SQL_string_throws()
{
var set = new InternalDbSet <FakeEntity>(new Mock <InternalSetForMock <FakeEntity> >().Object);
Assert.Equal(Strings.ArgumentIsNullOrWhitespace("sql"), Assert.Throws <ArgumentException>(() => set.SqlQuery(null)).Message);
}
private void ExportDataDbSet <TEntity>(string tableName, InternalDbSet <TEntity> dbSet) where TEntity : class
{
try
{
if (dbSet == null)
{
return;
}
TypeInfo typeInfo;
object value;
using (FileStream fs = new FileStream(Path.Combine(_exportPath, _fileName), FileMode.Append, FileAccess.Write))
{
using (StreamWriter sr = new StreamWriter(fs, Encoding.UTF8))
{
Type tableType = typeof(TEntity);
sr.Write(_tableSeparator);
sr.Write(tableName); //table name
sr.WriteLine();
var fieldProperties = tableType.GetProperties(BindingFlags.Instance | BindingFlags.Public);
if (fieldProperties != null)
{
sr.Write(_headerTableBeginner);
foreach (var fieldProperty in fieldProperties)
{
typeInfo = fieldProperty.PropertyType.GetTypeInfo();
if (typeInfo.IsPrimitive || typeInfo.IsValueType || fieldProperty.PropertyType == typeof(string))
{
sr.Write(fieldProperty.Name);
sr.Write(_fieldSeparator);
}
}
sr.WriteLine();
foreach (TEntity entity in dbSet)
{
if (entity == null)
{
continue;
}
sr.Write(_headerfieldBeginner);
foreach (var fieldProperty in fieldProperties)
{
typeInfo = fieldProperty.PropertyType.GetTypeInfo();
if (typeInfo.IsPrimitive || typeInfo.IsValueType || fieldProperty.PropertyType == typeof(string))
{
value = fieldProperty.GetValue(entity);
sr.Write(value);
sr.Write(_fieldSeparator);
}
}
sr.WriteLine();
}
}
}
}
}
catch (Exception except)
{
_logger.LogError("ExportDataTable failed", except);
}
}
public void Non_Generic_DbSet_Remove_returns_the_added_entity()
{
var set = new InternalDbSet<FakeEntity>(new Mock<InternalSetForMock<FakeEntity>>().Object);
var entity = new FakeEntity();
var retVal = set.Remove(entity);
Assert.Same(entity, retVal);
}
public void Passing_whitespace_SQL_string_to_non_generic_entity_query_method_throws()
{
var set = new InternalDbSet<FakeEntity>(new Mock<InternalSetForMock<FakeEntity>>().Object);
Assert.Equal(Strings.ArgumentIsNullOrWhitespace("sql"), Assert.Throws<ArgumentException>(() => set.SqlQuery(" ")).Message);
}
// --------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Construct a new DbSetXT object.
/// </summary>
/// <param name="context">The DbContext this DbSet is associated with.</param>
/// <param name="services">The CoreXT service provider that the underlying DbContext is associated with.</param>
public DbSetXT(DbContext context, ICoreXTServiceProvider services)
{
DbContext = context ?? throw new ArgumentNullException(nameof(context));
_DbSet = new InternalDbSet <TEntity>(DbContext);
Services = services;
}
public void With_valid_arguments_doesnt_throw()
{
var set = new InternalDbSet <FakeEntity>(new Mock <InternalSetForMock <FakeEntity> >().Object);
Assert.NotNull(set.SqlQuery("query"));
}
