Inheritance: MarshalByRefObject, IColumnMappingCollection
コード例 #1
0
 internal static string[] MapColumnNames(DataColumnMappingCollection mappingCollection, string[] names, MappingDirection direction)
 {
     if ((mappingCollection == null) || (names == null))
     {
         return new string[0];
     }
     ArrayList list = new ArrayList();
     foreach (string str2 in names)
     {
         string sourceColumn;
         try
         {
             if (direction == MappingDirection.DataSetToSource)
             {
                 sourceColumn = mappingCollection.GetByDataSetColumn(str2).SourceColumn;
             }
             else
             {
                 DataColumnMapping mapping = mappingCollection[str2];
                 sourceColumn = mapping.DataSetColumn;
             }
         }
         catch (IndexOutOfRangeException)
         {
             sourceColumn = str2;
         }
         list.Add(sourceColumn);
     }
     return (string[]) list.ToArray(typeof(string));
 }
コード例 #2
0
ファイル: DbProviderHelper.cs プロジェクト: htawab/wiscms
 public static DataTableMapping CreateDataTableMapping(string sourceTable, string dataSetTable, DataColumnMappingCollection dataColumnMappings)
 {
     DataTableMapping dataTableMapping = new DataTableMapping(sourceTable, dataSetTable);
     foreach (DataColumnMapping dataColumnMapping in dataColumnMappings)
         dataTableMapping.ColumnMappings.Add(dataColumnMapping);
     return dataTableMapping;
 }
コード例 #3
0
 public void AddException1()
 {
     Assert.Throws<InvalidCastException>(() =>
     {
         DataColumnMappingCollection c = new DataColumnMappingCollection();
         _columnMapCollection.Add(c);
     });
 }
コード例 #4
0
		public void GetReady()
		{
			cols=new DataColumnMapping[5];
			cols[0]=new DataColumnMapping("sourceName","dataSetName");
			cols[1]=new DataColumnMapping("sourceID","dataSetID");
			cols[2]=new DataColumnMapping("sourceAddress","dataSetAddress");
			cols[3]=new DataColumnMapping("sourcePhone","dataSetPhone");
			cols[4]=new DataColumnMapping("sourcePIN","dataSetPIN");
			columnMapCollection=new DataColumnMappingCollection();			
		}
コード例 #5
0
 public DataColumnMappingCollectionTest()
 {
     _cols = new DataColumnMapping[5];
     _cols[0] = new DataColumnMapping("sourceName", "dataSetName");
     _cols[1] = new DataColumnMapping("sourceID", "dataSetID");
     _cols[2] = new DataColumnMapping("sourceAddress", "dataSetAddress");
     _cols[3] = new DataColumnMapping("sourcePhone", "dataSetPhone");
     _cols[4] = new DataColumnMapping("sourcePIN", "dataSetPIN");
     _columnMapCollection = new DataColumnMappingCollection();
 }
コード例 #6
0
        public int Update(DataSet dataSet, string srcTable)
        {
            MissingMappingAction mappingAction = MissingMappingAction;

            if (mappingAction == MissingMappingAction.Ignore)
            {
                mappingAction = MissingMappingAction.Error;
            }

            DataTableMapping tableMapping = DataTableMappingCollection.GetTableMappingBySchemaAction(TableMappings, srcTable, srcTable, mappingAction);

            DataTable dataTable = dataSet.Tables [tableMapping.DataSetTable];

            if (dataTable == null)
            {
                throw new ArgumentException(String.Format("Missing table {0}",
                                                          srcTable));
            }

            /** Copied from another Update function **/
            if (tableMapping != null)
            {
                foreach (DataColumn col in dataTable.Columns)
                {
                    if (tableMapping.ColumnMappings.IndexOf(col.ColumnName) >= 0)
                    {
                        continue;
                    }
                    DataColumnMapping columnMapping = DataColumnMappingCollection.GetColumnMappingBySchemaAction(tableMapping.ColumnMappings, col.ColumnName, MissingMappingAction);
                    if (columnMapping == null)
                    {
                        columnMapping = new DataColumnMapping(col.ColumnName, col.ColumnName);
                    }
                    tableMapping.ColumnMappings.Add(columnMapping);
                }
            }
            else
            {
                ArrayList cmc = new ArrayList();
                foreach (DataColumn col in dataTable.Columns)
                {
                    cmc.Add(new DataColumnMapping(col.ColumnName, col.ColumnName));
                }
                tableMapping =
                    new DataTableMapping(
                        dataTable.TableName,
                        dataTable.TableName,
                        cmc.ToArray(typeof(DataColumnMapping)) as DataColumnMapping []);
            }
            /**end insert from another update**/
            return(Update(dataTable, tableMapping));
        }
