System.Data [00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00] 1.0.3300.0 1.0.5000.0 2.0.0.0 Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details. System.Data.Common.DataAdapter System.Data.IDbDataAdapter System.ICloneable The class inherits from the class and helps a class implement a DataAdapter designed for use with a relational database. An application does not create an instance of the interface directly, but creates an instance of a class that inherits and . Classes that inherit must implement the inherited members, and typically define additional members to add provider-specific functionality. For example, the class defines the property, and the interface defines eight overloads of the method. In turn, the class inherits the method, and also defines two additional overloads of that take an ADO Recordset object as a parameter.

Aids implementation of the interface. Inheritors of implement a set of functions to provide strong typing, but inherit most of the functionality needed to fully implement a DataAdapter.

Constructor When you create an instance of , the following read/write properties are set to the following initial values. Properties Initial value A new . A new . A new . A new . MissingMappingAction.Passthrough MissingSchemaAction.Add You can change the value of any of these properties through a separate call to the property.

Initializes a new instance of a DataAdapter class.

1.0.5000.0 2.0.0.0 Constructor 1.0.5000.0 2.0.0.0 This overload of the constructor is designed for use by a .NET Framework data provider when implementing a similar constructor for use in a clone implementation.

Initializes a new instance of a DataAdapter class from an existing object of the same type.

A DataAdapter object used to create the new DataAdapter. Method 2.0.0.0 System.Int32 In , this method throws . Classes that inherit from override this method to provide support for batches.

Adds a to the current batch.

The number of commands in the batch before adding the . The to add to the batch. Method 2.0.0.0 System.Void In , this method throws . Classes that inherit from override this method to provide support for batches.

Removes all objects from the batch.

Method System.Data.Common.RowUpdatedEventArgs To be added

Initializes a new instance of the class.

A new instance of the class. The used to update the data source. The executed during the . Whether the command is an UPDATE, INSERT, DELETE, or SELECT statement. A object. 1.0.5000.0 2.0.0.0 Method System.Data.Common.RowUpdatingEventArgs To be added

Initializes a new instance of the class.

A new instance of the class. The that updates the data source. The to execute during the . Whether the command is an UPDATE, INSERT, DELETE, or SELECT statement. A object. 1.0.5000.0 2.0.0.0 Field System.String "Table" is the default name used by the object for table mappings. is when an application adds a table mapping to be used with , but does not specify a name.

The default name used by the object for table mappings.

1.0.5000.0 2.0.0.0 Property 2.0.0.0 System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden) System.ComponentModel.Browsable(false) System.Data.Common.DbCommand To be added. During , if this property is not set and primary key information is present in the , the is automatically generated.

Gets or sets a command for deleting records from the data set.

Method System.Void To be added

Releases the unmanaged resources used by the and optionally releases the managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources. 1.0.5000.0 2.0.0.0 Method 2.0.0.0 System.Int32 In , this method throws . Classes that inherit from override this method to provide support for batches.

Executes the current batch.

The return value from the last command in the batch. Method System.Int32 The method retrieves the data from the data source using a SELECT statement. The object associated with the select command must be valid, but it does not need to be open. If the is closed before is called, it is opened to retrieve data and then closed. If the connection is open before is called, it remains open. If an error or an exception is encountered while populating the data tables, rows added prior to the occurrence of the error remain in the data tables. The remainder of the operation is aborted. If a command does not return any rows, no tables are added to the , and no exception is raised. If the object encounters duplicate columns while populating a , it generates names for the subsequent columns using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When the query specified returns multiple results, the result set for each row returning query is placed 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). Because no table is created for a query that does not return rows, if you process an insert query followed by a select query, the table created for the select query is named "Table" because it is the first table created. Applications using column and table names should ensure that conflicts with these naming patterns does not occur. When the SELECT statement used to populate the returns multiple results, such as batch SQL statements, if one of the results contains an error, all subsequent results are skipped and are not added to the . When using subsequent calls to refresh the contents of the , two conditions must be met: The SQL statement should match the one initially used to populate the . The Key column information must be present. If primary key information is present, any duplicate rows are reconciled and only appear once in the that corresponds to the . Primary key information may be set either through , by specifying the property of the , or by setting the property to AddWithKey. If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a value for the resulting . You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see Defining a Primary Key for a Table. When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey.

