mono/mcs/class/referencesource/System.Data/System/Data/XmlDataLoader.cs

//------------------------------------------------------------------------------
// <copyright file="XmlDataLoader.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">[....]</owner>
// <owner current="true" primary="false">[....]</owner>
//------------------------------------------------------------------------------

namespace System.Data {
    using System;
    using System.Collections;
    using System.Data.Common;
    using System.Diagnostics;
    using System.Globalization;
    using System.Text;
    using System.Xml;
    using System.Xml.Serialization;

    internal sealed class XmlDataLoader {
        DataSet dataSet;
        XmlToDatasetMap nodeToSchemaMap = null;
        Hashtable       nodeToRowMap;
        Stack           childRowsStack = null;
        Hashtable       htableExcludedNS = null;
        bool    fIsXdr = false;
        internal bool    isDiffgram = false;

        DataRow topMostRow = null;

        XmlElement topMostNode = null;
        bool ignoreSchema = false;

        DataTable dataTable;
        bool isTableLevel = false;
        private bool fromInference = false;

        internal XmlDataLoader( DataSet dataset, bool IsXdr, bool ignoreSchema) {
            // Initialization
            this.dataSet = dataset;
            this.nodeToRowMap = new Hashtable();
            this.fIsXdr = IsXdr;
            this.ignoreSchema = ignoreSchema;
        }

        internal XmlDataLoader( DataSet dataset, bool IsXdr, XmlElement topNode, bool ignoreSchema) {
            // Initialization
            this.dataSet = dataset;
            this.nodeToRowMap = new Hashtable();
            this.fIsXdr = IsXdr;

            // Allocate the stack and create the mappings            
            childRowsStack = new Stack(50);

            topMostNode = topNode;
            this.ignoreSchema = ignoreSchema;
        }

        internal XmlDataLoader( DataTable datatable, bool IsXdr, bool ignoreSchema) {
            // Initialization
            this.dataSet = null;
            dataTable = datatable;
            isTableLevel = true;
            this.nodeToRowMap = new Hashtable();
            this.fIsXdr = IsXdr;
            this.ignoreSchema = ignoreSchema;
        }

        internal XmlDataLoader( DataTable datatable, bool IsXdr, XmlElement topNode, bool ignoreSchema) {
            // Initialization
            this.dataSet = null;
            dataTable = datatable;
            isTableLevel = true;
            this.nodeToRowMap = new Hashtable();
            this.fIsXdr = IsXdr;

            // Allocate the stack and create the mappings

            childRowsStack = new Stack(50);
            topMostNode = topNode;
            this.ignoreSchema = ignoreSchema;
        }

        internal bool FromInference {
            get {
                return fromInference;
            }
            set {
                fromInference = value;
            }
        }        

        // after loading, all detached DataRows are attached to their tables
        private void AttachRows( DataRow parentRow, XmlNode parentElement ) {
            if (parentElement == null)
                return;

            for (XmlNode n = parentElement.FirstChild; n != null; n = n.NextSibling) {
                if (n.NodeType == XmlNodeType.Element) {
                    XmlElement e = (XmlElement) n;
                    DataRow r = GetRowFromElement( e );
                    if (r != null && r.RowState == DataRowState.Detached) {
                        if (parentRow != null)
                            r.SetNestedParentRow( parentRow, /*setNonNested*/ false );

                        r.Table.Rows.Add( r );
                    } 
                    else if (r == null) {
                        // n is a 'sugar element'
                        AttachRows( parentRow, n );
                    }

                    // attach all detached rows
                    AttachRows( r, n );
                }
            }
        }

        private int CountNonNSAttributes (XmlNode node) {
            int count = 0;
            for (int i = 0; i < node.Attributes.Count; i++) {
                XmlAttribute attr = node.Attributes[i];
                if (!FExcludedNamespace(node.Attributes[i].NamespaceURI))
                        count++;
            }            
            return count;
        }

        private string GetValueForTextOnlyColums( XmlNode n ) {
            string value = null;

            // don't consider whitespace
            while (n != null && (n.NodeType == XmlNodeType.Whitespace || !IsTextLikeNode(n.NodeType))) {
                n = n.NextSibling;
            }
            
            if (n != null) {
                if (IsTextLikeNode( n.NodeType ) && (n.NextSibling == null || !IsTextLikeNode( n.NodeType ))) {
                    // don't use string builder if only one text node exists
                    value = n.Value;
                    n = n.NextSibling;
                }
                else {
                    StringBuilder sb = new StringBuilder();
                    while (n != null && IsTextLikeNode( n.NodeType )) {
                        sb.Append( n.Value );
                        n = n.NextSibling;
                    }
                    value = sb.ToString();
                }
            }

            if (value == null)
                value = String.Empty;

            return value;
        }

        private string GetInitialTextFromNodes( ref XmlNode n ) {
            string value = null;

            if (n != null) {
                // don't consider whitespace
                while (n.NodeType == XmlNodeType.Whitespace)
                    n = n.NextSibling;

                if (IsTextLikeNode( n.NodeType ) && (n.NextSibling == null || !IsTextLikeNode( n.NodeType ))) {
                    // don't use string builder if only one text node exists
                    value = n.Value;
                    n = n.NextSibling;
                }
                else {
                    StringBuilder sb = new StringBuilder();
                    while (n != null && IsTextLikeNode( n.NodeType )) {
                        sb.Append( n.Value );
                        n = n.NextSibling;
                    }
                    value = sb.ToString();
                }
            }

            if (value == null)
                value = String.Empty;

            return value;
        }

        private DataColumn GetTextOnlyColumn( DataRow row ) {
            DataColumnCollection columns = row.Table.Columns;
            int cCols = columns.Count;
            for (int iCol = 0; iCol < cCols; iCol++) {
                DataColumn c = columns[iCol];
                if (IsTextOnly( c ))
                    return c;
            }
            return null;
        }

        internal DataRow GetRowFromElement( XmlElement e ) {
            return(DataRow) nodeToRowMap[e];
        }        

