public object GetColumnSchema(XmlNode node, bool fIgnoreNamespace)
        {
            Debug.Assert(node != null, "Argument validation");
            TableSchemaInfo tableSchemaInfo = null;

            XmlNode nodeRegion = (node.NodeType == XmlNodeType.Attribute) ? ((XmlAttribute)node).OwnerElement : node.ParentNode;

            do
            {
                if (nodeRegion == null || nodeRegion.NodeType != XmlNodeType.Element)
                {
                    return(null);
                }
                tableSchemaInfo = (TableSchemaInfo)(fIgnoreNamespace ? tableSchemaMap[nodeRegion.LocalName] : tableSchemaMap[nodeRegion]);
                nodeRegion      = nodeRegion.ParentNode;
            } while(tableSchemaInfo == null);

            if (fIgnoreNamespace)
            {
                return(tableSchemaInfo.ColumnsSchemaMap[node.LocalName]);
            }
            else
            {
                return(tableSchemaInfo.ColumnsSchemaMap[node]);
            }
        }
Beispiel #2
0
        private TableSchemaInfo AddTableSchema(XmlNameTable nameTable, DataTable table)
        {
            string encodedTableName = table.EncodedTableName;
            string localName        = nameTable.Get(encodedTableName);

            if (localName == null)
            {
                localName = nameTable.Add(encodedTableName);
            }
            table.encodedTableName = localName;
            string namespaceURI = nameTable.Get(table.Namespace);

            if (namespaceURI == null)
            {
                namespaceURI = nameTable.Add(table.Namespace);
            }
            else if (table.tableNamespace != null)
            {
                table.tableNamespace = namespaceURI;
            }
            TableSchemaInfo info = new TableSchemaInfo(table);

            this.tableSchemaMap[new XmlNodeIdentety(localName, namespaceURI)] = info;
            return(info);
        }
Beispiel #3
0
        private void BuildIdentityMap(XmlNameTable nameTable, DataSet dataSet)
        {
            _tableSchemaMap = new XmlNodeIdHashtable(dataSet.Tables.Count);
            // This hash table contains
            // tables schemas as TableSchemaInfo objects
            // These objects holds reference to the table.
            // Hash tables with columns schema maps
            // and child tables schema maps

            string dsNamespace =
                nameTable.Get(dataSet.Namespace) ?? // Attempt to look up DataSet namespace in the name table
                nameTable.Add(dataSet.Namespace);   //  Found? Nope. Add it

            dataSet._namespaceURI = dsNamespace;    // Set a DataSet namespace URI

            foreach (DataTable t in dataSet.Tables)
            {                    // For each table
                TableSchemaInfo tableSchemaInfo = AddTableSchema(nameTable, t);
                // Add table schema info to hash table

                if (tableSchemaInfo != null)
                {
                    foreach (DataColumn c in t.Columns)
                    {              // Add column schema map
                        // don't include auto-generated PK, FK and any hidden columns to be part of mapping
                        if (IsMappedColumn(c))
                        {                        // If mapped column
                            AddColumnSchema(nameTable, c, tableSchemaInfo.ColumnsSchemaMap);
                        }                        // Add it to the map
                    }

                    // Add child nested tables to the schema

                    foreach (DataRelation r in t.ChildRelations)
                    {     // Do we have a child tables ?
                        if (r.Nested)
                        { // Is it nested?
                            // don't include non nested tables

                            // Handle namespaces and names as usuall

                            string _tableLocalName = XmlConvert.EncodeLocalName(r.ChildTable.TableName);
                            string?tableLocalName  =
                                nameTable.Get(_tableLocalName) ??
                                nameTable.Add(_tableLocalName);

                            string?tableNamespace =
                                nameTable.Get(r.ChildTable.Namespace) ??
                                nameTable.Add(r.ChildTable.Namespace);

                            XmlNodeIdentety idTable = new XmlNodeIdentety(tableLocalName, tableNamespace);
                            tableSchemaInfo.ColumnsSchemaMap[idTable] = r.ChildTable;
                        }
                    }
                }
            }
        }
        // This one is used while reading data with preloaded schema

        private void BuildIdentityMap(XmlNameTable nameTable, DataTable dataTable)
        {
            ArrayList tableList = GetSelfAndDescendants(dataTable);     // Get list of tables we're loading

            // This includes our table and
            // related tables tree

            this.tableSchemaMap = new XmlNodeIdHashtable(tableList.Count);
            // Create hash table to hold all
            // tables to load.

            foreach (DataTable t in tableList)                          // For each table

            {
                TableSchemaInfo tableSchemaInfo = AddTableSchema(nameTable, t);
                // Create schema info
                if (tableSchemaInfo != null)
                {
                    foreach (DataColumn c in t.Columns)                 // Add column information
                    // don't include auto-generated PK, FK and any hidden columns to be part of mapping
                    {
                        if (IsMappedColumn(c))
                        {
                            AddColumnSchema(nameTable, c, tableSchemaInfo.ColumnsSchemaMap);
                        }
                    }

                    foreach (DataRelation r in t.ChildRelations)        // Add nested tables information
                    {
                        if (r.Nested)                                   // Is it nested?
                        // don't include non nested tables

                        // Handle namespaces and names as usuall

                        {
                            string _tableLocalName = XmlConvert.EncodeLocalName(r.ChildTable.TableName);
                            string tableLocalName  = nameTable.Get(_tableLocalName);

                            if (tableLocalName == null)
                            {
                                tableLocalName = nameTable.Add(_tableLocalName);
                            }

                            string tableNamespace = nameTable.Get(r.ChildTable.Namespace);

                            if (tableNamespace == null)
                            {
                                tableNamespace = nameTable.Add(r.ChildTable.Namespace);
                            }

                            XmlNodeIdentety idTable = new XmlNodeIdentety(tableLocalName, tableNamespace);
                            tableSchemaInfo.ColumnsSchemaMap[idTable] = r.ChildTable;
                        }
                    }
                }
            }
        }