Adds or refreshes rows in the .

The number of rows successfully added to or refreshed in the . This does not include rows affected by statements that do not return rows. A to fill with records and, if necessary, schema. 1.0.5000.0 2.0.0.0 Method System.Int32 The method retrieves rows from the data source using the SELECT statement specified by an associated 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 is called, it is opened to retrieve data, then closed. If the connection is open before is called, it remains open. The operation then adds the rows to destination objects in the , creating the objects if they do not already exist. When creating objects, the operation normally creates only column name metadata. However, if the property is set to AddWithKey, appropriate primary keys and constraints are also created. If the encounters duplicate columns while populating a , it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the each result set is placed in a separate table. The overload of that takes as a parameter only obtains the first result. Use an overload of that takes as a parameter to obtain multiple results. The method supports scenarios where the contains multiple objects whose names differ only by case. In such situations, performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.

DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
    adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".

If is called and the contains only one whose name differs only by case, that is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.

DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
    adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.

You can use the method multiple times on the same . 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 . If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a value for the resulting . You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see Defining a Primary Key for a Table. When handling batch SQL statements that return multiple results, the implementation of and for a .NET Framework data provider retrieves schema information for only the first result.

Adds or refreshes rows in a specified range in the to match those in the data source using the name.

The number of rows successfully added to or refreshed in the . This does not include rows affected by statements that do not return rows. The name of the to use for table mapping. 1.0.5000.0 2.0.0.0 Method System.Int32 The method retrieves the data from the data source using a SELECT statement. The object associated with the select command must be valid, but it does not need to be open. If the is closed before is called, it is opened to retrieve data, then closed. If the connection is open before is called, it remains open. If a command does not return any rows, no tables are added to the , and no exception is raised. If the object encounters duplicate columns while populating a , it will generate names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When the query specified returns multiple results, each result set is placed 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). Since no table is created for a query that does not return rows, if you were to process an insert query followed by a select query, the table created for the select query would be named "Table", because it is the first table created. Applications using column and table names should ensure that conflicts with these naming patterns does not occur. The method supports scenarios where the contains multiple objects whose names differ only by case. In such situations, performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
 adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".

If is called and the contains only one whose name differs only by case, that is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.

If an error or an exception is encountered while populating the data tables, rows added prior to the occurrence of the error remain in the data tables. The remainder of the operation is aborted. When the SELECT statement used to populate the returns multiple results, such as a batch SQL statement, be aware of the following: If one of the results contains an error, all subsequent results are skipped and not added to the . When using subsequent calls to refresh the contents of the , two conditions must be met: The SQL statement should match the one initially used to populate the . The Key column information must be present. If primary key information is present, any duplicate rows are reconciled and only appear once in the that corresponds to the . Primary key information may be set either through , by specifying the property of the , or by setting the property to AddWithKey. If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a value for the resulting . You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see Defining a Primary Key for a Table. When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey.

Adds or refreshes rows in the to match those in the data source using the and names.

To be added.

To be added. To be added. Method System.Int32 The method retrieves rows from the data source using the SELECT statement specified by an associated 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 is called, it is opened to retrieve data and then closed. If the connection is open before is called, it remains open. The operation then adds the rows to the specified destination object in the , creating the object if it does not already exist. When creating a object, the operation normally creates only column name metadata. However, if the property is set to AddWithKey, appropriate primary keys and constraints are also created. If the object encounters duplicate columns while populating a , it will generate names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. The overload of that takes as a parameter only obtains the first result. Use an overload of that takes as a parameter to obtain multiple results. You can use the method multiple times on the same . 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 . If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a value for the resulting . You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see Defining a Primary Key for a Table. When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey.

Adds or refreshes rows in a to match those in the data source using the specified , and .