        internal bool FColumnElement(XmlElement e) {
            if (nodeToSchemaMap.GetColumnSchema(e, FIgnoreNamespace(e)) == null)
                return false;

            if (CountNonNSAttributes(e) > 0)
                return false;

            for (XmlNode tabNode = e.FirstChild; tabNode != null; tabNode = tabNode.NextSibling)
                if (tabNode is XmlElement)
                    return false;

            return true;                          
        }
        
        private bool FExcludedNamespace(string ns) {
            if (ns.Equals(Keywords.XSD_XMLNS_NS))
                return true;
                
            if (htableExcludedNS == null)
                return false;
                
            return htableExcludedNS.Contains(ns);
        }

        private bool FIgnoreNamespace(XmlNode node) {
            XmlNode ownerNode;
            if (!fIsXdr)
                return false;
            if (node is XmlAttribute)
                ownerNode = ((XmlAttribute)node).OwnerElement;
            else
                ownerNode = node;
            if (ownerNode.NamespaceURI.StartsWith("x-schema:#", StringComparison.Ordinal))
                return true;
            else
                return false;
        }
        
        private bool FIgnoreNamespace(XmlReader node) {
            if (fIsXdr && node.NamespaceURI.StartsWith("x-schema:#", StringComparison.Ordinal))
                return true;
            else
                return false;
        }

        internal bool IsTextLikeNode( XmlNodeType n ) {
            switch (n) {
                case XmlNodeType.EntityReference:
                    throw ExceptionBuilder.FoundEntity();
                
                case XmlNodeType.Text:
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                case XmlNodeType.CDATA:
                    return true;

                default:
                    return false;
            }
        }

        internal bool IsTextOnly( DataColumn c ) {
            if (c.ColumnMapping != MappingType.SimpleContent)
                return false;
            else 
                return true;
        }

        internal void LoadData( XmlDocument xdoc ) {
            if (xdoc.DocumentElement == null)
                return;

            bool saveEnforce;

            if (isTableLevel) {
                saveEnforce = dataTable.EnforceConstraints;
                dataTable.EnforceConstraints = false;
            }
            else {
                saveEnforce = dataSet.EnforceConstraints;
                dataSet.EnforceConstraints = false;
                dataSet.fInReadXml = true;
            }

            if (isTableLevel) {
                nodeToSchemaMap = new XmlToDatasetMap(dataTable, xdoc.NameTable);
            }
            else {
                nodeToSchemaMap = new XmlToDatasetMap(dataSet, xdoc.NameTable);
            }
/*
            // Top level table or dataset ?
            XmlElement rootElement = xdoc.DocumentElement;
            Hashtable tableAtoms = new Hashtable();
            XmlNode tabNode;
            if (CountNonNSAttributes (rootElement) > 0)
                dataSet.fTopLevelTable = true;
            else {
                for (tabNode = rootElement.FirstChild; tabNode != null; tabNode = tabNode.NextSibling) {
                    if (tabNode is XmlElement && tabNode.LocalName != Keywords.XSD_SCHEMA) {
                        object value = tableAtoms[QualifiedName (tabNode.LocalName, tabNode.NamespaceURI)];
                        if (value == null || (bool)value == false) {
                            dataSet.fTopLevelTable = true;
                            break;
                        }
                    }
                }
            }
*/
            DataRow topRow = null;
            if (isTableLevel ||(dataSet!= null && dataSet.fTopLevelTable) ){
                XmlElement e = xdoc.DocumentElement;
                DataTable topTable = (DataTable) nodeToSchemaMap.GetSchemaForNode(e, FIgnoreNamespace(e));
                if (topTable != null) {
                    topRow = topTable.CreateEmptyRow(); //enzol perf
                    nodeToRowMap[ e ] = topRow;

                    // get all field values.
                    LoadRowData( topRow, e );
                    topTable.Rows.Add(topRow);                              
                }
            }

            LoadRows( topRow, xdoc.DocumentElement );
            AttachRows( topRow, xdoc.DocumentElement );


            if (isTableLevel) {
                dataTable.EnforceConstraints = saveEnforce;
            }
            else {
                dataSet.fInReadXml = false;
                dataSet.EnforceConstraints = saveEnforce;
            }

        }

        private void LoadRowData(DataRow row, XmlElement rowElement) {
            XmlNode n;
            DataTable table = row.Table;
            if (FromInference)
                table.Prefix = rowElement.Prefix;

            // keep a list of all columns that get updated
            Hashtable foundColumns = new Hashtable();

            row.BeginEdit();

            // examine all children first
            n = rowElement.FirstChild;

            // Look for data to fill the TextOnly column
            DataColumn column = GetTextOnlyColumn( row );
            if (column != null) {
                foundColumns[column] = column;
                string text = GetValueForTextOnlyColums( n ) ;
                if (XMLSchema.GetBooleanAttribute(rowElement, Keywords.XSI_NIL, Keywords.XSINS, false) && Common.ADP.IsEmpty(text) )
                    row[column] = DBNull.Value;
                else
                    SetRowValueFromXmlText( row, column, text );
            }

            // Walk the region to find elements that map to columns
            while (n != null && n != rowElement) {
                if (n.NodeType == XmlNodeType.Element) {
                    XmlElement e = (XmlElement) n;

                    object schema = nodeToSchemaMap.GetSchemaForNode( e, FIgnoreNamespace(e) );
                    if (schema is DataTable) {
                        if (FColumnElement(e))
                            schema = nodeToSchemaMap.GetColumnSchema( e, FIgnoreNamespace(e) );
                    }
                    
                    // if element has its own table mapping, it is a separate region
                    if (schema == null || schema is DataColumn) {
                        // descend to examine child elements
                        n = e.FirstChild;

                        if (schema != null && schema is DataColumn) {
                            DataColumn c = (DataColumn) schema;

                            if (c.Table == row.Table && c.ColumnMapping != MappingType.Attribute && foundColumns[c] == null) {
                                foundColumns[c] = c;
                                string text = GetValueForTextOnlyColums( n ) ;
                                if (XMLSchema.GetBooleanAttribute(e, Keywords.XSI_NIL, Keywords.XSINS, false) && Common.ADP.IsEmpty(text) )
                                    row[c] = DBNull.Value;
                                else
                                    SetRowValueFromXmlText( row, c, text );
                            }
                        } 
                        else if ((schema == null) && (n!=null)) {
                            continue;
                        }


                        // nothing left down here, continue from element
                        if (n == null)
                            n = e;
                    }
                }

                // if no more siblings, ascend back toward original element (rowElement)
                while (n != rowElement && n.NextSibling == null) {
                    n = n.ParentNode;
                }

                if (n != rowElement)
                    n = n.NextSibling;
            }

            //
            // Walk the attributes to find attributes that map to columns.
            //
            foreach( XmlAttribute attr in rowElement.Attributes ) {
                object schema = nodeToSchemaMap.GetColumnSchema( attr, FIgnoreNamespace(attr) );
                if (schema != null && schema is DataColumn) {
                    DataColumn c = (DataColumn) schema;

                    if (c.ColumnMapping == MappingType.Attribute && foundColumns[c] == null) {
                        foundColumns[c] = c;
                        n = attr.FirstChild;
                        SetRowValueFromXmlText( row, c, GetInitialTextFromNodes( ref n ) );
                    }
                }
            }

            // Null all columns values that aren't represented in the tree
            foreach( DataColumn c in row.Table.Columns ) {
                if (foundColumns[c] == null && XmlToDatasetMap.IsMappedColumn(c)) {
                    if (!c.AutoIncrement) {
                        if (c.AllowDBNull)  {
                            row[c] = DBNull.Value;
                        }
                        else {
                            row[c] = c.DefaultValue;
                        }
                    }
                    else {
                        c.Init(row.tempRecord);
                    }
                }
            }       

            row.EndEdit();
        }
        