Beispiel #5
0
 private static void MapColumnInformation(TableSchema table, TableSchemaInfo tSchema)
 {
     foreach (var c in table.Columns)
     {
         var cSchema = new ColumnSchemaInfo();
         cSchema.ColumnName = c.Name;
         cSchema.DataType   = c.DataType.ToString();
         tSchema.Columns.Add(cSchema);
     }
 }
Beispiel #6
0
        public void AddTable(TableSchemaInfo schema)
        {
            if (!HasTable(schema.TableName))
            {
                var columns = new List <Column>();
                schema.Columns.ForEach(c => columns.Add(new Column(c.ColumnName, Type.GetType(c.DataType))));

                var table = new Table(schema.TableName, columns, _id, _process);
                Tables.Add(table);
            }
        }
Beispiel #7
0
        private static void MapTableInformation(DbSchema schema, DbSchemaInfo info)
        {
            foreach (var table in schema.Tables)
            {
                var tSchema = new TableSchemaInfo();
                tSchema.TableName = table.TableName;
                MapColumnInformation(table, tSchema);

                info.Tables.Add(tSchema);
            }
        }
Beispiel #8
0
        public DataTable GetTableForNode(XmlReader node, bool fIgnoreNamespace)
        {
            TableSchemaInfo tableSchemaInfo = (TableSchemaInfo)(fIgnoreNamespace ? _tableSchemaMap[node.LocalName] : _tableSchemaMap[node]);

            if (tableSchemaInfo != null)
            {
                _lastTableSchemaInfo = tableSchemaInfo;
                return(_lastTableSchemaInfo.TableSchema);
            }
            return(null);
        }
Beispiel #9
0
        public DataTable GetTableForNode(XmlReader node, bool fIgnoreNamespace)
        {
            TableSchemaInfo info = fIgnoreNamespace ? ((TableSchemaInfo)this.tableSchemaMap[node.LocalName]) : ((TableSchemaInfo)this.tableSchemaMap[node]);

            if (info != null)
            {
                this.lastTableSchemaInfo = info;
                return(this.lastTableSchemaInfo.TableSchema);
            }
            return(null);
        }
