protected void AddColumns(params Expression <Func <TEntity, object> >[] members)
{
foreach (var member in members)
{
if (member.Body is NewExpression newExpression)
{
foreach (var arg in newExpression.Arguments)
{
ColumnMappings.Add(Expression.Lambda <Func <TEntity, object> >(
Expression.Convert(arg, typeof(object)),
member.Parameters));
}
;
}
else
{
var memberExpression = (member.Body is UnaryExpression unaryExpression)
? unaryExpression.Operand as MemberExpression
: member.Body as MemberExpression;
if (memberExpression == null)
{
throw new ArgumentException($"Invalid expression in parameter list: '{member}'", nameof(members));
}
ColumnMappings.Add(MakeColumnExpression <TEntity>(memberExpression.Member));
}
}
}
protected void AddDefaultColumnMappings <TOperationEntity>(
List <ColumnMapping <TOperationEntity> > mappings)
where TOperationEntity : class
{
var ignoredProperties = IgnoredColumns.Select(x => x.Name).ToList();
ignoredProperties.AddRange(mappings
.Where(x => !x.IsPrimaryKey)
.Select(x =>
{
var memberExpression = (x.SourceExpression.Body is UnaryExpression unaryExpression)
? unaryExpression.Operand as MemberExpression
: x.SourceExpression.Body as MemberExpression;
return(memberExpression?.Member.Name);
})
.Where(x => !string.IsNullOrEmpty(x)));
var columns = typeof(TEntity)
.GetProperties()
.Where(x => !ignoredProperties.Contains(x.Name))
.ToList();
if (KeyColumnMapping != null)
{
var keyExpression = (KeyColumnMapping.Body is UnaryExpression unaryExpression)
? unaryExpression.Operand as MemberExpression
: KeyColumnMapping.Body as MemberExpression;
columns.RemoveAll(x => x.Name == keyExpression.Member.Name);
}
ColumnMappings.AddRange(columns.Select(MakeColumnExpression <TEntity>));
}
internal void InitializeColumnMappings(Dictionary <string, ForeignKeyColumnInfo> fks)
{
foreach (KeyValuePair <string, ForeignKeyColumnInfo> kvp in fks)
{
string fkTableName = kvp.Value.ReferencedTableName;
if (string.IsNullOrEmpty(fkTableName))
{
continue;
}
if (ColumnMappings.ContainsKey(fkTableName))
{
continue;
}
Dictionary <string, Column> dicCols = GetColumnsFromTable(fkTableName, WizardForm.Connection);
List <ColumnValidation> myColValidations = ValidationsGrid.GetColumnValidationList(fkTableName, dicCols, null);
ColumnMappings.Add(fkTableName, myColValidations.ToDictionary(p => { return(p.Name); }));
}
}
public void Compile()
{
_columnProperties = ColumnMappings.ToDictionary(m => m.ColumnName, m => m.ColumnInfo, IsCaseSensitive? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);
CreateAccessors();
}
public BulkCopyDataReader(List <T> data) : base(data)
{
ColumnMappings.AddRange(_PropertyInfos.Select(i => new SqlBulkCopyColumnMapping(i.Name, i.Name)));
}
private void WriteToServer(ISqlCeBulkCopyInsertAdapter adapter)
{
CheckDestination();
if (_conn.State != ConnectionState.Open)
{
_conn.Open();
}
GetAndDropConstraints();
List <KeyValuePair <int, int> > map;
int totalRows = 0;
SqlCeTransaction localTrans = _trans ?? _conn.BeginTransaction();
if (ColumnMappings.Count > 0)
{
//mapping are set, and should be validated
map = ColumnMappings.ValidateCollection(_conn, localTrans, adapter, _keepNulls, _destination);
}
else
{
//create default column mappings
map = SqlCeBulkCopyColumnMappingCollection.Create(_conn, localTrans, adapter, _keepNulls, _destination);
}
using (var cmd = new SqlCeCommand(_destination, _conn, localTrans))
{
cmd.CommandType = CommandType.TableDirect;
using (var rs = cmd.ExecuteResultSet(ResultSetOptions.Updatable))
{
var idOrdinal = SqlCeBulkCopyTableHelpers.IdentityOrdinal(_conn, localTrans, _destination);
var rec = rs.CreateRecord();
var rowCounter = 0;
IdInsertOn(localTrans, idOrdinal);
//Converting to an array removed the perf issue of a list and foreach statement.
var cm = map.ToArray();
while (adapter.Read())
{
if (adapter.SkipRow())
{
continue;
}
for (var i = 0; i < cm.Length; i++)
{
//caching the values this way do not cause a perf issue.
var sourceIndex = cm[i].Key;
var destIndex = cm[i].Value;
// Let the destination assign identity values
if (!_keepIdentity && destIndex == idOrdinal)
{
continue;
}
//determine if we should ever allow this in the map.
if (sourceIndex < 0)
{
continue;
}
var value = sourceIndex > -1 ? adapter.Get(sourceIndex) : null;
if (value != null && value.GetType() != DbNullType)
{
rec.SetValue(destIndex, value);
}
else
{
//we can't write to an auto number column so continue
if (_keepNulls && destIndex == idOrdinal)
{
continue;
}
if (_keepNulls)
{
rec.SetValue(destIndex, DBNull.Value);
}
else
{
rec.SetDefault(destIndex);
}
}
}
rowCounter++;
totalRows++;
try
{
rs.Insert(rec);
}
catch (SqlCeException ex)
{
if (ex.NativeError == 25016 && _ignoreDuplicateErrors) //A duplicate value cannot be inserted into a unique index.
{
System.Diagnostics.Trace.TraceWarning("SqlCeBulkCopy: Duplicate value error was ignored");
continue;
}
else
{
throw;
}
}
// Fire event if needed
if (RowsCopied != null && _notifyAfter > 0 && rowCounter == _notifyAfter)
{
FireRowsCopiedEvent(totalRows);
rowCounter = 0;
}
}
IdInsertOff(localTrans, idOrdinal);
if (RowsCopied != null)
{
FireRowsCopiedEvent(totalRows);
}
}
}
//if we have our own transaction, we will commit it
if (_trans == null)
{
localTrans.Commit(CommitMode.Immediate);
localTrans.Dispose();
}
ResetSeed(totalRows);
RestoreConstraints();
}