コード例 #7
0
        [EditorBrowsableAttribute(EditorBrowsableState.Advanced)]   // MDAC 69508
        static public DataColumn GetDataColumn(DataColumnMappingCollection columnMappings, string sourceColumn, Type dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
        {
            if (null != columnMappings)
            {
                int index = columnMappings.IndexOf(sourceColumn);
                if (-1 != index)
                {
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceInfo)
                    {
                        Debug.WriteLine("mapping match on SourceColumn \"" + sourceColumn + "\"");
                    }
#endif
                    return(columnMappings.items[index].GetDataColumnBySchemaAction(dataTable, dataType, schemaAction));
                }
            }
            if (ADP.IsEmpty(sourceColumn))
            {
                throw ADP.InvalidSourceColumn("sourceColumn");
            }
            switch (mappingAction)
            {
            case MissingMappingAction.Passthrough:
#if DEBUG
                if (AdapterSwitches.DataSchema.TraceInfo)
                {
                    Debug.WriteLine("mapping passthrough of SourceColumn \"" + sourceColumn + "\"");
                }
#endif
                return(DataColumnMapping.GetDataColumnBySchemaAction(sourceColumn, sourceColumn, dataTable, dataType, schemaAction));

            case MissingMappingAction.Ignore:
#if DEBUG
                if (AdapterSwitches.DataSchema.TraceWarning)
                {
                    Debug.WriteLine("mapping filter of SourceColumn \"" + sourceColumn + "\"");
                }
#endif
                return(null);

            case MissingMappingAction.Error:
#if DEBUG
                if (AdapterSwitches.DataSchema.TraceError)
                {
                    Debug.WriteLine("mapping error on SourceColumn \"" + sourceColumn + "\"");
                }
#endif
                throw ADP.MissingColumnMapping(sourceColumn);
            }
            throw ADP.InvalidMissingMappingAction(mappingAction);
        }
コード例 #8
0
        public static DataColumnMapping GetColumnMappingBySchemaAction(DataColumnMappingCollection columnMappings, string sourceColumn, MissingMappingAction mappingAction)
        {
            if (null != columnMappings)
            {
                int index = columnMappings.IndexOf(sourceColumn);
                if (-1 != index)
                {
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceInfo)
                    {
                        Debug.WriteLine($"mapping match on SourceColumn \"{sourceColumn}\"");
                    }
#endif
                    return(columnMappings._items[index]);
                }
            }
            if (string.IsNullOrEmpty(sourceColumn))
            {
                throw ADP.InvalidSourceColumn(nameof(sourceColumn));
            }
            switch (mappingAction)
            {
            case MissingMappingAction.Passthrough:
#if DEBUG
                if (AdapterSwitches.DataSchema.TraceInfo)
                {
                    Debug.WriteLine($"mapping passthrough of SourceColumn \"{sourceColumn}\"");
                }
#endif
                return(new DataColumnMapping(sourceColumn, sourceColumn));

            case MissingMappingAction.Ignore:
#if DEBUG
                if (AdapterSwitches.DataSchema.TraceWarning)
                {
                    Debug.WriteLine($"mapping filter of SourceColumn \"{sourceColumn}\"");
                }
#endif
                return(null);

            case MissingMappingAction.Error:
#if DEBUG
                if (AdapterSwitches.DataSchema.TraceError)
                {
                    Debug.WriteLine($"mapping error on SourceColumn \"{sourceColumn}\"");
                }
#endif
                throw ADP.MissingColumnMapping(sourceColumn);
            }
            throw ADP.InvalidMissingMappingAction(mappingAction);
        }
コード例 #9
0
ファイル: DbDataAdapter.cs プロジェクト: raj581/Marvin
        public int Update(DataTable dataTable)
        {
            /*
             * int index = TableMappings.IndexOfDataSetTable (dataTable.TableName);
             * if (index < 0)
             * throw new ArgumentException ();
             * return Update (dataTable, TableMappings [index]);
             */
            DataTableMapping tableMapping = TableMappings.GetByDataSetTable(dataTable.TableName);

            if (tableMapping == null)
            {
                tableMapping = DataTableMappingCollection.GetTableMappingBySchemaAction(
                    TableMappings,
                    dataTable.TableName,
                    dataTable.TableName,
                    MissingMappingAction);
                if (tableMapping != null)
                {
                    foreach (DataColumn col in dataTable.Columns)
                    {
                        if (tableMapping.ColumnMappings.IndexOf(col.ColumnName) >= 0)
                        {
                            continue;
                        }
                        DataColumnMapping columnMapping = DataColumnMappingCollection.GetColumnMappingBySchemaAction(tableMapping.ColumnMappings, col.ColumnName, MissingMappingAction);
                        if (columnMapping == null)
                        {
                            columnMapping = new DataColumnMapping(col.ColumnName, col.ColumnName);
                        }
                        tableMapping.ColumnMappings.Add(columnMapping);
                    }
                }
                else
                {
                    ArrayList cmc = new ArrayList();
                    foreach (DataColumn col in dataTable.Columns)
                    {
                        cmc.Add(new DataColumnMapping(col.ColumnName, col.ColumnName));
                    }
                    tableMapping =
                        new DataTableMapping(
                            dataTable.TableName,
                            dataTable.TableName,
                            cmc.ToArray(typeof(DataColumnMapping)) as DataColumnMapping []);
                }
            }
            return(Update(dataTable, tableMapping));
        }