Beispiel #10
0
 public object GetColumnSchema(DataTable table, XmlReader dataReader, bool fIgnoreNamespace)
 {
     if ((this.lastTableSchemaInfo == null) || (this.lastTableSchemaInfo.TableSchema != table))
     {
         this.lastTableSchemaInfo = fIgnoreNamespace ? ((TableSchemaInfo)this.tableSchemaMap[table.EncodedTableName]) : ((TableSchemaInfo)this.tableSchemaMap[table]);
     }
     if (fIgnoreNamespace)
     {
         return(this.lastTableSchemaInfo.ColumnsSchemaMap[dataReader.LocalName]);
     }
     return(this.lastTableSchemaInfo.ColumnsSchemaMap[dataReader]);
 }
 private TableSchemaInfo AddTableSchema(DataTable table, XmlNameTable nameTable)
 {
     string localName = nameTable.Get(table.EncodedTableName);
     string namespaceURI = nameTable.Get(table.Namespace);
     if (localName == null)
     {
         return null;
     }
     TableSchemaInfo info = new TableSchemaInfo(table);
     this.tableSchemaMap[new XmlNodeIdentety(localName, namespaceURI)] = info;
     return info;
 }
Beispiel #12
0
        public object GetSchemaForNode(XmlNode node, bool fIgnoreNamespace)
        {
            TableSchemaInfo info = null;

            if (node.NodeType == XmlNodeType.Element)
            {
                info = fIgnoreNamespace ? ((TableSchemaInfo)this.tableSchemaMap[node.LocalName]) : ((TableSchemaInfo)this.tableSchemaMap[node]);
            }
            if (info != null)
            {
                return(info.TableSchema);
            }
            return(this.GetColumnSchema(node, fIgnoreNamespace));
        }
Beispiel #13
0
        private TableSchemaInfo AddTableSchema(DataTable table, XmlNameTable nameTable)
        {
            string localName    = nameTable.Get(table.EncodedTableName);
            string namespaceURI = nameTable.Get(table.Namespace);

            if (localName == null)
            {
                return(null);
            }
            TableSchemaInfo info = new TableSchemaInfo(table);

            this.tableSchemaMap[new XmlNodeIdentety(localName, namespaceURI)] = info;
            return(info);
        }
        public object GetColumnSchema(DataTable table, XmlReader dataReader, bool fIgnoreNamespace)
        {
            TableSchemaInfo tableSchemaInfo = null;

            tableSchemaInfo = (TableSchemaInfo)(fIgnoreNamespace ? tableSchemaMap[table.EncodedTableName] : tableSchemaMap[table]);

            if (fIgnoreNamespace)
            {
                return(tableSchemaInfo.ColumnsSchemaMap[dataReader.LocalName]);
            }
            else
            {
                return(tableSchemaInfo.ColumnsSchemaMap[dataReader]);
            }
        }
        public DataTable GetTableForNode(XmlReader node, bool fIgnoreNamespace)
        {
            TableSchemaInfo tableSchemaInfo = null;

            tableSchemaInfo = (TableSchemaInfo)(fIgnoreNamespace ? tableSchemaMap[node.LocalName] : tableSchemaMap[node]);

            if (tableSchemaInfo != null)
            {
                return(tableSchemaInfo.TableSchema);
            }
            else
            {
                return(null);
            }
        }
Beispiel #16
0
        // Used to infer schema

        public object GetSchemaForNode(XmlNode node, bool fIgnoreNamespace)
        {
            TableSchemaInfo tableSchemaInfo = null;

            if (node.NodeType == XmlNodeType.Element)
            {         // If element
                tableSchemaInfo = (TableSchemaInfo)(fIgnoreNamespace ? _tableSchemaMap[node.LocalName] : _tableSchemaMap[node]);
            }         // Look up table schema info for it

            if (tableSchemaInfo != null)
            {                                        // Got info ?
                return(tableSchemaInfo.TableSchema); // Yes, Return table
            }

            return(GetColumnSchema(node, fIgnoreNamespace));     // Attempt to locate column
        }