        // load all data from tree structre into datarows
        private void LoadRows( DataRow parentRow, XmlNode parentElement ) {
            if (parentElement == null)
                return;

            // Skip schema node as well
            if (parentElement.LocalName == Keywords.XSD_SCHEMA && parentElement.NamespaceURI == Keywords.XSDNS ||
                parentElement.LocalName == Keywords.SQL_SYNC   && parentElement.NamespaceURI == Keywords.UPDGNS ||                
                parentElement.LocalName == Keywords.XDR_SCHEMA && parentElement.NamespaceURI == Keywords.XDRNS)
                return;

            for (XmlNode n = parentElement.FirstChild; n != null; n = n.NextSibling) {
                if (n is XmlElement) {
                    XmlElement e = (XmlElement) n;
                    object schema = nodeToSchemaMap.GetSchemaForNode( e, FIgnoreNamespace(e) );

                    if (schema != null && schema is DataTable) {
                        DataRow r = GetRowFromElement( e );
                        if (r == null) {
                            // skip columns which has the same name as another table
                            if (parentRow != null && FColumnElement(e))
                                continue;
                                
                            r = ((DataTable)schema).CreateEmptyRow();
                            nodeToRowMap[ e ] = r;

                            // get all field values.
                            LoadRowData( r, e );
                        }

                        // recurse down to inner elements
                        LoadRows( r, n );
                    }
                    else {
                        // recurse down to inner elements
                        LoadRows( null, n );
                    }
                }
            }
        }

        private void SetRowValueFromXmlText( DataRow row, DataColumn col, string xmlText ) {
            row[col] = col.ConvertXmlToObject(xmlText);
        }

        internal void LoadTopMostRow(ref bool[] foundColumns) {
            // Attempt to load row from top node we backed up in DataSet.ReadXml()
            // In most cases it contains the DataSet name and no information

            // Check if DataSet object matches the top node (it won't in most cases)

            Object obj = nodeToSchemaMap.GetSchemaForNode(topMostNode,FIgnoreNamespace(topMostNode));
            
            if (obj is DataTable) {                         // It's a table? Load it.
                DataTable table = (DataTable) obj;

                topMostRow = table.CreateEmptyRow();
                
                foundColumns = new bool[topMostRow.Table.Columns.Count];

                //
                // Walk the attributes to find attributes that map to columns.
                //
                foreach( XmlAttribute attr in topMostNode.Attributes ) {
                    object schema = nodeToSchemaMap.GetColumnSchema( attr, FIgnoreNamespace(attr) );

                    if (schema != null && schema is DataColumn) {
                        DataColumn c = (DataColumn) schema;

                        if (c.ColumnMapping == MappingType.Attribute) {
                            XmlNode n = attr.FirstChild;
                            SetRowValueFromXmlText( topMostRow, c, GetInitialTextFromNodes( ref n ) );
                            foundColumns[c.Ordinal] = true;
                        }
                    }
                }

            }
            topMostNode = null;
        }

        private XmlReader dataReader = null;
        private object XSD_XMLNS_NS;
        private object XDR_SCHEMA;
        private object XDRNS;
        private object SQL_SYNC;
        private object UPDGNS;
        private object XSD_SCHEMA;
        private object XSDNS;

        private object DFFNS;
        private object MSDNS;
        private object DIFFID;
        private object HASCHANGES;
        private object ROWORDER;

        private void InitNameTable() {
            XmlNameTable nameTable = dataReader.NameTable;

            XSD_XMLNS_NS = nameTable.Add(Keywords.XSD_XMLNS_NS);
            XDR_SCHEMA = nameTable.Add(Keywords.XDR_SCHEMA);
            XDRNS = nameTable.Add(Keywords.XDRNS);
            SQL_SYNC = nameTable.Add(Keywords.SQL_SYNC);
            UPDGNS = nameTable.Add(Keywords.UPDGNS);
            XSD_SCHEMA = nameTable.Add(Keywords.XSD_SCHEMA);
            XSDNS = nameTable.Add(Keywords.XSDNS);

            DFFNS = nameTable.Add(Keywords.DFFNS);
            MSDNS = nameTable.Add(Keywords.MSDNS);
            DIFFID = nameTable.Add(Keywords.DIFFID);
            HASCHANGES = nameTable.Add(Keywords.HASCHANGES);
            ROWORDER = nameTable.Add(Keywords.ROWORDER);
        }