コード例 #10
0
        object ICloneable.Clone()
        {
            DataTableMapping clone = new DataTableMapping();
            clone._dataSetTableName = _dataSetTableName;
            clone._sourceTableName = _sourceTableName;

            if ((null != _columnMappings) && (0 < ColumnMappings.Count))
            {
                DataColumnMappingCollection parameters = clone.ColumnMappings;
                foreach (ICloneable parameter in ColumnMappings)
                {
                    parameters.Add(parameter.Clone());
                }
            }
            return clone;
        }
コード例 #11
0
 public static DataColumnMapping GetColumnMappingBySchemaAction(DataColumnMappingCollection columnMappings, string sourceColumn, MissingMappingAction mappingAction)
 {
     if (columnMappings.Contains(sourceColumn))
     {
         return(columnMappings[sourceColumn]);
     }
     if (mappingAction == MissingMappingAction.Ignore)
     {
         return(null);
     }
     if (mappingAction == MissingMappingAction.Error)
     {
         throw new InvalidOperationException(String.Format("Missing SourceColumn mapping for '{0}'", sourceColumn));
     }
     return(new DataColumnMapping(sourceColumn, sourceColumn));
 }
コード例 #12
0
        object ICloneable.Clone()
        {
            DataTableMapping mapping = new DataTableMapping {
                _dataSetTableName = this._dataSetTableName,
                _sourceTableName  = this._sourceTableName
            };

            if ((this._columnMappings != null) && (0 < this.ColumnMappings.Count))
            {
                DataColumnMappingCollection columnMappings = mapping.ColumnMappings;
                foreach (ICloneable cloneable in this.ColumnMappings)
                {
                    columnMappings.Add(cloneable.Clone());
                }
            }
            return(mapping);
        }
コード例 #13
0
        /// <include file='doc\DataTableMapping.uex' path='docs/doc[@for="DataTableMapping.ICloneable.Clone"]/*' />
        /// <internalonly/>
        object ICloneable.Clone()
        {
            DataTableMapping clone = new DataTableMapping(); // MDAC 81448

            clone.SourceTable  = SourceTable;
            clone.DataSetTable = DataSetTable;

            if ((null != this.columnMappings) && (0 < ColumnMappings.Count))
            {
                DataColumnMappingCollection parameters = clone.ColumnMappings;
                foreach (ICloneable parameter in ColumnMappings)
                {
                    parameters.Add(parameter.Clone());
                }
            }
            return(clone);
        }