The number of rows successfully added to or refreshed in the . This does not include rows affected by statements that do not return rows. A to fill with records and, if necessary, schema. The SQL SELECT statement used to retrieve rows from the data source. One of the values. 1.0.5000.0 2.0.0.0 Method 2.0.0.0 System.Int32 System.ParamArray The method retrieves rows from the data source using the SELECT statement specified by an associated 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 is called, it is opened to retrieve data, and then it is closed. If the connection is open before is called, it remains open. The operation then adds the rows to destination objects in the , creating the objects if they do not already exist. When creating objects, the operation normally creates only column name metadata. However, if the property is set to AddWithKey, appropriate primary keys and constraints are also created. If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a value for the resulting . You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see Defining a Primary Key for a Table. If the data adapter encounters duplicate columns while populating a , it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the , each result set is placed 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 using column and table names should ensure that conflicts with these naming patterns does not occur. When the SELECT statement used to populate the returns multiple results, such as a batch SQL statements, if one of the results contains an error, all subsequent results are skipped and not added to the . You can use the method multiple times on the same . 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 . When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey.

Adds or refreshes rows in a to match those in the data source starting at the specified record and retrieving up to the specified maximum number of records.

The number of rows successfully added to or refreshed in the . This value does not include rows affected by statements that do not return rows. The zero-based record number to start with. The maximum number of records to retrieve. The objects to fill from the data source. Method System.Int32 A value of 0 gets all records found after the start record. If is greater than the number of remaining rows, only the remaining rows are returned, and no error is issued. If the corresponding select command is a statement returning multiple results, only applies to the first result. The method retrieves the data from the data source using a SELECT statement. The object associated with the SELECT statement must be valid, but it does not need to be open. If the is closed before is called, it is opened to retrieve data and then closed. If the connection is open before is called, it remains open. If a command does not return any rows, no tables are added to the , but no exception is raised. If the object encounters duplicate columns while populating a , it will generate names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When the query specified returns multiple results, each result set is placed 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). Because no table is created for a query that does not return rows, if you process an insert query followed by a select query, the table created for the select query is named "Table", because it is the first table created. Applications using column and table names should ensure that conflicts with these naming patterns does not occur. The method supports scenarios where the contains multiple objects whose names differ only by case. In such situations, performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.

DataSet dataset = new DataSet();
dataset.Tables.Add("aaa");
dataset.Tables.Add("AAA");
adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".

If is called and the contains only one whose name differs only by case, that is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.

DataSet dataset = new DataSet();
dataset.Tables.Add("aaa");
adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.

If an error or an exception is encountered while populating the data tables, rows added prior to the occurrence of the error remain in the data tables. The remainder of the operation is aborted. When the SELECT statement used to populate the returns multiple results, such as batch SQL statements, be aware of the following: When processing multiple results from a batch SQL statement, only applies to the first result. The same is true for rows containing chaptered results (.NET Framework Data Provider for OLE DB only). The top level result is limited by , but all child rows are added. If one of the results contains an error, all subsequent results are skipped and not added to the . When using subsequent calls to refresh the contents of the , two conditions must be met: The SQL statement should match the one initially used to populate the . The Key column information must be present. If primary key information is present, any duplicate rows will be reconciled and only appear once in the that corresponds to the . Primary key information may be set either through , by specifying the property of the , or by setting the property to AddWithKey. If the SelectCommand returns the results of an OUTER JOIN, the DataAdapter does not set a value for the resulting . You must explicitly define the primary key to ensure that duplicate rows are resolved correctly. For more information, see Defining a Primary Key for a Table. When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey. The DataSet will not contain more than the number of records indicated by . However, the entire result set generated by the query is still returned from the server.

Adds or refreshes rows in a specified range in the to match those in the data source using the and names.

The number of rows successfully added to or refreshed in the . This does not include rows affected by statements that do not return rows. A to fill with records and, if necessary, schema. The zero-based record number to start with. The maximum number of records to retrieve. The name of the source table to use for table mapping. 1.0.5000.0 2.0.0.0 Method System.Int32 To be added: an object of type 'Data.DataSet' To be added: an object of type 'string' To be added: an object of type 'Data.IDataReader' To be added: an object of type 'int' To be added: an object of type 'int'

To be added

To be added: an object of type 'int' To be added 1.0.5000.0 Method 2.0.0.0 System.Int32 A value of 0 gets all records found after the start record. If is greater than the number of remaining rows, only the remaining rows are returned and no error is issued. The method retrieves the data from the data source using a SELECT statement. The object associated with the SELECT statement must be valid, but it does not need to be open. If the is closed before is called, it is opened to retrieve data, then closed. If the connection is open before is called, it remains open. If a command does not return any rows, no tables are added to the , but no exception is raised. If the object encounters duplicate columns while populating a , it will generate names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When the query specified returns multiple results, each result set is placed 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). Since no table is created for a query that does not return rows, if you were to process an insert query followed by a select query, the table created for the select query would be named "Table", because it is the first table created. Applications using column and table names should ensure that conflicts with these naming patterns does not occur. The method supports scenarios where the contains multiple objects whose names differ only by case. In such situations, performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
 adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".