        internal void LoadData(XmlReader reader) {
            dataReader = DataTextReader.CreateReader(reader);

            int entryDepth = dataReader.Depth;                  // Store current XML element depth so we'll read
                                                                // correct portion of the XML and no more
            bool fEnforce = isTableLevel ? dataTable.EnforceConstraints : dataSet.EnforceConstraints;         
                                                                // Keep constraints status for datataset/table
            InitNameTable();                                    // Adds DataSet namespaces to reader's nametable

            if (nodeToSchemaMap == null) {                      // Create XML to dataset map
                nodeToSchemaMap = isTableLevel ? new XmlToDatasetMap(dataReader.NameTable, dataTable) :
                                                 new XmlToDatasetMap(dataReader.NameTable, dataSet);
            }

            if (isTableLevel) {
                dataTable.EnforceConstraints = false;           // Disable constraints
            }
            else {
                dataSet.EnforceConstraints = false;             // Disable constraints
                dataSet.fInReadXml = true;                      // We're in ReadXml now
            }

            if (topMostNode != null) {                          // Do we have top node?

                if (!isDiffgram && !isTableLevel) {             // Not a diffgram  and not DataSet?
                    DataTable table = nodeToSchemaMap.GetSchemaForNode(topMostNode, FIgnoreNamespace(topMostNode)) as DataTable;
                                                                // Try to match table in the dataset to this node
                    if (table != null) {                        // Got the table ?
                        LoadTopMostTable(table);                // Load top most node
                    }
                }

                topMostNode = null;                             // topMostNode is no more. Good riddance.
            }

            while( !dataReader.EOF ) {                          // Main XML parsing loop. Check for EOF just in case.
                if (dataReader.Depth < entryDepth)              // Stop if we have consumed all elements allowed
                    break;

                if ( reader.NodeType != XmlNodeType.Element ) { // Read till Element is found
                    dataReader.Read();
                    continue;
                }                
                DataTable table = nodeToSchemaMap.GetTableForNode(dataReader, FIgnoreNamespace(dataReader));
                                                                // Try to get table for node
                if (table == null) {                            // Read till table is found

                    if (!ProcessXsdSchema())                    // Check for schemas...
                        dataReader.Read();                      // Not found? Read next element.

                    continue;
                }                

                LoadTable(table,  false /* isNested */);        // Here goes -- load data for this table
                                                                // This is a root table, so it's not nested
            }

            if (isTableLevel) {
                dataTable.EnforceConstraints = fEnforce;        // Restore constraints and return
            } 
            else {
                dataSet.fInReadXml = false;                     // We're done.
                dataSet.EnforceConstraints = fEnforce;          // Restore constraints and return
            }
        }

        // Loads a top most table. 
        // This is neded because desktop is capable of loading almost anything into the dataset.
        // The top node could be a DataSet element or a Table element. To make things worse,
        // you could have a table with the same name as dataset.
        // Here's how we're going to dig into this mess:
        //
        //                                 TopNode is null ?
        //                                / No           \ Yes
        //                  Table matches TopNode ?       Current node is the table start
        //                 / No                  \ Yes (LoadTopMostTable called in this case only)
        //   Current node is the table start    DataSet name matches one of the tables ?
        //      TopNode is dataset node        / Yes                                  \ No
        //                                    /                                        TopNode is the table
        //      Current node matches column or nested table in the table ?             and current node
        //     / No                                                 \ Yes              is a column or a
        //     TopNode is DataSet                            TopNode is table          nested table
        // 
        // Yes, it is terrible and I don't like it also..
        