コード例 #14
0
		public static DataColumn GetDataColumn (DataColumnMappingCollection columnMappings, string sourceColumn, Type dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
		{
			throw new NotImplementedException ();
		}
コード例 #15
0
ファイル: DataAdapter.cs プロジェクト: Skycweb/mono-skycweb
        /// <summary>
        ///     Creates or Modifies the schema of the given DataTable based on the schema of
        ///     the reader and the arguments passed.
        /// </summary>
        internal static int[] BuildSchema(IDataReader reader, DataTable table,
                                          SchemaType schemaType,
                                          MissingSchemaAction missingSchAction,
                                          MissingMappingAction missingMapAction,
                                          DataTableMappingCollection dtMapping
                                          )
        {
            int readerIndex = 0;

            // FIXME : this fails if query has fewer columns than a table
            int[] mapping = new int[table.Columns.Count];             // mapping the reader indexes to the datatable indexes

            for (int i = 0; i < mapping.Length; i++)
            {
                mapping[i] = -1;
            }

            ArrayList primaryKey       = new ArrayList();
            ArrayList sourceColumns    = new ArrayList();
            bool      createPrimaryKey = true;

            DataTable schemaTable = reader.GetSchemaTable();

            DataColumn ColumnNameCol      = schemaTable.Columns["ColumnName"];
            DataColumn DataTypeCol        = schemaTable.Columns["DataType"];
            DataColumn IsAutoIncrementCol = schemaTable.Columns["IsAutoIncrement"];
            DataColumn AllowDBNullCol     = schemaTable.Columns["AllowDBNull"];
            DataColumn IsReadOnlyCol      = schemaTable.Columns["IsReadOnly"];
            DataColumn IsKeyCol           = schemaTable.Columns["IsKey"];
            DataColumn IsUniqueCol        = schemaTable.Columns["IsUnique"];
            DataColumn ColumnSizeCol      = schemaTable.Columns["ColumnSize"];

            foreach (DataRow schemaRow in schemaTable.Rows)
            {
                // generate a unique column name in the source table.
                string sourceColumnName;
                string realSourceColumnName;
                if (ColumnNameCol == null || schemaRow.IsNull(ColumnNameCol) ||
                    (string)schemaRow [ColumnNameCol] == String.Empty)
                {
                    sourceColumnName     = DefaultSourceColumnName;
                    realSourceColumnName = DefaultSourceColumnName + "1";
                }
                else
                {
                    sourceColumnName     = (string)schemaRow [ColumnNameCol];
                    realSourceColumnName = sourceColumnName;
                }

                for (int i = 1; sourceColumns.Contains(realSourceColumnName); i += 1)
                {
                    realSourceColumnName = String.Format("{0}{1}", sourceColumnName, i);
                }
                sourceColumns.Add(realSourceColumnName);

                // generate DataSetColumnName from DataTableMapping, if any
                DataTableMapping tableMapping = null;

                //FIXME : The sourcetable name shud get passed as a parameter..
                int    index    = dtMapping.IndexOfDataSetTable(table.TableName);
                string srcTable = (index != -1 ? dtMapping[index].SourceTable : table.TableName);
                tableMapping = DataTableMappingCollection.GetTableMappingBySchemaAction(dtMapping, ADP.IsEmpty(srcTable) ? " " : srcTable, table.TableName, missingMapAction);
                if (tableMapping != null)
                {
                    table.TableName = tableMapping.DataSetTable;
                    // check to see if the column mapping exists
                    DataColumnMapping columnMapping = DataColumnMappingCollection.GetColumnMappingBySchemaAction(tableMapping.ColumnMappings, realSourceColumnName, missingMapAction);
                    if (columnMapping != null)
                    {
                        Type       columnType = schemaRow[DataTypeCol] as Type;
                        DataColumn col        = columnType != null?columnMapping.GetDataColumnBySchemaAction(
                            table,
                            columnType,
                            missingSchAction) : null;

                        if (col != null)
                        {
                            // if the column is not in the table - add it.
                            if (table.Columns.IndexOf(col) == -1)
                            {
                                if (missingSchAction == MissingSchemaAction.Add ||
                                    missingSchAction == MissingSchemaAction.AddWithKey)
                                {
                                    table.Columns.Add(col);
                                }

                                int[] tmp = new int[mapping.Length + 1];
                                Array.Copy(mapping, 0, tmp, 0, col.Ordinal);
                                Array.Copy(mapping, col.Ordinal, tmp, col.Ordinal + 1, mapping.Length - col.Ordinal);
                                mapping = tmp;
                            }

                            if (missingSchAction == MissingSchemaAction.AddWithKey)
                            {
                                object value       = (AllowDBNullCol != null) ? schemaRow[AllowDBNullCol] : null;
                                bool   allowDBNull = value is bool?(bool)value : true;

                                value = (IsKeyCol != null) ? schemaRow[IsKeyCol] : null;
                                bool isKey = value is bool?(bool)value : false;

                                value = (IsAutoIncrementCol != null) ? schemaRow[IsAutoIncrementCol] : null;
                                bool isAutoIncrement = value is bool?(bool)value : false;

                                value = (IsReadOnlyCol != null) ? schemaRow[IsReadOnlyCol] : null;
                                bool isReadOnly = value is bool?(bool)value : false;

                                value = (IsUniqueCol != null) ? schemaRow[IsUniqueCol] : null;
                                bool isUnique = value is bool?(bool)value : false;

                                col.AllowDBNull = allowDBNull;
                                // fill woth key info
                                if (isAutoIncrement && DataColumn.CanAutoIncrement(columnType))
                                {
                                    col.AutoIncrement = true;
                                    if (!allowDBNull)
                                    {
                                        col.AllowDBNull = false;
                                    }
                                }

                                if (columnType == DbTypes.TypeOfString)
                                {
                                    col.MaxLength = (ColumnSizeCol != null) ? (int)schemaRow[ColumnSizeCol] : 0;
                                }

                                if (isReadOnly)
                                {
                                    col.ReadOnly = true;
                                }

                                if (!allowDBNull && (!isReadOnly || isKey))
                                {
                                    col.AllowDBNull = false;
                                }
                                if (isUnique && !isKey && !columnType.IsArray)
                                {
                                    col.Unique = true;
                                    if (!allowDBNull)
                                    {
                                        col.AllowDBNull = false;
                                    }
                                }

                                // This might not be set by all DataProviders
                                bool isHidden = false;
                                if (schemaTable.Columns.Contains("IsHidden"))
                                {
                                    value    = schemaRow["IsHidden"];
                                    isHidden = ((value is bool) ? (bool)value : false);
                                }

                                if (isKey && !isHidden)
                                {
                                    primaryKey.Add(col);
                                    if (allowDBNull)
                                    {
                                        createPrimaryKey = false;
                                    }
                                }
                            }
                            // add the ordinal of the column as a key and the index of the column in the datareader as a value.
                            mapping[col.Ordinal] = readerIndex++;
                        }
                    }
                }
            }
            if (primaryKey.Count > 0)
            {
                DataColumn[] colKey = (DataColumn[])(primaryKey.ToArray(typeof(DataColumn)));
                if (createPrimaryKey)
                {
                    table.PrimaryKey = colKey;
                }
                else
                {
                    UniqueConstraint uConstraint = new UniqueConstraint(colKey);
                    for (int i = 0; i < table.Constraints.Count; i++)
                    {
                        if (table.Constraints[i].Equals(uConstraint))
                        {
                            uConstraint = null;
                            break;
                        }
                    }

                    if (uConstraint != null)
                    {
                        table.Constraints.Add(uConstraint);
                    }
                }
            }
            return(mapping);
        }
コード例 #16
0
 internal void ConvertTableTypeTo(System.Data.Design.TableType newTableType)
 {
     if (newTableType != this.tableType)
     {
         IComponentChangeService service = (IComponentChangeService) this.GetService(typeof(IComponentChangeService));
         if (service != null)
         {
             service.OnComponentChanging(this, null);
         }
         try
         {
             this.TableType = newTableType;
             this.mainSource = null;
             this.sources = null;
             this.mappings = null;
             this.provider = string.Empty;
             this.OnTableTypeChanged();
         }
         finally
         {
             if (service != null)
             {
                 service.OnComponentChanged(this, null, null, null);
             }
         }
     }
 }
コード例 #17
0
		public static DataColumnMapping GetColumnMappingBySchemaAction (DataColumnMappingCollection columnMappings, string sourceColumn, MissingMappingAction mappingAction)
		{
			if (columnMappings.Contains (sourceColumn))
				return columnMappings[sourceColumn];
			if (mappingAction == MissingMappingAction.Ignore)
				return null;
			if (mappingAction == MissingMappingAction.Error)
				throw new InvalidOperationException (String.Format ("Missing SourceColumn mapping for '{0}'", sourceColumn));
			return new DataColumnMapping (sourceColumn, sourceColumn);
		}
コード例 #18
0
 public DataColumnMapping?GetColumnMappingBySchemaAction(string sourceColumn, MissingMappingAction mappingAction)
 {
     return(DataColumnMappingCollection.GetColumnMappingBySchemaAction(_columnMappings, sourceColumn, mappingAction));
 }
コード例 #19
0
        public static DataColumn GetDataColumn(DataColumnMappingCollection columnMappings, string sourceColumn, Type dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
        {
            if (null != columnMappings)
            {
                int index = columnMappings.IndexOf(sourceColumn);
                if (-1 != index)
                {
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceInfo)
                    {
                        Debug.WriteLine($"mapping match on SourceColumn \"{sourceColumn}\"");
                    }
#endif
                    return columnMappings._items[index].GetDataColumnBySchemaAction(dataTable, dataType, schemaAction);
                }
            }
            if (string.IsNullOrEmpty(sourceColumn))
            {
                throw ADP.InvalidSourceColumn(nameof(sourceColumn));
            }
            switch (mappingAction)
            {
                case MissingMappingAction.Passthrough:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceInfo)
                    {
                        Debug.WriteLine($"mapping passthrough of SourceColumn \"{sourceColumn}\"");
                    }
#endif
                    return DataColumnMapping.GetDataColumnBySchemaAction(sourceColumn, sourceColumn, dataTable, dataType, schemaAction);

                case MissingMappingAction.Ignore:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceWarning)
                    {
                        Debug.WriteLine($"mapping filter of SourceColumn \"{sourceColumn}\"");
                    }
#endif
                    return null;

                case MissingMappingAction.Error:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceError)
                    {
                        Debug.WriteLine($"mapping error on SourceColumn \"{sourceColumn}\"");
                    }