If is called and the contains only one whose name differs only by case, that is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.

Adds or refreshes rows in a specified range in the to match those in the data source using the and names.

The number of rows added to or refreshed in the data tables. The objects to fill from the data source. The zero-based record number to start with. The maximum number of records to retrieve. The executed to fill the objects. One of the values. Method System.Int32 The method retrieves rows from the data source using the SELECT statement specified by an associated 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 is called, it is opened to retrieve data, then closed. If the connection is open before is called, it remains open. The operation then adds the rows to destination objects in the , creating the objects if they do not already exist. When creating objects, the operation normally creates only column name metadata. However, if the property is set to AddWithKey, appropriate primary keys and constraints are also created. If the encounters duplicate columns while populating a , it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the each result set is placed 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 using column and table names should ensure that conflicts with these naming patterns does not occur. The method supports scenarios where the contains multiple objects whose names differ only by case. In such situations, performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.Fill(dataset, "aaa"); // Fills "aaa", which already exists in the DataSet.
 adapter.Fill(dataset, "Aaa"); // Adds a new table called "Aaa".

If is called and the contains only one whose name differs only by case, that is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.Fill(dataset, "AAA"); // Fills table "aaa" because only one similarly named table is in the DataSet.

Adds or refreshes rows in a specified range in the to match those in the data source using the and source table names, command string, and command behavior.

The number of rows successfully added to or refreshed in the . This does not include rows affected by statements that do not return rows. A to fill with records and, if necessary, schema. The zero-based record number to start with. The maximum number of records to retrieve. The name of the source table to use for table mapping. The SQL SELECT statement used to retrieve rows from the data source. One of the values. 1.0.5000.0 2.0.0.0 Property 2.0.0.0 System.Data.CommandBehavior To be added. To be added.

Gets or sets the behavior of the command used to fill the data adapter.

Event System.Data.FillErrorEventHandler

To be added

To be added 1.0.5000.0 System.Data.DataSysDescription(Description="Event triggered when a recoverable error occurs during Fill.") Method System.Data.DataTable[] This method retrieves the schema information from the data source using the . A operation adds a to the destination . It then adds columns to the of the , and configures the following properties if they exist at the data source: . You must set and separately. also configures the and properties according to the following rules: If one or more primary key columns are returned by the , they are used as the primary key columns for the . If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a is added to the , but the property is not set. If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the . Note that primary keys and unique constraints are added to the according to the preceding rules, but other constraint types are not added. 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 specifying query hints, see Query Hint (Transact-SQL). Primary key information is used during to find and replace any rows whose key columns match. If this is not the desired behavior, use without requesting schema information. If the encounters duplicate columns while populating a , it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the each result set is placed 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 using column and table names should ensure that conflicts with these naming patterns does not occur. The object associated with the select command must be valid, but it does not need to open. If the is closed before is called, it is opened to retrieve data, then closed. If the connection is open before is called, it is left open. When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey. When using , the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.

Adds a named "Table" to the specified and configures the schema to match that in the data source based on the specified .

A reference to a collection of objects that were added to the . A to insert the schema in. One of the values that specify how to insert the schema. 1.0.5000.0 2.0.0.0 Method System.Data.DataTable The method retrieves the schema from the data source using the . The connection object associated with the must be valid, but it does not need to be open. If the connection is closed before is called, it is opened to retrieve data, then closed. If the connection is open before is called, it remains open. A operation returns a . It then adds columns to the of the , and configures the following properties if they exist at the data source: . You must set and separately. also configures the and properties according to the following rules: If a has already been defined for the DataTable, or the DataTable contains data, the PrimaryKey property will not be set. If one or more primary key columns are returned by the , they are used as the primary key columns for the DataTable. If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a is added to the , but the PrimaryKey property is not set. If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the DataTable. Note that primary keys and unique constraints are added to the according to the preceding rules, but other constraint types are not added. This process may require several round-trips to the server. 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 specifying query hints, see Query Hint (Transact-SQL). If the encounters duplicate columns while populating a , it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the each result set is placed 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 using column and table names should ensure that conflicts with these naming patterns does not occur. does not return any rows. Use the method to add rows to a . When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey. When using , the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.