        private void LoadTopMostTable(DataTable table) {
           
            //        /------------------------------- This one is in topMostNode (backed up to XML DOM)
            //  <Table> /----------------------------- We are here on entrance
            //      <Column>Value</Column>
            //      <AnotherColumn>Value</AnotherColumn>
            //  </Table> ...
            //            \------------------------------ We are here on exit           


            Debug.Assert (table != null, "Table to be loaded is null on LoadTopMostTable() entry");
            Debug.Assert (topMostNode != null, "topMostNode is null on LoadTopMostTable() entry");
            Debug.Assert (!isDiffgram, "Diffgram mode is on while we have topMostNode table. This is bad." );

            bool topNodeIsTable = isTableLevel || (dataSet.DataSetName != table.TableName);
                                                                // If table name we have matches dataset
                                                                // name top node could be a DataSet OR a table.
                                                                // It's a table overwise.
            DataRow row = null;                                 // Data row we're going to add to this table

            bool matchFound = false;                            // Assume we found no matching elements

            int entryDepth = dataReader.Depth - 1;              // Store current reader depth so we know when to stop reading
                                                                // Adjust depth by one as we've read top most element 
                                                                // outside this method. 
            string textNodeValue;                               // Value of a text node we might have

            Debug.Assert (entryDepth >= 0, "Wrong entry Depth for top most element." );

            int entryChild = childRowsStack.Count;              // Memorize child stack level on entry
            
            DataColumn c;                                       // Hold column here
            DataColumnCollection collection = table.Columns;    // Hold column collectio here

            object[] foundColumns = new object[collection.Count];
                                                                // This is the columns data we might find
            XmlNode n;                                          // Need this to pass by reference

            foreach( XmlAttribute attr in topMostNode.Attributes ) {
                                                                // Check all attributes in this node

                c = nodeToSchemaMap.GetColumnSchema( attr, FIgnoreNamespace(attr)) as DataColumn;
                                                                // Try to mach attribute to column
                if ((c != null) && (c.ColumnMapping == MappingType.Attribute)) {
                                                                // If it's a column with attribute mapping
                    n = attr.FirstChild;

                    foundColumns[c.Ordinal] = c.ConvertXmlToObject(GetInitialTextFromNodes(ref n));
                                                                // Get value
                    matchFound = true;                          // and note we found a matching element
                }
            }

            // Now handle elements. This could be columns or nested tables
            // We'll skip the rest as we have no idea what to do with it.

            // Note: we do not need to read first as we're already as it has been done by caller.
            
            while (entryDepth < dataReader.Depth ) {
                switch (dataReader.NodeType) {                  // Process nodes based on type
                case XmlNodeType.Element:                       // It's an element
                    object o = nodeToSchemaMap.GetColumnSchema(table, dataReader, FIgnoreNamespace(dataReader));
                                                                // Get dataset element for this XML element
                    c = o as DataColumn;                        // Perhaps, it's a column?

                    if ( c != null ) {                          // Do we have matched column in this table?

                        // Let's load column data

                        if (foundColumns[c.Ordinal] == null) {
                                                                // If this column was not found before
                            LoadColumn (c, foundColumns);       // Get column value.
                            matchFound = true;                  // Got matched row.
                        } 
                        else {
                            dataReader.Read();                  // Advance to next element. 
                        } 
                    } 
                    else  {
                        DataTable nestedTable = o as DataTable; 
                                                                // Perhaps, it's a nested table ?
                        if ( nestedTable != null ) {            // Do we have matched table in DataSet ?
                            LoadTable (nestedTable, true /* isNested */);            
                                                                // Yes. Load nested table (recursive)
                            matchFound = true;                  // Got matched nested table 
                        } 
                        else if (ProcessXsdSchema()) {          // Check for schema. Skip or load if found.
                            continue;                           // Schema has been found. Process the next element 
                                                                // we're already at (done by schema processing).
                        }
                        else {                                  // Not a table or column in this table ?
                            if (!(matchFound || topNodeIsTable)) {
                                                                // Could top node be a DataSet?


                                return;                         // Assume top node is DataSet 
                                                                // and stop top node processing
                            }
                            dataReader.Read();                  // Continue to the next element.
                        }
                    }
                    break;
                // Oops. Not supported
                case XmlNodeType.EntityReference:               // Oops. No support for Entity Reference
                    throw ExceptionBuilder.FoundEntity();
                case XmlNodeType.Text:                          // It looks like a text.
                case XmlNodeType.Whitespace:                    // This actually could be
                case XmlNodeType.CDATA:                         // if we have XmlText in our table
                case XmlNodeType.SignificantWhitespace:
                    textNodeValue = dataReader.ReadString();    
                                                                // Get text node value.
                    c = table.xmlText;                          // Get XML Text column from our table

                    if (c != null && foundColumns[c.Ordinal] == null) {
                                                                // If XmlText Column is set
                                                                // and we do not have data already                
                        foundColumns[c.Ordinal] = c.ConvertXmlToObject(textNodeValue);
                                                                // Read and store the data
                    }

                    break;
                default:
                    dataReader.Read();                  // We don't process that, skip to the next element.
                    break;
                }
            }

            dataReader.Read();                          // Proceed to the next element.

            // It's the time to populate row with loaded data and add it to the table we'we just read to the table

            for ( int i = foundColumns.Length -1; i >= 0; --i) {
                                                            // Check all columns
                if (null == foundColumns[i]) {              // Got data for this column ?
                    c = collection[i];                      // No. Get column for this index

                    if (c.AllowDBNull && c.ColumnMapping != MappingType.Hidden && !c.AutoIncrement) {
                        foundColumns[i] = DBNull.Value;     // Assign DBNull if possible
                                                            // table.Rows.Add() below will deal
                                                            // with default values and autoincrement
                    }
                }
            }

            row = table.Rows.AddWithColumnEvents(foundColumns);             // Create, populate and add row

            while (entryChild < childRowsStack.Count) {     // Process child rows we might have
                DataRow childRow = (DataRow) childRowsStack.Pop();  
                                                            // Get row from the stack
                bool unchanged = (childRow.RowState == DataRowState.Unchanged);
                                                            // Is data the same as before?
                childRow.SetNestedParentRow(row, /*setNonNested*/ false);
                                                            // Set parent row
                if (unchanged)                              // Restore record if child row's unchanged
                    childRow.oldRecord = childRow.newRecord; 
            }
        }

        // Loads a table. 
        // Yes, I know it's a big method. This is done to avoid performance penalty of calling methods 
        // with many arguments and to keep recursion within one method only. To make code readable,
        // this method divided into 3 parts: attribute processing (including diffgram), 
        // nested elements processing and loading data. Please keep it this way.

