<?xml version="1.0" encoding="utf-8"?>
<Type Name="IDataAdapter" FullName="System.Data.IDataAdapter">
  <TypeSignature Language="C#" Maintainer="auto" Value="public interface IDataAdapter" />
  <AssemblyInfo>
    <AssemblyName>System.Data</AssemblyName>
    <AssemblyPublicKey>[00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00]</AssemblyPublicKey>
    <AssemblyVersion>1.0.3300.0</AssemblyVersion>
    <AssemblyVersion>1.0.5000.0</AssemblyVersion>
    <AssemblyVersion>2.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the &lt;link location="node:gtk-sharp/programming/threads"&gt;Gtk# Thread Programming&lt;/link&gt; for details.</ThreadSafetyStatement>
  <Interfaces />
  <Docs>
    <remarks>
      <attribution license="cc4" from="Microsoft" modified="false" />
      <para>The <see cref="T:System.Data.IDataAdapter" /> interface allows an inheriting class to implement a DataAdapter class, which represents the bridge between a data source and a <see cref="T:System.Data.DataSet" />. For more information about DataAdapter classes, see <format type="text/html"><a href="3FA0AC7D-E266-4954-BFAC-3FBE2F913153">[&lt;topic://cpconpopulatingdatasetfromdataadapter&gt;]</a></format>.</para>
      <para>An application does not create an instance of the <see cref="T:System.Data.IDataAdapter" /> interface directly, but implements an instance of a class that inherits <see cref="T:System.Data.IDataAdapter" />.</para>
      <para>Classes that inherit <see cref="T:System.Data.IDataAdapter" /> must implement the inherited members, and they typically define additional members to add provider-specific functionality. For example, the <see cref="T:System.Data.IDataAdapter" /> interface defines a <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> method that takes a <see cref="T:System.Data.DataSet" /> as a parameter. In turn, the <see cref="T:System.Data.OleDb.OleDbDataAdapter" /> class inherits the <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method and also defines two additional overloads of the <see cref="M:System.Data.OleDb.OleDbDataAdapter.Fill(System.Data.DataTable,System.Object)" /> method that take an ADO Recordset object as a parameter.</para>
    </remarks>
    <summary>
      <attribution license="cc4" from="Microsoft" modified="false" />
      <para>Allows an object to implement a DataAdapter, and represents a set of methods and mapping action-related properties that are used to fill and update a <see cref="T:System.Data.DataSet" /> and update a data source.</para>
      <para>
        <see cref="T:System.Data.IDbDataAdapter" /> instances are for data sources that are (or resemble) relational databases with textual commands (like tsql), while <see cref="T:System.Data.IDataAdapter" /> instances could can use any type of data source.</para>
    </summary>
  </Docs>
  <Members>
    <Member MemberName="Fill">
      <MemberSignature Language="C#" Value="public int Fill (System.Data.DataSet dataSet);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>
            <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> retrieves rows from the data source using the SELECT statement specified by an associated <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> property. The connection object associated with the SELECT statement must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> is called, it remains open.</para>
          <para>The <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> operation then adds the rows to destination <see cref="T:System.Data.DataTable" /> objects in the <see cref="T:System.Data.DataSet" />, creating the <see cref="T:System.Data.DataTable" /> objects if they do not already exist. When creating <see cref="T:System.Data.DataTable" /> objects, the <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> operation usually creates only column name metadata. However, if the <see cref="P:System.Data.IDataAdapter.MissingSchemaAction" /> property is set to AddWithKey, appropriate primary keys and constraints are also created.</para>
          <para>If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a <see cref="P:System.Data.DataTable.PrimaryKey" /> value for the resulting <see cref="T:System.Data.DataTable" />. You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see <format type="text/html"><a href="2EA85959-E763-4669-8BD9-46A9DAB894BD">[&lt;topic://cpcondefiningprimarykeyfortable&gt;]</a></format>.</para>
          <para>If the <see cref="T:System.Data.IDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the successive columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are put in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" />, each result set is put in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on). Applications should use caution when using column and table names to ensure that conflicts with these naming patterns do not occur.</para>
          <para>When the SELECT statement that is used to populate the <see cref="T:System.Data.DataSet" /> returns multiple results, such as a batch SQL statement, if one of the results contains an error, all successive results are skipped and not added to the <see cref="T:System.Data.DataSet" />.</para>
          <para>You can use the <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> method multiple times on the same <see cref="T:System.Data.DataTable" />. If a primary key exists, incoming rows are merged with matching rows that already exist. If no primary key exists, incoming rows are appended to the <see cref="T:System.Data.DataTable" />.</para>
          <block subset="none" type="note">
            <para>When handling batch SQL statements that return multiple results, the implementation of <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> and <see cref="M:System.Data.IDataAdapter.FillSchema(System.Data.DataSet,System.Data.SchemaType)" /> for a .NET Framework data provider retrieves schema information for only the first result.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds or updates rows in the <see cref="T:System.Data.DataSet" /> to match those in the data source using the <see cref="T:System.Data.DataSet" /> name, and creates a <see cref="T:System.Data.DataTable" /> named "Table".</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet" />. This does not include rows affected by statements that do not return rows.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />A <see cref="T:System.Data.DataSet" /> to fill with records and, if necessary, schema. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FillSchema">
      <MemberSignature Language="C#" Value="public System.Data.DataTable[] FillSchema (System.Data.DataSet dataSet, System.Data.SchemaType schemaType);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.DataTable[]</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
        <Parameter Name="schemaType" Type="System.Data.SchemaType" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="M:System.Data.IDataAdapter.FillSchema(System.Data.DataSet,System.Data.SchemaType)" /> method retrieves the schema from the data source using the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />. The connection object associated with the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" /> must be valid, but it does not need to be open. If the connection is closed before <see cref="M:System.Data.IDataAdapter.FillSchema(System.Data.DataSet,System.Data.SchemaType)" /> is called, it is opened to retrieve data, then closed. If the connection is open before <see cref="M:System.Data.IDataAdapter.FillSchema(System.Data.DataSet,System.Data.SchemaType)" /> is called, it remains open.</para>
          <para>A <see cref="M:System.Data.IDataAdapter.FillSchema(System.Data.DataSet,System.Data.SchemaType)" /> operation adds a <see cref="T:System.Data.DataTable" /> to the destination <see cref="T:System.Data.DataSet" />. It then adds columns to the <see cref="T:System.Data.DataColumnCollection" /> of the <see cref="T:System.Data.DataTable" /> and configures the following <see cref="T:System.Data.DataColumn" /> properties if they exist at the data source: </para>
          <list type="bullet">
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AllowDBNull" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.AutoIncrement" />. You must set <see cref="P:System.Data.DataColumn.AutoIncrementStep" /> and <see cref="P:System.Data.DataColumn.AutoIncrementSeed" /> separately.</para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.MaxLength" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.ReadOnly" /> </para>
            </item>
            <item>
              <para>
                <see cref="P:System.Data.DataColumn.Unique" /> </para>
            </item>
          </list>
          <para>
            <see cref="M:System.Data.IDataAdapter.FillSchema(System.Data.DataSet,System.Data.SchemaType)" /> also configures the <see cref="P:System.Data.DataTable.PrimaryKey" /> and <see cref="P:System.Data.DataTable.Constraints" /> properties according to the following rules: </para>
          <list type="bullet">
            <item>
              <para>If one or more primary key columns are returned by the <see cref="P:System.Data.IDbDataAdapter.SelectCommand" />, they are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
            <item>
              <para>If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if all the unique columns are non-nullable. If any of the columns are nullable, a <see cref="T:System.Data.UniqueConstraint" /> is added to the <see cref="T:System.Data.ConstraintCollection" />, but the <see cref="P:System.Data.DataTable.PrimaryKey" /> property is not set.</para>
            </item>
            <item>
              <para>If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the <see cref="T:System.Data.DataTable" />.</para>
            </item>
          </list>
          <para>Note that primary keys and unique constraints are added to the <see cref="T:System.Data.ConstraintCollection" /> according to the previous rules, but other constraint types are not added.</para>
          <para>If a unique clustered index is defined on a column or columns in a SQL Server table and the primary key constraint is defined on a separate set of columns, then the names of the columns in the clustered index will be returned. To return the name or names of the primary key columns, use a query hint with the SELECT statement that specifies the name of the primary key index. For more information about how to specify query hints, see <see cref="http://msdn.microsoft.com/library/ms181714.aspx">Query Hint (Transact-SQL)</see>.</para>
          <para>If the <see cref="T:System.Data.IDataAdapter" /> encounters duplicate columns while populating a <see cref="T:System.Data.DataTable" />, it generates names for the successive columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are put in the <see cref="T:System.Data.DataSet" /> according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the <see cref="T:System.Data.DataSet" />, each result set is put in a separate table. Additional result sets are named by appending integral values to the specified table name (for example, "Table", "Table1", "Table2", and so on). Applications should use caution when using column and table names to ensure that conflicts with these naming patterns do not occur.</para>
          <para>
            <see cref="M:System.Data.IDataAdapter.FillSchema(System.Data.DataSet,System.Data.SchemaType)" /> returns no rows. Use the <see cref="M:System.Data.IDataAdapter.Fill(System.Data.DataSet)" /> method to add rows to a <see cref="T:System.Data.DataTable" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Adds a <see cref="T:System.Data.DataTable" /> named "Table" to the specified <see cref="T:System.Data.DataSet" /> and configures the schema to match that in the data source based on the specified <see cref="T:System.Data.SchemaType" />.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>An array of <see cref="T:System.Data.DataTable" /> objects that contain schema information returned from the data source.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataSet" /> to be filled with the schema from the data source. </param>
        <param name="schemaType">
          <attribution license="cc4" from="Microsoft" modified="false" />One of the <see cref="T:System.Data.SchemaType" /> values. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="GetFillParameters">
      <MemberSignature Language="C#" Value="public System.Data.IDataParameter[] GetFillParameters ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.IDataParameter[]</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <code>private static void GetParameters(String connectiongString) {
           using (SqlConnection conn = new SqlConnection(connectiongString)) {
              String queryString = "Select [CourseID],[Title],[Credits] from [MySchool].[dbo].[Course] where [Year]=@Year and [Credits]&gt;=@Credits"; 
              SqlParameter year = new SqlParameter("@Year", 2012); 
              SqlParameter credits = new SqlParameter("@Credits", SqlDbType.Int, 4, "Credits"); 
              credits.Value = 4; SqlCommand command = new SqlCommand(queryString, conn); 
              command.Parameters.Add(year); 
              command.Parameters.Add(credits); 
              IDbDataAdapter mySchool = new SqlDataAdapter(command); 
              IDataParameter[] parameters = mySchool.GetFillParameters();
              Console.WriteLine("{0,-15}{1,-15}{2,-15}{3,-15}{4,-15}", "ParameterName", "SourceColumn", "Direction", "DbType", "Value"); 
              foreach (IDataParameter parameter in parameters) { 
                 Console.WriteLine("{0,-15}{1,-15}{2,-15}{3,-15}{4,-15}", parameter.ParameterName, parameter.SourceColumn, parameter.Direction, parameter.DbType, parameter.Value); 
              }
           }
        }</code>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Gets the parameters set by the user when executing an SQL SELECT statement.</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>An array of <see cref="T:System.Data.IDataParameter" /> objects that contains the parameters set by the user.</para>
        </returns>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="MissingMappingAction">
      <MemberSignature Language="C#" Value="public System.Data.MissingMappingAction MissingMappingAction { set; get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.MissingMappingAction</ReturnType>
      </ReturnValue>
      <Parameters>
      </Parameters>
      <Docs>
        <value>To be added: an object of type 'MissingMappingAction'</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="P:System.Data.IDataAdapter.TableMappings" /> property provides the master mapping between the returned records and the <see cref="T:System.Data.DataSet" />.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Indicates or specifies whether unmapped source tables or columns are passed with their source names in order to be filtered or to raise an error.</para>
        </summary>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="MissingSchemaAction">
      <MemberSignature Language="C#" Value="public System.Data.MissingSchemaAction MissingSchemaAction { set; get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.MissingSchemaAction</ReturnType>
      </ReturnValue>
      <Parameters>
      </Parameters>
      <Docs>
        <value>To be added: an object of type 'MissingSchemaAction'</value>
        <remarks>To be added</remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Indicates or specifies whether missing source tables, columns, and their relationships are added to the dataset schema, ignored, or cause an error to be raised.</para>
        </summary>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="TableMappings">
      <MemberSignature Language="C#" Value="public System.Data.ITableMappingCollection TableMappings { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Data.ITableMappingCollection</ReturnType>
      </ReturnValue>
      <Docs>
        <value>To be added: an object of type 'ITableMappingCollection'</value>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The <see cref="T:System.Data.IDataAdapter" /> uses only the mappings for the source table named "Table". All SELECT, INSERT, DELETE, and UPDATE statements returning data must do so using consistent column naming. The column names returned in the records must be unique, otherwise columns with duplicate names overwrite previous data. On <see cref="M:System.Data.IDataAdapter.Update(System.Data.DataSet)" />, only the table mapped to the source table named "Table" will have its changes reconciled.</para>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Indicates how a source table is mapped to a dataset table.</para>
        </summary>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Update">
      <MemberSignature Language="C#" Value="public int Update (System.Data.DataSet dataSet);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="dataSet" Type="System.Data.DataSet" />
      </Parameters>
      <Docs>
        <remarks>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>When an application calls the <see cref="M:System.Data.IDataAdapter.Update(System.Data.DataSet)" /> method, the <see cref="T:System.Data.IDataAdapter" /> examines the <see cref="P:System.Data.DataRow.RowState" /> property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the <see cref="T:System.Data.DataSet" />. For example, <see cref="M:System.Data.IDataAdapter.Update(System.Data.DataSet)" /> might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, because of the ordering of the rows in the <see cref="T:System.Data.DataTable" />.</para>
          <para>Be aware that these statements are not performed as a batch process; each row is updated individually. An application can call the <see cref="M:System.Data.DataSet.GetChanges" /> method if you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see <format type="text/html"><a href="D1BD9A8C-0E29-40E3-BDA8-D89176B72FB1">[&lt;topic://cpconUpdatingDatabaseWithDataAdapterDataSet&gt;]</a></format>.</para>
          <para>If INSERT, UPDATE, or DELETE statements have not been specified, the <see cref="M:System.Data.Common.DataAdapter.Update(System.Data.DataSet)" /> method generates an exception. However, you can create a <see cref="T:System.Data.SqlClient.SqlCommandBuilder" /> or <see cref="T:System.Data.OleDb.OleDbCommandBuilder" /> object to automatically generate SQL statements for single-table updates if you set the SelectCommand property of a .NET Framework data provider. Then, any additional SQL statements that you do not set are generated by the CommandBuilder. This generation logic requires key column information to be present in the <see cref="T:System.Data.DataSet" />. For more information see <format type="text/html"><a href="6E3FB8B5-373B-4F9E-AB03-A22693DF8E91">[&lt;topic://cpconAutomaticallyGeneratedCommands&gt;]</a></format>.</para>
          <para>The <see cref="M:System.Data.Common.DataAdapter.Update(System.Data.DataSet)" /> method retrieves rows from the table listed in the first mapping before performing an update. The <see cref="M:System.Data.Common.DataAdapter.Update(System.Data.DataSet)" /> then updates the row using the value of the <see cref="P:System.Data.IDbCommand.UpdatedRowSource" /> property. Any additional rows returned are ignored.</para>
          <para>After any data is loaded back into the <see cref="T:System.Data.DataSet" />, the <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised, allowing the user to inspect the reconciled <see cref="T:System.Data.DataSet" /> row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted.</para>
          <para>When using <see cref="M:System.Data.IDataAdapter.Update(System.Data.DataSet)" />, the order of execution is as follows: </para>
          <list type="ordered">
            <item>
              <para>The values in the <see cref="T:System.Data.DataRow" /> are moved to the parameter values.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>The command executes.</para>
            </item>
            <item>
              <para>If the command is set to FirstReturnedRecord, then the first returned result is put in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>If there are output parameters, they are put in the <see cref="T:System.Data.DataRow" />.</para>
            </item>
            <item>
              <para>The <see cref="M:System.Data.Common.DbDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)" /> event is raised.</para>
            </item>
            <item>
              <para>
                <see cref="M:System.Data.DataRow.AcceptChanges" /> is called.</para>
            </item>
          </list>
          <para>Each command associated with the <see cref="T:System.Data.IDataAdapter" /> usually has a parameter collection associated with it. Parameters are mapped to the current row through the SourceColumn and SourceVersion properties of a .NET Framework data provider's Parameter class. SourceColumn refers to a <see cref="T:System.Data.DataTable" /> column that the <see cref="T:System.Data.IDataAdapter" /> references to obtain parameter values for the current row.</para>
          <para>SourceColumn refers to the unmapped column name before any table mappings have been applied. If SourceColumn refers to a nonexistent column, the action taken depends on one of the following <see cref="T:System.Data.MissingMappingAction" /> values.</para>
          <list type="table">
            <listheader>
              <item>
                <term>
                  <para>Enumeration Value </para>
                </term>
                <description>
                  <para>Action Taken </para>
                </description>
              </item>
            </listheader>
            <item>
              <term>
                <para>MissingMappingAction.Passthrough </para>
              </term>
              <description>
                <para>Use the source column names and table names in the <see cref="T:System.Data.DataSet" /> if no mapping is present. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Ignore </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually caused by an error. </para>
              </description>
            </item>
            <item>
              <term>
                <para>MissingMappingAction.Error </para>
              </term>
              <description>
                <para>A <see cref="T:System.SystemException" /> is generated. </para>
              </description>
            </item>
          </list>
          <para>The SourceColumn property is also used to map the value for output or input/output parameters back to the DataSet. An exception is generated if it refers to a nonexistent column.</para>
          <para>The SourceVersion property of a .NET Framework data provider's Parameter class determines whether to use the Original, Current, or Proposed version of the column value. This capability is frequently used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations.</para>
          <block subset="none" type="note">
            <para>If an error occurs while updating a row, an exception is thrown and execution of the update is discontinued. To continue the update operation without generating exceptions when an error is encountered, set the <see cref="P:System.Data.Common.DataAdapter.ContinueUpdateOnError" /> property to true before calling <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />. You may also respond to errors on a per-row basis within the RowUpdated event of a DataAdapter. To continue the update operation without generating an exception within the RowUpdated event, set the <see cref="P:System.Data.Common.RowUpdatedEventArgs.Status" /> property of the <see cref="T:System.Data.Common.RowUpdatedEventArgs" /> to <see cref="F:System.Data.UpdateStatus.Continue" />.</para>
          </block>
        </remarks>
        <summary>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>Calls the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified <see cref="T:System.Data.DataSet" /> from a <see cref="T:System.Data.DataTable" /> named "Table".</para>
        </summary>
        <returns>
          <attribution license="cc4" from="Microsoft" modified="false" />
          <para>The number of rows successfully updated from the <see cref="T:System.Data.DataSet" />.</para>
        </returns>
        <param name="dataSet">
          <attribution license="cc4" from="Microsoft" modified="false" />The <see cref="T:System.Data.DataSet" /> used to update the data source. </param>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>1.0.5000.0</AssemblyVersion>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
  </Members>
</Type>