Configures the schema of the specified based on the specified .

A that contains schema information returned from the data source. The to be filled with the schema from the data source. One of the values. 1.0.5000.0 2.0.0.0 Method System.Data.DataTable[] This method retrieves the schema information from the data source using the . A operation adds a to the destination . It then adds columns to the of the , and configures the following properties if they exist at the data source: . You must set and separately. also configures the and properties according to the following rules: If one or more primary key columns are returned by the , they are used as the primary key columns for the . If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a is added to the , but the property is not set. If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the . Note that primary keys and unique constraints are added to the according to the preceding rules, but other constraint types are not added. 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 specifying query hints, see Query Hint (Transact-SQL). Primary key information is used during to find and replace any rows whose key columns match. If this is not the desired behavior, use without requesting schema information. If the encounters duplicate columns while populating a , it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the each result set is placed 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 using column and table names should ensure that conflicts with these naming patterns does not occur. The method supports scenarios where the contains multiple objects whose names differ only by case. In such situations, performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.FillSchema(dataset, "aaa"); // Fills the schema of "aaa", which already exists in the DataSet.
 adapter.FillSchema(dataset, "Aaa"); // Adds a new table called "Aaa".

If is called and the contains only one whose name differs only by case, that is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.FillSchema(dataset, "AAA"); // Fills the schema of table "aaa" because only one similarly named table is in the DataSet.

The object associated with the select command must be valid, but it does not need to open. If the is closed before is called, it is opened to retrieve data, then closed. If the connection is open before is called, it is left open. When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey. When using , the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.

Adds a to the specified and configures the schema to match that in the data source based upon the specified and .

A reference to a collection of objects that were added to the . A to insert the schema in. One of the values that specify how to insert the schema. The name of the source table to use for table mapping. 1.0.5000.0 2.0.0.0 Method System.Data.DataTable The method retrieves the schema from the data source using the . The connection object associated with the must be valid, but it does not need to be open. If the connection is closed before is called, it is opened to retrieve data, then closed. If the connection is open before is called, it remains open. A operation adds a to the destination . It then adds columns to the of the , and configures the following properties if they exist at the data source: . You must set and separately. also configures the and properties according to the following rules: If one or more primary key columns are returned by the , they are used as the primary key columns for the . If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a is added to the , but the property is not set. If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the . Note that primary keys and unique constraints are added to the according to the preceding rules, but other constraint types are not added. 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 specifying query hints, see Query Hint (Transact-SQL). If the encounters duplicate columns while populating a , it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the each result set is placed 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 using column and table names should ensure that conflicts with these naming patterns does not occur. does not return any rows. Use the method to add rows to a . When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey. When using , the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.

Configures the schema of the specified based on the specified , command string, and values.

A of object that contains schema information returned from the data source. The to be filled with the schema from the data source. One of the values. The SQL SELECT statement used to retrieve rows from the data source. One of the values. 1.0.5000.0 2.0.0.0 Method System.Data.DataTable[] The method retrieves the schema from the data source using the . The connection object associated with the must be valid, but it does not need to be open. If the connection is closed before is called, it is opened to retrieve data, then closed. If the connection is open before is called, it remains open. A operation adds a to the destination . It then adds columns to the of the , and configures the following properties if they exist at the data source: . You must set and separately. also configures the and properties according to the following rules: If one or more primary key columns are returned by the , they are used as the primary key columns for the . If no primary key columns are returned but unique columns are, the unique columns are used as the primary key if, and only if, all the unique columns are nonnullable. If any of the columns are nullable, a is added to the , but the property is not set. If both primary key columns and unique columns are returned, the primary key columns are used as the primary key columns for the . Note that primary keys and unique constraints are added to the according to the preceding rules, but other constraint types are not added. 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 specifying query hints, see Query Hint (Transact-SQL). If the encounters duplicate columns while populating a , it generates names for the subsequent columns, using the pattern "columnname1", "columnname2", "columnname3", and so on. If the incoming data contains unnamed columns, they are placed in the according to the pattern "Column1", "Column2", and so on. When multiple result sets are added to the each result set is placed 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 using column and table names should ensure that conflicts with these naming patterns does not occur. The method supports scenarios where the contains multiple objects whose names differ only by case. In such situations, performs a case-sensitive comparison to find the corresponding table, and creates a new table if no exact match exists. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 dataset.Tables.Add("AAA");
 adapter.FillSchema(dataset, "aaa"); // Fills the schema of "aaa", which already exists in the DataSet.
 adapter.FillSchema(dataset, "Aaa"); // Adds a new table called "Aaa".

