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")); }