#endif
                    throw ADP.MissingColumnMapping(sourceColumn);
            }
            throw ADP.InvalidMissingMappingAction(mappingAction);
        }
コード例 #20
0
ファイル: DataTableMapping.cs プロジェクト: nlhepler/mono
		public DataTableMapping () 
		{
			dataSetTable = String.Empty;
			sourceTable = String.Empty;
			columnMappings = new DataColumnMappingCollection ();
		}
コード例 #21
0
 public DataColumn?GetDataColumn(string sourceColumn, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type?dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
 {
     return(DataColumnMappingCollection.GetDataColumn(_columnMappings, sourceColumn, dataType, dataTable, mappingAction, schemaAction));
 }
コード例 #22
0
 public DataTableMapping()
 {
     dataSetTable   = String.Empty;
     sourceTable    = String.Empty;
     columnMappings = new DataColumnMappingCollection();
 }
        public static DataColumn GetDataColumn(DataColumnMappingCollection columnMappings, string sourceColumn, Type dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
        {
            if (columnMappings != null)
            {
                int index = columnMappings.IndexOf(sourceColumn);
                if (-1 != index)
                {
                    return columnMappings.items[index].GetDataColumnBySchemaAction(dataTable, dataType, schemaAction);
                }
            }
            if (ADP.IsEmpty(sourceColumn))
            {
                throw ADP.InvalidSourceColumn("sourceColumn");
            }
            switch (mappingAction)
            {
                case MissingMappingAction.Passthrough:
                    return DataColumnMapping.GetDataColumnBySchemaAction(sourceColumn, sourceColumn, dataTable, dataType, schemaAction);

                case MissingMappingAction.Ignore:
                    return null;

                case MissingMappingAction.Error:
                    throw ADP.MissingColumnMapping(sourceColumn);
            }
            throw ADP.InvalidMissingMappingAction(mappingAction);
        }
コード例 #24
0
 public static DataColumn GetDataColumn(DataColumnMappingCollection columnMappings, string sourceColumn, Type dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
 {
     throw new NotImplementedException();
 }
コード例 #25
0
ファイル: DbDataAdapter.cs プロジェクト: raj581/Marvin
        public int Update(DataRow [] dataRows)
        {
            if (dataRows == null)
            {
                throw new ArgumentNullException("dataRows");
            }

            if (dataRows.Length == 0)
            {
                return(0);
            }

            if (dataRows [0] == null)
            {
                throw new ArgumentException("dataRows[0].");
            }

            DataTable table = dataRows [0].Table;

            if (table == null)
            {
                throw new ArgumentException("table is null reference.");
            }

            // all rows must be in the same table
            for (int i = 0; i < dataRows.Length; i++)
            {
                if (dataRows [i] == null)
                {
                    throw new ArgumentException("dataRows[" + i + "].");
                }
                if (dataRows [i].Table != table)
                {
                    throw new ArgumentException(
                              " DataRow["
                              + i
                              + "] is from a different DataTable than DataRow[0].");
                }
            }

            // get table mapping for this rows
            DataTableMapping tableMapping = TableMappings.GetByDataSetTable(table.TableName);

            if (tableMapping == null)
            {
                tableMapping = DataTableMappingCollection.GetTableMappingBySchemaAction(
                    TableMappings,
                    table.TableName,
                    table.TableName,
                    MissingMappingAction);
                if (tableMapping != null)
                {
                    foreach (DataColumn col in table.Columns)
                    {
                        if (tableMapping.ColumnMappings.IndexOf(col.ColumnName) >= 0)
                        {
                            continue;
                        }
                        DataColumnMapping columnMapping = DataColumnMappingCollection.GetColumnMappingBySchemaAction(tableMapping.ColumnMappings, col.ColumnName, MissingMappingAction);
                        if (columnMapping == null)
                        {
                            columnMapping = new DataColumnMapping(col.ColumnName, col.ColumnName);
                        }
                        tableMapping.ColumnMappings.Add(columnMapping);
                    }
                }
                else
                {
                    ArrayList cmc = new ArrayList();
                    foreach (DataColumn col in table.Columns)
                    {
                        cmc.Add(new DataColumnMapping(col.ColumnName, col.ColumnName));
                    }
                    tableMapping =
                        new DataTableMapping(
                            table.TableName,
                            table.TableName,
                            cmc.ToArray(typeof(DataColumnMapping)) as DataColumnMapping []);
                }
            }

            DataRow[] copy = table.NewRowArray(dataRows.Length);
            Array.Copy(dataRows, 0, copy, 0, dataRows.Length);
            return(Update(copy, tableMapping));
        }
コード例 #26
0
 public DesignTable(System.Data.DataTable dataTable, System.Data.Design.TableType tableType, DataColumnMappingCollection mappings) : this(dataTable, tableType)
 {
     this.mappings = mappings;
 }
コード例 #27
0
 public DataColumn? GetDataColumn(string sourceColumn, Type? dataType, DataTable dataTable, MissingMappingAction mappingAction, MissingSchemaAction schemaAction)
 {
     return DataColumnMappingCollection.GetDataColumn(_columnMappings, sourceColumn, dataType, dataTable, mappingAction, schemaAction);
 }
コード例 #28
0
		public void AddException1()
		{
			DataColumnMappingCollection c=new DataColumnMappingCollection();
			columnMapCollection.Add((Object)c);
		}
コード例 #29
0
        [ EditorBrowsableAttribute(EditorBrowsableState.Advanced) ] // MDAC 69508
        static public DataColumnMapping GetColumnMappingBySchemaAction(DataColumnMappingCollection columnMappings, string sourceColumn, MissingMappingAction mappingAction) {
            if (null != columnMappings) {
                int index = columnMappings.IndexOf(sourceColumn);
                if (-1 != index) {
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceInfo) {
                        Debug.WriteLine("mapping match on SourceColumn \"" + sourceColumn + "\"");
                    }
#endif
                    return columnMappings.items[index];
                }
            }
            if (ADP.IsEmpty(sourceColumn)) {
                throw ADP.InvalidSourceColumn("sourceColumn");
            }
            switch (mappingAction) {
                case MissingMappingAction.Passthrough:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceInfo) {
                        Debug.WriteLine("mapping passthrough of SourceColumn \"" + sourceColumn + "\"");
                    }
#endif
                    return new DataColumnMapping(sourceColumn, sourceColumn);

                case MissingMappingAction.Ignore:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceWarning) {
                        Debug.WriteLine("mapping filter of SourceColumn \"" + sourceColumn + "\"");
                    }
#endif
                    return null;

                case MissingMappingAction.Error:
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceError) {
                        Debug.WriteLine("mapping error on SourceColumn \"" + sourceColumn + "\"");
                    }
#endif
                    throw ADP.MissingColumnMapping(sourceColumn);
            }
            throw ADP.InvalidMissingMappingAction(mappingAction);
        }