If is called and the contains only one whose name differs only by case, that is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.

 DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
 adapter.FillSchema(dataset, "AAA"); // Fills the schema of table "aaa" because only one similarly named table is in the DataSet.

does not return any rows. Use the method to add rows to a . When handling batch SQL statements that return multiple results, the implementation of for the .NET Framework Data Provider for OLE DB retrieves schema information for only the first result. To retrieve schema information for multiple results, use with the set to AddWithKey. When using , the .NET Framework Data Provider for SQL Server appends a FOR BROWSE clause to the statement being executed. The user should be aware of potential side effects, such as interference with the use of SET FMTONLY ON statements. See SQL Server Books Online for more information.

Adds a to the specified and configures the schema to match that in the data source based on the specified .

An array of objects that contain schema information returned from the data source. The to be filled with the schema from the data source. One of the values. The SQL SELECT statement used to retrieve rows from the data source. The name of the source table to use for table mapping. One of the values. 1.0.5000.0 2.0.0.0 Method 2.0.0.0 System.Data.IDataParameter In , this method throws . Classes that inherit from override this method to provide support for batches.

Returns a from one of the commands in the current batch.

The specified. The index of the command to retrieve the parameter from. The index of the parameter within the command. Method 2.0.0.0 System.Boolean To be added. To be added. To be added.

To be added.

To be added. To be added. Method System.Data.IDataParameter[] To be added

Gets the parameters set by the user when executing an SQL SELECT statement.

An array of objects that contains the parameters set by the user. 1.0.5000.0 2.0.0.0 System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Advanced) Method 2.0.0.0 System.Void In , this method throws . Classes that inherit from override this method to provide support for batches.

Initializes batching for the .

Property 2.0.0.0 System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden) System.ComponentModel.Browsable(false) System.Data.Common.DbCommand To be added. During , if this property is not set and primary key information is present in the , the will be automatically generated.

Gets or sets a command used to insert new records into the data source.

Method System.Void To be added: an object of type 'Data.FillErrorEventArgs'

To be added

To be added 1.0.5000.0 Method System.Void Raising an event invokes the event handler through a delegate. For an overview, see Raising an Event.

Raises the RowUpdated event of a .NET Framework data provider.

A that contains the event data. 1.0.5000.0 2.0.0.0 Method System.Void Raising an event invokes the event handler through a delegate. For an overview, see Raising an Event.

Raises the RowUpdating event of a .NET Framework data provider.

An that contains the event data. 1.0.5000.0 2.0.0.0 Property 2.0.0.0 System.ComponentModel.DesignerSerializationVisibility(System.ComponentModel.DesignerSerializationVisibility.Hidden) System.ComponentModel.Browsable(false) System.Data.Common.DbCommand To be added. To be added.

Gets or sets a command used to select records in the data source.

Property 2.0.0.0 System.Data.IDbCommand To be added. This member is an explicit interface member implementation. It can be used only when the instance is cast to an interface. For more information, see .

Gets or sets an SQL statement for deleting records from the data set.

Gets or sets an SQL statement used to insert new records into the data source.

Gets or sets an SQL statement used to select records in the data source.

Gets or sets an SQL statement used to update records in the data source.

Method 1.0.5000.0 2.0.0.0 System.Obsolete("use 'protected DbDataAdapter(DbDataAdapter)' ctor") System.Object This member is an explicit interface member implementation. It can be used only when the instance is cast to an interface. For more information, see .

Creates a new object that is a copy of the current instance.

A new object that is a copy of this instance. Method 2.0.0.0 System.Void In , this method throws . Classes that inherit from override this method to provide support for batches.

Ends batching for the .

