public VersionNotFoundException() : base(Res.GetString("DataSet_DefaultVersionNotFoundException"))
{
base.HResult = -2146232023;
}
public NoNullAllowedException() : base(Res.GetString("DataSet_DefaultNoNullAllowedException"))
{
base.HResult = -2146232026;
}
public DuplicateNameException() : base(Res.GetString("DataSet_DefaultDuplicateNameException"))
{
base.HResult = -2146232030;
}
internal override void Bind(DataTable table, ArrayList list)
{
#if DEBUG
if (CompModSwitches.AggregateNode.TraceVerbose)
{
Debug.WriteLine("Binding Aggregate expression " + this.ToString());
}
#endif
if (table == null)
{
throw ExprException.AggregateUnbound(this.ToString());
}
#if DEBUG
if (CompModSwitches.AggregateNode.TraceVerbose)
{
Debug.WriteLine("in table " + table.TableName);
}
#endif
if (local)
{
relation = null;
}
else
{
DataRelationCollection relations;
relations = table.ChildRelations;
if (relationName == null)
{
// must have one and only one relation
if (relations.Count > 1)
{
throw ExprException.UnresolvedRelation(table.TableName, this.ToString());
}
if (relations.Count == 1)
{
relation = relations[0];
}
else
{
throw ExprException.AggregateUnbound(this.ToString());
}
}
else
{
relation = relations[relationName];
}
Debug.Assert(relation != null, String.Format(Res.GetString(Res.Expr_AggregateUnbound), this.ToString()));
}
DataTable childTable = (relation == null) ? table : relation.ChildTable;
this.table = childTable;
this.column = childTable.Columns[columnName];
if (column == null)
{
throw ExprException.UnboundName(columnName);
}
// add column to the dependency list, do not add duplicate columns
Debug.Assert(column != null, "Failed to bind column " + columnName);
int i;
for (i = 0; i < list.Count; i++)
{
// walk the list, check if the current column already on the list
DataColumn dataColumn = (DataColumn)list[i];
if (column == dataColumn)
{
break;
}
}
if (i >= list.Count)
{
list.Add(column);
}
//UNDONE : Debug.WriteLineIf("AggregateNode", this.ToString() + " bound");
}
private void MergeRelation(DataRelation relation)
{
Debug.Assert(MissingSchemaAction.Error == missingSchemaAction ||
MissingSchemaAction.Add == missingSchemaAction,
"Unexpected value of MissingSchemaAction parameter : " + ((Enum)missingSchemaAction).ToString());
DataRelation destRelation = null;
// try to find given relation in this dataSet
int iDest = dataSet.Relations.InternalIndexOf(relation.RelationName);
if (iDest >= 0)
{
// check the columns and Relation properties..
destRelation = dataSet.Relations[iDest];
if (relation.ParentKey.ColumnsReference.Length != destRelation.ParentKey.ColumnsReference.Length)
{
dataSet.RaiseMergeFailed(null,
Res.GetString(Res.DataMerge_MissingDefinition, relation.RelationName),
missingSchemaAction
);
}
for (int i = 0; i < relation.ParentKey.ColumnsReference.Length; i++)
{
DataColumn dest = destRelation.ParentKey.ColumnsReference[i];
DataColumn src = relation.ParentKey.ColumnsReference[i];
if (0 != string.Compare(dest.ColumnName, src.ColumnName, false, dest.Table.Locale))
{
dataSet.RaiseMergeFailed(null,
Res.GetString(Res.DataMerge_ReltionKeyColumnsMismatch, relation.RelationName),
missingSchemaAction
);
}
dest = destRelation.ChildKey.ColumnsReference[i];
src = relation.ChildKey.ColumnsReference[i];
if (0 != string.Compare(dest.ColumnName, src.ColumnName, false, dest.Table.Locale))
{
dataSet.RaiseMergeFailed(null,
Res.GetString(Res.DataMerge_ReltionKeyColumnsMismatch, relation.RelationName),
missingSchemaAction
);
}
}
}
else
{
if (MissingSchemaAction.Add == missingSchemaAction)
{
// create identical realtion in the current dataset
DataTable parent;
if (_IgnoreNSforTableLookup)
{
parent = dataSet.Tables[relation.ParentTable.TableName];
}
else
{
parent = dataSet.Tables[relation.ParentTable.TableName, relation.ParentTable.Namespace];
}
DataTable child;
if (_IgnoreNSforTableLookup)
{
child = dataSet.Tables[relation.ChildTable.TableName];
}
else
{
child = dataSet.Tables[relation.ChildTable.TableName, relation.ChildTable.Namespace];
}
DataColumn[] parentColumns = new DataColumn[relation.ParentKey.ColumnsReference.Length];
DataColumn[] childColumns = new DataColumn[relation.ParentKey.ColumnsReference.Length];
for (int i = 0; i < relation.ParentKey.ColumnsReference.Length; i++)
{
parentColumns[i] = parent.Columns[relation.ParentKey.ColumnsReference[i].ColumnName];
childColumns[i] = child.Columns[relation.ChildKey.ColumnsReference[i].ColumnName];
}
try {
destRelation = new DataRelation(relation.RelationName, parentColumns, childColumns, relation.createConstraints);
destRelation.Nested = relation.Nested;
dataSet.Relations.Add(destRelation);
}
catch (Exception e) {
//
if (!Common.ADP.IsCatchableExceptionType(e))
{
throw;
}
ExceptionBuilder.TraceExceptionForCapture(e);
dataSet.RaiseMergeFailed(null, e.Message, missingSchemaAction);
}
}
else
{
Debug.Assert(MissingSchemaAction.Error == missingSchemaAction, "Unexpected value of MissingSchemaAction parameter : " + ((Enum)missingSchemaAction).ToString());
throw ExceptionBuilder.MergeMissingDefinition(relation.RelationName);
}
}
MergeExtendedProperties(relation.ExtendedProperties, destRelation.ExtendedProperties);
return;
}
private DataTable MergeSchema(DataTable table)
{
DataTable targetTable = null;
if (!isStandAlonetable)
{
if (dataSet.Tables.Contains(table.TableName, true))
{
if (_IgnoreNSforTableLookup)
{
targetTable = dataSet.Tables[table.TableName];
}
else
{
targetTable = dataSet.Tables[table.TableName, table.Namespace];
}
}
}
else
{
targetTable = dataTable;
}
if (targetTable == null) // in case of standalone table, we make sure that targetTable is not null, so if this check passes, it will be when it is called via detaset
{
if (MissingSchemaAction.Add == missingSchemaAction)
{
targetTable = table.Clone(table.DataSet); // if we are here mainly we are called from DataSet.Merge at this point we don't set
//expression columns, since it might have refer to other columns via relation, so it wont find the table and we get exception;
// do it after adding relations.
dataSet.Tables.Add(targetTable);
}
else if (MissingSchemaAction.Error == missingSchemaAction)
{
throw ExceptionBuilder.MergeMissingDefinition(table.TableName);
}
}
else
{
if (MissingSchemaAction.Ignore != missingSchemaAction)
{
// Do the columns
int oldCount = targetTable.Columns.Count;
for (int i = 0; i < table.Columns.Count; i++)
{
DataColumn src = table.Columns[i];
DataColumn dest = (targetTable.Columns.Contains(src.ColumnName, true)) ? targetTable.Columns[src.ColumnName] : null;
if (dest == null)
{
if (MissingSchemaAction.Add == missingSchemaAction)
{
dest = src.Clone();
targetTable.Columns.Add(dest);
}
else
{
if (!isStandAlonetable)
{
dataSet.RaiseMergeFailed(targetTable, Res.GetString(Res.DataMerge_MissingColumnDefinition, table.TableName, src.ColumnName), missingSchemaAction);
}
else
{
throw ExceptionBuilder.MergeFailed(Res.GetString(Res.DataMerge_MissingColumnDefinition, table.TableName, src.ColumnName));
}
}
}
else
{
if (dest.DataType != src.DataType ||
((dest.DataType == typeof(DateTime)) && (dest.DateTimeMode != src.DateTimeMode) && ((dest.DateTimeMode & src.DateTimeMode) != DataSetDateTime.Unspecified)))
{
if (!isStandAlonetable)
{
dataSet.RaiseMergeFailed(targetTable, Res.GetString(Res.DataMerge_DataTypeMismatch, src.ColumnName), MissingSchemaAction.Error);
}
else
{
throw ExceptionBuilder.MergeFailed(Res.GetString(Res.DataMerge_DataTypeMismatch, src.ColumnName));
}
}
//
MergeExtendedProperties(src.ExtendedProperties, dest.ExtendedProperties);
}
}
// Set DataExpression
if (isStandAlonetable)
{
for (int i = oldCount; i < targetTable.Columns.Count; i++)
{
targetTable.Columns[i].Expression = table.Columns[targetTable.Columns[i].ColumnName].Expression;
}
}
// check the PrimaryKey
DataColumn[] targetPKey = targetTable.PrimaryKey;
DataColumn[] tablePKey = table.PrimaryKey;
if (targetPKey.Length != tablePKey.Length)
{
// special case when the target table does not have the PrimaryKey
if (targetPKey.Length == 0)
{
DataColumn[] key = new DataColumn[tablePKey.Length];
for (int i = 0; i < tablePKey.Length; i++)
{
key[i] = targetTable.Columns[tablePKey[i].ColumnName];
}
targetTable.PrimaryKey = key;
}
else if (tablePKey.Length != 0)
{
dataSet.RaiseMergeFailed(targetTable, Res.GetString(Res.DataMerge_PrimaryKeyMismatch), missingSchemaAction);
}
}
else
{
for (int i = 0; i < targetPKey.Length; i++)
{
if (String.Compare(targetPKey[i].ColumnName, tablePKey[i].ColumnName, false, targetTable.Locale) != 0)
{
dataSet.RaiseMergeFailed(table,
Res.GetString(Res.DataMerge_PrimaryKeyColumnsMismatch, targetPKey[i].ColumnName, tablePKey[i].ColumnName),
missingSchemaAction
);
}
}
}
}
MergeExtendedProperties(table.ExtendedProperties, targetTable.ExtendedProperties);
}
return(targetTable);
}
public DBConcurrencyException() : this(Res.GetString(Res.ADP_DBConcurrencyExceptionMessage), null) // MDAC 84941
{
}