Beispiel #17
0
        private void BuildIdentityMap(DataTable dataTable, XmlNameTable nameTable)
        {
            this.tableSchemaMap = new XmlNodeIdHashtable(1);
            TableSchemaInfo info = this.AddTableSchema(dataTable, nameTable);

            if (info != null)
            {
                foreach (DataColumn column in dataTable.Columns)
                {
                    if (IsMappedColumn(column))
                    {
                        this.AddColumnSchema(column, nameTable, info.ColumnsSchemaMap);
                    }
                }
            }
        }
Beispiel #18
0
        private TableSchemaInfo AddTableSchema(XmlNameTable nameTable, DataTable table)
        {
            // Enzol:This is the opposite of the previous function:
            //       we populate the nametable so that the hash comparison can happen as
            //       object comparison instead of strings.
            // Sdub: GetIdentity is called from two places: BuildIdentityMap() and LoadRows()
            //       First case deals with decoded names; Second one with encoded names.
            //       We decided encoded names in first case (instead of decoding them in second)
            //       because it save us time in LoadRows(). We have, as usual, more data them schemas

            string _tableLocalName = table.EncodedTableName;            // Table name

            string?tableLocalName = nameTable.Get(_tableLocalName);     // Look it up in nametable

            if (tableLocalName == null)
            {                                                    // If not found
                tableLocalName = nameTable.Add(_tableLocalName); // Add it
            }

            table._encodedTableName = tableLocalName;                    // And set it back

            string?tableNamespace = nameTable.Get(table.Namespace);      // Look ip table namespace

            if (tableNamespace == null)
            {                                                    // If not found
                tableNamespace = nameTable.Add(table.Namespace); // Add it
            }
            else
            {
                if (table._tableNamespace != null)                       // Update table namespace
                {
                    table._tableNamespace = tableNamespace;
                }
            }


            TableSchemaInfo tableSchemaInfo = new TableSchemaInfo(table);

            // Create new table schema info
            _tableSchemaMap[new XmlNodeIdentety(tableLocalName, tableNamespace)] = tableSchemaInfo;
            // And add it to the hashtable
            return(tableSchemaInfo);                                     // Return it as we have to populate
                                                                         // Column schema map and Child table
                                                                         // schema map in it
        }
Beispiel #19
0
        // Used for inference

        private void BuildIdentityMap(DataTable dataTable, XmlNameTable nameTable)
        {
            _tableSchemaMap = new XmlNodeIdHashtable(1);

            TableSchemaInfo tableSchemaInfo = AddTableSchema(dataTable, nameTable);

            if (tableSchemaInfo != null)
            {
                foreach (DataColumn c in dataTable.Columns)
                {
                    // don't include auto-generated PK, FK and any hidden columns to be part of mapping
                    if (IsMappedColumn(c))
                    {
                        AddColumnSchema(c, nameTable, tableSchemaInfo.ColumnsSchemaMap);
                    }
                }
            }
        }
        public object GetSchemaForNode(XmlNode node, bool fIgnoreNamespace)
        {
            TableSchemaInfo tableSchemaInfo = null;

            if (node.NodeType == XmlNodeType.Element)
            {
                tableSchemaInfo = (TableSchemaInfo)(fIgnoreNamespace ? tableSchemaMap[node.LocalName] : tableSchemaMap[node]);
            }

            if (tableSchemaInfo != null)
            {
                return(tableSchemaInfo.TableSchema);
            }
            else
            {
                return(GetColumnSchema(node, fIgnoreNamespace));
            }
        }