Method System.Int32 When an application calls the method, the examines the property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the . For example, might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the . It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the method in situations where you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see Updating the Database with a DataAdapter and the DataSet. If INSERT, UPDATE, or DELETE statements have not been specified, the method generates an exception. However, you can create a or 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 . For more information see Automatically Generated Commands. The method retrieves rows from the table listed in the first mapping before performing an update. The then refreshes the row using the value of the property. Any additional rows returned are ignored. After any data is loaded back into the , the event is raised, allowing the user to inspect the reconciled row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted. When using , the order of execution is as follows: The values in the are moved to the parameter values. The event is raised. The command executes. If the command is set to FirstReturnedRecord, the first returned result is placed in the . If there are output parameters, they are placed in the . The event is raised. is called. Each command associated with the usually has a parameters 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 column that the references to obtain parameter values for the current row. 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 values. Enumeration value Action taken MissingMappingAction.Passthrough Use the source column names and table names in the if no mapping is present. MissingMappingAction.Ignore A is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. MissingMappingAction.Error A is generated. 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. 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 often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations. 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 property to true before calling . 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 property of the to .

Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified array in the .

The number of rows successfully updated from the . An array of objects used to update the data source. 1.0.5000.0 2.0.0.0 Method System.Int32 When an application calls the method, the examines the property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the . For example, might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the . It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the method in situations where you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see Updating the Database With a DataAdapter and a DataSet. If INSERT, UPDATE, or DELETE statements have not been specified, the method generates an exception. However, you can create a or 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 . For more information see Automatically Generated Commands. The method retrieves rows from the table listed in the first mapping before performing an update. The then refreshes the row using the value of the property. Any additional rows returned are ignored. After any data is loaded back into the , the event is raised, allowing the user to inspect the reconciled row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted. When using , the order of execution is as follows: The values in the are moved to the parameter values. The event is raised. The command executes. If the command is set to FirstReturnedRecord, then the first returned result is placed in the . If there are output parameters, they are placed in the . The event is raised. is called. Each command associated with the usually has a parameters 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 column that the references to obtain parameter values for the current row. 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 values. Enumeration value Action taken MissingMappingAction.Passthrough Use the source column names and table names in the if no mapping is present. MissingMappingAction.Ignore A is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. MissingMappingAction.Error A is generated. 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. 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 often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations. 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 property to true before calling . 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 property of the to .

Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified .

The number of rows successfully updated from the . The used to update the data source. 1.0.5000.0 2.0.0.0 Method System.Int32 When an application calls the method, the examines the property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the . For example, might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the . It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the method in situations where you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see Updating the Database With a DataAdapter and a DataSet. If INSERT, UPDATE, or DELETE statements have not been specified, the method generates an exception. However, you can create a or 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 . For more information see Automatically Generated Commands. The method retrieves rows from the table listed in the first mapping before performing an update. The then refreshes the row using the value of the property. Any additional rows returned are ignored. After any data is loaded back into the , the event is raised, allowing the user to inspect the reconciled row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted. When using , the order of execution is as follows: The values in the are moved to the parameter values. The event is raised. The command executes. If the command is set to FirstReturnedRecord, then the first returned result is placed in the . If there are output parameters, they are placed in the . The event is raised. is called. Each command associated with the usually has a parameters 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 column that the references to obtain parameter values for the current row. 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 values. Enumeration value Action taken MissingMappingAction.Passthrough Use the source column names and table names in the if no mapping is present. MissingMappingAction.Ignore A is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. MissingMappingAction.Error A is generated. 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. 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 often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations. 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 property to true before calling . 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 property of the to .

Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified .

The number of rows successfully updated from the . The used to update the data source. 1.0.5000.0 2.0.0.0 Method System.Int32 When an application calls the method, the examines the property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the . For example, might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the . It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the method in situations where you must control the sequence of statement types (for example, INSERTs before UPDATEs). For more information, see Updating the Database with a DataAdapter and the DataSet. If INSERT, UPDATE, or DELETE statements have not been specified, the method generates an exception. However, you can create a or 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 . For more information see Automatically Generated Commands. The method retrieves rows from the table listed in the first mapping before performing an update. The then refreshes the row using the value of the property. Any additional rows returned are ignored. After any data is loaded back into the , the event is raised, allowing the user to inspect the reconciled row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted. When using , the order of execution is as follows: The values in the are moved to the parameter values. The event is raised. The command executes. If the command is set to FirstReturnedRecord, then the first returned result is placed in the . If there are output parameters, they are placed in the . The event is raised. is called. Each command associated with the usually has a parameters 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 column that the references to obtain parameter values for the current row. 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 values. Enumeration value Action taken MissingMappingAction.Passthrough Use the source column names and table names in the if no mapping is present. MissingMappingAction.Ignore A is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. MissingMappingAction.Error A is generated. 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. 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 often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations. 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 property to true before calling . 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 property of the to .

Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified array of objects.

