mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
3700 lines
156 KiB
C#
3700 lines
156 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="DataSet.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
// <owner current="true" primary="true">Microsoft</owner>
|
|
// <owner current="true" primary="false">Microsoft</owner>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Data {
|
|
using System;
|
|
using System.Text;
|
|
using System.Runtime.Serialization;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
#if !NO_CONFIGURATION
|
|
using System.Xml.Serialization.Advanced;
|
|
#endif
|
|
using System.Xml.Schema;
|
|
using System.Runtime.Serialization.Formatters.Binary; //Binary Formatter
|
|
using System.CodeDom;
|
|
using System.CodeDom.Compiler;
|
|
using System.Configuration;
|
|
using System.Data.Common;
|
|
using System.Runtime.Versioning;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
#if !COREFX
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Represents an in-memory cache of data.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
ResDescriptionAttribute(Res.DataSetDescr),
|
|
DefaultProperty("DataSetName"),
|
|
ToolboxItem("Microsoft.VSDesigner.Data.VS.DataSetToolboxItem, " + AssemblyRef.MicrosoftVSDesigner),
|
|
Designer("Microsoft.VSDesigner.Data.VS.DataSetDesigner, " + AssemblyRef.MicrosoftVSDesigner),
|
|
Serializable,
|
|
XmlSchemaProvider("GetDataSetSchema"),
|
|
XmlRoot("DataSet")
|
|
]
|
|
public class DataSet : MarshalByValueComponent, System.ComponentModel.IListSource, IXmlSerializable, ISupportInitializeNotification, ISerializable {
|
|
|
|
private DataViewManager defaultViewManager;
|
|
|
|
// Public Collections
|
|
private readonly DataTableCollection tableCollection;
|
|
private readonly DataRelationCollection relationCollection;
|
|
internal PropertyCollection extendedProperties = null;
|
|
private string dataSetName = "NewDataSet";
|
|
private string _datasetPrefix = String.Empty;
|
|
internal string namespaceURI = string.Empty;
|
|
private bool enforceConstraints = true;
|
|
private const String KEY_XMLSCHEMA = "XmlSchema";
|
|
private const String KEY_XMLDIFFGRAM = "XmlDiffGram";
|
|
|
|
// globalization stuff
|
|
private bool _caseSensitive;
|
|
private CultureInfo _culture;
|
|
private bool _cultureUserSet;
|
|
|
|
// Internal definitions
|
|
internal bool fInReadXml = false;
|
|
internal bool fInLoadDiffgram = false;
|
|
internal bool fTopLevelTable = false;
|
|
internal bool fInitInProgress = false;
|
|
internal bool fEnableCascading = true;
|
|
internal bool fIsSchemaLoading = false;
|
|
private bool fBoundToDocument; // for XmlDataDocument
|
|
|
|
// Events
|
|
private PropertyChangedEventHandler onPropertyChangingDelegate;
|
|
private MergeFailedEventHandler onMergeFailed;
|
|
private DataRowCreatedEventHandler onDataRowCreated; // Internal for XmlDataDocument only
|
|
private DataSetClearEventhandler onClearFunctionCalled; // Internal for XmlDataDocument only
|
|
private System.EventHandler onInitialized;
|
|
|
|
|
|
internal readonly static DataTable[] zeroTables = new DataTable[0];
|
|
internal string mainTableName = "";
|
|
|
|
//default remoting format is XML
|
|
private SerializationFormat _remotingFormat = SerializationFormat.Xml;
|
|
|
|
private object _defaultViewManagerLock = new Object();
|
|
|
|
private static int _objectTypeCount; // Bid counter
|
|
private readonly int _objectID = System.Threading.Interlocked.Increment(ref _objectTypeCount);
|
|
private static XmlSchemaComplexType schemaTypeForWSDL = null;
|
|
|
|
internal bool UseDataSetSchemaOnly; // UseDataSetSchemaOnly , for YUKON
|
|
internal bool UdtIsWrapped; // if UDT is wrapped , for YUKON
|
|
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of the <see cref='System.Data.DataSet'/> class.</para>
|
|
/// </devdoc>
|
|
public DataSet() {
|
|
GC.SuppressFinalize(this);
|
|
Bid.Trace("<ds.DataSet.DataSet|API> %d#\n", ObjectID); // others will call this constr
|
|
// Set default locale
|
|
this.tableCollection = new DataTableCollection(this);
|
|
this.relationCollection = new DataRelationCollection.DataSetRelationCollection(this);
|
|
_culture = CultureInfo.CurrentCulture; // Set default locale
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of a <see cref='System.Data.DataSet'/>
|
|
/// class with the given name.</para>
|
|
/// </devdoc>
|
|
public DataSet(string dataSetName)
|
|
: this()
|
|
{
|
|
this.DataSetName = dataSetName;
|
|
}
|
|
|
|
[
|
|
DefaultValue(SerializationFormat.Xml)
|
|
]
|
|
public SerializationFormat RemotingFormat {
|
|
get {
|
|
return _remotingFormat;
|
|
}
|
|
set {
|
|
if (value != SerializationFormat.Binary && value != SerializationFormat.Xml) {
|
|
throw ExceptionBuilder.InvalidRemotingFormat(value);
|
|
}
|
|
_remotingFormat = value;
|
|
// this property is inherited to DataTable from DataSet.So we set this value to DataTable also
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
Tables[i].RemotingFormat = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
[BrowsableAttribute(false)]
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public virtual SchemaSerializationMode SchemaSerializationMode { //Typed DataSet calls into this
|
|
get {
|
|
return SchemaSerializationMode.IncludeSchema;
|
|
}
|
|
set {
|
|
if (value != SchemaSerializationMode.IncludeSchema) {
|
|
throw ExceptionBuilder.CannotChangeSchemaSerializationMode();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check whether the stream is binary serialized.
|
|
// 'static' function that consumes SerializationInfo
|
|
protected bool IsBinarySerialized(SerializationInfo info, StreamingContext context) {// mainly for typed DS
|
|
// our default remoting format is XML
|
|
SerializationFormat remotingFormat = SerializationFormat.Xml;
|
|
SerializationInfoEnumerator e = info.GetEnumerator();
|
|
|
|
while (e.MoveNext()) {
|
|
if (e.Name == "DataSet.RemotingFormat") {//DataSet.RemotingFormat does not exist in V1/V1.1 versions
|
|
remotingFormat = (SerializationFormat)e.Value;
|
|
break;
|
|
}
|
|
}
|
|
return (remotingFormat == SerializationFormat.Binary);
|
|
}
|
|
|
|
// Should Schema be included during Serialization
|
|
// 'static' function that consumes SerializationInfo
|
|
protected SchemaSerializationMode DetermineSchemaSerializationMode(SerializationInfo info, StreamingContext context) { //Typed DataSet calls into this
|
|
SchemaSerializationMode schemaSerializationMode = SchemaSerializationMode.IncludeSchema;
|
|
SerializationInfoEnumerator e = info.GetEnumerator();
|
|
|
|
while (e.MoveNext()) {
|
|
if (e.Name == "SchemaSerializationMode.DataSet") { //SchemaSerializationMode.DataSet does not exist in V1/V1.1 versions
|
|
schemaSerializationMode = (SchemaSerializationMode)e.Value;
|
|
break;
|
|
}
|
|
}
|
|
return schemaSerializationMode;
|
|
}
|
|
|
|
protected SchemaSerializationMode DetermineSchemaSerializationMode(XmlReader reader) { //Typed DataSet calls into this
|
|
SchemaSerializationMode schemaSerializationMode = SchemaSerializationMode.IncludeSchema;
|
|
reader.MoveToContent();
|
|
if (reader.NodeType == XmlNodeType.Element) {
|
|
if (reader.HasAttributes) {
|
|
string attribValue = reader.GetAttribute(Keywords.MSD_SCHEMASERIALIZATIONMODE, Keywords.MSDNS);
|
|
if ((String.Compare(attribValue, Keywords.MSD_EXCLUDESCHEMA, StringComparison.OrdinalIgnoreCase) == 0)) {
|
|
schemaSerializationMode = SchemaSerializationMode.ExcludeSchema;
|
|
}
|
|
else if ((String.Compare(attribValue, Keywords.MSD_INCLUDESCHEMA, StringComparison.OrdinalIgnoreCase) == 0)) {
|
|
schemaSerializationMode = SchemaSerializationMode.IncludeSchema;
|
|
}
|
|
else if (attribValue != null) { // if attrib does not exist, then don't throw
|
|
throw ExceptionBuilder.InvalidSchemaSerializationMode(typeof(SchemaSerializationMode), attribValue);
|
|
}
|
|
}
|
|
}
|
|
return schemaSerializationMode;
|
|
}
|
|
|
|
|
|
// Deserialize all the tables data of the dataset from binary/xml stream.
|
|
// 'instance' method that consumes SerializationInfo
|
|
protected void GetSerializationData(SerializationInfo info, StreamingContext context) {// mainly for typed DS
|
|
SerializationFormat remotingFormat = SerializationFormat.Xml;
|
|
SerializationInfoEnumerator e = info.GetEnumerator();
|
|
|
|
while (e.MoveNext()) {
|
|
if (e.Name == "DataSet.RemotingFormat") { //DataSet.RemotingFormat does not exist in V1/V1.1 versions
|
|
remotingFormat = (SerializationFormat)e.Value;
|
|
break;
|
|
}
|
|
}
|
|
DeserializeDataSetData(info, context, remotingFormat);
|
|
}
|
|
|
|
|
|
// Deserialize all the tables schema and data of the dataset from binary/xml stream.
|
|
protected DataSet(SerializationInfo info, StreamingContext context)
|
|
: this(info, context, true) {
|
|
}
|
|
protected DataSet(SerializationInfo info, StreamingContext context, bool ConstructSchema)
|
|
: this() {
|
|
SerializationFormat remotingFormat = SerializationFormat.Xml;
|
|
SchemaSerializationMode schemaSerializationMode = SchemaSerializationMode.IncludeSchema;
|
|
SerializationInfoEnumerator e = info.GetEnumerator();
|
|
|
|
while (e.MoveNext()) {
|
|
switch (e.Name) {
|
|
case "DataSet.RemotingFormat": //DataSet.RemotingFormat does not exist in V1/V1.1 versions
|
|
remotingFormat = (SerializationFormat)e.Value;
|
|
break;
|
|
case "SchemaSerializationMode.DataSet": //SchemaSerializationMode.DataSet does not exist in V1/V1.1 versions
|
|
schemaSerializationMode = (SchemaSerializationMode)e.Value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (schemaSerializationMode == SchemaSerializationMode.ExcludeSchema) {
|
|
InitializeDerivedDataSet();
|
|
}
|
|
|
|
// adding back this check will fix typed dataset XML remoting, but we have to fix case that
|
|
// a class inherits from DataSet and just relies on DataSet to deserialize (see SQL BU DT 374717)
|
|
// to fix that case also, we need to add a flag and add it to below check so return (no-op) will be
|
|
// conditional (flag needs to be set in TypedDataSet
|
|
if (remotingFormat == SerializationFormat.Xml && !ConstructSchema /* && this.GetType() != typeof(DataSet)*/) {
|
|
return; //For typed dataset xml remoting, this is a no-op
|
|
}
|
|
DeserializeDataSet(info, context, remotingFormat, schemaSerializationMode);
|
|
}
|
|
|
|
|
|
|
|
[System.Security.Permissions.SecurityPermissionAttribute(System.Security.Permissions.SecurityAction.LinkDemand, Flags = System.Security.Permissions.SecurityPermissionFlag.SerializationFormatter)]
|
|
public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {
|
|
SerializationFormat remotingFormat = RemotingFormat;
|
|
SerializeDataSet(info, context, remotingFormat);
|
|
}
|
|
|
|
// Deserialize all the tables data of the dataset from binary/xml stream.
|
|
protected virtual void InitializeDerivedDataSet() {
|
|
return;
|
|
}
|
|
|
|
// Serialize all the tables.
|
|
private void SerializeDataSet(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat) {
|
|
Debug.Assert(info != null);
|
|
info.AddValue("DataSet.RemotingVersion", new Version(2, 0));
|
|
|
|
// SqlHotFix 299, SerializationFormat enumeration types don't exist in V1.1 SP1
|
|
if (SerializationFormat.Xml != remotingFormat) {
|
|
info.AddValue("DataSet.RemotingFormat", remotingFormat);
|
|
}
|
|
|
|
// SqlHotFix 299, SchemaSerializationMode enumeration types don't exist in V1.1 SP1
|
|
if (SchemaSerializationMode.IncludeSchema != SchemaSerializationMode) {
|
|
//SkipSchemaDuringSerialization
|
|
info.AddValue("SchemaSerializationMode.DataSet", SchemaSerializationMode);
|
|
}
|
|
|
|
if (remotingFormat != SerializationFormat.Xml) {
|
|
if (SchemaSerializationMode == SchemaSerializationMode.IncludeSchema) {
|
|
|
|
//DataSet public state properties
|
|
SerializeDataSetProperties(info, context);
|
|
|
|
//Tables Count
|
|
info.AddValue("DataSet.Tables.Count", Tables.Count);
|
|
|
|
//Tables, Columns, Rows
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
BinaryFormatter bf = new BinaryFormatter(null, new StreamingContext(context.State, false));
|
|
MemoryStream memStream = new MemoryStream();
|
|
bf.Serialize(memStream, Tables[i]);
|
|
memStream.Position = 0;
|
|
info.AddValue(String.Format(CultureInfo.InvariantCulture, "DataSet.Tables_{0}", i), memStream.GetBuffer());
|
|
}
|
|
|
|
//Constraints
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
Tables[i].SerializeConstraints(info, context, i, true);
|
|
}
|
|
|
|
//Relations
|
|
SerializeRelations(info, context);
|
|
|
|
//Expression Columns
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
Tables[i].SerializeExpressionColumns(info, context, i);
|
|
}
|
|
}
|
|
else {
|
|
//Serialize DataSet public properties.
|
|
SerializeDataSetProperties(info, context);
|
|
}
|
|
//Rows
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
Tables[i].SerializeTableData(info, context, i);
|
|
}
|
|
} else { // old behaviour
|
|
|
|
String strSchema = this.GetXmlSchemaForRemoting(null);
|
|
|
|
String strData = null;
|
|
info.AddValue(KEY_XMLSCHEMA, strSchema);
|
|
|
|
StringBuilder strBuilder;
|
|
strBuilder = new StringBuilder(EstimatedXmlStringSize() * 2);
|
|
StringWriter strWriter = new StringWriter(strBuilder, CultureInfo.InvariantCulture);
|
|
XmlTextWriter w = new XmlTextWriter(strWriter);
|
|
WriteXml(w, XmlWriteMode.DiffGram);
|
|
strData = strWriter.ToString();
|
|
info.AddValue(KEY_XMLDIFFGRAM, strData);
|
|
}
|
|
}
|
|
|
|
// Deserialize all the tables - marked internal so that DataTable can call into this
|
|
internal void DeserializeDataSet(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat, SchemaSerializationMode schemaSerializationMode) {
|
|
// deserialize schema
|
|
DeserializeDataSetSchema(info, context, remotingFormat, schemaSerializationMode);
|
|
// deserialize data
|
|
DeserializeDataSetData(info, context, remotingFormat);
|
|
}
|
|
|
|
// Deserialize schema.
|
|
private void DeserializeDataSetSchema(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat, SchemaSerializationMode schemaSerializationMode) {
|
|
if (remotingFormat != SerializationFormat.Xml) {
|
|
if (schemaSerializationMode == SchemaSerializationMode.IncludeSchema) {
|
|
//DataSet public state properties
|
|
DeserializeDataSetProperties(info, context);
|
|
|
|
//Tables Count
|
|
int tableCount = info.GetInt32("DataSet.Tables.Count");
|
|
|
|
//Tables, Columns, Rows
|
|
for (int i = 0; i < tableCount; i++) {
|
|
Byte[] buffer = (Byte[])info.GetValue(String.Format(CultureInfo.InvariantCulture, "DataSet.Tables_{0}", i), typeof(Byte[]));
|
|
MemoryStream memStream = new MemoryStream(buffer);
|
|
memStream.Position = 0;
|
|
BinaryFormatter bf = new BinaryFormatter(null, new StreamingContext(context.State, false));
|
|
DataTable dt = (DataTable)bf.Deserialize(memStream);
|
|
Tables.Add(dt);
|
|
}
|
|
|
|
//Constraints
|
|
for (int i = 0; i < tableCount; i++) {
|
|
Tables[i].DeserializeConstraints(info, context, /* table index */i, /* serialize all constraints */ true); //
|
|
}
|
|
|
|
//Relations
|
|
DeserializeRelations(info, context);
|
|
|
|
//Expression Columns
|
|
for (int i = 0; i < tableCount; i++) {
|
|
Tables[i].DeserializeExpressionColumns(info, context, i);
|
|
}
|
|
} else {
|
|
//DeSerialize DataSet public properties.[Locale, CaseSensitive and EnforceConstraints]
|
|
DeserializeDataSetProperties(info, context);
|
|
}
|
|
} else {
|
|
string strSchema = (String)info.GetValue(KEY_XMLSCHEMA, typeof(System.String));
|
|
|
|
if (strSchema != null) {
|
|
this.ReadXmlSchema(new XmlTextReader(new StringReader(strSchema)), true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Deserialize all data.
|
|
private void DeserializeDataSetData(SerializationInfo info, StreamingContext context, SerializationFormat remotingFormat) {
|
|
if (remotingFormat != SerializationFormat.Xml) {
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
Tables[i].DeserializeTableData(info, context, i);
|
|
}
|
|
}
|
|
else {
|
|
string strData = (String)info.GetValue(KEY_XMLDIFFGRAM, typeof(System.String));
|
|
|
|
if (strData != null) {
|
|
this.ReadXml(new XmlTextReader(new StringReader(strData)), XmlReadMode.DiffGram);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Serialize just the dataset properties
|
|
private void SerializeDataSetProperties(SerializationInfo info, StreamingContext context) {
|
|
//DataSet basic properties
|
|
info.AddValue("DataSet.DataSetName", DataSetName);
|
|
info.AddValue("DataSet.Namespace", Namespace);
|
|
info.AddValue("DataSet.Prefix", Prefix);
|
|
//DataSet runtime properties
|
|
info.AddValue("DataSet.CaseSensitive", CaseSensitive);
|
|
info.AddValue("DataSet.LocaleLCID", Locale.LCID);
|
|
info.AddValue("DataSet.EnforceConstraints", EnforceConstraints);
|
|
|
|
//ExtendedProperties
|
|
info.AddValue("DataSet.ExtendedProperties", ExtendedProperties);
|
|
}
|
|
|
|
// DeSerialize dataset properties
|
|
private void DeserializeDataSetProperties(SerializationInfo info, StreamingContext context) {
|
|
//DataSet basic properties
|
|
dataSetName = info.GetString("DataSet.DataSetName");
|
|
namespaceURI = info.GetString("DataSet.Namespace");
|
|
_datasetPrefix = info.GetString("DataSet.Prefix");
|
|
//DataSet runtime properties
|
|
_caseSensitive = info.GetBoolean("DataSet.CaseSensitive");
|
|
int lcid = (int)info.GetValue("DataSet.LocaleLCID", typeof(int));
|
|
_culture = new CultureInfo(lcid);
|
|
_cultureUserSet = true;
|
|
enforceConstraints = info.GetBoolean("DataSet.EnforceConstraints");
|
|
|
|
|
|
|
|
//ExtendedProperties
|
|
extendedProperties = (PropertyCollection)info.GetValue("DataSet.ExtendedProperties", typeof(PropertyCollection));
|
|
}
|
|
|
|
// Gets relation info from the dataset.
|
|
// ***Schema for Serializing ArrayList of Relations***
|
|
// Relations -> [relationName]->[parentTableIndex, parentcolumnIndexes]->[childTableIndex, childColumnIndexes]->[Nested]->[extendedProperties]
|
|
private void SerializeRelations(SerializationInfo info, StreamingContext context) {
|
|
ArrayList relationList = new ArrayList();
|
|
|
|
foreach (DataRelation rel in Relations) {
|
|
int[] parentInfo = new int[rel.ParentColumns.Length + 1];
|
|
|
|
parentInfo[0] = Tables.IndexOf(rel.ParentTable);
|
|
for (int j = 1; j < parentInfo.Length; j++) {
|
|
parentInfo[j] = rel.ParentColumns[j - 1].Ordinal;
|
|
}
|
|
|
|
int[] childInfo = new int[rel.ChildColumns.Length + 1];
|
|
childInfo[0] = Tables.IndexOf(rel.ChildTable);
|
|
for (int j = 1; j < childInfo.Length; j++) {
|
|
childInfo[j] = rel.ChildColumns[j - 1].Ordinal;
|
|
}
|
|
|
|
ArrayList list = new ArrayList();
|
|
list.Add(rel.RelationName);
|
|
list.Add(parentInfo);
|
|
list.Add(childInfo);
|
|
list.Add(rel.Nested);
|
|
list.Add(rel.extendedProperties);
|
|
|
|
relationList.Add(list);
|
|
}
|
|
info.AddValue("DataSet.Relations", relationList);
|
|
}
|
|
|
|
/*
|
|
Adds relations to the dataset.
|
|
***Schema for Serializing ArrayList of Relations***
|
|
Relations -> [relationName]->[parentTableIndex, parentcolumnIndexes]->[childTableIndex, childColumnIndexes]->[Nested]->[extendedProperties]
|
|
*/
|
|
private void DeserializeRelations(SerializationInfo info, StreamingContext context) {
|
|
ArrayList relationList = (ArrayList)info.GetValue("DataSet.Relations", typeof(ArrayList));
|
|
|
|
foreach (ArrayList list in relationList) {
|
|
string relationName = (string)list[0];
|
|
int[] parentInfo = (int[])list[1];
|
|
int[] childInfo = (int[])list[2];
|
|
bool isNested = (bool)list[3];
|
|
PropertyCollection extendedProperties = (PropertyCollection)list[4];
|
|
|
|
//ParentKey Columns.
|
|
DataColumn[] parentkeyColumns = new DataColumn[parentInfo.Length - 1];
|
|
for (int i = 0; i < parentkeyColumns.Length; i++) {
|
|
parentkeyColumns[i] = Tables[parentInfo[0]].Columns[parentInfo[i + 1]];
|
|
}
|
|
|
|
//ChildKey Columns.
|
|
DataColumn[] childkeyColumns = new DataColumn[childInfo.Length - 1];
|
|
for (int i = 0; i < childkeyColumns.Length; i++) {
|
|
childkeyColumns[i] = Tables[childInfo[0]].Columns[childInfo[i + 1]];
|
|
}
|
|
|
|
//Create the Relation, without any constraints[Assumption: The constraints are added earlier than the relations]
|
|
DataRelation rel = new DataRelation(relationName, parentkeyColumns, childkeyColumns, false);
|
|
rel.CheckMultipleNested = false; // disable the check for multiple nested parent
|
|
rel.Nested = isNested;
|
|
rel.extendedProperties = extendedProperties;
|
|
|
|
Relations.Add(rel);
|
|
rel.CheckMultipleNested = true; // enable the check for multiple nested parent
|
|
}
|
|
}
|
|
|
|
internal void FailedEnableConstraints() {
|
|
this.EnforceConstraints = false;
|
|
throw ExceptionBuilder.EnforceConstraint();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets or sets a value indicating whether string
|
|
/// comparisons within <see cref='System.Data.DataTable'/>
|
|
/// objects are
|
|
/// case-sensitive.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
DefaultValue(false),
|
|
ResDescriptionAttribute(Res.DataSetCaseSensitiveDescr)
|
|
]
|
|
public bool CaseSensitive {
|
|
get {
|
|
return _caseSensitive;
|
|
}
|
|
set {
|
|
if (_caseSensitive != value)
|
|
{
|
|
bool oldValue = _caseSensitive;
|
|
_caseSensitive = value;
|
|
|
|
if (!ValidateCaseConstraint()) {
|
|
_caseSensitive = oldValue;
|
|
throw ExceptionBuilder.CannotChangeCaseLocale();
|
|
}
|
|
|
|
foreach (DataTable table in Tables) {
|
|
table.SetCaseSensitiveValue(value, false, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool System.ComponentModel.IListSource.ContainsListCollection {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets a custom view of the data contained by the <see cref='System.Data.DataSet'/> , one
|
|
/// that allows filtering, searching, and navigating through the custom data view.</para>
|
|
/// </devdoc>
|
|
[Browsable(false), ResDescriptionAttribute(Res.DataSetDefaultViewDescr)]
|
|
public DataViewManager DefaultViewManager {
|
|
get {
|
|
if (defaultViewManager == null) {
|
|
lock (_defaultViewManagerLock) {
|
|
if (defaultViewManager == null) {
|
|
defaultViewManager = new DataViewManager(this, true);
|
|
}
|
|
}
|
|
}
|
|
return defaultViewManager;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets or sets a value indicating whether constraint rules are followed when
|
|
/// attempting any update operation.</para>
|
|
/// </devdoc>
|
|
[DefaultValue(true), ResDescriptionAttribute(Res.DataSetEnforceConstraintsDescr)]
|
|
public bool EnforceConstraints {
|
|
get {
|
|
return enforceConstraints;
|
|
}
|
|
set {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.set_EnforceConstraints|API> %d#, %d{bool}\n", ObjectID, value);
|
|
try {
|
|
if (this.enforceConstraints != value) {
|
|
if (value)
|
|
EnableConstraints();
|
|
this.enforceConstraints = value;
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void RestoreEnforceConstraints(bool value) {
|
|
this.enforceConstraints = value;
|
|
}
|
|
|
|
internal void EnableConstraints()
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.EnableConstraints|INFO> %d#\n", ObjectID);
|
|
try {
|
|
bool errors = false;
|
|
for (ConstraintEnumerator constraints = new ConstraintEnumerator(this); constraints.GetNext(); ) {
|
|
Constraint constraint = (Constraint)constraints.GetConstraint();
|
|
errors |= constraint.IsConstraintViolated();
|
|
}
|
|
|
|
foreach (DataTable table in Tables) {
|
|
foreach (DataColumn column in table.Columns) {
|
|
if (!column.AllowDBNull) {
|
|
errors |= column.IsNotAllowDBNullViolated();
|
|
}
|
|
if (column.MaxLength >= 0) {
|
|
errors |= column.IsMaxLengthViolated();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (errors)
|
|
this.FailedEnableConstraints();
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets or
|
|
/// sets the name of this <see cref='System.Data.DataSet'/> .</para>
|
|
/// </devdoc>
|
|
[
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
DefaultValue(""),
|
|
ResDescriptionAttribute(Res.DataSetDataSetNameDescr)
|
|
]
|
|
public string DataSetName {
|
|
get {
|
|
return dataSetName;
|
|
}
|
|
set {
|
|
Bid.Trace("<ds.DataSet.set_DataSetName|API> %d#, '%ls'\n", ObjectID, value);
|
|
if (value != dataSetName) {
|
|
if (value == null || value.Length == 0)
|
|
throw ExceptionBuilder.SetDataSetNameToEmpty();
|
|
DataTable conflicting = Tables[value, Namespace];
|
|
if ((conflicting != null) && (!conflicting.fNestedInDataset))
|
|
throw ExceptionBuilder.SetDataSetNameConflicting(value);
|
|
RaisePropertyChanging("DataSetName");
|
|
this.dataSetName = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
ResDescriptionAttribute(Res.DataSetNamespaceDescr)
|
|
]
|
|
public string Namespace {
|
|
get {
|
|
return namespaceURI;
|
|
}
|
|
set {
|
|
Bid.Trace("<ds.DataSet.set_Namespace|API> %d#, '%ls'\n", ObjectID, value);
|
|
if (value == null)
|
|
value = String.Empty;
|
|
if (value != namespaceURI) {
|
|
RaisePropertyChanging("Namespace");
|
|
foreach (DataTable dt in Tables) {
|
|
if (dt.tableNamespace != null)
|
|
continue;
|
|
if ((dt.NestedParentRelations.Length == 0) ||
|
|
(dt.NestedParentRelations.Length == 1 && dt.NestedParentRelations[0].ChildTable == dt)) {
|
|
// dt.SelfNestedWithOneRelation) { // this is wrong bug it was previous behavior
|
|
if (Tables.Contains(dt.TableName, value, false, true))
|
|
throw ExceptionBuilder.DuplicateTableName2(dt.TableName, value);
|
|
dt.CheckCascadingNamespaceConflict(value);
|
|
dt.DoRaiseNamespaceChange();
|
|
}
|
|
}
|
|
namespaceURI = value;
|
|
|
|
|
|
if (Common.ADP.IsEmpty(value))
|
|
_datasetPrefix = String.Empty;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[
|
|
DefaultValue(""),
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
ResDescriptionAttribute(Res.DataSetPrefixDescr)
|
|
]
|
|
public string Prefix {
|
|
get { return _datasetPrefix; }
|
|
set {
|
|
if (value == null)
|
|
value = String.Empty;
|
|
|
|
if ((XmlConvert.DecodeName(value) == value) &&
|
|
(XmlConvert.EncodeName(value) != value))
|
|
throw ExceptionBuilder.InvalidPrefix(value);
|
|
|
|
|
|
if (value != _datasetPrefix) {
|
|
RaisePropertyChanging("Prefix");
|
|
_datasetPrefix = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets the collection of custom user information.</para>
|
|
/// </devdoc>
|
|
[
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
Browsable(false),
|
|
ResDescriptionAttribute(Res.ExtendedPropertiesDescr)
|
|
]
|
|
public PropertyCollection ExtendedProperties {
|
|
get {
|
|
if (extendedProperties == null) {
|
|
extendedProperties = new PropertyCollection();
|
|
}
|
|
return extendedProperties;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets a value indicating whether there are errors in any
|
|
/// of the rows in any of the tables of this <see cref='System.Data.DataSet'/> .
|
|
/// </para>
|
|
/// </devdoc>
|
|
[Browsable(false), ResDescriptionAttribute(Res.DataSetHasErrorsDescr)]
|
|
public bool HasErrors {
|
|
get {
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
if (Tables[i].HasErrors)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
[Browsable(false)]
|
|
public bool IsInitialized {
|
|
get {
|
|
return !fInitInProgress;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets or sets the locale information used to compare strings within the table.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
ResDescriptionAttribute(Res.DataSetLocaleDescr)
|
|
]
|
|
public CultureInfo Locale {
|
|
get {
|
|
// used for comparing not formating/parsing
|
|
Debug.Assert(null != _culture, "DataSet.Locale: null culture");
|
|
return _culture;
|
|
}
|
|
set {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.set_Locale|API> %d#\n", ObjectID);
|
|
try {
|
|
if (value != null) {
|
|
if (!_culture.Equals(value)) {
|
|
SetLocaleValue(value, true);
|
|
}
|
|
_cultureUserSet = true;
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void SetLocaleValue(CultureInfo value, bool userSet) {
|
|
bool flag = false;
|
|
bool exceptionThrown = false;
|
|
int tableCount = 0;
|
|
|
|
CultureInfo oldLocale = _culture;
|
|
bool oldUserSet = _cultureUserSet;
|
|
|
|
try {
|
|
_culture = value;
|
|
_cultureUserSet = userSet;
|
|
|
|
foreach (DataTable table in Tables) {
|
|
if (!table.ShouldSerializeLocale()) {
|
|
bool retchk = table.SetLocaleValue(value, false, false);
|
|
//Debug.Assert(retchk == table.ShouldSerializeLocale(), "unexpected setting of table locale"); may fire with Deserialize
|
|
}
|
|
}
|
|
|
|
flag = ValidateLocaleConstraint();
|
|
if (flag) {
|
|
flag = false;
|
|
foreach (DataTable table in Tables) {
|
|
tableCount++;
|
|
if (!table.ShouldSerializeLocale()) {
|
|
table.SetLocaleValue(value, false, true);
|
|
}
|
|
}
|
|
flag = true;
|
|
}
|
|
}
|
|
catch {
|
|
exceptionThrown = true;
|
|
throw;
|
|
}
|
|
finally {
|
|
if (!flag) { // reset old locale if ValidationFailed or exception thrown
|
|
_culture = oldLocale;
|
|
_cultureUserSet = oldUserSet;
|
|
foreach (DataTable table in Tables) {
|
|
if (!table.ShouldSerializeLocale()) {
|
|
table.SetLocaleValue(oldLocale, false, false);
|
|
}
|
|
}
|
|
try {
|
|
for (int i = 0; i < tableCount; ++i) {
|
|
if (!Tables[i].ShouldSerializeLocale()) {
|
|
Tables[i].SetLocaleValue(oldLocale, false, true);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
if (!Common.ADP.IsCatchableExceptionType(e)) {
|
|
throw;
|
|
}
|
|
Common.ADP.TraceExceptionWithoutRethrow(e);
|
|
}
|
|
if (!exceptionThrown) {
|
|
throw ExceptionBuilder.CannotChangeCaseLocale(null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal bool ShouldSerializeLocale() {
|
|
// this method is used design-time scenarios via reflection
|
|
// by the property grid to show the Locale property in bold or not
|
|
// by the code dom for persisting the Locale property or not
|
|
|
|
// we always want the locale persisted if set by user or different the current thread
|
|
// but that logic should by performed by the serializion code
|
|
return _cultureUserSet;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
|
|
public override ISite Site {
|
|
get {
|
|
return base.Site;
|
|
}
|
|
set {
|
|
ISite oldSite = Site;
|
|
if (value == null && oldSite != null) {
|
|
IContainer cont = oldSite.Container;
|
|
|
|
if (cont != null) {
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
if (Tables[i].Site != null) {
|
|
cont.Remove(Tables[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
base.Site = value;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Get the collection of relations that link tables and
|
|
/// allow navigation from parent tables to child tables.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
ResDescriptionAttribute(Res.DataSetRelationsDescr)
|
|
]
|
|
public DataRelationCollection Relations {
|
|
get {
|
|
return relationCollection;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Indicates whether <see cref='Relations'/> property should be persisted.
|
|
/// </para>
|
|
/// </devdoc>
|
|
protected virtual bool ShouldSerializeRelations() {
|
|
return true; /*Relations.Count > 0;*/ // VS7 300569
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Resets the <see cref='System.Data.DataSet.Relations'/> property to its default state.
|
|
/// </para>
|
|
/// </devdoc>
|
|
private void ResetRelations()
|
|
{
|
|
Relations.Clear();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets the collection of tables contained in the <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
[
|
|
DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
|
|
ResCategoryAttribute(Res.DataCategory_Data),
|
|
ResDescriptionAttribute(Res.DataSetTablesDescr)
|
|
]
|
|
public DataTableCollection Tables {
|
|
get {
|
|
return tableCollection;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Indicates whether <see cref='System.Data.DataSet.Tables'/> property should be persisted.
|
|
/// </para>
|
|
/// </devdoc>
|
|
protected virtual bool ShouldSerializeTables() {
|
|
return true;/*(Tables.Count > 0);*/ // VS7 300569
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Resets the <see cref='System.Data.DataSet.Tables'/> property to its default state.
|
|
/// </para>
|
|
/// </devdoc>
|
|
private void ResetTables()
|
|
{
|
|
Tables.Clear();
|
|
}
|
|
|
|
internal bool FBoundToDocument {
|
|
get {
|
|
return fBoundToDocument;
|
|
}
|
|
set {
|
|
fBoundToDocument = value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Commits all the changes made to this <see cref='System.Data.DataSet'/> since it was loaded or the last
|
|
/// time <see cref='System.Data.DataSet.AcceptChanges'/> was called.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void AcceptChanges()
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.AcceptChanges|API> %d#\n", ObjectID);
|
|
try {
|
|
for (int i = 0; i < Tables.Count; i++)
|
|
Tables[i].AcceptChanges();
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
internal event PropertyChangedEventHandler PropertyChanging {
|
|
add {
|
|
onPropertyChangingDelegate += value;
|
|
}
|
|
remove {
|
|
onPropertyChangingDelegate -= value;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Occurs when attempting to merge schemas for two tables with the same
|
|
/// name.</para>
|
|
/// </devdoc>
|
|
[
|
|
ResCategoryAttribute(Res.DataCategory_Action),
|
|
ResDescriptionAttribute(Res.DataSetMergeFailedDescr)
|
|
]
|
|
public event MergeFailedEventHandler MergeFailed {
|
|
add {
|
|
onMergeFailed += value;
|
|
}
|
|
remove {
|
|
onMergeFailed -= value;
|
|
}
|
|
}
|
|
|
|
internal event DataRowCreatedEventHandler DataRowCreated {
|
|
add {
|
|
onDataRowCreated += value;
|
|
}
|
|
remove {
|
|
onDataRowCreated -= value;
|
|
}
|
|
}
|
|
|
|
internal event DataSetClearEventhandler ClearFunctionCalled {
|
|
add {
|
|
onClearFunctionCalled += value;
|
|
}
|
|
remove {
|
|
onClearFunctionCalled -= value;
|
|
}
|
|
}
|
|
|
|
[
|
|
ResCategoryAttribute(Res.DataCategory_Action),
|
|
ResDescriptionAttribute(Res.DataSetInitializedDescr)
|
|
]
|
|
public event System.EventHandler Initialized {
|
|
add {
|
|
onInitialized += value;
|
|
}
|
|
remove {
|
|
onInitialized -= value;
|
|
}
|
|
}
|
|
|
|
public void BeginInit() {
|
|
fInitInProgress = true;
|
|
}
|
|
|
|
public void EndInit() {
|
|
Tables.FinishInitCollection();
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
Tables[i].Columns.FinishInitCollection();
|
|
}
|
|
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
Tables[i].Constraints.FinishInitConstraints();
|
|
}
|
|
|
|
((DataRelationCollection.DataSetRelationCollection)Relations).FinishInitRelations();
|
|
|
|
fInitInProgress = false;
|
|
OnInitialized();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Clears the <see cref='System.Data.DataSet'/> of any data by removing all rows in all tables.</para>
|
|
/// </devdoc>
|
|
public void Clear()
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Clear|API> %d#\n", ObjectID);
|
|
try {
|
|
OnClearFunctionCalled(null);
|
|
bool fEnforce = EnforceConstraints;
|
|
EnforceConstraints = false;
|
|
for (int i = 0; i < Tables.Count; i++)
|
|
Tables[i].Clear();
|
|
EnforceConstraints = fEnforce;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Clones the structure of the <see cref='System.Data.DataSet'/>, including all <see cref='System.Data.DataTable'/> schemas, relations, and
|
|
/// constraints.</para>
|
|
/// </devdoc>
|
|
// Prevent inlining so that reflection calls are not moved to caller that may be in a different assembly that may have a different grant set.
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|
public virtual DataSet Clone() {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Clone|API> %d#\n", ObjectID);
|
|
try {
|
|
DataSet ds = (DataSet)Activator.CreateInstance(this.GetType(), true);
|
|
|
|
if (ds.Tables.Count > 0) // Microsoft : To clean up all the schema in strong typed dataset.
|
|
ds.Reset();
|
|
|
|
//copy some original dataset properties
|
|
ds.DataSetName = DataSetName;
|
|
ds.CaseSensitive = CaseSensitive;
|
|
ds._culture = _culture;
|
|
ds._cultureUserSet = _cultureUserSet;
|
|
ds.EnforceConstraints = EnforceConstraints;
|
|
ds.Namespace = Namespace;
|
|
ds.Prefix = Prefix;
|
|
ds.RemotingFormat = RemotingFormat;
|
|
ds.fIsSchemaLoading = true; //delay expression evaluation
|
|
|
|
|
|
// ...Tables...
|
|
DataTableCollection tbls = Tables;
|
|
for (int i = 0; i < tbls.Count; i++) {
|
|
DataTable dt = tbls[i].Clone(ds);
|
|
dt.tableNamespace = tbls[i].Namespace; // hardcode the namespace for a second to not mess up
|
|
// DataRelation cloning.
|
|
ds.Tables.Add(dt);
|
|
}
|
|
|
|
// ...Constraints...
|
|
for (int i = 0; i < tbls.Count; i++) {
|
|
ConstraintCollection constraints = tbls[i].Constraints;
|
|
for (int j = 0; j < constraints.Count; j++) {
|
|
if (constraints[j] is UniqueConstraint)
|
|
continue;
|
|
ForeignKeyConstraint foreign = constraints[j] as ForeignKeyConstraint;
|
|
if (foreign.Table == foreign.RelatedTable)
|
|
continue;// we have already added this foreign key in while cloning the datatable
|
|
ds.Tables[i].Constraints.Add(constraints[j].Clone(ds));
|
|
}
|
|
}
|
|
|
|
// ...Relations...
|
|
DataRelationCollection rels = Relations;
|
|
for (int i = 0; i < rels.Count; i++) {
|
|
DataRelation rel = rels[i].Clone(ds);
|
|
rel.CheckMultipleNested = false; // disable the check for multiple nested parent
|
|
ds.Relations.Add(rel);
|
|
rel.CheckMultipleNested = true; // enable the check for multiple nested parent
|
|
}
|
|
|
|
// ...Extended Properties...
|
|
if (this.extendedProperties != null) {
|
|
foreach (Object key in this.extendedProperties.Keys) {
|
|
ds.ExtendedProperties[key] = this.extendedProperties[key];
|
|
}
|
|
}
|
|
|
|
foreach (DataTable table in Tables)
|
|
foreach (DataColumn col in table.Columns)
|
|
if (col.Expression.Length != 0)
|
|
ds.Tables[table.TableName, table.Namespace].Columns[col.ColumnName].Expression = col.Expression;
|
|
|
|
for (int i = 0; i < tbls.Count; i++) {
|
|
ds.Tables[i].tableNamespace = tbls[i].tableNamespace; // undo the hardcoding of the namespace
|
|
}
|
|
|
|
ds.fIsSchemaLoading = false; //reactivate column computations
|
|
|
|
return ds;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Copies both the structure and data for this <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
public DataSet Copy()
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Copy|API> %d#\n", ObjectID);
|
|
try {
|
|
DataSet dsNew = Clone();
|
|
bool fEnforceConstraints = dsNew.EnforceConstraints;
|
|
dsNew.EnforceConstraints = false;
|
|
foreach (DataTable table in this.Tables)
|
|
{
|
|
DataTable destTable = dsNew.Tables[table.TableName, table.Namespace];
|
|
|
|
foreach (DataRow row in table.Rows)
|
|
table.CopyRow(destTable, row);
|
|
}
|
|
|
|
dsNew.EnforceConstraints = fEnforceConstraints;
|
|
|
|
return dsNew;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
internal Int32 EstimatedXmlStringSize()
|
|
{
|
|
Int32 bytes = 100;
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
Int32 rowBytes = (Tables[i].TableName.Length + 4) << 2;
|
|
DataTable table = Tables[i];
|
|
for (int j = 0; j < table.Columns.Count; j++) {
|
|
rowBytes += ((table.Columns[j].ColumnName.Length + 4) << 2);
|
|
rowBytes += 20;
|
|
}
|
|
bytes += table.Rows.Count * rowBytes;
|
|
}
|
|
|
|
return bytes;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Returns a copy of the <see cref='System.Data.DataSet'/> that contains all changes made to
|
|
/// it since it was loaded or <see cref='System.Data.DataSet.AcceptChanges'/>
|
|
/// was last called.</para>
|
|
/// </devdoc>
|
|
public DataSet GetChanges()
|
|
{
|
|
return GetChanges(DataRowState.Added | DataRowState.Deleted | DataRowState.Modified);
|
|
}
|
|
|
|
private struct TableChanges {
|
|
private BitArray _rowChanges;
|
|
private int _hasChanges;
|
|
|
|
internal TableChanges(int rowCount) {
|
|
_rowChanges = new BitArray(rowCount);
|
|
_hasChanges = 0;
|
|
}
|
|
internal int HasChanges {
|
|
get { return _hasChanges; }
|
|
set { _hasChanges = value; }
|
|
}
|
|
internal bool this[int index] {
|
|
get { return _rowChanges[index]; }
|
|
set {
|
|
Debug.Assert(value && !_rowChanges[index], "setting twice or to false");
|
|
_rowChanges[index] = value;
|
|
_hasChanges++;
|
|
}
|
|
}
|
|
}
|
|
|
|
public DataSet GetChanges(DataRowState rowStates)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.GetChanges|API> %d#, rowStates=%d{ds.DataRowState}\n", ObjectID, (int)rowStates);
|
|
try {
|
|
DataSet dsNew = null;
|
|
bool fEnforceConstraints = false;
|
|
if (0 != (rowStates & ~(DataRowState.Added | DataRowState.Deleted | DataRowState.Modified | DataRowState.Unchanged))) {
|
|
throw ExceptionBuilder.InvalidRowState(rowStates);
|
|
}
|
|
|
|
// Initialize all the individual table bitmaps.
|
|
TableChanges[] bitMatrix = new TableChanges[Tables.Count];
|
|
for (int i = 0; i < bitMatrix.Length; ++i) {
|
|
bitMatrix[i] = new TableChanges(Tables[i].Rows.Count);
|
|
}
|
|
|
|
// find all the modified rows and their parents
|
|
MarkModifiedRows(bitMatrix, rowStates);
|
|
|
|
// copy the changes to a cloned table
|
|
for (int i = 0; i < bitMatrix.Length; ++i) {
|
|
Debug.Assert(0 <= bitMatrix[i].HasChanges, "negative change count");
|
|
if (0 < bitMatrix[i].HasChanges) {
|
|
if (null == dsNew) {
|
|
dsNew = this.Clone();
|
|
fEnforceConstraints = dsNew.EnforceConstraints;
|
|
dsNew.EnforceConstraints = false;
|
|
}
|
|
|
|
DataTable table = this.Tables[i];
|
|
DataTable destTable = dsNew.Tables[table.TableName, table.Namespace];
|
|
Debug.Assert(bitMatrix[i].HasChanges <= table.Rows.Count, "to many changes");
|
|
|
|
for (int j = 0; 0 < bitMatrix[i].HasChanges; ++j) { // Loop through the rows.
|
|
if (bitMatrix[i][j]) {
|
|
table.CopyRow(destTable, table.Rows[j]);
|
|
bitMatrix[i].HasChanges--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (null != dsNew) {
|
|
dsNew.EnforceConstraints = fEnforceConstraints;
|
|
}
|
|
return dsNew;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
private void MarkModifiedRows(TableChanges[] bitMatrix, DataRowState rowStates) {
|
|
// for every table, every row & every relation find the modified rows and for non-deleted rows, their parents
|
|
for (int tableIndex = 0; tableIndex < bitMatrix.Length; ++tableIndex) {
|
|
DataRowCollection rows = Tables[tableIndex].Rows;
|
|
int rowCount = rows.Count;
|
|
|
|
for (int rowIndex = 0; rowIndex < rowCount; ++rowIndex) {
|
|
DataRow row = rows[rowIndex];
|
|
DataRowState rowState = row.RowState;
|
|
Debug.Assert(DataRowState.Added == rowState ||
|
|
DataRowState.Deleted == rowState ||
|
|
DataRowState.Modified == rowState ||
|
|
DataRowState.Unchanged == rowState,
|
|
"unexpected DataRowState");
|
|
|
|
// if bit not already set and row is modified
|
|
if ((0 != (rowStates & rowState)) && !bitMatrix[tableIndex][rowIndex]) {
|
|
bitMatrix[tableIndex][rowIndex] = true;
|
|
|
|
if (DataRowState.Deleted != rowState) {
|
|
MarkRelatedRowsAsModified(bitMatrix, row);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MarkRelatedRowsAsModified(TableChanges[] bitMatrix, DataRow row) {
|
|
DataRelationCollection relations = row.Table.ParentRelations;
|
|
int relationCount = relations.Count;
|
|
for (int relatedIndex = 0; relatedIndex < relationCount; ++relatedIndex) {
|
|
DataRow[] relatedRows = row.GetParentRows(relations[relatedIndex], DataRowVersion.Current);
|
|
|
|
foreach (DataRow relatedRow in relatedRows) {
|
|
int relatedTableIndex = this.Tables.IndexOf(relatedRow.Table);
|
|
int relatedRowIndex = relatedRow.Table.Rows.IndexOf(relatedRow);
|
|
|
|
if (!bitMatrix[relatedTableIndex][relatedRowIndex]) {
|
|
bitMatrix[relatedTableIndex][relatedRowIndex] = true;
|
|
|
|
if (DataRowState.Deleted != relatedRow.RowState) {
|
|
// recurse into related rows
|
|
MarkRelatedRowsAsModified(bitMatrix, relatedRow);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
IList System.ComponentModel.IListSource.GetList() {
|
|
return DefaultViewManager;
|
|
}
|
|
|
|
internal string GetRemotingDiffGram(DataTable table)
|
|
{
|
|
StringWriter strWriter = new StringWriter(CultureInfo.InvariantCulture);
|
|
XmlTextWriter writer = new XmlTextWriter(strWriter);
|
|
writer.Formatting = Formatting.Indented;
|
|
if (strWriter != null) {
|
|
// Create and save the updates
|
|
new NewDiffgramGen(table, false).Save(writer, table);
|
|
}
|
|
|
|
return strWriter.ToString();
|
|
}
|
|
|
|
public string GetXml()
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.GetXml|API> %d#\n", ObjectID);
|
|
try {
|
|
|
|
// StringBuilder strBuilder = new StringBuilder(EstimatedXmlStringSize());
|
|
// StringWriter strWriter = new StringWriter(strBuilder);
|
|
StringWriter strWriter = new StringWriter(CultureInfo.InvariantCulture);
|
|
if (strWriter != null) {
|
|
XmlTextWriter w = new XmlTextWriter(strWriter);
|
|
w.Formatting = Formatting.Indented;
|
|
new XmlDataTreeWriter(this).Save(w, false);
|
|
}
|
|
return strWriter.ToString();
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
public string GetXmlSchema()
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.GetXmlSchema|API> %d#\n", ObjectID);
|
|
try {
|
|
StringWriter strWriter = new StringWriter(CultureInfo.InvariantCulture);
|
|
XmlTextWriter writer = new XmlTextWriter(strWriter);
|
|
writer.Formatting = Formatting.Indented;
|
|
if (strWriter != null) {
|
|
(new XmlTreeGen(SchemaFormat.Public)).Save(this, writer);
|
|
}
|
|
|
|
return strWriter.ToString();
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
internal string GetXmlSchemaForRemoting(DataTable table)
|
|
{
|
|
StringWriter strWriter = new StringWriter(CultureInfo.InvariantCulture);
|
|
XmlTextWriter writer = new XmlTextWriter(strWriter);
|
|
writer.Formatting = Formatting.Indented;
|
|
if (strWriter != null) {
|
|
if (table == null) {
|
|
if (this.SchemaSerializationMode == SchemaSerializationMode.ExcludeSchema)
|
|
(new XmlTreeGen(SchemaFormat.RemotingSkipSchema)).Save(this, writer);
|
|
else
|
|
(new XmlTreeGen(SchemaFormat.Remoting)).Save(this, writer);
|
|
}
|
|
else { // no skip schema support for typed datatable
|
|
(new XmlTreeGen(SchemaFormat.Remoting)).Save(table, writer);
|
|
}
|
|
}
|
|
|
|
return strWriter.ToString();
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets a value indicating whether the <see cref='System.Data.DataSet'/> has changes, including new,
|
|
/// deleted, or modified rows.</para>
|
|
/// </devdoc>
|
|
public bool HasChanges()
|
|
{
|
|
return HasChanges(DataRowState.Added | DataRowState.Deleted | DataRowState.Modified);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Gets a value indicating whether the <see cref='System.Data.DataSet'/> has changes, including new,
|
|
/// deleted, or modified rows, filtered by <see cref='System.Data.DataRowState'/>.</para>
|
|
/// </devdoc>
|
|
public bool HasChanges(DataRowState rowStates)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.HasChanges|API> %d#, rowStates=%d{ds.DataRowState}\n", ObjectID, (int)rowStates);
|
|
|
|
try {
|
|
const DataRowState allRowStates = DataRowState.Detached | DataRowState.Unchanged | DataRowState.Added | DataRowState.Deleted | DataRowState.Modified;
|
|
|
|
if ((rowStates & (~allRowStates)) != 0) {
|
|
throw ExceptionBuilder.ArgumentOutOfRange("rowState");
|
|
}
|
|
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
DataTable table = Tables[i];
|
|
|
|
for (int j = 0; j < table.Rows.Count; j++) {
|
|
DataRow row = table.Rows[j];
|
|
if ((row.RowState & rowStates) != 0) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Infer the XML schema from the specified <see cref='System.IO.TextReader'/> into the <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
public void InferXmlSchema(XmlReader reader, string[] nsArray)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.InferXmlSchema|API> %d#\n", ObjectID);
|
|
try {
|
|
if (reader == null)
|
|
return;
|
|
|
|
XmlDocument xdoc = new XmlDocument();
|
|
if (reader.NodeType == XmlNodeType.Element) {
|
|
XmlNode node = xdoc.ReadNode(reader);
|
|
xdoc.AppendChild(node);
|
|
}
|
|
else
|
|
xdoc.Load(reader);
|
|
if (xdoc.DocumentElement == null)
|
|
return;
|
|
|
|
InferSchema(xdoc, nsArray, XmlReadMode.InferSchema);
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Infer the XML schema from the specified <see cref='System.IO.TextReader'/> into the <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
public void InferXmlSchema(Stream stream, string[] nsArray)
|
|
{
|
|
if (stream == null)
|
|
return;
|
|
|
|
InferXmlSchema(new XmlTextReader(stream), nsArray);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Infer the XML schema from the specified <see cref='System.IO.TextReader'/> into the <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
public void InferXmlSchema(TextReader reader, string[] nsArray)
|
|
{
|
|
if (reader == null)
|
|
return;
|
|
|
|
InferXmlSchema(new XmlTextReader(reader), nsArray);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Infer the XML schema from the specified file into the <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
public void InferXmlSchema(String fileName, string[] nsArray)
|
|
{
|
|
XmlTextReader xr = new XmlTextReader(fileName);
|
|
try {
|
|
InferXmlSchema(xr, nsArray);
|
|
}
|
|
finally {
|
|
xr.Close();
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Reads the XML schema from the specified <see cref='T:System.Xml.XMLReader'/> into the <see cref='System.Data.DataSet'/>
|
|
/// .</para>
|
|
/// </devdoc>
|
|
public void ReadXmlSchema(XmlReader reader)
|
|
{
|
|
ReadXmlSchema(reader, false);
|
|
}
|
|
|
|
internal void ReadXmlSchema(XmlReader reader, bool denyResolving)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.ReadXmlSchema|INFO> %d#, reader, denyResolving=%d{bool}\n", ObjectID, denyResolving);
|
|
try {
|
|
int iCurrentDepth = -1;
|
|
|
|
if (reader == null)
|
|
return;
|
|
|
|
if (reader is XmlTextReader)
|
|
((XmlTextReader)reader).WhitespaceHandling = WhitespaceHandling.None;
|
|
|
|
XmlDocument xdoc = new XmlDocument(); // we may need this to infer the schema
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
iCurrentDepth = reader.Depth;
|
|
|
|
reader.MoveToContent();
|
|
|
|
if (reader.NodeType == XmlNodeType.Element) {
|
|
// if reader points to the schema load it...
|
|
|
|
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI == Keywords.XDRNS) {
|
|
// load XDR schema and exit
|
|
ReadXDRSchema(reader);
|
|
return;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
|
|
// load XSD schema and exit
|
|
ReadXSDSchema(reader, denyResolving);
|
|
return;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))
|
|
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
|
|
|
|
// ... otherwise backup the top node and all its attributes
|
|
XmlElement topNode = xdoc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
|
|
if (reader.HasAttributes) {
|
|
int attrCount = reader.AttributeCount;
|
|
for (int i = 0; i < attrCount; i++) {
|
|
reader.MoveToAttribute(i);
|
|
if (reader.NamespaceURI.Equals(Keywords.XSD_XMLNS_NS))
|
|
topNode.SetAttribute(reader.Name, reader.GetAttribute(i));
|
|
else {
|
|
XmlAttribute attr = topNode.SetAttributeNode(reader.LocalName, reader.NamespaceURI);
|
|
attr.Prefix = reader.Prefix;
|
|
attr.Value = reader.GetAttribute(i);
|
|
}
|
|
}
|
|
}
|
|
reader.Read();
|
|
|
|
while (MoveToElement(reader, iCurrentDepth)) {
|
|
|
|
// if reader points to the schema load it...
|
|
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI == Keywords.XDRNS) {
|
|
// load XDR schema and exit
|
|
ReadXDRSchema(reader);
|
|
return;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
|
|
// load XSD schema and exit
|
|
ReadXSDSchema(reader, denyResolving);
|
|
return;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))
|
|
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
|
|
|
|
|
|
XmlNode node = xdoc.ReadNode(reader);
|
|
topNode.AppendChild(node);
|
|
|
|
}
|
|
|
|
// read the closing tag of the current element
|
|
ReadEndElement(reader);
|
|
|
|
// if we are here no schema has been found
|
|
xdoc.AppendChild(topNode);
|
|
|
|
// so we InferSchema
|
|
InferSchema(xdoc, null, XmlReadMode.Auto);
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
internal bool MoveToElement(XmlReader reader, int depth) {
|
|
while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element && reader.Depth > depth) {
|
|
reader.Read();
|
|
}
|
|
return (reader.NodeType == XmlNodeType.Element);
|
|
}
|
|
|
|
private static void MoveToElement(XmlReader reader) {
|
|
while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element) {
|
|
reader.Read();
|
|
}
|
|
}
|
|
internal void ReadEndElement(XmlReader reader) {
|
|
while (reader.NodeType == XmlNodeType.Whitespace) {
|
|
reader.Skip();
|
|
}
|
|
if (reader.NodeType == XmlNodeType.None) {
|
|
reader.Skip();
|
|
}
|
|
else if (reader.NodeType == XmlNodeType.EndElement) {
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
|
|
internal void ReadXSDSchema(XmlReader reader, bool denyResolving) {
|
|
XmlSchemaSet sSet = new XmlSchemaSet();
|
|
|
|
int schemaFragmentCount = 1;
|
|
//read from current schmema element
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
|
|
if (reader.HasAttributes) {
|
|
string attribValue = reader.GetAttribute(Keywords.MSD_FRAGMENTCOUNT, Keywords.MSDNS); // this must not move the position
|
|
if (!Common.ADP.IsEmpty(attribValue)) {
|
|
schemaFragmentCount = int.Parse(attribValue, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
while (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
|
|
XmlSchema s = XmlSchema.Read(reader, null);
|
|
sSet.Add(s);
|
|
//read the end tag
|
|
ReadEndElement(reader);
|
|
|
|
if (--schemaFragmentCount > 0) {
|
|
MoveToElement(reader);
|
|
}
|
|
while (reader.NodeType == XmlNodeType.Whitespace) {
|
|
reader.Skip();
|
|
}
|
|
}
|
|
sSet.Compile();
|
|
XSDSchema schema = new XSDSchema();
|
|
schema.LoadSchema(sSet, this);
|
|
}
|
|
|
|
internal void ReadXDRSchema(XmlReader reader) {
|
|
XmlDocument xdoc = new XmlDocument(); // we may need this to infer the schema
|
|
XmlNode schNode = xdoc.ReadNode(reader);
|
|
xdoc.AppendChild(schNode);
|
|
XDRSchema schema = new XDRSchema(this, false);
|
|
this.DataSetName = xdoc.DocumentElement.LocalName;
|
|
schema.LoadSchema((XmlElement)schNode, this);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Reads the XML schema from the specified <see cref='System.IO.Stream'/> into the
|
|
/// <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
public void ReadXmlSchema(Stream stream)
|
|
{
|
|
if (stream == null)
|
|
return;
|
|
|
|
ReadXmlSchema(new XmlTextReader(stream), false);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Reads the XML schema from the specified <see cref='System.IO.TextReader'/> into the <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
public void ReadXmlSchema(TextReader reader)
|
|
{
|
|
if (reader == null)
|
|
return;
|
|
|
|
ReadXmlSchema(new XmlTextReader(reader), false);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>Reads the XML schema from the specified file into the <see cref='System.Data.DataSet'/>.</para>
|
|
/// </devdoc>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
public void ReadXmlSchema(String fileName)
|
|
{
|
|
XmlTextReader xr = new XmlTextReader(fileName);
|
|
try {
|
|
ReadXmlSchema(xr, false);
|
|
}
|
|
finally {
|
|
xr.Close();
|
|
}
|
|
}
|
|
|
|
#region WriteXmlSchema
|
|
/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to using the specified <see cref='Stream'/> object.</summary>
|
|
/// <param name="stream">A <see cref='Stream'/> object used to write to a file.</param>
|
|
public void WriteXmlSchema(Stream stream)
|
|
{
|
|
this.WriteXmlSchema(stream, SchemaFormat.Public, (Converter<Type, string>)null);
|
|
}
|
|
|
|
/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to using the specified <see cref='Stream'/> object.</summary>
|
|
/// <param name="stream">A <see cref='Stream'/> object used to write to a file.</param>
|
|
/// <param name="multipleTargetConverter">A delegate used to convert <see cref='Type'/> into string.</param>
|
|
public void WriteXmlSchema(Stream stream, Converter<Type, string> multipleTargetConverter)
|
|
{
|
|
ADP.CheckArgumentNull(multipleTargetConverter, "multipleTargetConverter");
|
|
this.WriteXmlSchema(stream, SchemaFormat.Public, multipleTargetConverter);
|
|
}
|
|
|
|
/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to a file.</summary>
|
|
/// <param name="fileName">The file name (including the path) to which to write.</param>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
public void WriteXmlSchema(String fileName)
|
|
{
|
|
this.WriteXmlSchema(fileName, SchemaFormat.Public, (Converter<Type, string>)null);
|
|
}
|
|
|
|
/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to a file.</summary>
|
|
/// <param name="fileName">The file name (including the path) to which to write.</param>
|
|
/// <param name="multipleTargetConverter">A delegate used to convert <see cref='Type'/> into string.</param>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
public void WriteXmlSchema(String fileName, Converter<Type, string> multipleTargetConverter)
|
|
{
|
|
ADP.CheckArgumentNull(multipleTargetConverter, "multipleTargetConverter");
|
|
this.WriteXmlSchema(fileName, SchemaFormat.Public, multipleTargetConverter);
|
|
}
|
|
|
|
/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to a <see cref='TextWriter'/> object.</summary>
|
|
/// <param name="writer">The <see cref='TextWriter'/> object with which to write.</param>
|
|
public void WriteXmlSchema(TextWriter writer)
|
|
{
|
|
this.WriteXmlSchema(writer, SchemaFormat.Public, (Converter<Type, string>)null);
|
|
}
|
|
|
|
/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to a <see cref='TextWriter'/> object.</summary>
|
|
/// <param name="writer">The <see cref='TextWriter'/> object with which to write.</param>
|
|
/// <param name="multipleTargetConverter">A delegate used to convert <see cref='Type'/> into string.</param>
|
|
public void WriteXmlSchema(TextWriter writer, Converter<Type, string> multipleTargetConverter)
|
|
{
|
|
ADP.CheckArgumentNull(multipleTargetConverter, "multipleTargetConverter");
|
|
this.WriteXmlSchema(writer, SchemaFormat.Public, multipleTargetConverter);
|
|
}
|
|
|
|
/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to an <see cref='XmlWriter'/> object.</summary>
|
|
/// <param name="writer">The <see cref='XmlWriter'/> object with which to write.</param>
|
|
public void WriteXmlSchema(XmlWriter writer)
|
|
{
|
|
this.WriteXmlSchema(writer, SchemaFormat.Public, (Converter<Type, string>)null);
|
|
}
|
|
|
|
/// <summary>Writes the <see cref='DataSet'/> structure as an XML schema to an <see cref='XmlWriter'/> object.</summary>
|
|
/// <param name="writer">The <see cref='XmlWriter'/> object with which to write.</param>
|
|
/// <param name="multipleTargetConverter">A delegate used to convert <see cref='Type'/> into string.</param>
|
|
public void WriteXmlSchema(XmlWriter writer, Converter<Type, string> multipleTargetConverter)
|
|
{
|
|
ADP.CheckArgumentNull(multipleTargetConverter, "multipleTargetConverter");
|
|
this.WriteXmlSchema(writer, SchemaFormat.Public, multipleTargetConverter);
|
|
}
|
|
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
private void WriteXmlSchema(String fileName, SchemaFormat schemaFormat, Converter<Type, string> multipleTargetConverter)
|
|
{
|
|
XmlTextWriter xw = new XmlTextWriter( fileName, null );
|
|
try {
|
|
xw.Formatting = Formatting.Indented;
|
|
xw.WriteStartDocument(true);
|
|
this.WriteXmlSchema(xw, schemaFormat, multipleTargetConverter);
|
|
xw.WriteEndDocument();
|
|
}
|
|
finally {
|
|
xw.Close();
|
|
}
|
|
}
|
|
|
|
private void WriteXmlSchema(Stream stream, SchemaFormat schemaFormat, Converter<Type, string> multipleTargetConverter)
|
|
{
|
|
if (stream == null)
|
|
return;
|
|
|
|
XmlTextWriter w = new XmlTextWriter(stream, null);
|
|
w.Formatting = Formatting.Indented;
|
|
|
|
this.WriteXmlSchema(w, schemaFormat, multipleTargetConverter);
|
|
}
|
|
|
|
private void WriteXmlSchema(TextWriter writer, SchemaFormat schemaFormat, Converter<Type, string> multipleTargetConverter)
|
|
{
|
|
if (writer == null)
|
|
return;
|
|
|
|
XmlTextWriter w = new XmlTextWriter(writer);
|
|
w.Formatting = Formatting.Indented;
|
|
|
|
this.WriteXmlSchema(w, schemaFormat, multipleTargetConverter);
|
|
}
|
|
|
|
private void WriteXmlSchema(XmlWriter writer, SchemaFormat schemaFormat, Converter<Type, string> multipleTargetConverter)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.WriteXmlSchema|INFO> %d#, schemaFormat=%d{ds.SchemaFormat}\n", ObjectID, (int)schemaFormat);
|
|
try {
|
|
// Generate SchemaTree and write it out
|
|
if (writer != null) {
|
|
XmlTreeGen treeGen = null;
|
|
if (schemaFormat == SchemaFormat.WebService &&
|
|
SchemaSerializationMode == SchemaSerializationMode.ExcludeSchema &&
|
|
writer.WriteState == WriteState.Element) {
|
|
treeGen = new XmlTreeGen(SchemaFormat.WebServiceSkipSchema);
|
|
}
|
|
else {
|
|
treeGen = new XmlTreeGen(schemaFormat);
|
|
}
|
|
|
|
treeGen.Save(this, (DataTable)null, writer, false, multipleTargetConverter);
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public XmlReadMode ReadXml(XmlReader reader)
|
|
{
|
|
return ReadXml(reader, false);
|
|
}
|
|
|
|
|
|
internal XmlReadMode ReadXml(XmlReader reader, bool denyResolving)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.ReadXml|INFO> %d#, denyResolving=%d{bool}\n", ObjectID, denyResolving);
|
|
try {
|
|
|
|
DataTable.DSRowDiffIdUsageSection rowDiffIdUsage = new DataTable.DSRowDiffIdUsageSection();
|
|
try {
|
|
bool fDataFound = false;
|
|
bool fSchemaFound = false;
|
|
bool fDiffsFound = false;
|
|
bool fIsXdr = false;
|
|
int iCurrentDepth = -1;
|
|
XmlReadMode ret = XmlReadMode.Auto;
|
|
bool isEmptyDataSet = false;
|
|
bool topNodeIsProcessed = false; // we chanche topnode and there is just one case that we miss to process it
|
|
// it is : <elem attrib1="Attrib">txt</elem>
|
|
|
|
// clear the hashtable to avoid conflicts between diffgrams, SqlHotFix 782
|
|
rowDiffIdUsage.Prepare(this);
|
|
|
|
if (reader == null)
|
|
return ret;
|
|
|
|
if (Tables.Count == 0) {
|
|
isEmptyDataSet = true;
|
|
}
|
|
|
|
if (reader is XmlTextReader)
|
|
((XmlTextReader)reader).WhitespaceHandling = WhitespaceHandling.Significant;
|
|
|
|
XmlDocument xdoc = new XmlDocument(); // we may need this to infer the schema
|
|
XmlDataLoader xmlload = null;
|
|
|
|
|
|
reader.MoveToContent();
|
|
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
iCurrentDepth = reader.Depth;
|
|
|
|
if (reader.NodeType == XmlNodeType.Element) {
|
|
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
|
|
this.ReadXmlDiffgram(reader);
|
|
// read the closing tag of the current element
|
|
ReadEndElement(reader);
|
|
return XmlReadMode.DiffGram;
|
|
}
|
|
|
|
// if reader points to the schema load it
|
|
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI == Keywords.XDRNS) {
|
|
// load XDR schema and exit
|
|
ReadXDRSchema(reader);
|
|
return XmlReadMode.ReadSchema; //since the top level element is a schema return
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
|
|
// load XSD schema and exit
|
|
ReadXSDSchema(reader, denyResolving);
|
|
return XmlReadMode.ReadSchema; //since the top level element is a schema return
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))
|
|
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
|
|
|
|
// now either the top level node is a table and we load it through dataReader...
|
|
|
|
// ... or backup the top node and all its attributes because we may need to InferSchema
|
|
XmlElement topNode = xdoc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
|
|
if (reader.HasAttributes) {
|
|
int attrCount = reader.AttributeCount;
|
|
for (int i = 0; i < attrCount; i++) {
|
|
reader.MoveToAttribute(i);
|
|
if (reader.NamespaceURI.Equals(Keywords.XSD_XMLNS_NS))
|
|
topNode.SetAttribute(reader.Name, reader.GetAttribute(i));
|
|
else {
|
|
XmlAttribute attr = topNode.SetAttributeNode(reader.LocalName, reader.NamespaceURI);
|
|
attr.Prefix = reader.Prefix;
|
|
attr.Value = reader.GetAttribute(i);
|
|
}
|
|
}
|
|
}
|
|
reader.Read();
|
|
string rootNodeSimpleContent = reader.Value;
|
|
|
|
while (MoveToElement(reader, iCurrentDepth)) {
|
|
|
|
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
|
|
this.ReadXmlDiffgram(reader);
|
|
// read the closing tag of the current element
|
|
// YUKON FIX ReadEndElement(reader);
|
|
// return XmlReadMode.DiffGram;
|
|
ret = XmlReadMode.DiffGram; // continue reading for multiple schemas
|
|
}
|
|
|
|
// if reader points to the schema load it...
|
|
|
|
|
|
if (!fSchemaFound && !fDataFound && reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI == Keywords.XDRNS) {
|
|
// load XDR schema and exit
|
|
ReadXDRSchema(reader);
|
|
fSchemaFound = true;
|
|
fIsXdr = true;
|
|
continue;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
|
|
// load XSD schema and exit
|
|
ReadXSDSchema(reader, denyResolving);
|
|
fSchemaFound = true;
|
|
continue;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))
|
|
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
|
|
|
|
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
|
|
this.ReadXmlDiffgram(reader);
|
|
fDiffsFound = true;
|
|
ret = XmlReadMode.DiffGram;
|
|
}
|
|
else {
|
|
// We have found data IFF the reader.NodeType == Element and reader.depth == currentDepth-1
|
|
// if reader.NodeType == whitespace, skip all white spaces.
|
|
// skip processing i.e. continue if the first non-whitespace node is not of type element.
|
|
while (!reader.EOF && reader.NodeType == XmlNodeType.Whitespace)
|
|
reader.Read();
|
|
if (reader.NodeType != XmlNodeType.Element)
|
|
continue;
|
|
// we found data here
|
|
fDataFound = true;
|
|
|
|
if (!fSchemaFound && Tables.Count == 0) {
|
|
XmlNode node = xdoc.ReadNode(reader);
|
|
topNode.AppendChild(node);
|
|
}
|
|
else {
|
|
if (xmlload == null)
|
|
xmlload = new XmlDataLoader(this, fIsXdr, topNode, false);
|
|
xmlload.LoadData(reader);
|
|
topNodeIsProcessed = true; // we process the topnode
|
|
if (fSchemaFound)
|
|
ret = XmlReadMode.ReadSchema;
|
|
else
|
|
ret = XmlReadMode.IgnoreSchema;
|
|
}
|
|
}
|
|
|
|
}
|
|
// read the closing tag of the current element
|
|
ReadEndElement(reader);
|
|
bool isfTopLevelTableSet = false;
|
|
bool tmpValue = this.fTopLevelTable;
|
|
//While inference we ignore root elements text content
|
|
if (!fSchemaFound && Tables.Count == 0 && !topNode.HasChildNodes) { //We shoule not come add SC of root elemnt to topNode if we are not infering
|
|
this.fTopLevelTable = true;
|
|
isfTopLevelTableSet = true;
|
|
if ((rootNodeSimpleContent != null && rootNodeSimpleContent.Length > 0))
|
|
topNode.InnerText = rootNodeSimpleContent;
|
|
}
|
|
if (!isEmptyDataSet) {
|
|
if ((rootNodeSimpleContent != null && rootNodeSimpleContent.Length > 0))
|
|
topNode.InnerText = rootNodeSimpleContent;
|
|
}
|
|
|
|
// now top node contains the data part
|
|
xdoc.AppendChild(topNode);
|
|
|
|
if (xmlload == null)
|
|
xmlload = new XmlDataLoader(this, fIsXdr, topNode, false);
|
|
|
|
if (!isEmptyDataSet && !topNodeIsProcessed) {
|
|
XmlElement root = xdoc.DocumentElement;
|
|
Debug.Assert(root.NamespaceURI != null, "root.NamespaceURI should not ne null, it should be empty string");
|
|
// just recognize that below given Xml represents datatable in toplevel
|
|
//<table attr1="foo" attr2="bar" table_Text="junk">text</table>
|
|
// only allow root element with simple content, if any
|
|
if (root.ChildNodes.Count == 0 ||
|
|
((root.ChildNodes.Count == 1) && root.FirstChild.GetType() == typeof(System.Xml.XmlText))) {
|
|
bool initfTopLevelTable = this.fTopLevelTable;
|
|
// if root element maps to a datatable
|
|
// ds and dt cant have the samm name and ns at the same time, how to write to xml
|
|
if (this.DataSetName != root.Name && this.namespaceURI != root.NamespaceURI &&
|
|
Tables.Contains(root.Name, (root.NamespaceURI.Length == 0) ? null : root.NamespaceURI, false, true)) {
|
|
this.fTopLevelTable = true;
|
|
}
|
|
try {
|
|
xmlload.LoadData(xdoc);
|
|
}
|
|
finally {
|
|
this.fTopLevelTable = initfTopLevelTable; // this is not for inference, we have schema and we were skipping
|
|
// topnode where it was a datatable, We must restore the value
|
|
}
|
|
}
|
|
}// above check and below check are orthogonal
|
|
// so we InferSchema
|
|
if (!fDiffsFound) {
|
|
// Load Data
|
|
if (!fSchemaFound && Tables.Count == 0) {
|
|
InferSchema(xdoc, null, XmlReadMode.Auto);
|
|
ret = XmlReadMode.InferSchema;
|
|
xmlload.FromInference = true;
|
|
try {
|
|
xmlload.LoadData(xdoc);
|
|
}
|
|
finally {
|
|
xmlload.FromInference = false;
|
|
}
|
|
}
|
|
//We dont need this assignement. Once we set it(where we set it during inference), it won't be changed
|
|
if (isfTopLevelTableSet)
|
|
this.fTopLevelTable = tmpValue;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
finally {
|
|
rowDiffIdUsage.Cleanup();
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public XmlReadMode ReadXml(Stream stream)
|
|
{
|
|
if (stream == null)
|
|
return XmlReadMode.Auto;
|
|
|
|
XmlTextReader xr = new XmlTextReader(stream);
|
|
|
|
// Prevent Dtd entity in dataset
|
|
xr.XmlResolver = null;
|
|
|
|
return ReadXml(xr, false);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public XmlReadMode ReadXml(TextReader reader)
|
|
{
|
|
if (reader == null)
|
|
return XmlReadMode.Auto;
|
|
|
|
XmlTextReader xr = new XmlTextReader(reader);
|
|
|
|
// Prevent Dtd entity in dataset
|
|
xr.XmlResolver = null;
|
|
|
|
return ReadXml(xr, false);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
public XmlReadMode ReadXml(string fileName)
|
|
{
|
|
XmlTextReader xr = new XmlTextReader(fileName);
|
|
|
|
// Prevent Dtd entity in dataset
|
|
xr.XmlResolver = null;
|
|
|
|
try
|
|
{
|
|
return ReadXml(xr, false);
|
|
}
|
|
finally {
|
|
xr.Close();
|
|
}
|
|
}
|
|
|
|
internal void InferSchema(XmlDocument xdoc, string[] excludedNamespaces, XmlReadMode mode) {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.InferSchema|INFO> %d#, mode=%d{ds.XmlReadMode}\n", ObjectID, (int)mode);
|
|
try {
|
|
string ns = xdoc.DocumentElement.NamespaceURI;
|
|
if (null == excludedNamespaces) {
|
|
excludedNamespaces = new string[0];
|
|
}
|
|
XmlNodeReader xnr = new XmlIgnoreNamespaceReader(xdoc, excludedNamespaces);
|
|
System.Xml.Schema.XmlSchemaInference infer = new System.Xml.Schema.XmlSchemaInference();
|
|
|
|
infer.Occurrence = XmlSchemaInference.InferenceOption.Relaxed;
|
|
|
|
if (mode == XmlReadMode.InferTypedSchema)
|
|
infer.TypeInference = XmlSchemaInference.InferenceOption.Restricted;
|
|
else
|
|
infer.TypeInference = XmlSchemaInference.InferenceOption.Relaxed;
|
|
|
|
XmlSchemaSet schemaSet = infer.InferSchema(xnr);
|
|
schemaSet.Compile();
|
|
|
|
XSDSchema schema = new XSDSchema();
|
|
schema.FromInference = true;
|
|
|
|
try {
|
|
schema.LoadSchema(schemaSet, this);
|
|
}
|
|
finally {
|
|
schema.FromInference = false; // this is always false if you are not calling fron inference
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
private bool IsEmpty() {
|
|
foreach (DataTable table in this.Tables)
|
|
if (table.Rows.Count > 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
private void ReadXmlDiffgram(XmlReader reader) {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.ReadXmlDiffgram|INFO> %d#\n", ObjectID);
|
|
try {
|
|
int d = reader.Depth;
|
|
bool fEnforce = this.EnforceConstraints;
|
|
this.EnforceConstraints = false;
|
|
DataSet newDs;
|
|
bool isEmpty = this.IsEmpty();
|
|
|
|
if (isEmpty) {
|
|
newDs = this;
|
|
}
|
|
else {
|
|
newDs = this.Clone();
|
|
newDs.EnforceConstraints = false;
|
|
}
|
|
|
|
foreach (DataTable t in newDs.Tables) {
|
|
t.Rows.nullInList = 0;
|
|
}
|
|
reader.MoveToContent();
|
|
if ((reader.LocalName != Keywords.DIFFGRAM) && (reader.NamespaceURI != Keywords.DFFNS))
|
|
return;
|
|
reader.Read();
|
|
if (reader.NodeType == XmlNodeType.Whitespace)
|
|
MoveToElement(reader, reader.Depth - 1 /*iCurrentDepth*/); // skip over whitespaces.
|
|
|
|
newDs.fInLoadDiffgram = true;
|
|
|
|
if (reader.Depth > d) {
|
|
if ((reader.NamespaceURI != Keywords.DFFNS) && (reader.NamespaceURI != Keywords.MSDNS)) {
|
|
//we should be inside the dataset part
|
|
XmlDocument xdoc = new XmlDocument();
|
|
XmlElement node = xdoc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
|
|
reader.Read();
|
|
if (reader.NodeType == XmlNodeType.Whitespace) {
|
|
MoveToElement(reader, reader.Depth - 1 /*iCurrentDepth*/); // skip over whitespaces.
|
|
}
|
|
if (reader.Depth - 1 > d) {
|
|
XmlDataLoader xmlload = new XmlDataLoader(newDs, false, node, false);
|
|
xmlload.isDiffgram = true; // turn on the special processing
|
|
xmlload.LoadData(reader);
|
|
}
|
|
ReadEndElement(reader);
|
|
if (reader.NodeType == XmlNodeType.Whitespace) {
|
|
MoveToElement(reader, reader.Depth - 1 /*iCurrentDepth*/); // skip over whitespaces.
|
|
}
|
|
}
|
|
Debug.Assert(reader.NodeType != XmlNodeType.Whitespace, "Should not be on Whitespace node");
|
|
|
|
if (((reader.LocalName == Keywords.SQL_BEFORE) && (reader.NamespaceURI == Keywords.DFFNS)) ||
|
|
((reader.LocalName == Keywords.MSD_ERRORS) && (reader.NamespaceURI == Keywords.DFFNS)))
|
|
|
|
{
|
|
//this will consume the changes and the errors part
|
|
XMLDiffLoader diffLoader = new XMLDiffLoader();
|
|
diffLoader.LoadDiffGram(newDs, reader);
|
|
}
|
|
|
|
// get to the closing diff tag
|
|
while (reader.Depth > d) {
|
|
reader.Read();
|
|
}
|
|
// read the closing tag
|
|
ReadEndElement(reader);
|
|
}
|
|
|
|
foreach (DataTable t in newDs.Tables) {
|
|
if (t.Rows.nullInList > 0)
|
|
throw ExceptionBuilder.RowInsertMissing(t.TableName);
|
|
}
|
|
|
|
newDs.fInLoadDiffgram = false;
|
|
|
|
//terrible performance!
|
|
foreach (DataTable t in newDs.Tables) {
|
|
DataRelation[] nestedParentRelations = t.NestedParentRelations;
|
|
foreach (DataRelation rel in nestedParentRelations) {
|
|
if (rel.ParentTable == t) {
|
|
foreach (DataRow r in t.Rows) {
|
|
foreach (DataRelation rel2 in nestedParentRelations) {
|
|
r.CheckForLoops(rel2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!isEmpty) {
|
|
this.Merge(newDs);
|
|
if (this.dataSetName == "NewDataSet")
|
|
this.dataSetName = newDs.dataSetName;
|
|
newDs.EnforceConstraints = fEnforce;
|
|
}
|
|
this.EnforceConstraints = fEnforce;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public XmlReadMode ReadXml(XmlReader reader, XmlReadMode mode)
|
|
{
|
|
return ReadXml(reader, mode, false);
|
|
}
|
|
|
|
internal XmlReadMode ReadXml(XmlReader reader, XmlReadMode mode, bool denyResolving)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.ReadXml|INFO> %d#, mode=%d{ds.XmlReadMode}, denyResolving=%d{bool}\n", ObjectID, (int)mode, denyResolving);
|
|
try {
|
|
|
|
XmlReadMode ret = mode;
|
|
|
|
if (reader == null)
|
|
return ret;
|
|
|
|
if (mode == XmlReadMode.Auto) {
|
|
// Dev11 915079: nested ReadXml calls on the same DataSet must be done outside of RowDiffIdUsage scope
|
|
return ReadXml(reader);
|
|
}
|
|
|
|
DataTable.DSRowDiffIdUsageSection rowDiffIdUsage = new DataTable.DSRowDiffIdUsageSection();
|
|
try {
|
|
|
|
bool fSchemaFound = false;
|
|
bool fDataFound = false;
|
|
bool fIsXdr = false;
|
|
int iCurrentDepth = -1;
|
|
|
|
// Dev11 904428: prepare and cleanup rowDiffId hashtable
|
|
rowDiffIdUsage.Prepare(this);
|
|
|
|
if (reader is XmlTextReader)
|
|
((XmlTextReader)reader).WhitespaceHandling = WhitespaceHandling.Significant;
|
|
|
|
XmlDocument xdoc = new XmlDocument(); // we may need this to infer the schema
|
|
|
|
if ((mode != XmlReadMode.Fragment) && (reader.NodeType == XmlNodeType.Element))
|
|
iCurrentDepth = reader.Depth;
|
|
|
|
reader.MoveToContent();
|
|
XmlDataLoader xmlload = null;
|
|
|
|
if (reader.NodeType == XmlNodeType.Element) {
|
|
XmlElement topNode = null;
|
|
if (mode == XmlReadMode.Fragment) {
|
|
xdoc.AppendChild(xdoc.CreateElement("ds_sqlXmlWraPPeR"));
|
|
topNode = xdoc.DocumentElement;
|
|
}
|
|
else { //handle the top node
|
|
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
|
|
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema)) {
|
|
this.ReadXmlDiffgram(reader);
|
|
// read the closing tag of the current element
|
|
ReadEndElement(reader);
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI == Keywords.XDRNS) {
|
|
// load XDR schema and exit
|
|
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema) &&
|
|
(mode != XmlReadMode.InferTypedSchema))
|
|
{
|
|
ReadXDRSchema(reader);
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
return ret; //since the top level element is a schema return
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
|
|
// load XSD schema and exit
|
|
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema) &&
|
|
(mode != XmlReadMode.InferTypedSchema))
|
|
{
|
|
ReadXSDSchema(reader, denyResolving);
|
|
}
|
|
else
|
|
reader.Skip();
|
|
return ret; //since the top level element is a schema return
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))
|
|
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
|
|
|
|
// now either the top level node is a table and we load it through dataReader...
|
|
// ... or backup the top node and all its attributes
|
|
topNode = xdoc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
|
|
if (reader.HasAttributes) {
|
|
int attrCount = reader.AttributeCount;
|
|
for (int i = 0; i < attrCount; i++) {
|
|
reader.MoveToAttribute(i);
|
|
if (reader.NamespaceURI.Equals(Keywords.XSD_XMLNS_NS))
|
|
topNode.SetAttribute(reader.Name, reader.GetAttribute(i));
|
|
else {
|
|
XmlAttribute attr = topNode.SetAttributeNode(reader.LocalName, reader.NamespaceURI);
|
|
attr.Prefix = reader.Prefix;
|
|
attr.Value = reader.GetAttribute(i);
|
|
}
|
|
}
|
|
}
|
|
reader.Read();
|
|
}
|
|
|
|
while (MoveToElement(reader, iCurrentDepth)) {
|
|
|
|
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI == Keywords.XDRNS) {
|
|
// load XDR schema
|
|
if (!fSchemaFound && !fDataFound && (mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema) &&
|
|
(mode != XmlReadMode.InferTypedSchema))
|
|
{
|
|
ReadXDRSchema(reader);
|
|
fSchemaFound = true;
|
|
fIsXdr = true;
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
|
|
// load XSD schema and exit
|
|
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema) &&
|
|
(mode != XmlReadMode.InferTypedSchema))
|
|
{
|
|
ReadXSDSchema(reader, denyResolving);
|
|
fSchemaFound = true;
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
|
|
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema)) {
|
|
this.ReadXmlDiffgram(reader);
|
|
ret = XmlReadMode.DiffGram;
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))
|
|
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
|
|
|
|
if (mode == XmlReadMode.DiffGram) {
|
|
reader.Skip();
|
|
continue; // we do not read data in diffgram mode
|
|
}
|
|
|
|
// if we are here we found some data
|
|
fDataFound = true;
|
|
|
|
if (mode == XmlReadMode.InferSchema || mode == XmlReadMode.InferTypedSchema) { //save the node in DOM until the end;
|
|
XmlNode node = xdoc.ReadNode(reader);
|
|
topNode.AppendChild(node);
|
|
}
|
|
else {
|
|
if (xmlload == null)
|
|
xmlload = new XmlDataLoader(this, fIsXdr, topNode, mode == XmlReadMode.IgnoreSchema);
|
|
xmlload.LoadData(reader);
|
|
}
|
|
} //end of the while
|
|
|
|
// read the closing tag of the current element
|
|
ReadEndElement(reader);
|
|
|
|
// now top node contains the data part
|
|
xdoc.AppendChild(topNode);
|
|
if (xmlload == null)
|
|
xmlload = new XmlDataLoader(this, fIsXdr, mode == XmlReadMode.IgnoreSchema);
|
|
|
|
if (mode == XmlReadMode.DiffGram) {
|
|
// we already got the diffs through XmlReader interface
|
|
return ret;
|
|
}
|
|
|
|
// Load Data
|
|
if (mode == XmlReadMode.InferSchema || mode == XmlReadMode.InferTypedSchema) {
|
|
InferSchema(xdoc, null, mode);
|
|
ret = XmlReadMode.InferSchema;
|
|
xmlload.FromInference = true;
|
|
// }
|
|
try {
|
|
xmlload.LoadData(xdoc);
|
|
}
|
|
finally {
|
|
xmlload.FromInference = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
finally {
|
|
// Dev11 904428: prepare and cleanup rowDiffId hashtable
|
|
rowDiffIdUsage.Cleanup();
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public XmlReadMode ReadXml(Stream stream, XmlReadMode mode)
|
|
{
|
|
if (stream == null)
|
|
return XmlReadMode.Auto;
|
|
|
|
XmlTextReader reader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(stream, XmlNodeType.Element, null) : new XmlTextReader(stream);
|
|
// Prevent Dtd entity in dataset
|
|
reader.XmlResolver = null;
|
|
return ReadXml(reader, mode, false);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public XmlReadMode ReadXml(TextReader reader, XmlReadMode mode)
|
|
{
|
|
if (reader == null)
|
|
return XmlReadMode.Auto;
|
|
|
|
XmlTextReader xmlreader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(reader.ReadToEnd(), XmlNodeType.Element, null) : new XmlTextReader(reader);
|
|
// Prevent Dtd entity in dataset
|
|
xmlreader.XmlResolver = null;
|
|
return ReadXml(xmlreader, mode, false);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
public XmlReadMode ReadXml(string fileName, XmlReadMode mode)
|
|
{
|
|
XmlTextReader xr = null;
|
|
if (mode == XmlReadMode.Fragment) {
|
|
FileStream stream = new FileStream(fileName, FileMode.Open);
|
|
xr = new XmlTextReader(stream, XmlNodeType.Element, null);
|
|
}
|
|
else
|
|
xr = new XmlTextReader(fileName);
|
|
|
|
// Prevent Dtd entity in dataset
|
|
xr.XmlResolver = null;
|
|
|
|
try
|
|
{
|
|
return ReadXml(xr, mode, false);
|
|
}
|
|
finally {
|
|
xr.Close();
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// Writes schema and data for the DataSet.
|
|
/// </devdoc>
|
|
public void WriteXml(Stream stream)
|
|
{
|
|
WriteXml(stream, XmlWriteMode.IgnoreSchema);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public void WriteXml(TextWriter writer)
|
|
{
|
|
WriteXml(writer, XmlWriteMode.IgnoreSchema);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public void WriteXml(XmlWriter writer)
|
|
{
|
|
WriteXml(writer, XmlWriteMode.IgnoreSchema);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
public void WriteXml(String fileName)
|
|
{
|
|
WriteXml(fileName, XmlWriteMode.IgnoreSchema);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Writes schema and data for the DataSet.
|
|
/// </devdoc>
|
|
public void WriteXml(Stream stream, XmlWriteMode mode)
|
|
{
|
|
if (stream != null) {
|
|
XmlTextWriter w = new XmlTextWriter(stream, null);
|
|
w.Formatting = Formatting.Indented;
|
|
|
|
WriteXml(w, mode);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public void WriteXml(TextWriter writer, XmlWriteMode mode)
|
|
{
|
|
if (writer != null) {
|
|
XmlTextWriter w = new XmlTextWriter(writer);
|
|
w.Formatting = Formatting.Indented;
|
|
|
|
WriteXml(w, mode);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// </devdoc>
|
|
public void WriteXml(XmlWriter writer, XmlWriteMode mode)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.WriteXml|API> %d#, mode=%d{ds.XmlWriteMode}\n", ObjectID, (int)mode);
|
|
try {
|
|
// Generate SchemaTree and write it out
|
|
if (writer != null) {
|
|
|
|
if (mode == XmlWriteMode.DiffGram) {
|
|
// Create and save the updates
|
|
// new UpdateTreeGen(UpdateTreeGen.UPDATE, (DataRowState)(-1), this).Save(writer, null);
|
|
new NewDiffgramGen(this).Save(writer);
|
|
}
|
|
else {
|
|
// Create and save xml data
|
|
new XmlDataTreeWriter(this).Save(writer, mode == XmlWriteMode.WriteSchema);
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[ResourceExposure(ResourceScope.Machine)]
|
|
[ResourceConsumption(ResourceScope.Machine)]
|
|
public void WriteXml(String fileName, XmlWriteMode mode)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.WriteXml|API> %d#, fileName='%ls', mode=%d{ds.XmlWriteMode}\n", ObjectID, fileName, (int)mode);
|
|
XmlTextWriter xw = new XmlTextWriter(fileName, null);
|
|
try {
|
|
xw.Formatting = Formatting.Indented;
|
|
xw.WriteStartDocument(true);
|
|
if (xw != null) {
|
|
// Create and save the updates
|
|
if (mode == XmlWriteMode.DiffGram) {
|
|
new NewDiffgramGen(this).Save(xw);
|
|
}
|
|
else {
|
|
// Create and save xml data
|
|
new XmlDataTreeWriter(this).Save(xw, mode == XmlWriteMode.WriteSchema);
|
|
}
|
|
}
|
|
xw.WriteEndDocument();
|
|
}
|
|
finally {
|
|
xw.Close();
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Gets the collection of parent relations which belong to a
|
|
/// specified table.
|
|
/// </para>
|
|
/// </devdoc>
|
|
internal DataRelationCollection GetParentRelations(DataTable table)
|
|
{
|
|
return table.ParentRelations;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Merges this <see cref='System.Data.DataSet'/> into a specified <see cref='System.Data.DataSet'/>.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void Merge(DataSet dataSet)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Merge|API> %d#, dataSet=%d\n", ObjectID, (dataSet != null) ? dataSet.ObjectID : 0);
|
|
try {
|
|
Merge(dataSet, false, MissingSchemaAction.Add);
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Merges this <see cref='System.Data.DataSet'/> into a specified <see cref='System.Data.DataSet'/> preserving changes according to
|
|
/// the specified argument.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void Merge(DataSet dataSet, bool preserveChanges)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Merge|API> %d#, dataSet=%d, preserveChanges=%d{bool}\n", ObjectID, (dataSet != null) ? dataSet.ObjectID : 0, preserveChanges);
|
|
try {
|
|
Merge(dataSet, preserveChanges, MissingSchemaAction.Add);
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Merges this <see cref='System.Data.DataSet'/> into a specified <see cref='System.Data.DataSet'/> preserving changes according to
|
|
/// the specified argument, and handling an incompatible schema according to the
|
|
/// specified argument.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void Merge(DataSet dataSet, bool preserveChanges, MissingSchemaAction missingSchemaAction) {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Merge|API> %d#, dataSet=%d, preserveChanges=%d{bool}, missingSchemaAction=%d{ds.MissingSchemaAction}\n", ObjectID, (dataSet != null) ? dataSet.ObjectID : 0, preserveChanges, (int)missingSchemaAction);
|
|
try {
|
|
|
|
// Argument checks
|
|
if (dataSet == null)
|
|
throw ExceptionBuilder.ArgumentNull("dataSet");
|
|
|
|
switch (missingSchemaAction) { // @perfnote: Enum.IsDefined
|
|
case MissingSchemaAction.Add:
|
|
case MissingSchemaAction.Ignore:
|
|
case MissingSchemaAction.Error:
|
|
case MissingSchemaAction.AddWithKey:
|
|
Merger merger = new Merger(this, preserveChanges, missingSchemaAction);
|
|
merger.MergeDataSet(dataSet);
|
|
break;
|
|
default:
|
|
throw Common.ADP.InvalidMissingSchemaAction(missingSchemaAction);
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Merges this <see cref='System.Data.DataTable'/> into a specified <see cref='System.Data.DataTable'/>.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void Merge(DataTable table)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Merge|API> %d#, table=%d\n", ObjectID, (table != null) ? table.ObjectID : 0);
|
|
try {
|
|
Merge(table, false, MissingSchemaAction.Add);
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Merges this <see cref='System.Data.DataTable'/> into a specified <see cref='System.Data.DataTable'/>. with a value to preserve changes
|
|
/// made to the target, and a value to deal with missing schemas.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public void Merge(DataTable table, bool preserveChanges, MissingSchemaAction missingSchemaAction)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Merge|API> %d#, table=%d, preserveChanges=%d{bool}, missingSchemaAction=%d{ds.MissingSchemaAction}\n", ObjectID, (table != null) ? table.ObjectID : 0, preserveChanges, (int)missingSchemaAction);
|
|
try {
|
|
// Argument checks
|
|
if (table == null)
|
|
throw ExceptionBuilder.ArgumentNull("table");
|
|
|
|
switch (missingSchemaAction) { // @perfnote: Enum.IsDefined
|
|
case MissingSchemaAction.Add:
|
|
case MissingSchemaAction.Ignore:
|
|
case MissingSchemaAction.Error:
|
|
case MissingSchemaAction.AddWithKey:
|
|
Merger merger = new Merger(this, preserveChanges, missingSchemaAction);
|
|
merger.MergeTable(table);
|
|
break;
|
|
default:
|
|
throw Common.ADP.InvalidMissingSchemaAction(missingSchemaAction);
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public void Merge(DataRow[] rows)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Merge|API> %d#, rows\n", ObjectID);
|
|
try {
|
|
Merge(rows, false, MissingSchemaAction.Add);
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public void Merge(DataRow[] rows, bool preserveChanges, MissingSchemaAction missingSchemaAction)
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Merge|API> %d#, preserveChanges=%d{bool}, missingSchemaAction=%d{ds.MissingSchemaAction}\n", ObjectID, preserveChanges, (int)missingSchemaAction);
|
|
try {
|
|
// Argument checks
|
|
if (rows == null)
|
|
throw ExceptionBuilder.ArgumentNull("rows");
|
|
|
|
switch (missingSchemaAction) { // @perfnote: Enum.IsDefined
|
|
case MissingSchemaAction.Add:
|
|
case MissingSchemaAction.Ignore:
|
|
case MissingSchemaAction.Error:
|
|
case MissingSchemaAction.AddWithKey:
|
|
Merger merger = new Merger(this, preserveChanges, missingSchemaAction);
|
|
merger.MergeRows(rows);
|
|
break;
|
|
default:
|
|
throw Common.ADP.InvalidMissingSchemaAction(missingSchemaAction);
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnPropertyChanging(PropertyChangedEventArgs pcevent)
|
|
{
|
|
if (onPropertyChangingDelegate != null)
|
|
onPropertyChangingDelegate(this, pcevent);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Inheriting classes should override this method to handle this event.
|
|
/// Call base.OnMergeFailed to send this event to any registered event
|
|
/// listeners.
|
|
/// </devdoc>
|
|
internal void OnMergeFailed(MergeFailedEventArgs mfevent)
|
|
{
|
|
if (onMergeFailed != null)
|
|
onMergeFailed(this, mfevent);
|
|
else
|
|
throw ExceptionBuilder.MergeFailed(mfevent.Conflict);
|
|
}
|
|
|
|
internal void RaiseMergeFailed(DataTable table, string conflict, MissingSchemaAction missingSchemaAction)
|
|
{
|
|
if (MissingSchemaAction.Error == missingSchemaAction)
|
|
throw ExceptionBuilder.MergeFailed(conflict);
|
|
|
|
MergeFailedEventArgs mfevent = new MergeFailedEventArgs(table, conflict);
|
|
OnMergeFailed(mfevent);
|
|
return;
|
|
}
|
|
|
|
internal void OnDataRowCreated(DataRow row) {
|
|
if (onDataRowCreated != null)
|
|
onDataRowCreated(this, row);
|
|
}
|
|
|
|
internal void OnClearFunctionCalled(DataTable table) {
|
|
if (onClearFunctionCalled != null)
|
|
onClearFunctionCalled(this, table);
|
|
}
|
|
|
|
private void OnInitialized() {
|
|
if (onInitialized != null) {
|
|
onInitialized(this, EventArgs.Empty);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// This method should be overriden by subclasses to restrict tables being removed.
|
|
/// </devdoc>
|
|
protected internal virtual void OnRemoveTable(DataTable table) {
|
|
}
|
|
|
|
internal void OnRemovedTable(DataTable table) {
|
|
DataViewManager viewManager = defaultViewManager;
|
|
if (null != viewManager) {
|
|
viewManager.DataViewSettings.Remove(table);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// This method should be overriden by subclasses to restrict tables being removed.
|
|
/// </devdoc>
|
|
protected virtual void OnRemoveRelation(DataRelation relation)
|
|
{
|
|
}
|
|
|
|
//
|
|
internal void OnRemoveRelationHack(DataRelation relation)
|
|
{
|
|
OnRemoveRelation(relation);
|
|
}
|
|
|
|
|
|
protected internal void RaisePropertyChanging(string name)
|
|
{
|
|
OnPropertyChanging(new PropertyChangedEventArgs(name));
|
|
}
|
|
|
|
internal DataTable[] TopLevelTables()
|
|
{
|
|
return TopLevelTables(false);
|
|
}
|
|
|
|
internal DataTable[] TopLevelTables(bool forSchema)
|
|
{
|
|
// first let's figure out if we can represent the given dataSet as a tree using
|
|
// the fact that all connected undirected graphs with n-1 edges are trees.
|
|
List<DataTable> topTables = new List<DataTable>();
|
|
|
|
if (forSchema) {
|
|
// prepend the tables that are nested more than once
|
|
for (int i = 0; i < Tables.Count; i++)
|
|
{
|
|
DataTable table = Tables[i];
|
|
if (table.NestedParentsCount > 1 || table.SelfNested)
|
|
topTables.Add(table);
|
|
}
|
|
}
|
|
for (int i = 0; i < Tables.Count; i++)
|
|
{
|
|
DataTable table = Tables[i];
|
|
if (table.NestedParentsCount == 0 && !topTables.Contains(table))
|
|
topTables.Add(table);
|
|
}
|
|
if (topTables.Count == 0)
|
|
return zeroTables;
|
|
return topTables.ToArray();
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// This method rolls back all the changes to have been made to this DataSet since
|
|
/// it was loaded or the last time AcceptChanges was called.
|
|
/// Any rows still in edit-mode cancel their edits. New rows get removed. Modified and
|
|
/// Deleted rows return back to their original state.
|
|
/// </devdoc>
|
|
public virtual void RejectChanges()
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.RejectChanges|API> %d#\n", ObjectID);
|
|
try {
|
|
bool fEnforce = EnforceConstraints;
|
|
EnforceConstraints = false;
|
|
for (int i = 0; i < Tables.Count; i++)
|
|
Tables[i].RejectChanges();
|
|
EnforceConstraints = fEnforce;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Resets the dataSet back to it's original state. Subclasses should override
|
|
/// to restore back to it's original state.
|
|
///
|
|
|
|
public virtual void Reset()
|
|
{
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Reset|API> %d#\n", ObjectID);
|
|
try {
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
ConstraintCollection cons = Tables[i].Constraints;
|
|
for (int j = 0; j < cons.Count; ) {
|
|
if (cons[j] is ForeignKeyConstraint) {
|
|
cons.Remove(cons[j]);
|
|
}
|
|
else
|
|
j++;
|
|
}
|
|
}
|
|
// SQLBU 502734: because of SQLBU 501916, dependent tables need to be notified when a table is cleared
|
|
// if relations are removed first, then exceptions happen
|
|
Clear();
|
|
Relations.Clear();
|
|
Tables.Clear();
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
internal bool ValidateCaseConstraint() {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.ValidateCaseConstraint|INFO> %d#\n", ObjectID);
|
|
try {
|
|
DataRelation relation = null;
|
|
for (int i = 0; i < Relations.Count; i++) {
|
|
relation = Relations[i];
|
|
if (relation.ChildTable.CaseSensitive != relation.ParentTable.CaseSensitive)
|
|
return false;
|
|
}
|
|
|
|
ForeignKeyConstraint constraint = null;
|
|
ConstraintCollection constraints = null;
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
constraints = Tables[i].Constraints;
|
|
for (int j = 0; j < constraints.Count; j++) {
|
|
if (constraints[j] is ForeignKeyConstraint) {
|
|
constraint = (ForeignKeyConstraint)constraints[j];
|
|
if (constraint.Table.CaseSensitive != constraint.RelatedTable.CaseSensitive)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
internal bool ValidateLocaleConstraint() {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.ValidateLocaleConstraint|INFO> %d#\n", ObjectID);
|
|
try {
|
|
DataRelation relation = null;
|
|
for (int i = 0; i < Relations.Count; i++) {
|
|
relation = Relations[i];
|
|
if (relation.ChildTable.Locale.LCID != relation.ParentTable.Locale.LCID)
|
|
return false;
|
|
}
|
|
|
|
ForeignKeyConstraint constraint = null;
|
|
ConstraintCollection constraints = null;
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
constraints = Tables[i].Constraints;
|
|
for (int j = 0; j < constraints.Count; j++) {
|
|
if (constraints[j] is ForeignKeyConstraint) {
|
|
constraint = (ForeignKeyConstraint)constraints[j];
|
|
if (constraint.Table.Locale.LCID != constraint.RelatedTable.Locale.LCID)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
// Microsoft: may be better to rewrite this as nonrecursive?
|
|
internal DataTable FindTable(DataTable baseTable, PropertyDescriptor[] props, int propStart) {
|
|
if (props.Length < propStart + 1)
|
|
return baseTable;
|
|
|
|
PropertyDescriptor currentProp = props[propStart];
|
|
|
|
if (baseTable == null) {
|
|
// the accessor is the table name. if we don't find it, return null.
|
|
if (currentProp is DataTablePropertyDescriptor) {
|
|
return FindTable(((DataTablePropertyDescriptor)currentProp).Table, props, propStart + 1);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
if (currentProp is DataRelationPropertyDescriptor) {
|
|
return FindTable(((DataRelationPropertyDescriptor)currentProp).Relation.ChildTable, props, propStart + 1);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
protected virtual void ReadXmlSerializable(XmlReader reader) {
|
|
//WebData 96421 and 104709, this is DataSet side fix for the thrown exception
|
|
// <DataSet xsi:nil="true"> does not mean DataSet is null,but it does not have any child
|
|
// so dont do anything, ignore the attributes and just return empty DataSet;
|
|
this.UseDataSetSchemaOnly = false;
|
|
this.UdtIsWrapped = false;
|
|
|
|
if (reader.HasAttributes) {
|
|
const string xsinill = Keywords.XSI + ":" + Keywords.XSI_NIL;
|
|
if (reader.MoveToAttribute(xsinill)) {
|
|
string nilAttrib = reader.GetAttribute(xsinill);
|
|
if (string.Compare(nilAttrib, "true", StringComparison.Ordinal) == 0) {// case sensitive true comparison
|
|
MoveToElement(reader, 1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
const string useDataSetSchemaOnlyString = Keywords.MSD + ":" + Keywords.USEDATASETSCHEMAONLY;
|
|
if (reader.MoveToAttribute(useDataSetSchemaOnlyString)) {
|
|
string _useDataSetSchemaOnly = reader.GetAttribute(useDataSetSchemaOnlyString);
|
|
if (string.Equals(_useDataSetSchemaOnly, "true", StringComparison.Ordinal) ||
|
|
string.Equals(_useDataSetSchemaOnly, "1", StringComparison.Ordinal))
|
|
{
|
|
this.UseDataSetSchemaOnly = true;
|
|
}
|
|
else if (!string.Equals(_useDataSetSchemaOnly, "false", StringComparison.Ordinal) &&
|
|
!string.Equals(_useDataSetSchemaOnly, "0", StringComparison.Ordinal))
|
|
{
|
|
throw ExceptionBuilder.InvalidAttributeValue(Keywords.USEDATASETSCHEMAONLY, _useDataSetSchemaOnly);
|
|
}
|
|
}
|
|
|
|
const string udtIsWrappedString = Keywords.MSD + ":" + Keywords.UDTCOLUMNVALUEWRAPPED;
|
|
if (reader.MoveToAttribute(udtIsWrappedString)) {
|
|
string _udtIsWrappedString = reader.GetAttribute(udtIsWrappedString);
|
|
if (string.Equals(_udtIsWrappedString, "true", StringComparison.Ordinal) ||
|
|
string.Equals(_udtIsWrappedString, "1", StringComparison.Ordinal))
|
|
{
|
|
this.UdtIsWrapped = true;
|
|
|
|
}
|
|
else if (!string.Equals(_udtIsWrappedString, "false", StringComparison.Ordinal) &&
|
|
!string.Equals(_udtIsWrappedString, "0", StringComparison.Ordinal))
|
|
{
|
|
throw ExceptionBuilder.InvalidAttributeValue(Keywords.UDTCOLUMNVALUEWRAPPED, _udtIsWrappedString);
|
|
}
|
|
}
|
|
}
|
|
ReadXml(reader, XmlReadMode.DiffGram, true);
|
|
}
|
|
|
|
protected virtual System.Xml.Schema.XmlSchema GetSchemaSerializable() {
|
|
return null;
|
|
}
|
|
|
|
/************************************************************************
|
|
To publish
|
|
int_tools\webserviceadmin.exe -install Application Application.dll
|
|
|
|
To test
|
|
http://localhost/application/service.asmx?wsdl
|
|
or
|
|
wsdl.exe /namespace:UserNamespace http://localhost/Application/Service.asmx?wsdl /out:Service.cs
|
|
|
|
The V1.0 & V1.1 WSDL for Untyped DataSet being returned as a result (no parameters)
|
|
<s:element name="anyUserSpecifiedMethodName">
|
|
<!-- This is where parameters go -->
|
|
<s:complexType />
|
|
</s:element>
|
|
<s:element name="anyUserSpecifiedMethodName"+"Response">
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element minOccurs="0" maxOccurs="1" name="anyUserSpecifiedMethodName"+"Result">
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element ref="s:schema" />
|
|
<s:any />
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
|
|
The V1.0 & V1.1 WSDL for Untyped DataSet as parameter, string for the result
|
|
<s:element name="anyUserSpecifiedMethodName">
|
|
<!-- This is where parameters go -->
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element minOccurs="0" maxOccurs="1" name="set">
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element ref="s:schema" />
|
|
<s:any />
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
<s:element name="anyUserSpecifiedMethodName"+"Response">
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element minOccurs="0" maxOccurs="1" name="anyUserSpecifiedMethodName"+"Result" type="s:string" />
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
|
|
The V2.0 WSDL for Untyped DataSet being returned as a result (no parameters)
|
|
<s:element name="anyUserSpecifiedMethodName">
|
|
<!-- This is where parameters go -->
|
|
<s:complexType />
|
|
</s:element>
|
|
<s:element name="anyUserSpecifiedMethodName"+"Response">
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element minOccurs="0" maxOccurs="1" name="anyUserSpecifiedMethodName"+"Result">
|
|
<s:complexType>
|
|
<s:sequence maxOccurs="unbounded">
|
|
<s:any minOccurs="0" namespace="http://www.w3.org/2001/XMLSchema" processContents="lax" />
|
|
<s:any minOccurs="0" namespace="urn:schemas-microsoft-com:xml-diffgram-v1" processContents="lax" />
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
|
|
The V2.0 WSDL for Untyped DataSet as a parameter, string for the result
|
|
<s:element name="anyUserSpecifiedMethodName">
|
|
<!-- This is where parameters go -->
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element minOccurs="0" maxOccurs="1" name="anyUserSpecifiedParameterName">
|
|
<s:complexType>
|
|
<s:sequence maxOccurs="unbounded">
|
|
<s:any minOccurs="0" namespace="http://www.w3.org/2001/XMLSchema" processContents="lax" />
|
|
<s:any minOccurs="0" namespace="urn:schemas-microsoft-com:xml-diffgram-v1" processContents="lax" />
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
<s:element name="anyUserSpecifiedMethodName"+"Response">
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element minOccurs="0" maxOccurs="1" name="anyUserSpecifiedMethodName"+"Result" type="s:string" />
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
|
|
The V1.0, V1.1 & V2.0 WSDL for Typed DataSet
|
|
<s:import schemaLocation="http://localhost/application/service.asmx?schema=typedDataSetName" namespace="typedDataSetName" />
|
|
<s:element name="anyUserSpecifiedMethodName">
|
|
<!-- This is where parameters go -->
|
|
<s:complexType />
|
|
</s:element>
|
|
<s:element name="anyUserSpecifiedMethodName"+"Response">
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:element minOccurs="0" maxOccurs="1" name="anyUserSpecifiedMethodName"+"Result">
|
|
<s:complexType>
|
|
<s:sequence>
|
|
<s:any namespace="typedDataSetName" />
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
</s:sequence>
|
|
</s:complexType>
|
|
</s:element>
|
|
************************************************************************/
|
|
public static XmlSchemaComplexType GetDataSetSchema(XmlSchemaSet schemaSet) {
|
|
// For performance resons we are exploiting the fact that config files content is constant
|
|
// for a given appdomain so we can safely cache the prepared schema complex type and reuse it
|
|
if (schemaTypeForWSDL == null) { // to change the config file, appdomain needs to restart; so it seems safe to cache the schema
|
|
XmlSchemaComplexType tempWSDL = new XmlSchemaComplexType();
|
|
XmlSchemaSequence sequence = new XmlSchemaSequence();
|
|
|
|
if (PublishLegacyWSDL())
|
|
{ // Default is Version 1.0
|
|
XmlSchemaElement elem = new XmlSchemaElement();
|
|
elem.RefName = new XmlQualifiedName(Keywords.XSD_SCHEMA, Keywords.XSDNS);
|
|
sequence.Items.Add(elem);
|
|
XmlSchemaAny any = new XmlSchemaAny();
|
|
sequence.Items.Add(any);
|
|
}
|
|
else
|
|
{ // this means Version == V2.0 or newer
|
|
XmlSchemaAny any = new XmlSchemaAny();
|
|
any.Namespace = XmlSchema.Namespace;
|
|
any.MinOccurs = 0;
|
|
any.ProcessContents = XmlSchemaContentProcessing.Lax;
|
|
sequence.Items.Add(any);
|
|
|
|
any = new XmlSchemaAny();
|
|
any.Namespace = Keywords.DFFNS;
|
|
any.MinOccurs = 0; // when recognizing WSDL - MinOccurs="0" denotes DataSet, a MinOccurs="1" for DataTable
|
|
any.ProcessContents = XmlSchemaContentProcessing.Lax;
|
|
sequence.Items.Add(any);
|
|
sequence.MaxOccurs = Decimal.MaxValue;
|
|
}
|
|
tempWSDL.Particle = sequence;
|
|
|
|
schemaTypeForWSDL = tempWSDL;
|
|
}
|
|
return schemaTypeForWSDL;
|
|
}
|
|
|
|
/********************************************
|
|
<configuration>
|
|
<configSections>
|
|
<section name="system.data.dataset" type="System.Configuration.NameValueFileSectionHandler, System, Version=%ASSEMBLY_VERSION%, Culture=neutral, PublicKeyToken=%ECMA_PUBLICKEY%" restartOnExternalChanges="false" />
|
|
</configSections>
|
|
<system.data.dataset>
|
|
<!-- if WSDL_VERSION is missing it will default to 1.0
|
|
<add key="WSDL_VERSION" value="1.0"/>
|
|
-->
|
|
<add key="WSDL_VERSION" value="2.0"/>
|
|
</system.data.dataset>
|
|
</configuration>
|
|
*******************************************/
|
|
private static bool PublishLegacyWSDL()
|
|
{
|
|
Single version = 1.0f; // Default is Version 1.0
|
|
#if !NO_CONFIGURATION
|
|
NameValueCollection settings = (NameValueCollection)PrivilegedConfigurationManager.GetSection(Keywords.WS_DATASETFULLQNAME);
|
|
if (settings != null)
|
|
{
|
|
string[] values = settings.GetValues(Keywords.WS_VERSION);
|
|
if ((null != values) && (0 < values.Length) && (null != values[0]))
|
|
{ // will throw FormatException if not a valid number
|
|
version = Single.Parse(values[0], CultureInfo.InvariantCulture);
|
|
}
|
|
}
|
|
#endif
|
|
return (version < 2.0f); // if config does not exist, Default is Version 1.0
|
|
}
|
|
|
|
XmlSchema IXmlSerializable.GetSchema() {
|
|
if (GetType() == typeof(DataSet)) {
|
|
return null;
|
|
}
|
|
MemoryStream stream = new MemoryStream();
|
|
// WriteXmlSchema(new XmlTextWriter(stream, null));
|
|
XmlWriter writer = new XmlTextWriter(stream, null);
|
|
if (writer != null) {
|
|
(new XmlTreeGen(SchemaFormat.WebService)).Save(this, writer);
|
|
}
|
|
stream.Position = 0;
|
|
return XmlSchema.Read(new XmlTextReader(stream), null);
|
|
// return GetSchemaSerializable();
|
|
}
|
|
|
|
void IXmlSerializable.ReadXml(XmlReader reader) {
|
|
bool fNormalization = true;
|
|
XmlTextReader xmlTextReader = null;
|
|
IXmlTextParser xmlTextParser = reader as IXmlTextParser;
|
|
if (xmlTextParser != null) {
|
|
fNormalization = xmlTextParser.Normalized;
|
|
xmlTextParser.Normalized = false;
|
|
}
|
|
else {
|
|
xmlTextReader = reader as XmlTextReader;
|
|
if (xmlTextReader != null) {
|
|
fNormalization = xmlTextReader.Normalization;
|
|
xmlTextReader.Normalization = false;
|
|
}
|
|
}
|
|
|
|
ReadXmlSerializable(reader);
|
|
|
|
if (xmlTextParser != null)
|
|
xmlTextParser.Normalized = fNormalization;
|
|
else if (xmlTextReader != null)
|
|
xmlTextReader.Normalization = fNormalization;
|
|
}
|
|
|
|
void IXmlSerializable.WriteXml(XmlWriter writer) {
|
|
this.WriteXmlSchema(writer, SchemaFormat.WebService, (Converter<Type, string>)null);
|
|
this.WriteXml(writer, XmlWriteMode.DiffGram);
|
|
}
|
|
|
|
public virtual void Load(IDataReader reader, LoadOption loadOption, FillErrorEventHandler errorHandler, params DataTable[] tables) {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.Load|API> reader, loadOption=%d{ds.LoadOption}", (int)loadOption);
|
|
try {
|
|
foreach (DataTable dt in tables) {
|
|
Common.ADP.CheckArgumentNull(dt, "tables");
|
|
if (dt.DataSet != this) {
|
|
throw ExceptionBuilder.TableNotInTheDataSet(dt.TableName);
|
|
}
|
|
}
|
|
Common.LoadAdapter adapter = new Common.LoadAdapter();
|
|
adapter.FillLoadOption = loadOption;
|
|
adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
|
|
if (null != errorHandler) {
|
|
adapter.FillError += errorHandler;
|
|
}
|
|
adapter.FillFromReader(tables, reader, 0, 0);
|
|
|
|
if (!reader.IsClosed && !reader.NextResult()) { //
|
|
reader.Close();
|
|
}
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
public void Load(IDataReader reader, LoadOption loadOption, params DataTable[] tables) {
|
|
Load(reader, loadOption, null, tables);
|
|
}
|
|
|
|
public void Load(IDataReader reader, LoadOption loadOption, params string[] tables) {
|
|
Common.ADP.CheckArgumentNull(tables, "tables");
|
|
DataTable[] dataTables = new DataTable[tables.Length];
|
|
for (int i = 0; i < tables.Length; i++) {
|
|
DataTable tempDT = this.Tables[tables[i]];
|
|
if (null == tempDT) {
|
|
tempDT = new DataTable(tables[i]);
|
|
// fxcop: new DataTable should inherit the CaseSensitive, Locale, Namespace from DataSet
|
|
Tables.Add(tempDT);
|
|
}
|
|
dataTables[i] = tempDT;
|
|
}
|
|
Load(reader, loadOption, null, dataTables);
|
|
}
|
|
|
|
public DataTableReader CreateDataReader() {
|
|
if (Tables.Count == 0)
|
|
throw ExceptionBuilder.CannotCreateDataReaderOnEmptyDataSet();
|
|
|
|
DataTable[] dataTables = new DataTable[Tables.Count];
|
|
for (int i = 0; i < Tables.Count; i++) {
|
|
dataTables[i] = Tables[i];
|
|
}
|
|
return CreateDataReader(dataTables);
|
|
}
|
|
|
|
public DataTableReader CreateDataReader(params DataTable[] dataTables) {
|
|
IntPtr hscp;
|
|
Bid.ScopeEnter(out hscp, "<ds.DataSet.GetDataReader|API> %d#\n", ObjectID);
|
|
try {
|
|
if (dataTables.Length == 0)
|
|
throw ExceptionBuilder.DataTableReaderArgumentIsEmpty();
|
|
|
|
for (int i = 0; i < dataTables.Length; i++) {
|
|
if (dataTables[i] == null)
|
|
throw ExceptionBuilder.ArgumentContainsNullValue();
|
|
}
|
|
|
|
return new DataTableReader(dataTables);
|
|
}
|
|
finally {
|
|
Bid.ScopeLeave(ref hscp);
|
|
}
|
|
}
|
|
|
|
internal string MainTableName {
|
|
get {
|
|
return mainTableName;
|
|
}
|
|
set {
|
|
this.mainTableName = value;
|
|
}
|
|
}
|
|
|
|
internal int ObjectID {
|
|
get {
|
|
return _objectID;
|
|
}
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
#if !NO_CODEDOM
|
|
public class DataSetSchemaImporterExtension : SchemaImporterExtension {
|
|
// DataSetSchemaImporterExtension is used for WebServices, it is used to recognize the schema of DataSet within wsdl
|
|
// If a non 2.0 enabled DataSetSchemaImporterExtension, wsdl will generate a classes that you can't cast to dataset / datatable
|
|
|
|
Hashtable importedTypes = new Hashtable();
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public override string ImportSchemaType(string name, string schemaNamespace, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) {
|
|
IList values = schemas.GetSchemas(schemaNamespace);
|
|
if (values.Count != 1) {
|
|
return null;
|
|
}
|
|
XmlSchema schema = values[0] as XmlSchema;
|
|
if (schema == null)
|
|
return null;
|
|
XmlSchemaType type = (XmlSchemaType)schema.SchemaTypes[new XmlQualifiedName(name, schemaNamespace)];
|
|
return ImportSchemaType(type, context, schemas, importer, compileUnit, mainNamespace, options, codeProvider);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public override string ImportSchemaType(XmlSchemaType type, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider) {
|
|
if (type == null) {
|
|
return null;
|
|
}
|
|
if (importedTypes[type] != null) {
|
|
mainNamespace.Imports.Add(new CodeNamespaceImport(typeof(DataSet).Namespace));
|
|
compileUnit.ReferencedAssemblies.Add("System.Data.dll");
|
|
return (string)importedTypes[type];
|
|
}
|
|
if (!(context is XmlSchemaElement))
|
|
return null;
|
|
|
|
XmlSchemaElement e = (XmlSchemaElement)context;
|
|
|
|
// recognizing the following is important, but not as part of SQLPT 120015394: Support WSI Compliant WSDL for DataSet
|
|
// <xs:element name="NewDataSet" msdata:IsDataSet="true">
|
|
// see also SQLBU 338644, 410965, 423446
|
|
//if (IsDataSet(e))
|
|
//{
|
|
// return GenerateTypedDataSet(e, schemas, mainNamespace, compileUnit.ReferencedAssemblies, codeProvider);
|
|
//}
|
|
|
|
if (type is XmlSchemaComplexType) {
|
|
XmlSchemaComplexType ct = (XmlSchemaComplexType)type;
|
|
|
|
if (ct.Particle is XmlSchemaSequence)
|
|
{
|
|
XmlSchemaObjectCollection items = ((XmlSchemaSequence)ct.Particle).Items;
|
|
if ((2 == items.Count) && (items[0] is XmlSchemaAny) && (items[1] is XmlSchemaAny))
|
|
{
|
|
XmlSchemaAny any0 = (XmlSchemaAny)items[0];
|
|
XmlSchemaAny any1 = (XmlSchemaAny)items[1];
|
|
if ((any0.Namespace == XmlSchema.Namespace) && (any1.Namespace == "urn:schemas-microsoft-com:xml-diffgram-v1"))
|
|
{ // new diffgramm format
|
|
string ns = null;
|
|
foreach (XmlSchemaAttribute a in ct.Attributes)
|
|
{
|
|
if (a.Name == "namespace")
|
|
{
|
|
ns = a.FixedValue.Trim();
|
|
break;
|
|
}
|
|
}
|
|
bool isDataSet = false;
|
|
|
|
// check for DataSet or DataTable
|
|
if (((XmlSchemaSequence)ct.Particle).MaxOccurs == Decimal.MaxValue)
|
|
{
|
|
isDataSet = true;
|
|
}
|
|
else if (any0.MaxOccurs == Decimal.MaxValue)
|
|
{
|
|
isDataSet = false;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if (ns == null)
|
|
{ //Un-Typed DataSet / DataTable
|
|
string typeName = isDataSet ? typeof(DataSet).FullName : typeof(DataTable).FullName;
|
|
importedTypes.Add(type, typeName);
|
|
mainNamespace.Imports.Add(new CodeNamespaceImport(typeof(DataSet).Namespace));
|
|
compileUnit.ReferencedAssemblies.Add("System.Data.dll");
|
|
return typeName;
|
|
}
|
|
else
|
|
{ // Typed DataSet / DataTable
|
|
foreach (XmlSchema schema in schemas.GetSchemas(ns))
|
|
{
|
|
if ((schema != null) && (schema.Id != null))
|
|
{
|
|
XmlSchemaElement ds = FindDataSetElement(schema); // implement FindDataTableElement(schema)
|
|
if (ds != null)
|
|
{
|
|
return ImportSchemaType(ds.SchemaType, ds, schemas, importer, compileUnit, mainNamespace, options, codeProvider);
|
|
}
|
|
// else return null
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (ct.Particle is XmlSchemaSequence || ct.Particle is XmlSchemaAll) {
|
|
XmlSchemaObjectCollection items = ((XmlSchemaGroupBase)ct.Particle).Items;
|
|
if (items.Count == 2) {
|
|
if (!(items[0] is XmlSchemaElement && items[1] is XmlSchemaAny)) return null;
|
|
XmlSchemaElement schema = (XmlSchemaElement)items[0];
|
|
if (!(schema.RefName.Name == "schema" && schema.RefName.Namespace == XmlSchema.Namespace)) return null;
|
|
string typeName = typeof(DataSet).FullName;
|
|
importedTypes.Add(type, typeName);
|
|
mainNamespace.Imports.Add(new CodeNamespaceImport(typeof(DataSet).Namespace));
|
|
compileUnit.ReferencedAssemblies.Add("System.Data.dll");
|
|
return typeName;
|
|
}
|
|
else if (1 == items.Count)
|
|
{
|
|
XmlSchemaAny any = items[0] as XmlSchemaAny;
|
|
if ((null != any) &&
|
|
(null != any.Namespace) &&
|
|
(any.Namespace.IndexOfAny(new char[] { '#', ' ' }) < 0)) // special syntax (##any, ##other, ...) or more than one Uri present
|
|
{
|
|
foreach (XmlSchema schema in schemas.GetSchemas(any.Namespace))
|
|
{
|
|
if ((null != schema) &&
|
|
(null != schema.Id))
|
|
{
|
|
XmlSchemaElement ds = FindDataSetElement(schema);
|
|
if (ds != null)
|
|
{
|
|
return ImportSchemaType(ds.SchemaType, ds, schemas, importer, compileUnit, mainNamespace, options, codeProvider);
|
|
}
|
|
// else return null
|
|
}
|
|
// else return null
|
|
}
|
|
}
|
|
// else return null
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
internal XmlSchemaElement FindDataSetElement(XmlSchema schema) {
|
|
foreach (XmlSchemaObject item in schema.Items) {
|
|
if (item is XmlSchemaElement && IsDataSet((XmlSchemaElement)item)) {
|
|
return (XmlSchemaElement)item;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal string GenerateTypedDataSet(XmlSchemaElement element, XmlSchemas schemas, CodeNamespace codeNamespace, StringCollection references, CodeDomProvider codeProvider) {
|
|
if (element == null)
|
|
return null;
|
|
|
|
if (importedTypes[element.SchemaType] != null)
|
|
return (string)importedTypes[element.SchemaType];
|
|
|
|
IList values = schemas.GetSchemas(element.QualifiedName.Namespace);
|
|
if (values.Count != 1) {
|
|
return null;
|
|
}
|
|
XmlSchema schema = values[0] as XmlSchema;
|
|
if (schema == null)
|
|
return null;
|
|
|
|
DataSet ds = new DataSet();
|
|
|
|
//
|
|
using (MemoryStream stream = new MemoryStream()) {
|
|
schema.Write(stream);
|
|
stream.Position = 0;
|
|
ds.ReadXmlSchema(stream);
|
|
}
|
|
|
|
#pragma warning disable 618 // ignore obsolete warning about TypedDataSetGenerator
|
|
CodeTypeDeclaration dsClass = new TypedDataSetGenerator().GenerateCode(ds, codeNamespace, codeProvider.CreateGenerator());
|
|
#pragma warning restore 618
|
|
string typeName = dsClass.Name;
|
|
importedTypes.Add(element.SchemaType, typeName);
|
|
references.Add("System.Data.dll");
|
|
return typeName;
|
|
}
|
|
|
|
internal static bool IsDataSet(XmlSchemaElement e) {
|
|
if (e.UnhandledAttributes != null) {
|
|
foreach (XmlAttribute a in e.UnhandledAttributes) {
|
|
if (a.LocalName == "IsDataSet" && a.NamespaceURI == Keywords.MSDNS) {
|
|
// currently the msdata:IsDataSet uses its own format for the boolean values
|
|
if (a.Value == "True" || a.Value == "true" || a.Value == "1") return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
#endif
|
|
}
|