Beispiel #21
0
        private void BuildIdentityMap(XmlNameTable nameTable, DataSet dataSet)
        {
            this.tableSchemaMap = new XmlNodeIdHashtable(dataSet.Tables.Count);
            string str3 = nameTable.Get(dataSet.Namespace);

            if (str3 == null)
            {
                str3 = nameTable.Add(dataSet.Namespace);
            }
            dataSet.namespaceURI = str3;
            foreach (DataTable table in dataSet.Tables)
            {
                TableSchemaInfo info = this.AddTableSchema(nameTable, table);
                if (info != null)
                {
                    foreach (DataColumn column in table.Columns)
                    {
                        if (IsMappedColumn(column))
                        {
                            this.AddColumnSchema(nameTable, column, info.ColumnsSchemaMap);
                        }
                    }
                    foreach (DataRelation relation in table.ChildRelations)
                    {
                        if (relation.Nested)
                        {
                            string array     = XmlConvert.EncodeLocalName(relation.ChildTable.TableName);
                            string localName = nameTable.Get(array);
                            if (localName == null)
                            {
                                localName = nameTable.Add(array);
                            }
                            string namespaceURI = nameTable.Get(relation.ChildTable.Namespace);
                            if (namespaceURI == null)
                            {
                                namespaceURI = nameTable.Add(relation.ChildTable.Namespace);
                            }
                            XmlNodeIdentety identety = new XmlNodeIdentety(localName, namespaceURI);
                            info.ColumnsSchemaMap[identety] = relation.ChildTable;
                        }
                    }
                }
            }
        }
Beispiel #22
0
        public object GetColumnSchema(XmlNode node, bool fIgnoreNamespace)
        {
            TableSchemaInfo info       = null;
            XmlNode         parentNode = (node.NodeType == XmlNodeType.Attribute) ? ((XmlAttribute)node).OwnerElement : node.ParentNode;

            do
            {
                if ((parentNode == null) || (parentNode.NodeType != XmlNodeType.Element))
                {
                    return(null);
                }
                info       = fIgnoreNamespace ? ((TableSchemaInfo)this.tableSchemaMap[parentNode.LocalName]) : ((TableSchemaInfo)this.tableSchemaMap[parentNode]);
                parentNode = parentNode.ParentNode;
            }while (info == null);
            if (fIgnoreNamespace)
            {
                return(info.ColumnsSchemaMap[node.LocalName]);
            }
            return(info.ColumnsSchemaMap[node]);
        }
        private TableSchemaInfo AddTableSchema(XmlNameTable nameTable, DataTable table)
        {
            // Enzol:This is the opposite of the previous function:
            //       we populate the nametable so that the hash comparison can happen as
            //       object comparison instead of strings.
            // Sdub: GetIdentity is called from two places: BuildIdentityMap() and LoadRows()
            //       First case deals with decoded names; Second one with encoded names.
            //       We decided encoded names in first case (instead of decoding them in second)
            //       because it save us time in LoadRows(). We have, as usual, more data them schemas

            string _tableLocalName = table.EncodedTableName;
            string tableLocalName  = nameTable.Get(_tableLocalName);

            if (tableLocalName == null)
            {
                tableLocalName = nameTable.Add(_tableLocalName);
            }
            table.encodedTableName = tableLocalName;

            string tableNamespace = nameTable.Get(table.Namespace);

            if (tableNamespace == null)
            {
                tableNamespace = nameTable.Add(table.Namespace);
            }
            else
            {
                if (table.tableNamespace != null)
                {
                    table.tableNamespace = tableNamespace;
                }
            }

            TableSchemaInfo tableSchemaInfo = new TableSchemaInfo(table);

            tableSchemaMap[new XmlNodeIdentety(tableLocalName, tableNamespace)] = tableSchemaInfo;
            return(tableSchemaInfo);
        }
