mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 4.0.0~alpha1

Browse Source 
Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9
This commit is contained in:
Jo Shields
2015-04-07 09:35:12 +01:00
parent 283343f570
commit 3c1f479b9d
22469 changed files with 2931443 additions and 869343 deletions
Download Patch File Download Diff File Expand all files Collapse all files

420
external/referencesource/System.Data.Linq/ChangeDirector.cs vendored Normal file
View File

@ -0,0 +1,420 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq.Expressions;
using System.Text;
using System.Reflection;
using System.Linq;
using System.Security.Permissions;
using System.Security;
namespace System.Data.Linq {
using System.Data.Linq.Mapping;
using System.Data.Linq.Provider;
using System.Diagnostics.CodeAnalysis;
/// <summary>
/// Controls how inserts, updates and deletes are performed.
/// </summary>
internal abstract class ChangeDirector {
internal abstract int Insert(TrackedObject item);
internal abstract int DynamicInsert(TrackedObject item);
internal abstract void AppendInsertText(TrackedObject item, StringBuilder appendTo);
internal abstract int Update(TrackedObject item);
internal abstract int DynamicUpdate(TrackedObject item);
internal abstract void AppendUpdateText(TrackedObject item, StringBuilder appendTo);
internal abstract int Delete(TrackedObject item);
internal abstract int DynamicDelete(TrackedObject item);
internal abstract void AppendDeleteText(TrackedObject item, StringBuilder appendTo);
internal abstract void RollbackAutoSync();
internal abstract void ClearAutoSyncRollback();
internal static ChangeDirector CreateChangeDirector(DataContext context) {
return new StandardChangeDirector(context);
}
/// <summary>
/// Implementation of ChangeDirector which calls user code if possible
/// and othewise falls back to creating SQL for 'INSERT', 'UPDATE' and 'DELETE'.
/// </summary>
internal class StandardChangeDirector : ChangeDirector {
private enum UpdateType { Insert, Update, Delete };
private enum AutoSyncBehavior { ApplyNewAutoSync, RollbackSavedValues }
DataContext context;
[SuppressMessage("Microsoft.MSInternal", "CA908:AvoidTypesThatRequireJitCompilationInPrecompiledAssemblies", Justification="[....]: FxCop bug Dev10:423110 -- List<KeyValuePair<object, object>> is not supposed to be flagged as a violation.")]
List<KeyValuePair<TrackedObject, object[]>> syncRollbackItems;
internal StandardChangeDirector(DataContext context) {
this.context = context;
}
[SuppressMessage("Microsoft.MSInternal", "CA908:AvoidTypesThatRequireJitCompilationInPrecompiledAssemblies", Justification="[....]: FxCop bug Dev10:423110 -- List<KeyValuePair<object, object>> is not supposed to be flagged as a violation.")]
private List<KeyValuePair<TrackedObject, object[]>> SyncRollbackItems {
get {
if (syncRollbackItems == null) {
syncRollbackItems = new List<KeyValuePair<TrackedObject, object[]>>();
}
return syncRollbackItems;
}
}
internal override int Insert(TrackedObject item) {
if (item.Type.Table.InsertMethod != null) {
try {
item.Type.Table.InsertMethod.Invoke(this.context, new object[] { item.Current });
}
catch (TargetInvocationException tie) {
if (tie.InnerException != null) {
throw tie.InnerException;
}
throw;
}
return 1;
}
else {
return DynamicInsert(item);
}
}
internal override int DynamicInsert(TrackedObject item) {
Expression cmd = this.GetInsertCommand(item);
if (cmd.Type == typeof(int)) {
return (int)this.context.Provider.Execute(cmd).ReturnValue;
}
else {
IEnumerable<object> facts = (IEnumerable<object>)this.context.Provider.Execute(cmd).ReturnValue;
object[] syncResults = (object[])facts.FirstOrDefault();
if (syncResults != null) {
// [....] any auto gen or computed members
AutoSyncMembers(syncResults, item, UpdateType.Insert, AutoSyncBehavior.ApplyNewAutoSync);
return 1;
}
else {
throw Error.InsertAutoSyncFailure();
}
}
}
internal override void AppendInsertText(TrackedObject item, StringBuilder appendTo) {
if (item.Type.Table.InsertMethod != null) {
appendTo.Append(Strings.InsertCallbackComment);
}
else {
Expression cmd = this.GetInsertCommand(item);
appendTo.Append(this.context.Provider.GetQueryText(cmd));
appendTo.AppendLine();
}
}
/// <summary>
/// Update the item, returning 0 if the update fails, 1 if it succeeds.
/// </summary>
internal override int Update(TrackedObject item) {
if (item.Type.Table.UpdateMethod != null) {
// create a copy - don't allow the override to modify our
// internal original values
try {
item.Type.Table.UpdateMethod.Invoke(this.context, new object[] { item.Current });
}
catch (TargetInvocationException tie) {
if (tie.InnerException != null) {
throw tie.InnerException;
}
throw;
}
return 1;
}
else {
return DynamicUpdate(item);
}
}
internal override int DynamicUpdate(TrackedObject item) {
Expression cmd = this.GetUpdateCommand(item);
if (cmd.Type == typeof(int)) {
return (int)this.context.Provider.Execute(cmd).ReturnValue;
}
else {
IEnumerable<object> facts = (IEnumerable<object>)this.context.Provider.Execute(cmd).ReturnValue;
object[] syncResults = (object[])facts.FirstOrDefault();
if (syncResults != null) {
// [....] any auto gen or computed members
AutoSyncMembers(syncResults, item, UpdateType.Update, AutoSyncBehavior.ApplyNewAutoSync);
return 1;
}
else {
return 0;
}
}
}
internal override void AppendUpdateText(TrackedObject item, StringBuilder appendTo) {
if (item.Type.Table.UpdateMethod != null) {
appendTo.Append(Strings.UpdateCallbackComment);
}
else {
Expression cmd = this.GetUpdateCommand(item);
appendTo.Append(this.context.Provider.GetQueryText(cmd));
appendTo.AppendLine();
}
}
internal override int Delete(TrackedObject item) {
if (item.Type.Table.DeleteMethod != null) {
try {
item.Type.Table.DeleteMethod.Invoke(this.context, new object[] { item.Current });
}
catch (TargetInvocationException tie) {
if (tie.InnerException != null) {
throw tie.InnerException;
}
throw;
}
return 1;
}
else {
return DynamicDelete(item);
}
}
internal override int DynamicDelete(TrackedObject item) {
Expression cmd = this.GetDeleteCommand(item);
int ret = (int)this.context.Provider.Execute(cmd).ReturnValue;
if (ret == 0) {
// we don't yet know if the delete failed because the check constaint did not match
// or item was already deleted. Verify the item exists
cmd = this.GetDeleteVerificationCommand(item);
ret = ((int?)this.context.Provider.Execute(cmd).ReturnValue) ?? -1;
}
return ret;
}
internal override void AppendDeleteText(TrackedObject item, StringBuilder appendTo) {
if (item.Type.Table.DeleteMethod != null) {
appendTo.Append(Strings.DeleteCallbackComment);
}
else {
Expression cmd = this.GetDeleteCommand(item);
appendTo.Append(this.context.Provider.GetQueryText(cmd));
appendTo.AppendLine();
}
}
[SuppressMessage("Microsoft.MSInternal", "CA908:AvoidTypesThatRequireJitCompilationInPrecompiledAssemblies", Justification="[....]: FxCop bug Dev10:423110 -- List<KeyValuePair<object, object>> is not supposed to be flagged as a violation.")]
internal override void RollbackAutoSync() {
// Rolls back any AutoSync values that may have been set already
// Those values are no longer valid since the transaction will be rolled back on the server
if (this.syncRollbackItems != null) {
foreach (KeyValuePair<TrackedObject, object[]> rollbackItemPair in this.SyncRollbackItems) {
TrackedObject rollbackItem = rollbackItemPair.Key;
object[] rollbackValues = rollbackItemPair.Value;
AutoSyncMembers(
rollbackValues,
rollbackItem,
rollbackItem.IsNew ? UpdateType.Insert : UpdateType.Update,
AutoSyncBehavior.RollbackSavedValues);
}
}
}
[SuppressMessage("Microsoft.MSInternal", "CA908:AvoidTypesThatRequireJitCompilationInPrecompiledAssemblies", Justification="[....]: FxCop bug Dev10:423110 -- List<KeyValuePair<object, object>> is not supposed to be flagged as a violation.")]
internal override void ClearAutoSyncRollback() {
this.syncRollbackItems = null;
}
private Expression GetInsertCommand(TrackedObject item) {
MetaType mt = item.Type;
// bind to InsertFacts if there are any members to syncronize
List<MetaDataMember> membersToSync = GetAutoSyncMembers(mt, UpdateType.Insert);
ParameterExpression p = Expression.Parameter(item.Type.Table.RowType.Type, "p");
if (membersToSync.Count > 0) {
Expression autoSync = this.CreateAutoSync(membersToSync, p);
LambdaExpression resultSelector = Expression.Lambda(autoSync, p);
return Expression.Call(typeof(DataManipulation), "Insert", new Type[] { item.Type.InheritanceRoot.Type, resultSelector.Body.Type }, Expression.Constant(item.Current), resultSelector);
}
else {
return Expression.Call(typeof(DataManipulation), "Insert", new Type[] { item.Type.InheritanceRoot.Type }, Expression.Constant(item.Current));
}
}
/// <summary>
/// For the meta members specified, create an array initializer for each and bind to
/// an output array.
/// </summary>
private Expression CreateAutoSync(List<MetaDataMember> membersToSync, Expression source) {
System.Diagnostics.Debug.Assert(membersToSync.Count > 0);
int i = 0;
Expression[] initializers = new Expression[membersToSync.Count];
foreach (MetaDataMember mm in membersToSync) {
initializers[i++] = Expression.Convert(this.GetMemberExpression(source, mm.Member), typeof(object));
}
return Expression.NewArrayInit(typeof(object), initializers);
}
private static List<MetaDataMember> GetAutoSyncMembers(MetaType metaType, UpdateType updateType) {
List<MetaDataMember> membersToSync = new List<MetaDataMember>();
foreach (MetaDataMember metaMember in metaType.PersistentDataMembers.OrderBy(m => m.Ordinal)) {
// add all auto generated members for the specified update type to the auto-[....] list
if ((updateType == UpdateType.Insert && metaMember.AutoSync == AutoSync.OnInsert) ||
(updateType == UpdateType.Update && metaMember.AutoSync == AutoSync.OnUpdate) ||
metaMember.AutoSync == AutoSync.Always) {
membersToSync.Add(metaMember);
}
}
return membersToSync;
}
/// <summary>
/// Synchronize the specified item by copying in data from the specified results.
/// Used to [....] members after successful insert or update, but also used to rollback to previous values if a failure
/// occurs on other entities in the same SubmitChanges batch.
/// </summary>
/// <param name="autoSyncBehavior">
/// If AutoSyncBehavior.ApplyNewAutoSync, the current value of the property is saved before the [....] occurs. This is used for normal synchronization after a successful update/insert.
/// Otherwise, the current value is not saved. This is used for rollback operations when something in the SubmitChanges batch failed, rendering the previously-[....]'d values invalid.
/// </param>
[SuppressMessage("Microsoft.MSInternal", "CA908:AvoidTypesThatRequireJitCompilationInPrecompiledAssemblies", Justification="[....]: FxCop bug Dev10:423110 -- List<KeyValuePair<object, object>> is not supposed to be flagged as a violation.")]
private void AutoSyncMembers(object[] syncResults, TrackedObject item, UpdateType updateType, AutoSyncBehavior autoSyncBehavior) {
System.Diagnostics.Debug.Assert(item != null);
System.Diagnostics.Debug.Assert(item.IsNew || item.IsPossiblyModified, "AutoSyncMembers should only be called for new and modified objects.");
object[] syncRollbackValues = null;
if (syncResults != null) {
int idx = 0;
List<MetaDataMember> membersToSync = GetAutoSyncMembers(item.Type, updateType);
System.Diagnostics.Debug.Assert(syncResults.Length == membersToSync.Count);
if (autoSyncBehavior == AutoSyncBehavior.ApplyNewAutoSync) {
syncRollbackValues = new object[syncResults.Length];
}
foreach (MetaDataMember mm in membersToSync) {
object value = syncResults[idx];
object current = item.Current;
MetaAccessor accessor =
(mm.Member is PropertyInfo && ((PropertyInfo)mm.Member).CanWrite)
? mm.MemberAccessor
: mm.StorageAccessor;
if (syncRollbackValues != null) {
syncRollbackValues[idx] = accessor.GetBoxedValue(current);
}
accessor.SetBoxedValue(ref current, DBConvert.ChangeType(value, mm.Type));
idx++;
}
}
if (syncRollbackValues != null) {
this.SyncRollbackItems.Add(new KeyValuePair<TrackedObject, object[]>(item, syncRollbackValues));
}
}
private Expression GetUpdateCommand(TrackedObject tracked) {
object database = tracked.Original;
MetaType rowType = tracked.Type.GetInheritanceType(database.GetType());
MetaType rowTypeRoot = rowType.InheritanceRoot;
ParameterExpression p = Expression.Parameter(rowTypeRoot.Type, "p");
Expression pv = p;
if (rowType != rowTypeRoot) {
pv = Expression.Convert(p, rowType.Type);
}
Expression check = this.GetUpdateCheck(pv, tracked);
if (check != null) {
check = Expression.Lambda(check, p);
}
// bind to out array if there are any members to synchronize
List<MetaDataMember> membersToSync = GetAutoSyncMembers(rowType, UpdateType.Update);
if (membersToSync.Count > 0) {
Expression autoSync = this.CreateAutoSync(membersToSync, pv);
LambdaExpression resultSelector = Expression.Lambda(autoSync, p);
if (check != null) {
return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type, resultSelector.Body.Type }, Expression.Constant(tracked.Current), check, resultSelector);
}
else {
return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type, resultSelector.Body.Type }, Expression.Constant(tracked.Current), resultSelector);
}
}
else if (check != null) {
return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type }, Expression.Constant(tracked.Current), check);
}
else {
return Expression.Call(typeof(DataManipulation), "Update", new Type[] { rowTypeRoot.Type }, Expression.Constant(tracked.Current));
}
}
private Expression GetUpdateCheck(Expression serverItem, TrackedObject tracked) {
MetaType mt = tracked.Type;
if (mt.VersionMember != null) {
return Expression.Equal(
this.GetMemberExpression(serverItem, mt.VersionMember.Member),
this.GetMemberExpression(Expression.Constant(tracked.Current), mt.VersionMember.Member)
);
}
else {
Expression expr = null;
foreach (MetaDataMember mm in mt.PersistentDataMembers) {
if (!mm.IsPrimaryKey) {
UpdateCheck check = mm.UpdateCheck;
if (check == UpdateCheck.Always ||
(check == UpdateCheck.WhenChanged && tracked.HasChangedValue(mm))) {
object memberValue = mm.MemberAccessor.GetBoxedValue(tracked.Original);
Expression eq =
Expression.Equal(
this.GetMemberExpression(serverItem, mm.Member),
Expression.Constant(memberValue, mm.Type)
);
expr = (expr != null) ? Expression.And(expr, eq) : eq;
}
}
}
return expr;
}
}
private Expression GetDeleteCommand(TrackedObject tracked) {
MetaType rowType = tracked.Type;
MetaType rowTypeRoot = rowType.InheritanceRoot;
ParameterExpression p = Expression.Parameter(rowTypeRoot.Type, "p");
Expression pv = p;
if (rowType != rowTypeRoot) {
pv = Expression.Convert(p, rowType.Type);
}
object original = tracked.CreateDataCopy(tracked.Original);
Expression check = this.GetUpdateCheck(pv, tracked);
if (check != null) {
check = Expression.Lambda(check, p);
return Expression.Call(typeof(DataManipulation), "Delete", new Type[] { rowTypeRoot.Type }, Expression.Constant(original), check);
}
else {
return Expression.Call(typeof(DataManipulation), "Delete", new Type[] { rowTypeRoot.Type }, Expression.Constant(original));
}
}
private Expression GetDeleteVerificationCommand(TrackedObject tracked) {
ITable table = this.context.GetTable(tracked.Type.InheritanceRoot.Type);
System.Diagnostics.Debug.Assert(table != null);
ParameterExpression p = Expression.Parameter(table.ElementType, "p");
Expression pred = Expression.Lambda(Expression.Equal(p, Expression.Constant(tracked.Current)), p);
Expression where = Expression.Call(typeof(Queryable), "Where", new Type[] { table.ElementType }, table.Expression, pred);
Expression selector = Expression.Lambda(Expression.Constant(0, typeof(int?)), p);
Expression select = Expression.Call(typeof(Queryable), "Select", new Type[] { table.ElementType, typeof(int?) }, where, selector);
Expression singleOrDefault = Expression.Call(typeof(Queryable), "SingleOrDefault", new Type[] { typeof(int?) }, select);
return singleOrDefault;
}
[SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification="Unknown reason.")]
private Expression GetMemberExpression(Expression exp, MemberInfo mi) {
FieldInfo fi = mi as FieldInfo;
if (fi != null)
return Expression.Field(exp, fi);
PropertyInfo pi = (PropertyInfo)mi;
return Expression.Property(exp, pi);
}
}
}
}