        private void LoadTable(DataTable table, bool isNested ) {

            //  <DataSet> /--------------------------- We are here on entrance
            //      <Table>               
            //          <Column>Value</Column>
            //          <AnotherColumn>Value</AnotherColumn>
            //      </Table>    /-------------------------- We are here on exit           
            //      <AnotherTable>
            //      ...
            //      </AnotherTable>
            //      ...
            //  </DataSet> 

            Debug.Assert (table != null, "Table to be loaded is null on LoadTable() entry");

            DataRow row = null;                                 // Data row we're going to add to this table

            int entryDepth = dataReader.Depth;                  // Store current reader depth so we know when to stop reading
            int entryChild = childRowsStack.Count;              // Memorize child stack level on entry

            DataColumn c;                                       // Hold column here
            DataColumnCollection collection = table.Columns;    // Hold column collectio here

            object[] foundColumns = new object[collection.Count];
                                                                // This is the columns data we found 
            // This is used to process diffgramms

            int rowOrder = -1;                                  // Row to insert data to
            string diffId = String.Empty;                       // Diffgram ID string
            string hasChanges = null;                           // Changes string
            bool hasErrors = false;                             // Set this in case of problem

            string textNodeValue;                               // Value of a text node we might have

            // Process attributes first                         

            for ( int i = dataReader.AttributeCount -1; i >= 0; --i) {    
                                                                // Check all attributes one by one
                dataReader.MoveToAttribute(i);                  // Get this attribute

                c = nodeToSchemaMap.GetColumnSchema(table, dataReader, FIgnoreNamespace(dataReader)) as DataColumn;
                                                                // Try to get column for this attribute

                if ((c != null) && (c.ColumnMapping == MappingType.Attribute)) {
                    // Yep, it is a column mapped as attribute
                    // Get value from XML and store it in the object array
                    foundColumns[c.Ordinal] = c.ConvertXmlToObject(dataReader.Value);
                }                                               // Oops. No column for this element
                
                // 



                // else if (table.XmlText != null &&               
                //          dataReader.NamespaceURI == Keywords.XSINS && 
                //          dataReader.LocalName == Keywords.XSI_NIL ) {
                //                                                 // Got XMLText column and it's a NIL attribute?
                //     if (XmlConvert.ToBoolean(dataReader.Value)) {
                //         // If NIL attribute set to true...
                //         // Assign DBNull to XmlText column
                //         foundColumns[table.XmlText.Ordinal] = DBNull.Value;
                //     }
                // }

                if ( isDiffgram ) {                             // Now handle some diffgram attributes 
                    if ( dataReader.NamespaceURI == Keywords.DFFNS ) {
                        switch (dataReader.LocalName) {
                        case Keywords.DIFFID:                   // Is it a diffgeam ID ?
                            diffId = dataReader.Value;          // Store ID
                            break;
                        case Keywords.HASCHANGES:               // Has chages attribute ?
                            hasChanges = dataReader.Value;      // Store value
                            break;
                        case Keywords.HASERRORS:                // Has errors attribute ?
                            hasErrors = (bool)Convert.ChangeType(dataReader.Value, typeof(bool), CultureInfo.InvariantCulture);
                                                                // Store value
                            break;
                        }
                    } 
                    else if ( dataReader.NamespaceURI == Keywords.MSDNS ) {
                        if ( dataReader.LocalName == Keywords.ROWORDER ) {
                                                                // Is it a row order attribute ?
                            rowOrder = (Int32)Convert.ChangeType(dataReader.Value, typeof(Int32), CultureInfo.InvariantCulture);
                                                                // Store it
                        } else if (dataReader.LocalName.StartsWith("hidden", StringComparison.Ordinal)) {
                                                                // Hidden column ?
                            c = collection[XmlConvert.DecodeName(dataReader.LocalName.Substring(6))];
                                                                // Let's see if we have one. 
                                                                // We have to decode name before we look it up
                                                                // We could not use XmlToDataSet map as it contains
                                                                // no hidden columns
                            if (( c != null)  && (c.ColumnMapping == MappingType.Hidden)) {
                                                                // Got column and it is hidden ?
                                foundColumns[c.Ordinal] = c.ConvertXmlToObject(dataReader.Value);
                            }
                        }
                    }
                }
            }                                                   // Done with attributes

            // Now handle elements. This could be columns or nested tables.

            //  <DataSet> /------------------- We are here after dealing with attributes
            //      <Table foo="FooValue" bar="BarValue">  
            //          <Column>Value</Column>
            //          <AnotherColumn>Value</AnotherColumn>
            //      </Table>
            //  </DataSet>

            if ( dataReader.Read() && entryDepth < dataReader.Depth) {
                                                                // Read to the next element and see if we're inside
                while ( entryDepth < dataReader.Depth ) {       // Get out as soon as we've processed all nested nodes.
                    switch (dataReader.NodeType) {              // Process nodes based on type
                    case XmlNodeType.Element:                   // It's an element
                        object o = nodeToSchemaMap.GetColumnSchema(table, dataReader, FIgnoreNamespace(dataReader));
                                                                // Get dataset element for this XML element
                        c = o as DataColumn;                    // Perhaps, it's a column?

                        if ( c != null ) {                      // Do we have matched column in this table?
                                                                // Let's load column data
                            if (foundColumns[c.Ordinal] == null) {
                                                                // If this column was not found before
                                LoadColumn (c, foundColumns);            
                                                                // Get column value
                            }
                            else {
                                dataReader.Read();              // Advance to next element. 
                            } 
                        } 
                        else  {
                            DataTable nestedTable = o as DataTable; 
                                                                // Perhaps, it's a nested table ?
                            if ( nestedTable != null ) {        // Do we have matched nested table in DataSet ?
                                LoadTable (nestedTable, true /* isNested */);            
                                                                // Yes. Load nested table (recursive)
                            }                                   // Not a table nor column? Check if it's schema.
                            else if (ProcessXsdSchema()) {      // Check for schema. Skip or load if found.
                                continue;                       // Schema has been found. Process the next element 
                                                                // we're already at (done by schema processing).
                            }
                            else {                              
                                // We've got element which is not supposed to he here according to the schema.
                                // That might be a table which was misplaced. We should've thrown on that, 
                                // but we'll try to load it so we could keep compatibility.
                                // We won't try to match to columns as we have no idea 
                                // which table this potential column might belong to.
                                DataTable misplacedTable = nodeToSchemaMap.GetTableForNode(dataReader, FIgnoreNamespace(dataReader));
                                                                // Try to get table for node

                                if (misplacedTable != null) {   // Got some matching table?
                                    LoadTable (misplacedTable, false /* isNested */);                       
                                                                // While table's XML element is nested,
                                                                // the table itself is not. Load it this way.
                                }                
                                else {
                                    dataReader.Read();          // Not a table? Try next element.
                                }
                            }
                        }
                        break;
                    case XmlNodeType.EntityReference:           // Oops. No support for Entity Reference
                        throw ExceptionBuilder.FoundEntity();
                    case XmlNodeType.Text:                      // It looks like a text.
                    case XmlNodeType.Whitespace:                // This actually could be
                    case XmlNodeType.CDATA:                     // if we have XmlText in our table
                    case XmlNodeType.SignificantWhitespace:
                        textNodeValue = dataReader.ReadString();    
                                                                // Get text node value.
                        c = table.xmlText;                      // Get XML Text column from our table

                        if (c != null && foundColumns[c.Ordinal] == null) {
                                                                // If XmlText Column is set
                                                                // and we do not have data already                
                            foundColumns[c.Ordinal] = c.ConvertXmlToObject(textNodeValue);
                                                                // Read and store the data
                        }
                        break;
                    default:
                            dataReader.Read();                  // We don't process that, skip to the next element.
                        break;
                    }
                }

                dataReader.Read();                              // We're done here, proceed to the next element.
            }

            // It's the time to populate row with loaded data and add it to the table we'we just read to the table

            if (isDiffgram) {                               // In case of diffgram
                row = table.NewRow(table.NewUninitializedRecord());
                                                            // just create an empty row
                row.BeginEdit();                            // and allow it's population with data 

                for ( int i = foundColumns.Length - 1; i >= 0 ; --i) {
                                                            // Check all columns
                    c = collection[i];                      // Get column for this index

                    c[row.tempRecord] = null != foundColumns[i] ? foundColumns[i] : DBNull.Value;
                                                            // Set column to loaded value of to
                                                            // DBNull if value is missing.
                }

                row.EndEdit();                              // Done with this row

                table.Rows.DiffInsertAt(row, rowOrder);     // insert data to specific location

                                                            // And do some diff processing
                if (hasChanges == null) {                   // No changes ?
                    row.oldRecord = row.newRecord;          // Restore old record
                } 

                if ((hasChanges == Keywords.MODIFIED) || hasErrors) {
                    table.RowDiffId[diffId] = row;    
                }

            }
            else {
                for ( int i = foundColumns.Length -1; i >= 0 ; --i) {
                                                            // Check all columns
                    if (null == foundColumns[i]) {          // Got data for this column ?
                        c = collection[i];                  // No. Get column for this index

                        if (c.AllowDBNull && c.ColumnMapping != MappingType.Hidden && !c.AutoIncrement) {
                            foundColumns[i] = DBNull.Value; // Assign DBNull if possible
                                                            // table.Rows.Add() below will deal
                                                            // with default values and autoincrement
                        }
                    }
                }

                row = table.Rows.AddWithColumnEvents(foundColumns);         // Create, populate and add row

            }

            // Data is loaded into the row and row is added to the table at this point

            while (entryChild < childRowsStack.Count) {     // Process child rows we might have
                DataRow childRow = (DataRow) childRowsStack.Pop();  
                                                            // Get row from the stack
                bool unchanged = (childRow.RowState == DataRowState.Unchanged);
                                                            // Is data the same as before?
                childRow.SetNestedParentRow(row, /*setNonNested*/ false);
                                                            // Set parent row

                if (unchanged)                              // Restore record if child row's unchanged
                    childRow.oldRecord = childRow.newRecord; 
            }

            if (isNested)                                   // Got parent ?
                childRowsStack.Push(row);                   // Push row to the stack

        }