Beispiel #24
0
        // Used to infere schema

        private TableSchemaInfo?AddTableSchema(DataTable table, XmlNameTable nameTable)
        {
            // SDUB: Because in our case reader already read the document all names that we can meet in the
            //       document already has an entry in NameTable.
            //       If in future we will build identity map before reading XML we can replace Get() to Add()
            // Sdub: GetIdentity is called from two places: BuildIdentityMap() and LoadRows()
            //       First case deals with decoded names; Second one with encoded names.
            //       We decided encoded names in first case (instead of decoding them in second)
            //       because it save us time in LoadRows(). We have, as usual, more data them schemas
            string?tableLocalName = nameTable.Get(table.EncodedTableName);
            string?tableNamespace = nameTable.Get(table.Namespace);

            if (tableLocalName == null)
            {
                // because name of this table isn't present in XML we don't need mapping for it.
                // Less mapping faster we work.
                return(null);
            }
            TableSchemaInfo tableSchemaInfo = new TableSchemaInfo(table);

            _tableSchemaMap[new XmlNodeIdentety(tableLocalName, tableNamespace)] = tableSchemaInfo;
            return(tableSchemaInfo);
        }
        private void BuildIdentityMap(XmlNameTable nameTable, DataSet dataSet)
        {
            this.tableSchemaMap = new XmlNodeIdHashtable(dataSet.Tables.Count);

            string dsNamespace = nameTable.Get(dataSet.Namespace);

            if (dsNamespace == null)
            {
                dsNamespace = nameTable.Add(dataSet.Namespace);
            }
            dataSet.namespaceURI = dsNamespace;

            foreach (DataTable t in dataSet.Tables)
            {
                TableSchemaInfo tableSchemaInfo = AddTableSchema(nameTable, t);
                if (tableSchemaInfo != null)
                {
                    foreach (DataColumn c in t.Columns)
                    {
                        // don't include auto-generated PK, FK and any hidden columns to be part of mapping
                        if (IsMappedColumn(c))
                        {
                            AddColumnSchema(nameTable, c, tableSchemaInfo.ColumnsSchemaMap);
                        }
                    }

                    foreach (DataRelation r in t.ChildRelations)
                    {
                        if (r.Nested)
                        {
                            // don't include non nested tables
                            AddChildTableSchema(nameTable, r, tableSchemaInfo.ChildTablesSchemaMap);
                        }
                    }
                }
            }
        }
 public object GetColumnSchema(DataTable table, XmlReader dataReader, bool fIgnoreNamespace)
 {
     if ((this.lastTableSchemaInfo == null) || (this.lastTableSchemaInfo.TableSchema != table))
     {
         this.lastTableSchemaInfo = fIgnoreNamespace ? ((TableSchemaInfo) this.tableSchemaMap[table.EncodedTableName]) : ((TableSchemaInfo) this.tableSchemaMap[table]);
     }
     if (fIgnoreNamespace)
     {
         return this.lastTableSchemaInfo.ColumnsSchemaMap[dataReader.LocalName];
     }
     return this.lastTableSchemaInfo.ColumnsSchemaMap[dataReader];
 }
 private TableSchemaInfo AddTableSchema(XmlNameTable nameTable, DataTable table)
 {
     string encodedTableName = table.EncodedTableName;
     string localName = nameTable.Get(encodedTableName);
     if (localName == null)
     {
         localName = nameTable.Add(encodedTableName);
     }
     table.encodedTableName = localName;
     string namespaceURI = nameTable.Get(table.Namespace);
     if (namespaceURI == null)
     {
         namespaceURI = nameTable.Add(table.Namespace);
     }
     else if (table.tableNamespace != null)
     {
         table.tableNamespace = namespaceURI;
     }
     TableSchemaInfo info = new TableSchemaInfo(table);
     this.tableSchemaMap[new XmlNodeIdentety(localName, namespaceURI)] = info;
     return info;
 }