コード例 #30
0
ファイル: DbDataAdapter.cs プロジェクト: raj581/Marvin
        protected virtual int Update(DataRow [] dataRows, DataTableMapping tableMapping)
        {
            int updateCount = 0;

            foreach (DataRow row in dataRows)
            {
                StatementType statementType = StatementType.Update;
                IDbCommand    command       = null;
                string        commandName   = String.Empty;

                switch (row.RowState)
                {
                case DataRowState.Added:
                    statementType = StatementType.Insert;
                    command       = ((IDbDataAdapter)this).InsertCommand;
                    commandName   = "Insert";
                    break;

                case DataRowState.Deleted:
                    statementType = StatementType.Delete;
                    command       = ((IDbDataAdapter)this).DeleteCommand;
                    commandName   = "Delete";
                    break;

                case DataRowState.Modified:
                    statementType = StatementType.Update;
                    command       = ((IDbDataAdapter)this).UpdateCommand;
                    commandName   = "Update";
                    break;

                case DataRowState.Unchanged:
                case DataRowState.Detached:
                    continue;
                }

                RowUpdatingEventArgs argsUpdating = CreateRowUpdatingEvent(row, command, statementType, tableMapping);
                row.RowError = null;
                OnRowUpdating(argsUpdating);
                switch (argsUpdating.Status)
                {
                case UpdateStatus.Continue:
                    //continue in update operation
                    break;

                case UpdateStatus.ErrorsOccurred:
                    if (argsUpdating.Errors == null)
                    {
                        argsUpdating.Errors = ExceptionHelper.RowUpdatedError();
                    }
                    row.RowError += argsUpdating.Errors.Message;
                    if (!ContinueUpdateOnError)
                    {
                        throw argsUpdating.Errors;
                    }
                    continue;

                case UpdateStatus.SkipAllRemainingRows:
                    return(updateCount);

                case UpdateStatus.SkipCurrentRow:
                    updateCount++;
                    continue;

                default:
                    throw ExceptionHelper.InvalidUpdateStatus(argsUpdating.Status);
                }
                command = argsUpdating.Command;
                try {
                    if (command != null)
                    {
                        DataColumnMappingCollection columnMappings = tableMapping.ColumnMappings;
#if ONLY_1_1
                        IDataParameter nullCheckParam = null;
#endif
                        foreach (IDataParameter parameter in command.Parameters)
                        {
                            if ((parameter.Direction & ParameterDirection.Input) == 0)
                            {
                                continue;
                            }

                            DataRowVersion rowVersion = parameter.SourceVersion;
                            // Parameter version is ignored for non-update commands
                            if (statementType == StatementType.Delete)
                            {
                                rowVersion = DataRowVersion.Original;
                            }

                            string dsColumnName = parameter.SourceColumn;
#if NET_2_0
                            if (columnMappings.Contains(dsColumnName))
                            {
                                dsColumnName = columnMappings [dsColumnName].DataSetColumn;
                            }

                            DbParameter nullCheckParam = parameter as DbParameter;
#else
                            if (columnMappings.Contains(dsColumnName))
                            {
                                dsColumnName = columnMappings [dsColumnName].DataSetColumn;
                            }
                            if (dsColumnName == null || dsColumnName.Length == 0)
                            {
                                nullCheckParam = parameter;
                                continue;
                            }
#endif

                            // Fetch columnName from column-mapping if found one,
                            // otherwise, use the source column name to fetch parameter value.
                            parameter.Value = row [dsColumnName, rowVersion];

#if NET_2_0
                            if (nullCheckParam != null && nullCheckParam.SourceColumnNullMapping)
                            {
#else
                            if (nullCheckParam != null)
                            {
#endif
                                if (parameter.Value != null && parameter.Value != DBNull.Value)
                                {
                                    nullCheckParam.Value = 0;
                                }
                                else
                                {
                                    nullCheckParam.Value = 1;
                                }
                                nullCheckParam = null;
                            }
                        }
                    }
                } catch (Exception e) {
                    argsUpdating.Errors = e;
                    argsUpdating.Status = UpdateStatus.ErrorsOccurred;
                }

                IDataReader reader = null;
                try {
                    if (command == null)
                    {
                        throw ExceptionHelper.UpdateRequiresCommand(commandName);
                    }

                    CommandBehavior commandBehavior = CommandBehavior.Default;
                    if (command.Connection.State == ConnectionState.Closed)
                    {
                        command.Connection.Open();
                        commandBehavior |= CommandBehavior.CloseConnection;
                    }

                    // use ExecuteReader because we want to use the commandbehavior parameter.
                    // so the connection will be closed if needed.
                    reader = command.ExecuteReader(commandBehavior);

                    // update the current row, if the update command returns any resultset
                    // ignore other than the first record.
                    DataColumnMappingCollection columnMappings = tableMapping.ColumnMappings;

                    if (command.UpdatedRowSource == UpdateRowSource.Both ||
                        command.UpdatedRowSource == UpdateRowSource.FirstReturnedRecord)
                    {
                        if (reader.Read())
                        {
                            DataTable retSchema = reader.GetSchemaTable();
                            foreach (DataRow dr in retSchema.Rows)
                            {
                                string columnName    = dr ["ColumnName"].ToString();
                                string dstColumnName = columnName;
                                if (columnMappings != null &&
                                    columnMappings.Contains(columnName))
                                {
                                    dstColumnName = columnMappings [dstColumnName].DataSetColumn;
                                }
                                DataColumn dstColumn = row.Table.Columns [dstColumnName];
                                if (dstColumn == null ||
                                    (dstColumn.Expression != null &&
                                     dstColumn.Expression.Length > 0))
                                {
                                    continue;
                                }
                                // info from : http://www.error-bank.com/microsoft.public.dotnet.framework.windowsforms.databinding/
                                // [email protected]_Thread.aspx
                                // disable readonly for non-expression columns.
                                bool readOnlyState = dstColumn.ReadOnly;
                                dstColumn.ReadOnly = false;
                                try {
                                    row [dstColumnName] = reader [columnName];
                                } finally {
                                    dstColumn.ReadOnly = readOnlyState;
                                }
                            }
                        }
                    }
                    reader.Close();

                    int tmp = reader.RecordsAffected;                     // records affected is valid only after closing reader
                    // if the execute does not effect any rows we throw an exception.
                    if (tmp == 0)
                    {
                        throw new DBConcurrencyException("Concurrency violation: the " +
                                                         commandName + "Command affected 0 records.", null,
                                                         new DataRow [] { row });
                    }
                    updateCount += tmp;

                    if (command.UpdatedRowSource == UpdateRowSource.Both ||
                        command.UpdatedRowSource == UpdateRowSource.OutputParameters)
                    {
                        // Update output parameters to row values
                        foreach (IDataParameter parameter in command.Parameters)
                        {
                            if (parameter.Direction != ParameterDirection.InputOutput &&
                                parameter.Direction != ParameterDirection.Output &&
                                parameter.Direction != ParameterDirection.ReturnValue)
                            {
                                continue;
                            }

                            string dsColumnName = parameter.SourceColumn;
                            if (columnMappings != null &&
                                columnMappings.Contains(parameter.SourceColumn))
                            {
                                dsColumnName = columnMappings [parameter.SourceColumn].DataSetColumn;
                            }
                            DataColumn dstColumn = row.Table.Columns [dsColumnName];
                            if (dstColumn == null ||
                                (dstColumn.Expression != null &&
                                 dstColumn.Expression.Length > 0))
                            {
                                continue;
                            }
                            bool readOnlyState = dstColumn.ReadOnly;
                            dstColumn.ReadOnly = false;
                            try {
                                row [dsColumnName] = parameter.Value;
                            } finally {
                                dstColumn.ReadOnly = readOnlyState;
                            }
                        }
                    }

                    RowUpdatedEventArgs updatedArgs = CreateRowUpdatedEvent(row, command, statementType, tableMapping);
                    OnRowUpdated(updatedArgs);
                    switch (updatedArgs.Status)
                    {
                    case UpdateStatus.Continue:
                        break;

                    case UpdateStatus.ErrorsOccurred:
                        if (updatedArgs.Errors == null)
                        {
                            updatedArgs.Errors = ExceptionHelper.RowUpdatedError();
                        }
                        row.RowError += updatedArgs.Errors.Message;
                        if (!ContinueUpdateOnError)
                        {
                            throw updatedArgs.Errors;
                        }
                        break;

                    case UpdateStatus.SkipCurrentRow:
                        continue;

                    case UpdateStatus.SkipAllRemainingRows:
                        return(updateCount);
                    }
#if NET_2_0
                    if (!AcceptChangesDuringUpdate)
                    {
                        continue;
                    }
#endif
                    row.AcceptChanges();
                } catch (Exception e) {
                    row.RowError = e.Message;
                    if (!ContinueUpdateOnError)
                    {
                        throw e;
                    }
                } finally {
                    if (reader != null && !reader.IsClosed)
                    {
                        reader.Close();
                    }
                }
            }
            return(updateCount);
        }