/// <summary>
/// Creates the CodeDOM for a method to delete a record from a table using transacted logic.
/// </summary>
/// <param name="tableSchema">A description of the table.</param>
public DestroyMethod(TableSchema tableSchema)
{
// Create a matrix of parameters for this operation.
DestroyParameterMatrix destroyParameterMatrix = new DestroyParameterMatrix(tableSchema);
// [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
// public void DestroyObject(System.Guid objectId, long rowVersion)
// {
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
this.CustomAttributes.AddRange(new CodeCustomAttributesForMethods());
this.Name = string.Format("Destroy{0}", tableSchema.Name);
List <CodeParameterDeclarationExpression> parameters = new List <CodeParameterDeclarationExpression>();
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in destroyParameterMatrix.ExternalParameterItems)
{
this.Parameters.Add(parameterPair.Value.CodeParameterDeclarationExpression);
}
// base.Channel.DestroyObject(description, externalId, name, objectId, rowVersion, typeCode);
List <CodeExpression> arguments = new List <CodeExpression>();
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in destroyParameterMatrix.ExternalParameterItems)
{
arguments.Add(new CodeArgumentReferenceExpression(parameterPair.Value.Name));
}
this.Statements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeBaseReferenceExpression(), "Channel"), this.Name,
arguments.ToArray()));
// }
}
/// <summary>
/// Creates the CodeDOM for a method to delete a record from a table using transacted logic.
/// </summary>
/// <param name="tableSchema">A description of the table.</param>
public DestroyMethod(TableSchema tableSchema)
{
// Create a matrix of parameters for this operation.
DestroyParameterMatrix destroyParameterMatrix = new DestroyParameterMatrix(tableSchema);
// /// <summary>
// /// Deletes a Employee record.
// /// </summary>
// /// <param name="employeeId">The value for the EmployeeId column.</param>
// /// <param name="rowVersion">The value for the RowVersion column.</param>
// /// <param name="rowVersion">Used for Optimistic Concurrency Checking.</param>
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement(string.Format("Deletes a {0} record.", tableSchema.Name), true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in destroyParameterMatrix.ExternalParameterItems)
{
this.Comments.Add(new CodeCommentStatement(string.Format("<param name=\"{0}\">{1}</param>", parameterPair.Value.Name, parameterPair.Value.Description), true));
}
// [global::System.ServiceModel.OperationContractAttribute()]
// [global::System.ServiceModel.TransactionFlowAttribute(global::System.ServiceModel.TransactionFlowOption.Allowed)]
// [global::System.ServiceModel.ServiceKnownTypeAttribute(typeof(global::System.DBNull))]
// [global::System.ServiceModel.FaultContractAttribute(typeof(global::FluidTrade.Core.RecordNotFoundFault))]
// [global::System.ServiceModel.FaultContractAttribute(typeof(global::FluidTrade.Core.OptimisticConcurrencyFault))]
// void DestroyEmployee(int employeeId, long rowVersion);
string actionUri = string.Format("http://tempuri.org/I{0}/Destroy{1}", tableSchema.DataModel.Name, tableSchema.Name);
string actionReplyUri = string.Format("http://tempuri.org/I{0}/Destroy{1}Response", tableSchema.DataModel.Name, tableSchema.Name);
this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(System.ServiceModel.OperationContractAttribute)), new CodeAttributeArgument("Action", new CodePrimitiveExpression(actionUri)), new CodeAttributeArgument("ReplyAction", new CodePrimitiveExpression(actionReplyUri))));
this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(System.ServiceModel.TransactionFlowAttribute)), new CodeAttributeArgument(new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(System.ServiceModel.TransactionFlowOption)), "Allowed"))));
this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(System.ServiceModel.ServiceKnownTypeAttribute)), new CodeAttributeArgument(new CodeTypeOfExpression(new CodeGlobalTypeReference(typeof(System.DBNull))))));
this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(System.ServiceModel.FaultContractAttribute)), new CodeAttributeArgument(new CodeTypeOfExpression(new CodeGlobalTypeReference(typeof(RecordNotFoundFault))))));
this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(System.ServiceModel.FaultContractAttribute)), new CodeAttributeArgument(new CodeTypeOfExpression(new CodeGlobalTypeReference(typeof(OptimisticConcurrencyFault))))));
this.Attributes = MemberAttributes.Public | MemberAttributes.Abstract;
this.Name = string.Format("Destroy{0}", tableSchema.Name);
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in destroyParameterMatrix.ExternalParameterItems)
{
this.Parameters.Add(parameterPair.Value.CodeParameterDeclarationExpression);
}
}
/// <summary>
/// Creates the CodeDOM for a method to delete a record from a table using transacted logic.
/// </summary>
/// <param name="tableSchema">A description of the table.</param>
public DestroyMethod(TableSchema tableSchema)
{
// Create a matrix of parameters for this operation.
DestroyParameterMatrix destroyParameterMatrix = new DestroyParameterMatrix(tableSchema);
// This is the key used to identify the record to be deleted.
CodeArgumentReferenceExpression primaryKeyExpression = null;
foreach (KeyValuePair <string, ExternalParameterItem> externalParamterPair in destroyParameterMatrix.ExternalParameterItems)
{
if (externalParamterPair.Value is UniqueConstraintParameterItem)
{
primaryKeyExpression = new CodeArgumentReferenceExpression(externalParamterPair.Value.Name);
}
}
// These are the names of common varibles generated by this CodeDOM.
CodeTypeReference rowType = new CodeTypeReference(string.Format("{0}Row", tableSchema.Name));
CodeVariableReferenceExpression rowVariableExpression = new CodeRandomVariableReferenceExpression();
// /// <summary>
// /// Deletes a Employee record.
// /// </summary>
// /// <param name="employeeId">The value for the EmployeeId column.</param>
// /// <param name="rowVersion">The value for the RowVersion column.</param>
// /// <param name="rowVersion">Used for Optimistic Concurrency Checking.</param>
// [global::System.ServiceModel.OperationBehaviorAttribute(TransactionScopeRequired=true)]
// [FluidTrade.Core.ClaimsPrincipalPermission(System.Security.Permissions.SecurityAction.Demand, ClaimType=FluidTrade.Core.ClaimTypes.Destroy, Resource=FluidTrade.Core.Resources.Application)]
// public void DestroyEmployee(int employeeId, long rowVersion) {
this.Comments.Add(new CodeCommentStatement("<summary>", true));
this.Comments.Add(new CodeCommentStatement(string.Format("Deletes a {0} record.", tableSchema.Name), true));
this.Comments.Add(new CodeCommentStatement("</summary>", true));
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in destroyParameterMatrix.ExternalParameterItems)
{
this.Comments.Add(new CodeCommentStatement(string.Format("<param name=\"{0}\">{1}</param>", parameterPair.Value.Name, parameterPair.Value.Description), true));
}
this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(System.ServiceModel.OperationBehaviorAttribute)), new CodeAttributeArgument("TransactionScopeRequired", new CodePrimitiveExpression(true))));
//AR FB 408 - Remove Claims requirement
//this.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeGlobalTypeReference(typeof(ClaimsPrincipalPermission)), new CodeAttributeArgument(new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(System.Security.Permissions.SecurityAction)), "Demand")),
// new CodeAttributeArgument("ClaimType", new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(ClaimTypes)), "Destroy")),
// new CodeAttributeArgument("Resource", new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(Resources)), "Application"))));
this.Attributes = MemberAttributes.Public | MemberAttributes.Final;
this.Name = string.Format("Destroy{0}", tableSchema.Name);
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in destroyParameterMatrix.ExternalParameterItems)
{
this.Parameters.Add(parameterPair.Value.CodeParameterDeclarationExpression);
}
// This method can't do much without a primary key.
if (tableSchema.PrimaryKey == null)
{
return;
}
// // This provides a context for the middle tier transactions.
// global::FluidTrade.Core.MiddleTierContext middleTierTransaction = global::FluidTrade.Core.MiddleTierContext.Current;
CodeVariableReferenceExpression transactionExpression = new CodeRandomVariableReferenceExpression();
this.Statements.Add(new CodeCreateMiddleTierContextStatement(tableSchema.DataModel, transactionExpression));
// // This record and any children in cascading relationships will be destroyed.
// FluidTrade.UnitTest.Server.DataModel.EmployeeRow employeeRow = FluidTrade.UnitTest.Server.DataModel.Employee.FindByEmployeeId(new object[] {
// employeeId});
// if ((employeeRow == null)) {
// throw new global::System.ServiceModel.FaultException<RecordNotFoundFault>(new global::FluidTrade.Core.RecordNotFoundFault("Attempt to access a Employee record ({0}) that doesn\'t exist", employeeId));
// }
this.Statements.Add(new CodeVariableDeclarationStatement(rowType, rowVariableExpression.VariableName, new CodeFindByIndexExpression(tableSchema, primaryKeyExpression)));
this.Statements.Add(new CodeCheckRecordExistsStatement(tableSchema, rowVariableExpression, primaryKeyExpression));
this.Statements.Add(new CodeAcquireRecordWriterLockExpression(transactionExpression, rowVariableExpression, tableSchema));
this.Statements.Add(new CodeAddLockToTransactionExpression(transactionExpression, rowVariableExpression));
// // This makes sure the record wasn't deleted between the time it was found and the time it was locked.
// if ((employeeRow.RowState == System.Data.DataRowState.Detached)) {
// throw new global::System.ServiceModel.FaultException<RecordNotFoundFault>(new global::FluidTrade.Core.RecordNotFoundFault("Attempt to access a Employee record ({0}) that doesn\'t exist", employeeId));
// }
this.Statements.Add(new CodeCheckRecordDetachedStatement(tableSchema, rowVariableExpression, primaryKeyExpression));
// // The Optimistic Concurrency check allows only one client to destroy a record at a time.
// if ((employeeRow.RowVersion != rowVersion)) {
// throw;
// }
this.Statements.Add(new CodeCheckConcurrencyStatement(tableSchema, rowVariableExpression, primaryKeyExpression));
// // Delete each of the child Engineer records in a cascade.
// DataModel.EngineerRow[] employeeEngineerRowsByFK_Employee_Engineer = employeeRow.GetEngineerRows();
// for (int engineerIndex = 0; (engineerIndex < employeeEngineerRowsByFK_Employee_Engineer.Length); engineerIndex = (engineerIndex + 1)) {
// // Get the next Engineer row in the list of children and lock it for the duration of the transaction.
// DataModel.EngineerRow engineerRow = employeeEngineerRowsByFK_Employee_Engineer[engineerIndex];
// engineerRow.AcquireWriterLock(middleTierTransaction.AdoResourceManager.Guid, FluidTrade.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(engineerRow);
// // This makes sure the record wasn't deleted between the time it was found and the time it was locked.
// if ((engineerRow.RowState != System.Data.DataRowState.Detached)) {
// this.DestroyEngineer(engineerRow.EngineerId, engineerRow.RowVersion);
// }
// }
// // Delete each of the child Manager records in a cascade.
// DataModel.ManagerRow[] employeeManagerRowsByFK_Employee_Manager = employeeRow.GetManagerRows();
// for (int managerIndex = 0; (managerIndex < employeeManagerRowsByFK_Employee_Manager.Length); managerIndex = (managerIndex + 1)) {
// // Get the next Manager row in the list of children and lock it for the duration of the transaction.
// DataModel.ManagerRow managerRow = employeeManagerRowsByFK_Employee_Manager[managerIndex];
// managerRow.AcquireWriterLock(middleTierTransaction.AdoResourceManager.Guid, FluidTrade.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(managerRow);
// // This makes sure the record wasn't deleted between the time it was found and the time it was locked.
// if ((managerRow.RowState != System.Data.DataRowState.Detached)) {
// this.DestroyManager(managerRow.ManagerId, managerRow.RowVersion);
// }
// }
// // Delete each of the child ProjectMember records in a cascade.
// DataModel.ProjectMemberRow[] employeeProjectMemberRowsByFK_Employee_ProjectMember = employeeRow.GetProjectMemberRows();
// for (int projectMemberIndex = 0; (projectMemberIndex < employeeProjectMemberRowsByFK_Employee_ProjectMember.Length); projectMemberIndex = (projectMemberIndex + 1)) {
// // Get the next ProjectMember row in the list of children and lock it for the duration of the transaction.
// DataModel.ProjectMemberRow projectMemberRow = employeeProjectMemberRowsByFK_Employee_ProjectMember[projectMemberIndex];
// projectMemberRow.AcquireWriterLock(middleTierTransaction.AdoResourceManager.Guid, FluidTrade.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(projectMemberRow);
// // This makes sure the record wasn't deleted between the time it was found and the time it was locked.
// if ((projectMemberRow.RowState != System.Data.DataRowState.Detached)) {
// this.DestroyProjectMember(projectMemberRow.EmployeeId, projectMemberRow.ProjectId, projectMemberRow.RowVersion);
// }
// }
foreach (KeyValuePair <string, RelationSchema> relationPair in tableSchema.ChildRelations)
{
if (relationPair.Value.ChildKeyConstraint.DeleteRule == ForeignKeyConstraintSchema.CascadeRules.Cascade)
{
// The child records in this table will be destroyed.
TableSchema childTableSchema = relationPair.Value.ChildTable;
// This collects the variables and types needed to build the statements to delete the child records.
CodeVariableReferenceExpression iteratorVariableExpression = new CodeRandomVariableReferenceExpression();
CodeTypeReference rowArrayType = new CodeTypeReference(string.Format("{0}Row[]", childTableSchema.Name));
CodeVariableReferenceExpression rowArrayVariableExpression = new CodeRandomVariableReferenceExpression();
CodeTypeReference childRowType = new CodeTypeReference(string.Format("{0}Row", childTableSchema.Name));
CodeVariableReferenceExpression childRowVariableExpression = new CodeRandomVariableReferenceExpression();
CodeMethodReferenceExpression getMethodExpression = relationPair.Value.IsDistinctPathToChild ?
new CodeMethodReferenceExpression(rowVariableExpression, string.Format("Get{0}Rows", childTableSchema.Name)) :
new CodeMethodReferenceExpression(rowVariableExpression, string.Format("Get{0}RowsBy{1}", childTableSchema.Name, relationPair.Value.Name));
// // Delete each of the child Engineer records in a cascade.
// DataModel.EngineerRow[] employeeEngineerRowsByFK_Employee_Engineer = employeeRow.GetEngineerRows();
// for (int engineerIndex = 0; (engineerIndex < employeeEngineerRowsByFK_Employee_Engineer.Length); engineerIndex = (engineerIndex + 1)) {
this.Statements.Add(new CodeVariableDeclarationStatement(rowArrayType, rowArrayVariableExpression.VariableName, new CodeMethodInvokeExpression(getMethodExpression)));
CodeIterationStatement forEachRecord = new CodeIterationStatement(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(System.Int32)), iteratorVariableExpression.VariableName, new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(iteratorVariableExpression, CodeBinaryOperatorType.LessThan, new CodePropertyReferenceExpression(rowArrayVariableExpression, "Length")),
new CodeAssignStatement(iteratorVariableExpression, new CodeBinaryOperatorExpression(iteratorVariableExpression, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))));
// // Get the next Engineer row in the list of children and lock it for the duration of the transaction.
// DataModel.EngineerRow engineerRow = employeeEngineerRowsByFK_Employee_Engineer[engineerIndex];
// engineerRow.AcquireWriterLock(middleTierTransaction.AdoResourceManager.Guid, FluidTrade.UnitTest.Server.DataModel.lockTimeout);
// middleTierTransaction.AdoResourceManager.AddLock(engineerRow);
forEachRecord.Statements.Add(new CodeVariableDeclarationStatement(childRowType, childRowVariableExpression.VariableName, new CodeIndexerExpression(rowArrayVariableExpression, iteratorVariableExpression)));
forEachRecord.Statements.Add(new CodeAcquireRecordWriterLockExpression(transactionExpression, childRowVariableExpression, tableSchema));
forEachRecord.Statements.Add(new CodeAddLockToTransactionExpression(transactionExpression, childRowVariableExpression));
// // This makes sure the record wasn't deleted between the time it was found and the time it was locked.
// if ((engineerRow.RowState != System.Data.DataRowState.Detached)) {
// this.DestroyEngineer(engineerRow.EngineerId, engineerRow.RowVersion);
// }
CodeConditionStatement ifDetatched = new CodeConditionStatement(new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(childRowVariableExpression, "RowState"), CodeBinaryOperatorType.IdentityInequality, new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(System.Data.DataRowState)), "Detached")));
DestroyParameterMatrix childMatrix = new DestroyParameterMatrix(childTableSchema);
List <CodeExpression> childParameters = new List <CodeExpression>();
foreach (KeyValuePair <string, ExternalParameterItem> externalParameterPair in childMatrix.ExternalParameterItems)
{
if (externalParameterPair.Value is UniqueConstraintParameterItem)
{
List <CodeExpression> primaryKeyParameters = new List <CodeExpression>();
foreach (ColumnSchema primaryKeyColumn in childTableSchema.PrimaryKey.Columns)
{
primaryKeyParameters.Add(new CodePropertyReferenceExpression(childRowVariableExpression, primaryKeyColumn.Name));
}
childParameters.Add(new CodeArrayCreateExpression(new CodeGlobalTypeReference(typeof(System.Object)), primaryKeyParameters.ToArray()));
}
else
{
childParameters.Add(new CodePropertyReferenceExpression(childRowVariableExpression, "RowVersion"));
}
}
ifDetatched.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), string.Format("Destroy{0}", childTableSchema.Name), childParameters.ToArray()));
forEachRecord.Statements.Add(ifDetatched);
// }
this.Statements.Add(forEachRecord);
}
}
// System.Data.SqlClient.SqlCommand SqlCommand = new global::System.Data.SqlClient.SqlCommand("delete \"Employee\" where \"EmployeeId\"=@employeeId", middleTierTransaction.SqlConnection);
// SqlCommand.Parameters.Add(new global::System.Data.SqlClient.SqlParameter("@employeeId", System.Data.SqlDbType.Int, 0, System.Data.ParameterDirection.Input, false, 0, 0, null, System.Data.DataRowVersion.Current, employeeRow[FluidTrade.UnitTest.Server.DataModel.Employee.EmployeeIdColumn]));
// SqlCommand.ExecuteNonQuery();
if (tableSchema.IsPersistent)
{
CodeVariableReferenceExpression sqlCommandVariableExpression = new CodeRandomVariableReferenceExpression();
if (tableSchema.PrimaryKey != null)
{
string deleteCommandText = string.Format("delete \"{0}\"", tableSchema.Name);
ColumnSchema[] keyColumns = tableSchema.PrimaryKey.Columns;
if (keyColumns.Length > 0)
{
deleteCommandText += string.Format(" where \"{0}\"=@{1}", keyColumns[0].Name, CommonConversion.ToCamelCase(keyColumns[0].Name));
for (int keyIndex = 1; keyIndex < keyColumns.Length; keyIndex++)
{
deleteCommandText += string.Format(" and \"{0}\"=@{1}", keyColumns[1].Name, CommonConversion.ToCamelCase(keyColumns[1].Name));
}
}
this.Statements.Add(new CodeVariableDeclarationStatement(new CodeGlobalTypeReference(typeof(System.Data.SqlClient.SqlCommand)), sqlCommandVariableExpression.VariableName, new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(System.Data.SqlClient.SqlCommand)), new CodePrimitiveExpression(deleteCommandText), new CodePropertyReferenceExpression(transactionExpression, "SqlConnection"))));
foreach (ColumnSchema columnSchema in tableSchema.PrimaryKey.Columns)
{
string variableName = CommonConversion.ToCamelCase(columnSchema.Name);
CodeExpression codeExpression = new CodeIndexerExpression(rowVariableExpression, new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(tableSchema.DataModel.Name), tableSchema.Name), string.Format("{0}Column", columnSchema.Name)));
this.Statements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(sqlCommandVariableExpression, "Parameters"), "Add", new CodeObjectCreateExpression(new CodeGlobalTypeReference(typeof(System.Data.SqlClient.SqlParameter)), new CodePrimitiveExpression(string.Format("@{0}", variableName)), TypeConverter.Convert(columnSchema.DataType), new CodePrimitiveExpression(0), new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(System.Data.ParameterDirection)), "Input"), new CodePrimitiveExpression(false), new CodePrimitiveExpression(0), new CodePrimitiveExpression(0), new CodePrimitiveExpression(null), new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(System.Data.DataRowVersion)), "Current"), codeExpression)));
}
this.Statements.Add(new CodeMethodInvokeExpression(sqlCommandVariableExpression, "ExecuteNonQuery"));
}
}
// // Delete the Employee record from the ADO data model.
// middleTierTransaction.AdoResourceManager.AddRecord(employeeRow);
// try {
// FluidTrade.UnitTest.Server.DataModel.ReaderWriterLock.EnterWriteLock();
// FluidTrade.UnitTest.Server.DataModel.ProjectMember.AcquireLock();
// employeeRow.Delete();
// }
// finally {
// FluidTrade.UnitTest.Server.DataModel.ReaderWriterLock.ExitWriteLock();
// }
this.Statements.Add(new CodeAddRecordToTransactionExpression(transactionExpression, rowVariableExpression));
CodeTryCatchFinallyStatement tryFinallyStatement = new CodeTryCatchFinallyStatement();
tryFinallyStatement.TryStatements.Add(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(tableSchema.DataModel.Name), "DataLock"), "EnterWriteLock"));
tryFinallyStatement.TryStatements.Add(new CodeMethodInvokeExpression(rowVariableExpression, "Delete"));
tryFinallyStatement.FinallyStatements.Add(
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(tableSchema.DataModel.Name), "DataLock"), "ExitWriteLock"));
this.Statements.Add(tryFinallyStatement);
// DataModel.DestinationOrder.OnRowValidate(new DestinationOrderRowChangeEventArgs(pe9564f2717374e96a76d5222e2258784, System.Data.DataRowAction.Change));
this.Statements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(tableSchema.DataModel.Name), tableSchema.Name), "OnRowValidate",
new CodeObjectCreateExpression(string.Format("{0}RowChangeEventArgs", tableSchema.Name), rowVariableExpression, new CodePropertyReferenceExpression(new CodeGlobalTypeReferenceExpression(typeof(System.Data.DataRowAction)), "Delete"))));
// }
}