Beispiel #28
0
        // Used to infere schema

        private TableSchemaInfo AddTableSchema(DataTable table, XmlNameTable nameTable)
        {
            // SDUB: Because in our case reader already read the document all names that we can meet in the
            //       document already has an entry in NameTable.
            //       If in future we will build identity map before reading XML we can replace Get() to Add()
            // Sdub: GetIdentity is called from two places: BuildIdentityMap() and LoadRows()
            //       First case deals with decoded names; Second one with encoded names.
            //       We decided encoded names in first case (instead of decoding them in second) 
            //       because it save us time in LoadRows(). We have, as usual, more data them schemas
            string tableLocalName = nameTable.Get(table.EncodedTableName);
            string tableNamespace = nameTable.Get(table.Namespace);
            if (tableLocalName == null)
            {
                // because name of this table isn't present in XML we don't need mapping for it.
                // Less mapping faster we work.
                return null;
            }
            TableSchemaInfo tableSchemaInfo = new TableSchemaInfo(table);
            _tableSchemaMap[new XmlNodeIdentety(tableLocalName, tableNamespace)] = tableSchemaInfo;
            return tableSchemaInfo;
        }
Beispiel #29
0
        private TableSchemaInfo AddTableSchema(XmlNameTable nameTable, DataTable table)
        {
            // Enzol:This is the opposite of the previous function:
            //       we populate the nametable so that the hash comparison can happen as
            //       object comparison instead of strings.
            // Sdub: GetIdentity is called from two places: BuildIdentityMap() and LoadRows()
            //       First case deals with decoded names; Second one with encoded names.
            //       We decided encoded names in first case (instead of decoding them in second) 
            //       because it save us time in LoadRows(). We have, as usual, more data them schemas

            string _tableLocalName = table.EncodedTableName;            // Table name

            string tableLocalName = nameTable.Get(_tableLocalName);     // Look it up in nametable

            if (tableLocalName == null)
            {                                // If not found
                tableLocalName = nameTable.Add(_tableLocalName);        // Add it
            }

            table._encodedTableName = tableLocalName;                    // And set it back

            string tableNamespace = nameTable.Get(table.Namespace);     // Look ip table namespace

            if (tableNamespace == null)
            {                               // If not found
                tableNamespace = nameTable.Add(table.Namespace);        // Add it
            }
            else
            {
                if (table._tableNamespace != null)                       // Update table namespace
                    table._tableNamespace = tableNamespace;
            }


            TableSchemaInfo tableSchemaInfo = new TableSchemaInfo(table);
            // Create new table schema info
            _tableSchemaMap[new XmlNodeIdentety(tableLocalName, tableNamespace)] = tableSchemaInfo;
            // And add it to the hashtable
            return tableSchemaInfo;                                     // Return it as we have to populate
                                                                        // Column schema map and Child table 
                                                                        // schema map in it
        }
Beispiel #30
0
        public object GetColumnSchema(DataTable table, XmlReader dataReader, bool fIgnoreNamespace)
        {
            if ((_lastTableSchemaInfo == null) || (_lastTableSchemaInfo.TableSchema != table))
            {
                _lastTableSchemaInfo = (TableSchemaInfo)(fIgnoreNamespace ? _tableSchemaMap[table.EncodedTableName] : _tableSchemaMap[table]);
            }

            if (fIgnoreNamespace)
                return _lastTableSchemaInfo.ColumnsSchemaMap[dataReader.LocalName];
            return _lastTableSchemaInfo.ColumnsSchemaMap[dataReader];
        }
Beispiel #31
0
 public DataTable GetTableForNode(XmlReader node, bool fIgnoreNamespace)
 {
     TableSchemaInfo tableSchemaInfo = (TableSchemaInfo)(fIgnoreNamespace ? _tableSchemaMap[node.LocalName] : _tableSchemaMap[node]);
     if (tableSchemaInfo != null)
     {
         _lastTableSchemaInfo = tableSchemaInfo;
         return _lastTableSchemaInfo.TableSchema;
     }
     return null;
 }
 public DataTable GetTableForNode(XmlReader node, bool fIgnoreNamespace)
 {
     TableSchemaInfo info = fIgnoreNamespace ? ((TableSchemaInfo) this.tableSchemaMap[node.LocalName]) : ((TableSchemaInfo) this.tableSchemaMap[node]);
     if (info != null)
     {
         this.lastTableSchemaInfo = info;
         return this.lastTableSchemaInfo.TableSchema;
     }
     return null;
 }