The number of rows successfully updated from the . An array of objects used to update the data source. The collection to use. 1.0.5000.0 2.0.0.0 Method System.Int32 When an application calls the method, the examines the property, and executes the required INSERT, UPDATE, or DELETE statements iteratively for each row, based on the order of the indexes configured in the . For example, might execute a DELETE statement, followed by an INSERT statement, and then another DELETE statement, due to the ordering of the rows in the . It should be noted that these statements are not performed as a batch process; each row is updated individually. An application can call the method in situations where you must control the sequence of statement types (for example, INSERT before UPDATE). For more information, see Updating the Database With a DataAdapter and a DataSet. If INSERT, UPDATE, or DELETE statements have not been specified, the method generates an exception. However, you can create a or 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 . For more information see Automatically Generated Commands. The method supports scenarios where the contains multiple objects whose names differ only by case. When multiple tables with the same name, but different case, exist in a DataSet, performs a case-sensitive comparison to find the corresponding table, and generates an exception if no exact match exists. The following C# code illustrates this behavior.

DataSet ds = new DataSet();
 ds.Tables.Add("aaa");
 ds.Tables.Add("AAA");
 adapter.Update(ds, "aaa"); // Updates "aaa", which already exists in the DataSet.
 adapter.Update(ds, "AAA"); // Updates "AAA", which already exists in the DataSet.
    adapter.Update(ds, "Aaa"); // Results in an exception.

If is called and the contains only one whose name differs only by case, that is updated. In this scenario, the comparison is case insensitive. The following C# code illustrates this behavior.

DataSet dataset = new DataSet();
 dataset.Tables.Add("aaa");
    adapter.Update(dataset, "AAA"); // Updates table "aaa" because only one similarly named table is in the DataSet.

The method retrieves rows from the table listed in the first mapping before performing an update. The then refreshes the row using the value of the property. Any additional rows returned are ignored. After any data is loaded back into the , the event is raised, allowing the user to inspect the reconciled row and any output parameters returned by the command. After a row updates successfully, the changes to that row are accepted. When using , the order of execution is as follows: The values in the are moved to the parameter values. The event is raised. The command executes. If the command is set to FirstReturnedRecord, then the first returned result is placed in the . If there are output parameters, they are placed in the . The event is raised. is called. Each command associated with the usually has a parameters 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 column that the references to obtain parameter values for the current row. 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 values. Enumeration value Action taken MissingMappingAction.Passthrough Use the source column names and table names in the if no mapping is present. MissingMappingAction.Ignore A is generated. When the mappings are explicitly set, a missing mapping for an input parameter is usually the result of an error. MissingMappingAction.Error A is generated. 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. 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 often used to include original values in the WHERE clause of an UPDATE statement to check for optimistic concurrency violations. 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 property to true before calling . 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 property of the to .

Updates the values in the database by executing the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the with the specified name.

The number of rows successfully updated from the . The to use to update the data source. The name of the source table to use for table mapping. 1.0.5000.0 2.0.0.0 Property 2.0.0.0 System.ComponentModel.DefaultValue(1) System.Int32 To be added. Use the property to update a data source with changes from a . If the data provider supports batch processing, this can increase application performance by reducing the number of round-trips to the server. In ADO.NET 2.0, this property is supported for the .NET data providers for SQL Server (SqlClient) and Oracle (OracleClient). Executing an extremely large batch could decrease performance. Therefore, you should test for the optimum batch size setting before implementing your application. An will be thrown if the value is set to a number less than zero.

Gets or sets a value that enables or disables batch processing support, and specifies the number of commands that can be executed in a batch.

Gets or sets a command used to update records in the data source.