        // Returns column value
        private void LoadColumn (DataColumn column, object[] foundColumns) {

            //  <DataSet>    /--------------------------------- We are here on entrance
            //      <Table> /
            //          <Column>Value</Column>
            //          <AnotherColumn>Value</AnotherColumn>
            //      </Table>    \------------------------------ We are here on exit
            //  </DataSet>

            //  <Column>                                        If we have something like this
            //      <Foo>FooVal</Foo>                           We would grab first text-like node
            //      Value                                       In this case it would be "FooVal"
            //      <Bar>BarVal</Bar>                           And not "Value" as you might think
            //  </Column>                                       This is how desktop works

            string text = String.Empty;                         // Column text. Assume empty string
            string xsiNilString = null;                         // Possible NIL attribute string

            int entryDepth = dataReader.Depth;                  // Store depth so we won't read too much

            if (dataReader.AttributeCount > 0)                  // If have attributes
                xsiNilString = dataReader.GetAttribute(Keywords.XSI_NIL, Keywords.XSINS);
                                                                // Try to get NIL attribute
                                                                // We have to do it before we move to the next element
            if (column.IsCustomType) {                          // Custom type column
                object columnValue   = null;                    // Column value we're after. Assume no value.

                string xsiTypeString = null;                    // XSI type name from TYPE attribute
                string typeName      = null;                    // Type name from MSD_INSTANCETYPE attribute

                XmlRootAttribute xmlAttrib = null;              // Might need this attribute for XmlSerializer

                if (dataReader.AttributeCount > 0) {            // If have attributes, get attributes we'll need
                    xsiTypeString    = dataReader.GetAttribute(Keywords.TYPE, Keywords.XSINS);
                    typeName         = dataReader.GetAttribute(Keywords.MSD_INSTANCETYPE, Keywords.MSDNS);
                }

                // Check if need to use XmlSerializer. We need to do that if type does not implement IXmlSerializable.
                // We also need to do that if no polymorphism for this type allowed.

                bool useXmlSerializer = !column.ImplementsIXMLSerializable && 
                    !( (column.DataType == typeof(Object)) || (typeName != null) || (xsiTypeString != null) );

                // Check if we have an attribute telling us value is null.
    
                if ((xsiNilString != null) && XmlConvert.ToBoolean(xsiNilString)) { 
                    if (!useXmlSerializer) {                    // See if need to set typed null.
                        if (typeName != null && typeName.Length > 0) { 
                                                                // Got type name
                            columnValue = SqlUdtStorage.GetStaticNullForUdtType(DataStorage.GetType(typeName));
                        }
                    }

                    if (null == columnValue) {                  // If no value,
                        columnValue = DBNull.Value;             // change to DBNull;
                    }

                    if ( !dataReader.IsEmptyElement )           // In case element is not empty
                        while (dataReader.Read() && (entryDepth < dataReader.Depth));
                                                                // Read current elements
                    dataReader.Read();                          // And start reading next element.

                }
                else {                                          // No NIL attribute. Get value
                    bool skipped = false;

                    if (column.Table.DataSet != null && column.Table.DataSet.UdtIsWrapped) {
                        dataReader.Read(); // if UDT is wrapped, skip the wrapper
                        skipped = true;
                    }

                    if (useXmlSerializer) {                     // Create an attribute for XmlSerializer
                        if (skipped) {
                            xmlAttrib = new XmlRootAttribute(dataReader.LocalName);
                            xmlAttrib.Namespace = dataReader.NamespaceURI ;
                        }
                        else {
                            xmlAttrib = new XmlRootAttribute(column.EncodedColumnName);
                            xmlAttrib.Namespace = column.Namespace;
                        }
                    }

                    columnValue = column.ConvertXmlToObject(dataReader, xmlAttrib);
                                                                // Go get the value
                    if (skipped) {
                        dataReader.Read(); // if Wrapper is skipped, skip its end tag
                    }
                }

                foundColumns[column.Ordinal] = columnValue;     // Store value

            } 
            else {                                                  // Not a custom type. 
                if ( dataReader.Read() && entryDepth < dataReader.Depth) {
                                                                    // Read to the next element and see if we're inside.
                    while (entryDepth < dataReader.Depth) {
                        switch (dataReader.NodeType) {              // Process nodes based on type
                        case XmlNodeType.Text:                      // It looks like a text. And we need it.
                        case XmlNodeType.Whitespace:
                        case XmlNodeType.CDATA:
                        case XmlNodeType.SignificantWhitespace:
                            if (0 == text.Length) {                 // In case we do not have value already

                                text = dataReader.Value;            // Get value.

                                // See if we have other text nodes near. In most cases this loop will not be executed. 
                                StringBuilder builder = null;
                                while ( dataReader.Read() && entryDepth < dataReader.Depth && IsTextLikeNode(dataReader.NodeType)) {
                                    if (builder == null) {
                                        builder = new StringBuilder(text);
                                    }
                                    builder.Append(dataReader.Value);  // Concatenate other sequential text like
                                                                       // nodes we might have. This is rare.
                                                                       // We're using this instead of dataReader.ReadString()
                                                                       // which would do the same thing but slower.
                                }

                                if (builder != null) {
                                    text = builder.ToString();
                                }
                            }
                            else {
                                dataReader.ReadString();            // We've got column value already. Read this one and ignore it.
                            }
                            break;
                        case XmlNodeType.Element:
                            if (ProcessXsdSchema()) {               // Check for schema. Skip or load if found.
                                continue;                           // Schema has been found. Process the next element 
                                                                    // we're already at (done by schema processing).
                            }
                            else {                              
                                // We've got element which is not supposed to he here.
                                // That might be table which was misplaced.
                                // Or it might be a column inside column (also misplaced).
                                object o = nodeToSchemaMap.GetColumnSchema(column.Table, dataReader, FIgnoreNamespace(dataReader));
                                                                    // Get dataset element for this XML element
                                DataColumn c = o as DataColumn;     // Perhaps, it's a column?
            
                                if ( c != null ) {                  // Do we have matched column in this table?

                                    // Let's load column data
                        
                                    if (foundColumns[c.Ordinal] == null) {
                                                                    // If this column was not found before
                                        LoadColumn (c, foundColumns);            
                                                                    // Get column value
                                    }       
                                    else {
                                        dataReader.Read();          // Already loaded, proceed to the next element
                                    }
                                } 
                                else  {
                                    DataTable nestedTable = o as DataTable; 
                                                                    // Perhaps, it's a nested table ?
                                    if ( nestedTable != null ) {        
                                                                    // Do we have matched table in DataSet ?
                                        LoadTable (nestedTable, true /* isNested */);            
                                                                    // Yes. Load nested table (recursive)
                                    }
                                    else {                          // Not a nested column nor nested table.    
                                                                    // Let's try other tables in the DataSet
        
                                        DataTable misplacedTable = nodeToSchemaMap.GetTableForNode(dataReader, FIgnoreNamespace(dataReader));
                                                                    // Try to get table for node
                                        if (misplacedTable != null) {   
                                                                    // Got some table to match?
                                            LoadTable (misplacedTable, false /* isNested */);                       
                                                                    // While table's XML element is nested,
                                                                    // the table itself is not. Load it this way.
                                        } 
                                        else {
                                            dataReader.Read();      // No match? Try next element
                                        }               
                                    }
                                }
                            }
                            break;
                        case XmlNodeType.EntityReference:           // Oops. No support for Entity Reference
                            throw ExceptionBuilder.FoundEntity();
                        default:
                            dataReader.Read();                      // We don't process that, skip to the next element.
                            break;
                        }
            
                    }

                    dataReader.Read();                              // We're done here. To the next element.
                }

                if (0 == text.Length && xsiNilString != null && XmlConvert.ToBoolean(xsiNilString)) {
                    foundColumns[column.Ordinal] = DBNull.Value;     
                                                                    // If no data and NIL attribute is true set value to null
                }
                else {
                    foundColumns[column.Ordinal] = column.ConvertXmlToObject(text);
                }
    
            }

        }

        // Check for schema and skips or loads XSD schema if found. Returns true if schema found.
        // DataReader would be set on the first XML element after the schema of schema was found.
        // If no schema detected, reader's position will not change.
        private bool ProcessXsdSchema () {
            if (((object)dataReader.LocalName == XSD_SCHEMA && (object)dataReader.NamespaceURI == XSDNS )) {
                                                                    // Found XSD schema
                if ( ignoreSchema ) {                               // Should ignore it?
                    dataReader.Skip();                              // Yes, skip it
                }
                else {                                              // Have to load schema.
                    if ( isTableLevel ) {                           // Loading into the DataTable ?
                        dataTable.ReadXSDSchema(dataReader, false); // Invoke ReadXSDSchema on a table
                        nodeToSchemaMap = new XmlToDatasetMap(dataReader.NameTable, dataTable);
                    }                                               // Rebuild XML to DataSet map with new schema.
                    else {                                          // Loading into the DataSet ?
                        dataSet.ReadXSDSchema(dataReader, false);   // Invoke ReadXSDSchema on a DataSet
                        nodeToSchemaMap = new XmlToDatasetMap(dataReader.NameTable, dataSet);
                    }                                               // Rebuild XML to DataSet map with new schema.
                }
            }
            else if (((object)dataReader.LocalName == XDR_SCHEMA && (object)dataReader.NamespaceURI == XDRNS ) || 
                    ((object)dataReader.LocalName == SQL_SYNC   && (object)dataReader.NamespaceURI == UPDGNS))
            {
                dataReader.Skip();                                  // Skip XDR or SQL sync 
            }
            else {
                return false;                                       // No schema found. That means reader's position 
                                                                    // is unchganged. Report that to the caller.
            }

            return true;                                            // Schema found, reader's position changed.
        }
    }
}