TeslaFi-Import/MySql.Data.xml
Rama master · réplica de lectura del repositorio original.
<?xml version="1.0"?>
<doc>
<assembly>
<name>MySql.Data</name>
</assembly>
<members>
<member name="T:MySql.Data.MySqlClient.Authentication.CachingSha2AuthenticationPlugin">
<summary>
The implementation of the caching_sha2_password authentication plugin.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.CachingSha2AuthenticationPlugin.GeneratePassword">
<summary>
Generates a byte array set with the password of the user in the expected format based on the
SSL settings of the current connection.
</summary>
<returns>A byte array that contains the password of the user in the expected format.</returns>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.AuthStage">
<summary>
Defines the stage of the authentication.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin">
<summary>
Defines the default behavior for an authentication plugin.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.AuthenticationData">
<summary>
Gets or sets the authentication data returned by the server.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.GetPlugin(System.String,MySql.Data.MySqlClient.NativeDriver,System.Byte[])">
<summary>
This is a factory method that is used only internally. It creates an auth plugin based on the method type
</summary>
<param name="method"></param>
<param name="driver"></param>
<param name="authData"></param>
<returns></returns>
</member>
<member name="P:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.Settings">
<summary>
Gets the connection option settings.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.ServerVersion">
<summary>
Gets the server version associated with this authentication plugin.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.Encoding">
<summary>
Gets the encoding assigned to the native driver.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.SetAuthData(System.Byte[])">
<summary>
Sets the authentication data required to encode, encrypt, or convert the password of the user.
</summary>
<param name="data">A byte array containing the authentication data provided by the server.</param>
<remarks>This method may be overriden based on the requirements by the implementing authentication plugin.</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.CheckConstraints">
<summary>
Defines the behavior when checking for constraints.
</summary>
<remarks>This method is intended to be overriden.</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.AuthenticationFailed(System.Exception)">
<summary>
Throws a <see cref="T:MySql.Data.MySqlClient.MySqlException"/> that encapsulates the original exception.
</summary>
<param name="ex">The exception to encapsulate.</param>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.AuthenticationSuccessful">
<summary>
Defines the behavior when authentication is successful.
</summary>
<remarks>This method is intended to be overriden.</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.MoreData(System.Byte[])">
<summary>
Defines the behavior when more data is required from the server.
</summary>
<param name="data">The data returned by the server.</param>
<returns>The data to return to the server.</returns>
<remarks>This method is intended to be overriden.</remarks>
</member>
<member name="P:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.PluginName">
<summary>
Gets the plugin name based on the authentication plugin type defined during the creation of this object.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.GetUsername">
<summary>
Gets the user name associated to the connection settings.
</summary>
<returns>The user name associated to the connection settings.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlAuthenticationPlugin.GetPassword">
<summary>
Gets the encoded, encrypted, or converted password based on the authentication plugin type defined during the creation of this object.
This method is intended to be overriden.
</summary>
<returns>An object containing the encoded, encrypted, or converted password.</returns>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.MySqlNativePasswordPlugin">
<summary>
Allows connections to a user account set with the mysql_native_password authentication plugin.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.MySqlNativePasswordPlugin.Get411Password(System.String,System.Byte[])">
<summary>
Returns a byte array containing the proper encryption of the
given password/seed according to the new 4.1.1 authentication scheme.
</summary>
<param name="password"></param>
<param name="seedBytes"></param>
<returns></returns>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.Sha256AuthenticationPlugin">
<summary>
The implementation of the sha256_password authentication plugin.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.Sha256AuthenticationPlugin.rawPubkey">
<summary>
The byte array representation of the public key provided by the server.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Authentication.Sha256AuthenticationPlugin.GetXor(System.Byte[],System.Byte[])">
<summary>
Applies XOR to the byte arrays provided as input.
</summary>
<returns>A byte array that contains the results of the XOR operation.</returns>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.MySqlWindowsAuthenticationPlugin">
<summary>
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.SecBufferType">
<summary>
Defines the type of the security buffer.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.SecHandle">
<summary>
Defines a security handle.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.SecBuffer">
<summary>
Describes a buffer allocated by a transport to pass to a security package.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SecBuffer.cbBuffer">
<summary>
Specifies the size, in bytes, of the buffer.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SecBuffer.BufferType">
<summary>
Bit flags that indicate the type of the buffer.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SecBuffer.pvBuffer">
<summary>
Pointer to a buffer.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.SECURITY_INTEGER">
<summary>
Hold a numeric value used in defining other data types.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SECURITY_INTEGER.LowPart">
<summary>
Least significant digits.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SECURITY_INTEGER.HighPart">
<summary>
Most significant digits.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.SECURITY_HANDLE">
<summary>
Holds a pointer used to define a security handle.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SECURITY_HANDLE.LowPart">
<summary>
Least significant digits.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SECURITY_HANDLE.HighPart">
<summary>
Most significant digits.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Authentication.SecPkgContext_Sizes">
<summary>
Indicates the sizes of important structures used in the message support functions.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SecPkgContext_Sizes.cbMaxToken">
<summary>
Specifies the maximum size of the security token used in the authentication changes.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SecPkgContext_Sizes.cbMaxSignature">
<summary>
Specifies the maximum size of the signature created by the <b>MakeSignature</b> function.
This member must be zero if integrity services are not requested or available.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SecPkgContext_Sizes.cbBlockSize">
<summary>
Specifies the preferred integral size of the messages.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.Authentication.SecPkgContext_Sizes.cbSecurityTrailer">
<summary>
Size of the security trailer to be appended to messages.
This member should be zero if the relevant services are not requested or available.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlBulkLoader">
<summary>
Allows importing large amounts of data into a database with bulk loading.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.Connection">
<summary>
Gets or sets the connection.
</summary>
<value>The connection.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.FieldTerminator">
<summary>
Gets or sets the field terminator.
</summary>
<value>The field terminator.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.LineTerminator">
<summary>
Gets or sets the line terminator.
</summary>
<value>The line terminator.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.TableName">
<summary>
Gets or sets the name of the table.
</summary>
<value>The name of the table.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.CharacterSet">
<summary>
Gets or sets the character set.
</summary>
<value>The character set.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.FileName">
<summary>
Gets or sets the name of the file.
</summary>
<value>The name of the file.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.Timeout">
<summary>
Gets or sets the timeout.
</summary>
<value>The timeout.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.Local">
<summary>
Gets or sets a value indicating whether the filename that is to be loaded
is local to the client or not
</summary>
<value><c>true</c> if local; otherwise, <c>false</c>.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.NumberOfLinesToSkip">
<summary>
Gets or sets the number of lines to skip.
</summary>
<value>The number of lines to skip.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.LinePrefix">
<summary>
Gets or sets the line prefix.
</summary>
<value>The line prefix.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.FieldQuotationCharacter">
<summary>
Gets or sets the field quotation character.
</summary>
<value>The field quotation character.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.FieldQuotationOptional">
<summary>
Gets or sets a value indicating whether [field quotation optional].
</summary>
<value>
<c>true</c> if [field quotation optional]; otherwise, <c>false</c>.
</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.EscapeCharacter">
<summary>
Gets or sets the escape character.
</summary>
<value>The escape character.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.ConflictOption">
<summary>
Gets or sets the conflict option.
</summary>
<value>The conflict option.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.Priority">
<summary>
Gets or sets the priority.
</summary>
<value>The priority.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.Columns">
<summary>
Gets the columns.
</summary>
<value>The columns.</value>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlBulkLoader.Expressions">
<summary>
Gets the expressions.
</summary>
<value>The expressions.</value>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlBulkLoader.Load">
<summary>
Executes the load operation.
</summary>
<returns>The number of rows inserted.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlBulkLoader.LoadAsync">
<summary>
Asynchronous version of the load operation.
</summary>
<returns>The number of rows inserted.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlBulkLoader.LoadAsync(System.Threading.CancellationToken)">
<summary>
Executes the load operation asynchronously while the cancellation isn't requested.
</summary>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows inserted.</returns>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlBulkLoaderPriority">
<summary>
Represents the priority set for bulk loading operations.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.MySqlBulkLoaderPriority.None">
<summary>
This is the default and indicates normal priority
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.MySqlBulkLoaderPriority.Low">
<summary>
Low priority will cause the load operation to wait until all readers of the table
have finished. This only affects storage engines that use only table-level locking
such as MyISAM, Memory, and Merge.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.MySqlBulkLoaderPriority.Concurrent">
<summary>
Concurrent priority is only relevant for MyISAM tables and signals that if the table
has no free blocks in the middle that other readers can retrieve data from the table
while the load operation is happening.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlBulkLoaderConflictOption">
<summary>
Represents the behavior when conflicts arise during bulk loading operations.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.MySqlBulkLoaderConflictOption.None">
<summary>
This is the default and indicates normal operation. In the event of a LOCAL load, this
is the same as ignore. When the data file is on the server, then a key conflict will
cause an error to be thrown and the rest of the data file ignored.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.MySqlBulkLoaderConflictOption.Replace">
<summary>
Replace column values when a key conflict occurs.
</summary>
</member>
<member name="F:MySql.Data.MySqlClient.MySqlBulkLoaderConflictOption.Ignore">
<summary>
Ignore any rows where the primary key conflicts.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.CharSetMap">
<summary>
Summary description for CharSetMap.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.CharSetMap.GetEncoding(MySql.Data.Common.DBVersion,System.String)">
<summary>
Returns the text encoding for a given MySQL character set name
</summary>
<param name="version">Version of the connection requesting the encoding</param>
<param name="charSetName">Name of the character set to get the encoding for</param>
<returns>Encoding object for the given character set name</returns>
</member>
<member name="M:MySql.Data.MySqlClient.CharSetMap.InitializeMapping">
<summary>
Initializes the mapping.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlCommand">
<summary>Represents a SQL statement to execute against a MySQL database. This class cannot be inherited.</summary><remarks>
<B>MySqlCommand</B> features the following methods for executing commands at a MySQL database:
<list type="table">
<listheader>
<term>Item</term>
<term>Description</term>
</listheader>
<item>
<term>
<a href="MySql.Data.MySqlClient.MySqlCommand.ExecuteReader_overloads.html">ExecuteReader</a>
</term>
<description>Executes commands that return rows.</description>
</item>
<item>
<term>
<a href="MySql.Data.MySqlClient.MySqlCommand.ExecuteNonQuery.html">ExecuteNonQuery</a>
</term>
<description>Executes commands such as SQL INSERT, DELETE, and UPDATE statements.</description>
</item>
<item>
<term>
<a href="MySql.Data.MySqlClient.MySqlCommand.ExecuteScalar.html">ExecuteScalar</a>
</term>
<description>Retrieves a single value (for example, an aggregate value) from a database.</description>
</item>
</list>
You can reset the <B>CommandText</B> property and reuse the <B>MySqlCommand</B>
object. However, you must close the <A href="MySql.Data.MySqlClient.MySqlDataReader.html">MySqlDataReader</A>
before you can execute a new or previous command.
If a <A href="MySql.Data.MySqlClient.MySqlException.html">MySqlException</A> is
generated by the method executing a <B>MySqlCommand</B>, the <A href="MySql.Data.MySqlClient.MySqlConnection.html">MySqlConnection</A>
remains open. It is the responsibility of the programmer to close the connection.
<note>
Using the '@' symbol for paramters is now the preferred approach although the old pattern of using
'?' is still supported. Please be aware though that using '@' can cause conflicts when user variables
are also used. To help with this situation please see the documentation on the 'allow user variables'
connection string option. The 'old syntax' connection string option has now been deprecated.
</note>
</remarks><example>
The following example creates a <A href="frlrfsystemdatasqlclientsqlcommandclasstopic.htm">MySqlCommand</A> and
a <B>MySqlConnection</B>. The <B>MySqlConnection</B> is opened and set as the <A href="frlrfsystemdatasqlclientsqlcommandclassconnectiontopic.htm">Connection</A>
for the <B>MySqlCommand</B>. The example then calls <A href="frlrfsystemdatasqlclientsqlcommandclassexecutenonquerytopic.htm">ExecuteNonQuery</A>,
and closes the connection. To accomplish this, the <B>ExecuteNonQuery</B> is
passed a connection string and a query string that is a SQL INSERT
statement.
<code lang="vbnet">
Public Sub InsertRow(myConnectionString As String)
" If the connection string is null, use a default.
If myConnectionString = "" Then
myConnectionString = "Database=Test;Data Source=localhost;User Id=username;Password=pass"
End If
Dim myConnection As New MySqlConnection(myConnectionString)
Dim myInsertQuery As String = "INSERT INTO Orders (id, customerId, amount) Values(1001, 23, 30.66)"
Dim myCommand As New MySqlCommand(myInsertQuery)
myCommand.Connection = myConnection
myConnection.Open()
myCommand.ExecuteNonQuery()
myCommand.Connection.Close()
End Sub
</code>
<code lang="C#">
public void InsertRow(string myConnectionString)
{
// If the connection string is null, use a default.
if(myConnectionString == "")
{
myConnectionString = "Database=Test;Data Source=localhost;User Id=username;Password=pass";
}
MySqlConnection myConnection = new MySqlConnection(myConnectionString);
string myInsertQuery = "INSERT INTO Orders (id, customerId, amount) Values(1001, 23, 30.66)";
MySqlCommand myCommand = new MySqlCommand(myInsertQuery);
myCommand.Connection = myConnection;
myConnection.Open();
myCommand.ExecuteNonQuery();
myCommand.Connection.Close();
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.#ctor">
<overloads>
<summary>
Initializes a new instance of the MySqlCommand class.
</summary>
<example>
The following example creates a MySqlCommand and sets some of its properties.
<para />
<note>
This example shows how to use one of the overloaded
versions of the MySqlCommand constructor. For other examples that might be available,
see the individual overload topics.
</note>
<code lang="vbnet">
Public Sub CreateMySqlCommand()
Dim myConnection As New MySqlConnection _
("Persist Security Info=False;database=test;server=myServer")
myConnection.Open()
Dim myTrans As MySqlTransaction = myConnection.BeginTransaction()
Dim mySelectQuery As String = "SELECT * FROM MyTable"
Dim myCommand As New MySqlCommand(mySelectQuery, myConnection, myTrans)
myCommand.CommandTimeout = 20
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand()
{
MySqlConnection myConnection = new MySqlConnection("Persist Security Info=False;
database=test;server=myServer");
myConnection.Open();
MySqlTransaction myTrans = myConnection.BeginTransaction();
string mySelectQuery = "SELECT * FROM myTable";
MySqlCommand myCommand = new MySqlCommand(mySelectQuery, myConnection,myTrans);
myCommand.CommandTimeout = 20;
}
</code>
<code lang="C++">
public:
void CreateMySqlCommand()
{
MySqlConnection* myConnection = new MySqlConnection(S"Persist Security Info=False;
database=test;server=myServer");
myConnection->Open();
MySqlTransaction* myTrans = myConnection->BeginTransaction();
String* mySelectQuery = S"SELECT * FROM myTable";
MySqlCommand* myCommand = new MySqlCommand(mySelectQuery, myConnection, myTrans);
myCommand->CommandTimeout = 20;
};
</code>
</example>
</overloads><summary>
Initializes a new instance of the MySqlCommand class.
</summary><remarks>
The base constructor initializes all fields to their default values. The
following table shows initial property values for an instance of <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />.
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" />
</term>
<term>empty string ("")</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandTimeout" />
</term>
<term>0</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandType" />
</term>
<term>CommandType.Text</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.Connection" />
</term>
<term>Null</term>
</item>
</list>
<para>
You can change the value for any of these properties through a separate call to
the property.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and
sets some of its properties.
<code lang="vbnet">
Public Sub CreateMySqlCommand()
Dim myCommand As New MySqlCommand()
myCommand.CommandType = CommandType.Text
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand()
{
MySqlCommand myCommand = new MySqlCommand();
myCommand.CommandType = CommandType.Text;
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.#ctor(System.String)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> class with the text of the query.
</summary><param name="cmdText">The text of the query.</param><remarks>
When an instance of <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> is created,
the following read/write properties are set to initial values.
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" />
</term>
<term>
<i>cmdText</i>
</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandTimeout" />
</term>
<term>0</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandType" />
</term>
<term>CommandType.Text</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.Connection" />
</term>
<term>Null</term>
</item>
</list>
<para>
You can change the value for any of these properties through a separate call to
the property.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and
sets some of its properties.
<code lang="vbnet">
Public Sub CreateMySqlCommand()
Dim sql as String = "SELECT * FROM mytable"
Dim myCommand As New MySqlCommand(sql)
myCommand.CommandType = CommandType.Text
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand()
{
string sql = "SELECT * FROM mytable";
MySqlCommand myCommand = new MySqlCommand(sql);
myCommand.CommandType = CommandType.Text;
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.#ctor(System.String,MySql.Data.MySqlClient.MySqlConnection)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> class
with the text of the query and a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />.
</summary><param name="cmdText">The text of the query.</param><param name="connection">
A <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> that represents the
connection to an instance of SQL Server.
</param><remarks>
When an instance of <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> is created,
the following read/write properties are set to initial values.
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" />
</term>
<term>
<i>cmdText</i>
</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandTimeout" />
</term>
<term>0</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandType" />
</term>
<term>CommandType.Text</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.Connection" />
</term>
<term>
<i>connection</i>
</term>
</item>
</list>
<para>
You can change the value for any of these properties through a separate call to
the property.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and
sets some of its properties.
<code lang="vbnet">
Public Sub CreateMySqlCommand()
Dim conn as new MySqlConnection("server=myServer")
Dim sql as String = "SELECT * FROM mytable"
Dim myCommand As New MySqlCommand(sql, conn)
myCommand.CommandType = CommandType.Text
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand()
{
MySqlConnection conn = new MySqlConnection("server=myserver")
string sql = "SELECT * FROM mytable";
MySqlCommand myCommand = new MySqlCommand(sql, conn);
myCommand.CommandType = CommandType.Text;
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.#ctor(System.String,MySql.Data.MySqlClient.MySqlConnection,MySql.Data.MySqlClient.MySqlTransaction)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> class
with the text of the query, a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />, and the
<see cref="T:MySql.Data.MySqlClient.MySqlTransaction" />.
</summary><param name="cmdText">The text of the query.</param><param name="connection">
A <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> that represents the
connection to an instance of SQL Server.
</param><param name="transaction">
The <see cref="T:MySql.Data.MySqlClient.MySqlTransaction" /> in which the <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> executes.
</param><remarks>
When an instance of <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> is created,
the following read/write properties are set to initial values.
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" />
</term>
<term>
<i>cmdText</i>
</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandTimeout" />
</term>
<term>0</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandType" />
</term>
<term>CommandType.Text</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.Connection" />
</term>
<term>
<i>connection</i>
</term>
</item>
</list>
<para>
You can change the value for any of these properties through a separate call to
the property.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and
sets some of its properties.
<code lang="vbnet">
Public Sub CreateMySqlCommand()
Dim conn as new MySqlConnection("server=myServer")
conn.Open();
Dim txn as MySqlTransaction = conn.BeginTransaction()
Dim sql as String = "SELECT * FROM mytable"
Dim myCommand As New MySqlCommand(sql, conn, txn)
myCommand.CommandType = CommandType.Text
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand()
{
MySqlConnection conn = new MySqlConnection("server=myserver")
conn.Open();
MySqlTransaction txn = conn.BeginTransaction();
string sql = "SELECT * FROM mytable";
MySqlCommand myCommand = new MySqlCommand(sql, conn, txn);
myCommand.CommandType = CommandType.Text;
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.LastInsertedId">
<summary>
Gets the last inserted id.
</summary>
<!-- No matching elements were found for the following include tag --><include file="docs/mysqlcommand.xml" path="docs/LastInseredId/*" />
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.CommandText">
<summary>
Gets or sets the SQL statement to execute at the data source.
</summary><value>
The SQL statement or stored procedure to execute. The default is an empty string.
</value><remarks>
<para>
When the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandType" /> property is set to <B>StoredProcedure</B>,
the <B>CommandText</B> property should be set to the name of the stored procedure.
The user may be required to use escape character syntax if the stored procedure name
contains any special characters. The command executes this stored procedure when
you call one of the Execute methods. Starting with Connector/NET 5.0, having both a stored function
and stored procedure with the same name in the same database is not supported. It is
suggested that you provide unqiue names for your stored routines.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and sets some of its properties.
<code lang="vbnet">
Public Sub CreateMySqlCommand()
Dim myCommand As New MySqlCommand()
myCommand.CommandText = "SELECT * FROM Mytable ORDER BY id"
myCommand.CommandType = CommandType.Text
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand()
{
MySqlCommand myCommand = new MySqlCommand();
myCommand.CommandText = "SELECT * FROM mytable ORDER BY id";
myCommand.CommandType = CommandType.Text;
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.CommandTimeout">
<summary>
Gets or sets the wait time before terminating the attempt to execute a command
and generating an error.
</summary><value>
The time (in seconds) to wait for the command to execute. The default is 30
seconds.
</value><remarks>
CommandTimeout is dependent on the ability of MySQL to cancel an executing query.
Because of this, CommandTimeout is only supported when connected to MySQL
version 5.0.0 or higher.
</remarks>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.CommandType">
<summary>
Gets or sets a value indicating how the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" /> property is to be interpreted.
</summary><value>
One of the <see cref="T:System.Data.CommandType" /> values. The default is <B>Text</B>.
</value><remarks>
<para>
When you set the <B>CommandType</B> property to <B>StoredProcedure</B>, you
should set the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" /> property to the name of the stored
procedure. The command executes this stored procedure when you call one of the
Execute methods.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and sets some of its properties.
<code lang="vbnet">
Public Sub CreateMySqlCommand()
Dim myCommand As New MySqlCommand()
myCommand.CommandType = CommandType.Text
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand()
{
MySqlCommand myCommand = new MySqlCommand();
myCommand.CommandType = CommandType.Text;
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.IsPrepared">
<summary>
Gets a boolean value that indicates whether the Prepared method has been called.
</summary>
<!-- No matching elements were found for the following include tag --><include file="docs/mysqlcommand.xml" path="docs/IsPrepared/*" />
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.Connection">
<summary>
Gets or sets the <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> used by this instance of the
<see cref="T:MySql.Data.MySqlClient.MySqlCommand" />.
</summary><value>
The connection to a data source. The default value is a null reference
(<B>Nothing</B> in Visual Basic).
</value><remarks>
<para>
If you set <B>Connection</B> while a transaction is in progress and the
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.Transaction" /> property is not null, an <see cref="T:System.InvalidOperationException" />
is generated. If the <B>Transaction</B> property is not null and the transaction
has already been committed or rolled back, <B>Transaction</B> is set to
null.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and sets some of its properties.
<code lang="vbnet">
Public Sub CreateMySqlCommand()
Dim mySelectQuery As String = "SELECT * FROM mytable ORDER BY id"
Dim myConnectString As String = "Persist Security Info=False;database=test;server=myServer"
Dim myCommand As New MySqlCommand(mySelectQuery)
myCommand.Connection = New MySqlConnection(myConnectString)
myCommand.CommandType = CommandType.Text
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand()
{
string mySelectQuery = "SELECT * FROM mytable ORDER BY id";
string myConnectString = "Persist Security Info=False;database=test;server=myServer";
MySqlCommand myCommand = new MySqlCommand(mySelectQuery);
myCommand.Connection = new MySqlConnection(myConnectString);
myCommand.CommandType = CommandType.Text;
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.Parameters">
<summary>
Get the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection" />
</summary><value>
The parameters of the SQL statement or stored procedure. The default is
an empty collection.
</value><remarks>
Connector/NET does not support unnamed parameters. Every parameter added to the collection must
have an associated name.
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and displays its parameters.
To accomplish this, the method is passed a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />, a query string
that is a SQL SELECT statement, and an array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter" /> objects.
<code lang="vbnet">
Public Sub CreateMySqlCommand(myConnection As MySqlConnection, _
mySelectQuery As String, myParamArray() As MySqlParameter)
Dim myCommand As New MySqlCommand(mySelectQuery, myConnection)
myCommand.CommandText = "SELECT id, name FROM mytable WHERE age=@age"
myCommand.UpdatedRowSource = UpdateRowSource.Both
myCommand.Parameters.Add(myParamArray)
Dim j As Integer
For j = 0 To myCommand.Parameters.Count - 1
myCommand.Parameters.Add(myParamArray(j))
Next j
Dim myMessage As String = ""
Dim i As Integer
For i = 0 To myCommand.Parameters.Count - 1
myMessage += myCommand.Parameters(i).ToString() & ControlChars.Cr
Next i
Console.WriteLine(myMessage)
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand(MySqlConnection myConnection, string mySelectQuery,
MySqlParameter[] myParamArray)
{
MySqlCommand myCommand = new MySqlCommand(mySelectQuery, myConnection);
myCommand.CommandText = "SELECT id, name FROM mytable WHERE age=@age";
myCommand.Parameters.Add(myParamArray);
for (int j=0; j<myParamArray.Length; j++)
{
myCommand.Parameters.Add(myParamArray[j]) ;
}
string myMessage = "";
for (int i = 0; i < myCommand.Parameters.Count; i++)
{
myMessage += myCommand.Parameters[i].ToString() + "\n";
}
MessageBox.Show(myMessage);
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.Transaction">
<summary>
Gets or sets the <see cref="T:MySql.Data.MySqlClient.MySqlTransaction" /> within which the <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> executes.
</summary><value>
The <see cref="T:MySql.Data.MySqlClient.MySqlTransaction" />. The default value is a null reference (<B>Nothing</B> in Visual Basic).
</value><remarks>
You cannot set the <B>Transaction</B> property if it is already set to a
specific value, and the command is in the process of executing. If you set the
transaction property to a <see cref="T:MySql.Data.MySqlClient.MySqlTransaction" /> object that is not connected
to the same <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> as the <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> object,
an exception will be thrown the next time you attempt to execute a statement.
</remarks>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.EnableCaching">
<summary>
Gets or sets a boolean value that indicates whether caching is enabled.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.CacheAge">
<summary>
Gets or sets the seconds for how long a TableDirect result should be cached.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.UpdatedRowSource">
<summary>
Gets or sets how command results are applied to the DataRow when used by the
Update method of the DbDataAdapter.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommand.DesignTimeVisible">
<summary>
Gets or sets a value indicating whether the command object should be visible in a Windows Form Designer control.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.Cancel">
<summary>
Attempts to cancel the execution of a currently active command
</summary>
<remarks>
Cancelling a currently active query only works with MySQL versions 5.0.0 and higher.
</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.CreateParameter">
<summary>
Creates a new instance of a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object.
</summary>
<remarks>
This method is a strongly-typed version of <see cref="M:System.Data.IDbCommand.CreateParameter"/>.
</remarks>
<returns>A <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.CheckState">
<summary>
Check the connection to make sure
- it is open
- it is not currently being used by a reader
- and we have the right version of MySQL for the requested command type
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.ExecuteNonQuery">
<summary>
Executes a SQL statement against the connection and returns the number of rows affected.
</summary><returns>Number of rows affected</returns><remarks>
You can use ExecuteNonQuery to perform any type of database operation,
however any resultsets returned will not be available. Any output parameters
used in calling a stored procedure will be populated with data and can be
retrieved after execution is complete.
For UPDATE, INSERT, and DELETE statements, the return value is the number
of rows affected by the command. For all other types of statements, the return
value is -1.
</remarks><example>
The following example creates a MySqlCommand and then
executes it using ExecuteNonQuery. The example is passed a string that is a
SQL statement (such as UPDATE, INSERT, or DELETE) and a string to use to
connect to the data source.
<code lang="vbnet">
Public Sub CreateMySqlCommand(myExecuteQuery As String, myConnection As MySqlConnection)
Dim myCommand As New MySqlCommand(myExecuteQuery, myConnection)
myCommand.Connection.Open()
myCommand.ExecuteNonQuery()
myConnection.Close()
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand(string myExecuteQuery, MySqlConnection myConnection)
{
MySqlCommand myCommand = new MySqlCommand(myExecuteQuery, myConnection);
myCommand.Connection.Open();
myCommand.ExecuteNonQuery();
myConnection.Close();
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.ResetReader">
<summary>
Reset reader to null, to avoid "There is already an open data reader"
on the next ExecuteReader(). Used in error handling scenarios.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.ResetSqlSelectLimit">
<summary>
Reset SQL_SELECT_LIMIT that could have been modified by CommandBehavior.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.ExecuteReader">
<summary>
Sends the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" /> to the <see cref="T:MySql.Data.MySqlClient.MySqlConnection">Connection</see>
and builds a <see cref="T:MySql.Data.MySqlClient.MySqlDataReader" />.
</summary><returns>
A <see cref="T:MySql.Data.MySqlClient.MySqlDataReader" /> object.
</returns><remarks>
<para>
When the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandType" /> property is set to <B>StoredProcedure</B>,
the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" /> property should be set to the name of the stored
procedure. The command executes this stored procedure when you call
<B>ExecuteReader</B>.
</para>
<para>
While the <see cref="T:MySql.Data.MySqlClient.MySqlDataReader" /> is in use, the associated
<see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> is busy serving the <B>MySqlDataReader</B>.
While in this state, no other operations can be performed on the
<B>MySqlConnection</B> other than closing it. This is the case until the
<see cref="M:MySql.Data.MySqlClient.MySqlDataReader.Close" /> method of the <B>MySqlDataReader</B> is called.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />, then executes it by
passing a string that is a SQL SELECT statement, and a string to use to connect to the
data source.
<code lang="vbnet">
Public Sub CreateMySqlDataReader(mySelectQuery As String, myConnection As MySqlConnection)
Dim myCommand As New MySqlCommand(mySelectQuery, myConnection)
myConnection.Open()
Dim myReader As MySqlDataReader
myReader = myCommand.ExecuteReader()
Try
While myReader.Read()
Console.WriteLine(myReader.GetString(0))
End While
Finally
myReader.Close
myConnection.Close
End Try
End Sub
</code>
<code lang="C#">
public void CreateMySqlDataReader(string mySelectQuery, MySqlConnection myConnection)
{
MySqlCommand myCommand = new MySqlCommand(mySelectQuery, myConnection);
myConnection.Open();
MMySqlDataReader myReader;
myReader = myCommand.ExecuteReader();
try
{
while(myReader.Read())
{
Console.WriteLine(myReader.GetString(0));
}
}
finally
{
myReader.Close();
myConnection.Close();
}
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.ExecuteReader(System.Data.CommandBehavior)">
<summary>
Sends the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" /> to the <see cref="T:MySql.Data.MySqlClient.MySqlConnection">Connection</see>,
and builds a <see cref="T:MySql.Data.MySqlClient.MySqlDataReader" /> using one of the <see cref="T:System.Data.CommandBehavior" /> values.
</summary><param name="behavior">
One of the <see cref="T:System.Data.CommandBehavior" /> values.
</param><remarks>
<para>
When the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandType" /> property is set to <B>StoredProcedure</B>,
the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandText" /> property should be set to the name of the stored
procedure. The command executes this stored procedure when you call
<B>ExecuteReader</B>.
</para>
<para>
The <see cref="T:MySql.Data.MySqlClient.MySqlDataReader" /> supports a special mode that enables large binary
values to be read efficiently. For more information, see the <B>SequentialAccess</B>
setting for <see cref="T:System.Data.CommandBehavior" />.
</para>
<para>
While the <see cref="T:MySql.Data.MySqlClient.MySqlDataReader" /> is in use, the associated
<see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> is busy serving the <B>MySqlDataReader</B>.
While in this state, no other operations can be performed on the
<B>MySqlConnection</B> other than closing it. This is the case until the
<see cref="M:MySql.Data.MySqlClient.MySqlDataReader.Close" /> method of the <B>MySqlDataReader</B> is called.
If the <B>MySqlDataReader</B> is created with <B>CommandBehavior</B> set to
<B>CloseConnection</B>, closing the <B>MySqlDataReader</B> closes the connection
automatically.
</para>
<note>
When calling ExecuteReader with the SingleRow behavior, you should be aware that using a <i>limit</i>
clause in your SQL will cause all rows (up to the limit given) to be retrieved by the client. The
<see cref="M:MySql.Data.MySqlClient.MySqlDataReader.Read" /> method will still return false after the first row but pulling all rows of data
into the client will have a performance impact. If the <i>limit</i> clause is not necessary, it should
be avoided.
</note>
</remarks><returns>
A <see cref="T:MySql.Data.MySqlClient.MySqlDataReader" /> object.
</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.ExecuteScalar">
<summary>
Executes the query, and returns the first column of the first row in the
result set returned by the query. Extra columns or rows are ignored.
</summary><returns>
The first column of the first row in the result set, or a null reference if the
result set is empty
</returns><remarks>
<para>
Use the <B>ExecuteScalar</B> method to retrieve a single value (for example,
an aggregate value) from a database. This requires less code than using the
<see cref="M:MySql.Data.MySqlClient.MySqlCommand.ExecuteReader" /> method, and then performing the operations necessary
to generate the single value using the data returned by a <see cref="T:MySql.Data.MySqlClient.MySqlDataReader" />
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and then
executes it using <B>ExecuteScalar</B>. The example is passed a string that is a
SQL statement that returns an aggregate result, and a string to use to
connect to the data source.
<code lang="vbnet">
Public Sub CreateMySqlCommand(myScalarQuery As String, myConnection As MySqlConnection)
Dim myCommand As New MySqlCommand(myScalarQuery, myConnection)
myCommand.Connection.Open()
myCommand.ExecuteScalar()
myConnection.Close()
End Sub
</code>
<code lang="C#">
public void CreateMySqlCommand(string myScalarQuery, MySqlConnection myConnection)
{
MySqlCommand myCommand = new MySqlCommand(myScalarQuery, myConnection);
myCommand.Connection.Open();
myCommand.ExecuteScalar();
myConnection.Close();
}
</code>
<code lang="C++">
public:
void CreateMySqlCommand(String* myScalarQuery, MySqlConnection* myConnection)
{
MySqlCommand* myCommand = new MySqlCommand(myScalarQuery, myConnection);
myCommand->Connection->Open();
myCommand->ExecuteScalar();
myConnection->Close();
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.Prepare(System.Int32)">
<!-- No matching elements were found for the following include tag --><include file="docs/mysqlcommand.xml" path="docs/Prepare2/*" />
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.Prepare">
<summary>
Creates a prepared version of the command on an instance of MySQL Server.
</summary><remarks>
<para>
Prepared statements are only supported on MySQL version 4.1 and higher. Calling
prepare while connected to earlier versions of MySQL will succeed but will execute
the statement in the same way as unprepared.
</para>
</remarks><example>
The following example demonstrates the use of the <b>Prepare</b> method.
<code lang="VB.NET">
public sub PrepareExample()
Dim cmd as New MySqlCommand("INSERT INTO mytable VALUES (@val)", myConnection)
cmd.Parameters.Add( "@val", 10 )
cmd.Prepare()
cmd.ExecuteNonQuery()
cmd.Parameters(0).Value = 20
cmd.ExecuteNonQuery()
end sub
</code>
<code lang="C#">
private void PrepareExample()
{
MySqlCommand cmd = new MySqlCommand("INSERT INTO mytable VALUES (@val)", myConnection);
cmd.Parameters.Add( "@val", 10 );
cmd.Prepare();
cmd.ExecuteNonQuery();
cmd.Parameters[0].Value = 20;
cmd.ExecuteNonQuery();
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.BeginExecuteReader">
<summary>
Initiates the asynchronous execution of the SQL statement or stored procedure
that is described by this <see cref="T:MySql.Data.MySqlClient.MySqlCommand"/>, and retrieves one or more
result sets from the server.
</summary>
<returns>An <see cref="T:System.IAsyncResult"/> that can be used to poll, wait for results,
or both; this value is also needed when invoking EndExecuteReader,
which returns a <see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> instance that can be used to retrieve
the returned rows. </returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.BeginExecuteReader(System.Data.CommandBehavior)">
<summary>
Initiates the asynchronous execution of the SQL statement or stored procedure
that is described by this <see cref="T:MySql.Data.MySqlClient.MySqlCommand"/> using one of the
<b>CommandBehavior</b> values.
</summary>
<param name="behavior">One of the <see cref="T:System.Data.CommandBehavior"/> values, indicating
options for statement execution and data retrieval.</param>
<returns>An <see cref="T:System.IAsyncResult"/> that can be used to poll, wait for results,
or both; this value is also needed when invoking EndExecuteReader,
which returns a <see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> instance that can be used to retrieve
the returned rows. </returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.EndExecuteReader(System.IAsyncResult)">
<summary>
Finishes asynchronous execution of a SQL statement, returning the requested
<see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/>.
</summary>
<param name="result">The <see cref="T:System.IAsyncResult"/> returned by the call to
<see cref="M:MySql.Data.MySqlClient.MySqlCommand.BeginExecuteReader"/>.</param>
<returns>A <b>MySqlDataReader</b> object that can be used to retrieve the requested rows. </returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.BeginExecuteNonQuery(System.AsyncCallback,System.Object)">
<summary>
Initiates the asynchronous execution of the SQL statement or stored procedure
that is described by this <see cref="T:MySql.Data.MySqlClient.MySqlCommand"/>.
</summary>
<param name="callback">
An <see cref="T:System.AsyncCallback"/> delegate that is invoked when the command's
execution has completed. Pass a null reference (<b>Nothing</b> in Visual Basic)
to indicate that no callback is required.</param>
<param name="stateObject">A user-defined state object that is passed to the
callback procedure. Retrieve this object from within the callback procedure
using the <see cref="P:System.IAsyncResult.AsyncState"/> property.</param>
<returns>An <see cref="T:System.IAsyncResult"/> that can be used to poll or wait for results,
or both; this value is also needed when invoking <see cref="M:MySql.Data.MySqlClient.MySqlCommand.EndExecuteNonQuery(System.IAsyncResult)"/>,
which returns the number of affected rows. </returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.BeginExecuteNonQuery">
<summary>
Initiates the asynchronous execution of the SQL statement or stored procedure
that is described by this <see cref="T:MySql.Data.MySqlClient.MySqlCommand"/>.
</summary>
<returns>An <see cref="T:System.IAsyncResult"/> that can be used to poll or wait for results,
or both; this value is also needed when invoking <see cref="M:MySql.Data.MySqlClient.MySqlCommand.EndExecuteNonQuery(System.IAsyncResult)"/>,
which returns the number of affected rows. </returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.EndExecuteNonQuery(System.IAsyncResult)">
<summary>
Finishes asynchronous execution of a SQL statement.
</summary>
<param name="asyncResult">The <see cref="T:System.IAsyncResult"/> returned by the call
to <see cref="M:MySql.Data.MySqlClient.MySqlCommand.BeginExecuteNonQuery"/>.</param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.AddCallStatement(System.String)">
<summary>
Verifies if a query is valid even if it has not spaces or is a stored procedure call
</summary>
<param name="query">Query to validate</param>
<returns>If it is necessary to add call statement</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommand.Clone">
<summary>
Creates a clone of this <see cref="T:MySql.Data.MySqlClient.MySqlCommand"/> object. CommandText, Connection, and Transaction properties
are included as well as the entire parameter list.
</summary>
<returns>The cloned <see cref="T:MySql.Data.MySqlClient.MySqlCommand"/> object.</returns>
</member>
<member name="T:MySql.Data.MySqlClient.Common.NamedPipeStream">
<summary>
Summary description for API.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.CompressedStream">
<summary>
Summary description for CompressedStream.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlConnection">
<summary>
Represents an open connection to a MySQL Server database. This class cannot be inherited.
</summary><remarks>
<para>
A <b>MySqlConnection</b> object represents a session to a MySQL Server
data source. When you create an instance of <B>MySqlConnection</B>, all
properties are set to their initial values. For a list of these values, see the
<B>MySqlConnection</B> constructor.
</para>
<para>
If the <B>MySqlConnection</B> goes out of scope, it is not closed. Therefore,
you must explicitly close the connection by calling <see cref="M:MySql.Data.MySqlClient.MySqlConnection.Close" />
or <see cref="M:MySql.Data.MySqlClient.MySqlConnection.Dispose" />.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and
a <B>MySqlConnection</B>. The <B>MySqlConnection</B> is opened and set as the
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.Connection" /> for the <B>MySqlCommand</B>. The example then calls
<see cref="M:MySql.Data.MySqlClient.MySqlCommand.ExecuteNonQuery" />, and closes the connection. To accomplish this, the <B>ExecuteNonQuery</B> is
passed a connection string and a query string that is a SQL INSERT
statement.
<code lang="vbnet">
<c>
Public Sub InsertRow(myConnectionString As String)
' If the connection string is null, use a default.
If myConnectionString = "" Then
myConnectionString = "Database=Test;Data Source=localhost;User Id=username;Password=pass"
End If
Dim myConnection As New MySqlConnection(myConnectionString)
Dim myInsertQuery As String = "INSERT INTO Orders (id, customerId, amount) Values(1001, 23, 30.66)"
Dim myCommand As New MySqlCommand(myInsertQuery)
myCommand.Connection = myConnection
myConnection.Open()
myCommand.ExecuteNonQuery()
myCommand.Connection.Close()
End Sub
</c>
</code>
<code lang="C#">
<c>
public void InsertRow(string myConnectionString)
{
// If the connection string is null, use a default.
if(myConnectionString == "")
{
myConnectionString = "Database=Test;Data Source=localhost;User Id=username;Password=pass";
}
MySqlConnection myConnection = new MySqlConnection(myConnectionString);
string myInsertQuery = "INSERT INTO Orders (id, customerId, amount) Values(1001, 23, 30.66)";
MySqlCommand myCommand = new MySqlCommand(myInsertQuery);
myCommand.Connection = myConnection;
myConnection.Open();
myCommand.ExecuteNonQuery();
myCommand.Connection.Close();
}
</c>
</code>
</example>
</member>
<member name="E:MySql.Data.MySqlClient.MySqlConnection.InfoMessage">
<summary>Occurs when MySQL returns warnings as a result of executing a command or query.</summary><remarks>
</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.#ctor">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> class.
</summary><remarks>
When a new instance of <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> is created, the read/write
properties are set to the following initial values unless they are specifically
set using their associated keywords in the <see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString" /> property.
<para />
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString" />
</term>
<term>empty string ("")</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionTimeout" />
</term>
<term>15</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.Database" />
</term>
<term>empty string ("")</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.DataSource" />
</term>
<term>empty string ("")</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.ServerVersion" />
</term>
<term>empty string ("")</term>
</item>
</list>
<para />
You can change the value for these properties only by using the <B>ConnectionString</B> property.
</remarks><example>
</example><overloads>
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> class.
</summary>
</overloads>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.#ctor(System.String)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> class when given a string containing the connection string.
</summary><remarks>
When a new instance of <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> is created, the read/write
properties are set to the following initial values unless they are specifically
set using their associated keywords in the <see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString" /> property.
<para />
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString" />
</term>
<term>empty string ("")</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionTimeout" />
</term>
<term>15</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.Database" />
</term>
<term>empty string ("")</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.DataSource" />
</term>
<term>empty string ("")</term>
</item>
<item>
<term>
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.ServerVersion" />
</term>
<term>empty string ("")</term>
</item>
</list>
<para />
You can change the value for these properties only by using the <B>ConnectionString</B> property.
</remarks><example>
</example><param name="connectionString">The connection properties used to open the MySQL database. </param>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.ServerThread">
<summary>
Returns the id of the server thread this connection is executing on
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.DataSource">
<summary>
Gets the name of the MySQL server to which to connect.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionTimeout">
<summary>
Gets the time to wait while trying to establish a connection before terminating the attempt and generating an error.
</summary><exception cref="T:System.ArgumentException">The value set is less than 0.</exception><remarks>
A value of 0 indicates no limit, and should be avoided in a
<see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString" /> because an attempt to connect
will wait indefinitely.
</remarks><example>
The following example creates a MySqlConnection
and sets some of its properties in the connection string.
<code lang="vbnet">
Public Sub CreateSqlConnection()
Dim myConnection As New MySqlConnection()
myConnection.ConnectionString = "Persist Security Info=False;Username=user;Password=pass;database=test1;server=localhost;Connect Timeout=30"
myConnection.Open()
End Sub
</code>
<code lang="C#">
public void CreateSqlConnection()
{
MySqlConnection myConnection = new MySqlConnection();
myConnection.ConnectionString = "Persist Security Info=False;Username=user;Password=pass;database=test1;server=localhost;Connect Timeout=30";
myConnection.Open();
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.Database">
<summary>Gets the name of the current database or the database to be used after a connection is opened.</summary><returns>The name of the current database or the name of the database to be used after a connection is opened. The default value is an empty string.</returns><remarks>
<para>
The <B>Database</B> property does not update dynamically.
If you change the current database using a SQL statement, then this property
may reflect the wrong value. If you change the current database using the <see cref="M:MySql.Data.MySqlClient.MySqlConnection.ChangeDatabase(System.String)" />
method, this property is updated to reflect the new database.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> and displays
some of its read-only properties.
<code lang="vbnet">
Public Sub CreateMySqlConnection()
Dim myConnString As String = _
"Persist Security Info=False;database=test;server=localhost;user id=joeuser;pwd=pass"
Dim myConnection As New MySqlConnection( myConnString )
myConnection.Open()
MessageBox.Show( "Server Version: " + myConnection.ServerVersion _
+ ControlChars.NewLine + "Database: " + myConnection.Database )
myConnection.ChangeDatabase( "test2" )
MessageBox.Show( "ServerVersion: " + myConnection.ServerVersion _
+ ControlChars.NewLine + "Database: " + myConnection.Database )
myConnection.Close()
End Sub
</code>
<code lang="C#">
public void CreateMySqlConnection()
{
string myConnString =
"Persist Security Info=False;database=test;server=localhost;user id=joeuser;pwd=pass";
MySqlConnection myConnection = new MySqlConnection( myConnString );
myConnection.Open();
MessageBox.Show( "Server Version: " + myConnection.ServerVersion
+ "\nDatabase: " + myConnection.Database );
myConnection.ChangeDatabase( "test2" );
MessageBox.Show( "ServerVersion: " + myConnection.ServerVersion
+ "\nDatabase: " + myConnection.Database );
myConnection.Close();
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.UseCompression">
<summary>
Indicates if this connection should use compression when communicating with the server.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.State">
<summary>Gets the current state of the connection.</summary><returns>
A bitwise combination of the <see cref="T:System.Data.ConnectionState" /> values. The default is <B>Closed</B>.
</returns><remarks>
The allowed state changes are:
<list type="bullet">
<item>
From <B>Closed</B> to <B>Open</B>, using the <B>Open</B> method of the connection object.
</item>
<item>
From <B>Open</B> to <B>Closed</B>, using either the <B>Close</B> method or the <B>Dispose</B> method of the connection object.
</item>
</list>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />, opens it,
displays some of its properties, then closes the connection.
<code lang="vbnet">
Public Sub CreateMySqlConnection(myConnString As String)
Dim myConnection As New MySqlConnection(myConnString)
myConnection.Open()
MessageBox.Show("ServerVersion: " + myConnection.ServerVersion _
+ ControlChars.Cr + "State: " + myConnection.State.ToString())
myConnection.Close()
End Sub
</code>
<code lang="C#">
public void CreateMySqlConnection(string myConnString)
{
MySqlConnection myConnection = new MySqlConnection(myConnString);
myConnection.Open();
MessageBox.Show("ServerVersion: " + myConnection.ServerVersion +
"\nState: " + myConnection.State.ToString());
myConnection.Close();
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.ServerVersion">
<summary>Gets a string containing the version of the MySQL server to which the client is connected.</summary><returns>The version of the instance of MySQL.</returns><exception cref="T:System.InvalidOperationException">The connection is closed.</exception><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />, opens it,
displays some of its properties, then closes the connection.
<code lang="vbnet">
Public Sub CreateMySqlConnection(myConnString As String)
Dim myConnection As New MySqlConnection(myConnString)
myConnection.Open()
MessageBox.Show("ServerVersion: " + myConnection.ServerVersion _
+ ControlChars.Cr + "State: " + myConnection.State.ToString())
myConnection.Close()
End Sub
</code>
<code lang="C#">
public void CreateMySqlConnection(string myConnString)
{
MySqlConnection myConnection = new MySqlConnection(myConnString);
myConnection.Open();
MessageBox.Show("ServerVersion: " + myConnection.ServerVersion +
"\nState: " + myConnection.State.ToString());
myConnection.Close();
}
</code>
</example>#if !NETSTANDARD1_6
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString">
<summary>
Gets or sets the string used to connect to a MySQL Server database.
</summary><remarks>
<para>
The <B>ConnectionString</B> returned may not be exactly like what was originally
set but will be indentical in terms of keyword/value pairs. Security information
will not be included unless the Persist Security Info value is set to true.
</para>
<para>
You can use the <B>ConnectionString</B> property to connect to a database.
The following example illustrates a typical connection string.
</para>
<c>"Persist Security Info=False;database=MyDB;server=MySqlServer;user id=myUser;Password=myPass"</c>
<para>
The <B>ConnectionString</B> property can be set only when the connection is
closed. Many of the connection string values have corresponding read-only
properties. When the connection string is set, all of these properties are
updated, except when an error is detected. In this case, none of the properties
are updated. <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> properties return only those settings contained in the
<B>ConnectionString</B>.
</para>
<para>
To connect to a local machine, specify "localhost" for the server. If you do not
specify a server, localhost is assumed.
</para>
<para>
Resetting the <B>ConnectionString</B> on a closed connection resets all
connection string values (and related properties) including the password. For
example, if you set a connection string that includes "Database= MyDb", and
then reset the connection string to "Data Source=myserver;User Id=myUser;Password=myPass",
the <see cref="P:MySql.Data.MySqlClient.MySqlConnection.Database" /> property is no longer set to MyDb.
</para>
<para>
The connection string is parsed immediately after being set. If errors in
syntax are found when parsing, a runtime exception, such as <see cref="T:System.ArgumentException" />,
is generated. Other errors can be found only when an attempt is made to open the
connection.
</para>
<para>
The basic format of a connection string consists of a series of keyword/value
pairs separated by semicolons. The equal sign (=) connects each keyword and its
value. To include values that contain a semicolon, single-quote character, or
double-quote character, the value must be enclosed in double quotes. If the
value contains both a semicolon and a double-quote character, the value can be
enclosed in single quotes. The single quote is also useful if the value begins
with a double-quote character. Conversely, the double quote can be used if the
value begins with a single quote. If the value contains both single-quote and
double-quote characters, the quote character used to enclose the value must be
doubled each time it occurs within the value.
</para>
<para>
To include preceding or trailing spaces in the string value, the value must
be enclosed in either single quotes or double quotes. Any leading or trailing
spaces around integer, Boolean, or enumerated values are ignored, even if
enclosed in quotes. However, spaces within a string literal keyword or value are
preserved. Using .NET Framework version 1.1, single or double quotes may be used
within a connection string without using delimiters (for example, Data Source=
my'Server or Data Source= my"Server), unless a quote character is the first or
last character in the value.
</para>
<para>
To include an equal sign (=) in a keyword or value, it must be preceded by
another equal sign. For example, in the hypothetical connection string
</para>
<c>"key==word=value"</c>
<para />
<para>the keyword is "key=word" and the value is "value".</para>
<para>
If a specific keyword in a keyword= value pair occurs multiple times in a
connection string, the last occurrence listed is used in the value set.
</para>
<para>Keywords are not case sensitive.</para>
<para>
The following table lists the valid names for keyword values within the
<B>ConnectionString</B>.
</para>
<div class="tablediv">
<table class="dtTABLE" cellspacing="0">
<tr valign="top">
<th width="33%">Name</th>
<th width="33%">Default</th>
<th width="33%">Description</th>
</tr>
<tr>
<td>
Connect Timeout<para> -or- </para>Connection Timeout
</td>
<td>15</td>
<td>
The length of time (in seconds) to wait for a connection to the server before
terminating the attempt and generating an error.
</td>
</tr>
<tr>
<td>
Host<para> -or- </para>Server<para> -or- </para>Data Source<para> -or- </para>
DataSource<para> -or- </para>Address<para> -or- </para>Addr<para> -or- </para>
Network Address
</td>
<td>localhost</td>
<td>
<para>
The name or network address of the instance of MySQL to which to connect. Multiple hosts can be
specified separated by &. This can be useful where multiple MySQL servers are configured for replication
and you are not concerned about the precise server you are connecting to. No attempt is made by the provider to
synchronize writes to the database so care should be taken when using this option.
</para>
<para>
In Unix environment with Mono, this can be a fully qualified path to MySQL socket filename. With this configuration, the Unix socket will be used instead of TCP/IP socket.
Currently only a single socket name can be given so accessing MySQL in a replicated environment using Unix sockets is not currently supported.
</para>
</td>
</tr>
<tr>
<td>Port</td>
<td>3306</td>
<td>
The port MySQL is using to listen for connections. This value is ignored if the connection protocol
is anything but socket.
</td>
</tr>
<tr>
<td>Protocol</td>
<td>socket</td>
<td>
Specifies the type of connection to make to the server.<para>Values can be:</para>
socket or tcp for a socket connection<br />
pipe for a named pipe connection<br />
unix for a Unix socket connection<br />
memory to use MySQL shared memory
</td>
</tr>
<tr>
<td>
CharSet<para> -or </para>Character Set
</td>
<td />
<td>
Specifies the character set that should be used to encode all queries sent to the server.
Resultsets are still returned in the character set of the data returned.
</td>
</tr>
<tr>
<td>Logging</td>
<td>false</td>
<td>When true, various pieces of information is output to any configured TraceListeners.</td>
</tr>
<tr>
<td>Allow Batch</td>
<td>true</td>
<td>
When true, multiple SQL statements can be sent with one command execution.<br /><br />
-Note-<br />
Starting with MySQL 4.1.1, batch statements should be separated by the server-defined seperator character.<br />
Commands sent to earlier versions of MySQL should be seperated with ';'.
</td>
</tr>
<tr>
<td>Encrypt</td>
<td>false</td>
<td>
When <B>true</B>, SSL/TLS encryption is used for all data sent between the
client and server if the server has a certificate installed. Recognized values
are <B>true</B>, <B>false</B>, <B>yes</B>, and <B>no</B>.
</td>
</tr>
<tr>
<td>
Initial Catalog<para> -or- </para>Database
</td>
<td>mysql</td>
<td>The name of the database to use intially</td>
</tr>
<tr>
<td>
Password<para> -or- </para>pwd
</td>
<td />
<td>The password for the MySQL account being used.</td>
</tr>
<tr>
<td>Persist Security Info</td>
<td>false</td>
<td>
When set to <B>false</B> or <B>no</B> (strongly recommended), security-sensitive
information, such as the password, is not returned as part of the connection if
the connection is open or has ever been in an open state. Resetting the
connection string resets all connection string values including the password.
Recognized values are <B>true</B>, <B>false</B>, <B>yes</B>, and <B>no</B>.
</td>
</tr>
<tr>
<td>
User Id<para> -or- </para>Username<para> -or- </para>Uid<para> -or- </para>User name
</td>
<td />
<td>The MySQL login account being used.</td>
</tr>
<tr>
<td>Shared Memory Name</td>
<td>MYSQL</td>
<td>The name of the shared memory object to use for communication if the connection protocol is set to memory.</td>
</tr>
<tr>
<td>Allow Zero Datetime</td>
<td>false</td>
<td>
True to have MySqlDataReader.GetValue() return a MySqlDateTime for date or datetime columns that have illegal values.
False will cause a DateTime object to be returned for legal values and an exception will be thrown for illegal values.
</td>
</tr>
<tr>
<td>Convert Zero Datetime</td>
<td>false</td>
<td>
True to have MySqlDataReader.GetValue() and MySqlDataReader.GetDateTime()
return DateTime.MinValue for date or datetime columns that have illegal values.
</td>
</tr>
<tr>
<td>
Pipe Name<para> -or- </para>Pipe
</td>
<td>mysql</td>
<td>
When set to the name of a named pipe, the <B>MySqlConnection</B> will attempt to connect to MySQL
on that named pipe.<br /><br />This settings only applies to the Windows platform.
</td>
</tr>
<tr>
<td>
Use Performance Monitor<para> -or- </para>UsePerformanceMonitor
</td>
<td>false</td>
<td>
Posts performance data that can be tracked using perfmon
</td>
</tr>
<tr>
<td>
Procedure Cache Size
</td>
<td>25</td>
<td>
How many stored procedure definitions can be held in the cache
</td>
</tr>
<tr>
<td>
Ignore Prepare
</td>
<td>true</td>
<td>
Instructs the provider to ignore any attempts to prepare commands. This option
was added to allow a user to disable prepared statements in an entire application
without modifying the code. A user might want to do this if errors or bugs are
encountered with MySQL prepared statements.
</td>
</tr>
<tr>
<td>Use Procedure Bodies</td>
<td>true</td>
<td>
Instructs the provider to attempt to call the procedure without first resolving the metadata. This
is useful in situations where the calling user does not have access to the mysql.proc table. To
use this mode, the parameters for the procedure must be added to the command in the same order
as they appear in the procedure definition and their types must be explicitly set.
</td>
</tr>
<tr>
<td>Auto Enlist</td>
<td>true</td>
<td>
Indicates whether the connection should automatically enlist in the current transaction,
if there is one.
</td>
</tr>
<tr>
<td>Respect Binary Flags</td>
<td>true</td>
<td>
Indicates whether the connection should respect all binary flags sent to the client
as part of column metadata. False will cause the connector to behave like
Connector/NET 5.0 and earlier.
</td>
</tr>
<tr>
<td>BlobAsUTF8IncludePattern</td>
<td>null</td>
<td>
Pattern that should be used to indicate which blob columns should be treated as UTF-8.
</td>
</tr>
<tr>
<td>BlobAsUTF8ExcludePattern</td>
<td>null</td>
<td>
Pattern that should be used to indicate which blob columns should not be treated as UTF-8.
</td>
</tr>
<tr>
<td>Default Command Timeout</td>
<td>30</td>
<td>
The default timeout that new MySqlCommand objects will use unless changed.
</td>
</tr>
<tr>
<td>Allow User Variables</td>
<td>false</td>
<td>
Should the provider expect user variables in the SQL.
</td>
</tr>
<tr>
<td>Interactive -or- Interactive Session</td>
<td>false</td>
<td>
Should this session be considered interactive?
</td>
</tr>
<tr>
<td>Functions Return String</td>
<td>false</td>
<td>
Set this option to true to force the return value of SQL functions to be string.
</td>
</tr>
<tr>
<td>Use Affected Rows</td>
<td>false</td>
<td>
Set this option to true to cause the affected rows reported to reflect only the
rows that are actually changed. By default, the number of rows that are matched
is returned.
</td>
</tr>
</table>
</div>
<para>
The following table lists the valid names for connection pooling values within
the <B>ConnectionString</B>. For more information about connection pooling, see
Connection Pooling for the MySql Data Provider.
</para>
<div class="tablediv">
<table class="dtTABLE" cellspacing="0">
<tr valign="top">
<th width="33%">Name</th>
<th width="33%">Default</th>
<th width="33%">Description</th>
</tr>
<tr>
<td>Connection Lifetime</td>
<td>0</td>
<td>
When a connection is returned to the pool, its creation time is compared with
the current time, and the connection is destroyed if that time span (in seconds)
exceeds the value specified by <B>Connection Lifetime</B>. This is useful in
clustered configurations to force load balancing between a running server and a
server just brought online.
<para>
A value of zero (0) causes pooled connections to have the maximum connection
timeout.
</para>
</td>
</tr>
<tr>
<td>Max Pool Size</td>
<td>100</td>
<td>The maximum number of connections allowed in the pool.</td>
</tr>
<tr>
<td>Min Pool Size</td>
<td>0</td>
<td>The minimum number of connections allowed in the pool.</td>
</tr>
<tr>
<td>Pooling</td>
<td>true</td>
<td>
When <B>true</B>, the <B>MySqlConnection</B> object is drawn from the appropriate
pool, or if necessary, is created and added to the appropriate pool. Recognized
values are <B>true</B>, <B>false</B>, <B>yes</B>, and <B>no</B>.
</td>
</tr>
<tr>
<td>Connection Reset</td>
<td>false</td>
<td>
Specifies whether the database connection should be reset when being
drawn from the pool. Leaving this as <b>false</b> will yeild much faster
connection opens but the user should understand the side effects
of doing this such as temporary tables and user variables from the previous
session not being cleared out.
</td>
</tr>
<tr>
<td>Cache Server Properties</td>
<td>false</td>
<td>
Specifies whether the server variables are cached between pooled connections.
On systems where the variables change infrequently and there are lots of
connection attempts, this can speed up things dramatically.
</td>
</tr>
</table>
</div>
<para>
When setting keyword or connection pooling values that require a Boolean
value, you can use 'yes' instead of 'true', and 'no' instead of 'false'.
</para>
<para>
<B>Note</B> The MySql Data Provider uses the native socket protocol to
communicate with MySQL. Therefore, it does not support the use of an ODBC data source name (DSN) when
connecting to MySQL because it does not add an ODBC layer.
</para>
<para>
<B>CAUTION</B> In this release, the application should use caution when constructing a
connection string based on user input (for example when retrieving user ID and password information from a
dialog box, and appending it to the connection string). The application should
ensure that a user cannot embed extra connection string parameters in these
values (for example, entering a password as "validpassword;database=somedb" in
an attempt to attach to a different database).
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> and sets some of its properties
<code lang="vbnet">
Public Sub CreateConnection()
Dim myConnection As New MySqlConnection()
myConnection.ConnectionString = "Persist Security Info=False;database=myDB;server=myHost;Connect Timeout=30;user id=myUser; pwd=myPass"
myConnection.Open()
End Sub 'CreateConnection
</code>
<code lang="C#">
public void CreateConnection()
{
MySqlConnection myConnection = new MySqlConnection();
myConnection.ConnectionString = "Persist Security Info=False;database=myDB;server=myHost;Connect Timeout=30;user id=myUser; pwd=myPass";
myConnection.Open();
}
</code>
</example><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> in Unix environment with Mono installed. MySQL socket filename used in this example is "/var/lib/mysql/mysql.sock". The actual filename depends on your MySQL configuration.
<code lang="vbnet">
Public Sub CreateConnection()
Dim myConnection As New MySqlConnection()
myConnection.ConnectionString = "database=myDB;server=/var/lib/mysql/mysql.sock;user id=myUser; pwd=myPass"
myConnection.Open()
End Sub 'CreateConnection
</code>
<code lang="C#">
public void CreateConnection()
{
MySqlConnection myConnection = new MySqlConnection();
myConnection.ConnectionString = "database=myDB;server=/var/lib/mysql/mysql.sock;user id=myUser; pwd=myPass";
myConnection.Open();
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConnection.IsPasswordExpired">
<summary>
Gets a boolean value that indicates whether the password associated to the connection is expired.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.BeginTransaction">
<summary>Begins a database transaction.</summary><returns>An object representing the new transaction.</returns><exception cref="T:System.InvalidOperationException">Parallel transactions are not supported.</exception><remarks>
<para>This command is equivalent to the MySQL BEGIN TRANSACTION command.</para>
<para>
You must explicitly commit or roll back the transaction using the <see cref="M:MySql.Data.MySqlClient.MySqlTransaction.Commit" /> or
<see cref="M:MySql.Data.MySqlClient.MySqlTransaction.Rollback" /> method.
<note>
If you do not specify an isolation level, the default isolation level is used. To specify an isolation
level with the <see cref="M:MySql.Data.MySqlClient.MySqlConnection.BeginTransaction" /> method, use the overload that takes the <I>iso</I> parameter. Also
note that any attempt to begin a transaction while a transaction is in progress will throw an exception on MySQL 4.1 and higher.
On MySQL 4.0, an exception will not be thrown because servers 4.0 and earlier did not report their transacation status.
</note>
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> and a
<see cref="T:MySql.Data.MySqlClient.MySqlTransaction" />. It also demonstrates how to use the <B>BeginTransaction</B>, a
<see cref="M:MySql.Data.MySqlClient.MySqlTransaction.Commit" />, and <see cref="M:MySql.Data.MySqlClient.MySqlTransaction.Rollback" /> methods.
<code lang="vbnet">
Public Sub RunTransaction(myConnString As String)
Dim myConnection As New MySqlConnection(myConnString)
myConnection.Open()
Dim myCommand As MySqlCommand = myConnection.CreateCommand()
Dim myTrans As MySqlTransaction
' Start a local transaction
myTrans = myConnection.BeginTransaction()
' Must assign both transaction object and connection
' to Command object for a pending local transaction
myCommand.Connection = myConnection
myCommand.Transaction = myTrans
Try
myCommand.CommandText = "Insert into Test (id, desc) VALUES (100, 'Description')"
myCommand.ExecuteNonQuery()
myCommand.CommandText = "Insert into Test (id, desc) VALUES (101, 'Description')"
myCommand.ExecuteNonQuery()
myTrans.Commit()
Console.WriteLine("Both records are written to database.")
Catch e As Exception
Try
myTrans.Rollback()
Catch ex As MySqlException
If Not myTrans.Connection Is Nothing Then
Console.WriteLine("An exception of type " + ex.GetType().ToString() + _
" was encountered while attempting to roll back the transaction.")
End If
End Try
Console.WriteLine("An exception of type " + e.GetType().ToString() + _
"was encountered while inserting the data.")
Console.WriteLine("Neither record was written to database.")
Finally
myConnection.Close()
End Try
End Sub
</code>
<code lang="C#">
public void RunTransaction(string myConnString)
{
MySqlConnection myConnection = new MySqlConnection(myConnString);
myConnection.Open();
MySqlCommand myCommand = myConnection.CreateCommand();
MySqlTransaction myTrans;
// Start a local transaction
myTrans = myConnection.BeginTransaction();
// Must assign both transaction object and connection
// to Command object for a pending local transaction
myCommand.Connection = myConnection;
myCommand.Transaction = myTrans;
try
{
myCommand.CommandText = "insert into Test (id, desc) VALUES (100, 'Description')";
myCommand.ExecuteNonQuery();
myCommand.CommandText = "insert into Test (id, desc) VALUES (101, 'Description')";
myCommand.ExecuteNonQuery();
myTrans.Commit();
Console.WriteLine("Both records are written to database.");
}
catch(Exception e)
{
try
{
myTrans.Rollback();
}
catch (SqlException ex)
{
if (myTrans.Connection != null)
{
Console.WriteLine("An exception of type " + ex.GetType() +
" was encountered while attempting to roll back the transaction.");
}
}
Console.WriteLine("An exception of type " + e.GetType() +
" was encountered while inserting the data.");
Console.WriteLine("Neither record was written to database.");
}
finally
{
myConnection.Close();
}
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.BeginTransaction(System.Data.IsolationLevel)">
<summary>Begins a database transaction with the specified isolation level.</summary><param name="iso">The isolation level under which the transaction should run. </param><returns>An object representing the new transaction.</returns><exception cref="T:System.InvalidOperationException">Parallel exceptions are not supported.</exception><remarks>
<para>This command is equivalent to the MySQL BEGIN TRANSACTION command.</para>
<para>
You must explicitly commit or roll back the transaction using the <see cref="M:MySql.Data.MySqlClient.MySqlTransaction.Commit" /> or
<see cref="M:MySql.Data.MySqlClient.MySqlTransaction.Rollback" /> method.
<note>
If you do not specify an isolation level, the default isolation level is used. To specify an isolation
level with the <see cref="M:MySql.Data.MySqlClient.MySqlConnection.BeginTransaction" /> method, use the overload that takes the <I>iso</I> parameter.
Also note that any attempt to begin a transaction while a transaction is in progress will throw an exception on MySQL 4.1 and higher.
On MySQL 4.0, an exception will not be thrown because servers 4.0 and earlier did not report their transacation status.
</note>
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> and a
<see cref="T:MySql.Data.MySqlClient.MySqlTransaction" />. It also demonstrates how to use the <B>BeginTransaction</B>, a
<see cref="M:MySql.Data.MySqlClient.MySqlTransaction.Commit" />, and <see cref="M:MySql.Data.MySqlClient.MySqlTransaction.Rollback" /> methods.
<code lang="vbnet">
Public Sub RunTransaction(myConnString As String)
Dim myConnection As New MySqlConnection(myConnString)
myConnection.Open()
Dim myCommand As MySqlCommand = myConnection.CreateCommand()
Dim myTrans As MySqlTransaction
' Start a local transaction
myTrans = myConnection.BeginTransaction()
' Must assign both transaction object and connection
' to Command object for a pending local transaction
myCommand.Connection = myConnection
myCommand.Transaction = myTrans
Try
myCommand.CommandText = "Insert into Test (id, desc) VALUES (100, 'Description')"
myCommand.ExecuteNonQuery()
myCommand.CommandText = "Insert into Test (id, desc) VALUES (101, 'Description')"
myCommand.ExecuteNonQuery()
myTrans.Commit()
Console.WriteLine("Both records are written to database.")
Catch e As Exception
Try
myTrans.Rollback()
Catch ex As MySqlException
If Not myTrans.Connection Is Nothing Then
Console.WriteLine("An exception of type " + ex.GetType().ToString() + _
" was encountered while attempting to roll back the transaction.")
End If
End Try
Console.WriteLine("An exception of type " + e.GetType().ToString() + _
"was encountered while inserting the data.")
Console.WriteLine("Neither record was written to database.")
Finally
myConnection.Close()
End Try
End Sub
</code>
<code lang="C#">
public void RunTransaction(string myConnString)
{
MySqlConnection myConnection = new MySqlConnection(myConnString);
myConnection.Open();
MySqlCommand myCommand = myConnection.CreateCommand();
MySqlTransaction myTrans;
// Start a local transaction
myTrans = myConnection.BeginTransaction();
// Must assign both transaction object and connection
// to Command object for a pending local transaction
myCommand.Connection = myConnection;
myCommand.Transaction = myTrans;
try
{
myCommand.CommandText = "insert into Test (id, desc) VALUES (100, 'Description')";
myCommand.ExecuteNonQuery();
myCommand.CommandText = "insert into Test (id, desc) VALUES (101, 'Description')";
myCommand.ExecuteNonQuery();
myTrans.Commit();
Console.WriteLine("Both records are written to database.");
}
catch(Exception e)
{
try
{
myTrans.Rollback();
}
catch (SqlException ex)
{
if (myTrans.Connection != null)
{
Console.WriteLine("An exception of type " + ex.GetType() +
" was encountered while attempting to roll back the transaction.");
}
}
Console.WriteLine("An exception of type " + e.GetType() +
" was encountered while inserting the data.");
Console.WriteLine("Neither record was written to database.");
}
finally
{
myConnection.Close();
}
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ChangeDatabase(System.String)">
<summary>Changes the current database for an open MySqlConnection.</summary><param name="databaseName">The name of the database to use.</param><remarks>
<para>
The value supplied in the <I>database</I> parameter must be a valid database
name. The <I>database</I> parameter cannot contain a null value, an empty
string, or a string with only blank characters.
</para>
<para>
When you are using connection pooling against MySQL, and you close
the connection, it is returned to the connection pool. The next time the
connection is retrieved from the pool, the reset connection request
executes before the user performs any operations.
</para>
</remarks><exception cref="T:System.ArgumentException">The database name is not valid.</exception><exception cref="T:System.InvalidOperationException">The connection is not open.</exception><exception cref="T:MySql.Data.MySqlClient.MySqlException">Cannot change the database.</exception><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> and displays
some of its read-only properties.
<code lang="vbnet">
Public Sub CreateMySqlConnection()
Dim myConnString As String = _
"Persist Security Info=False;database=test;server=localhost;user id=joeuser;pwd=pass"
Dim myConnection As New MySqlConnection( myConnString )
myConnection.Open()
MessageBox.Show( "Server Version: " + myConnection.ServerVersion _
+ ControlChars.NewLine + "Database: " + myConnection.Database )
myConnection.ChangeDatabase( "test2" )
MessageBox.Show( "ServerVersion: " + myConnection.ServerVersion _
+ ControlChars.NewLine + "Database: " + myConnection.Database )
myConnection.Close()
End Sub
</code>
<code lang="C#">
public void CreateMySqlConnection()
{
string myConnString =
"Persist Security Info=False;database=test;server=localhost;user id=joeuser;pwd=pass";
MySqlConnection myConnection = new MySqlConnection( myConnString );
myConnection.Open();
MessageBox.Show( "Server Version: " + myConnection.ServerVersion
+ "\nDatabase: " + myConnection.Database );
myConnection.ChangeDatabase( "test2" );
MessageBox.Show( "ServerVersion: " + myConnection.ServerVersion
+ "\nDatabase: " + myConnection.Database );
myConnection.Close();
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.Ping">
<summary>
Pings the server.
</summary>
<returns><c>true</c> if the ping was successful; otherwise, <c>false</c>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.Open">
<summary>Opens a database connection with the property settings specified by the ConnectionString.</summary><exception cref="T:System.InvalidOperationException">Cannot open a connection without specifying a data source or server.</exception><exception cref="T:MySql.Data.MySqlClient.MySqlException">A connection-level error occurred while opening the connection.</exception><remarks>
<para>
The <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> draws an open connection from the connection pool if one is available.
Otherwise, it establishes a new connection to an instance of MySQL.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />, opens it,
displays some of its properties, then closes the connection.
<code lang="vbnet">
Public Sub CreateMySqlConnection(myConnString As String)
Dim myConnection As New MySqlConnection(myConnString)
myConnection.Open()
MessageBox.Show("ServerVersion: " + myConnection.ServerVersion _
+ ControlChars.Cr + "State: " + myConnection.State.ToString())
myConnection.Close()
End Sub
</code>
<code lang="C#">
public void CreateMySqlConnection(string myConnString)
{
MySqlConnection myConnection = new MySqlConnection(myConnString);
myConnection.Open();
MessageBox.Show("ServerVersion: " + myConnection.ServerVersion +
"\nState: " + myConnection.State.ToString());
myConnection.Close();
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.CreateCommand">
<summary>
Creates and returns a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> object associated with the <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />.
</summary><returns>
A <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> object.
</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.Close">
<summary>Closes the connection to the database. This is the preferred method of closing any open connection.</summary><remarks>
<para>
The <B>Close</B> method rolls back any pending transactions. It then releases
the connection to the connection pool, or closes the connection if connection
pooling is disabled.
</para>
<para>
An application can call <B>Close</B> more than one time. No exception is
generated.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />, opens it,
displays some of its properties, then closes the connection.
<code lang="vbnet">
Public Sub CreateMySqlConnection(myConnString As String)
Dim myConnection As New MySqlConnection(myConnString)
myConnection.Open()
MessageBox.Show("ServerVersion: " + myConnection.ServerVersion _
+ ControlChars.Cr + "State: " + myConnection.State.ToString())
myConnection.Close()
End Sub
</code>
<code lang="C#">
public void CreateMySqlConnection(string myConnString)
{
MySqlConnection myConnection = new MySqlConnection(myConnString);
myConnection.Open();
MessageBox.Show("ServerVersion: " + myConnection.ServerVersion +
"\nState: " + myConnection.State.ToString());
myConnection.Close();
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.CancelQuery(System.Int32)">
<summary>
Cancels the query after the specified time interval.
</summary>
<param name="timeout">The length of time (in seconds) to wait for the cancelation of the command execution.</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.SetCommandTimeout(System.Int32)">
<summary>
Sets query timeout. If timeout has been set prior and not
yet cleared ClearCommandTimeout(), it has no effect.
</summary>
<param name="value">timeout in seconds</param>
<returns>true if </returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ClearCommandTimeout">
<summary>
Clears query timeout, allowing next SetCommandTimeout() to succeed.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.GetSchemaCollection(System.String,System.String[])">
<summary>
Gets a schema collection based on the provided restriction values.
</summary>
<param name="collectionName">The name of the collection.</param>
<param name="restrictionValues">The values to restrict.</param>
<returns>A schema collection object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ClearPool(MySql.Data.MySqlClient.MySqlConnection)">
<summary>Empties the connection pool associated with the specified connection.</summary><param name="connection">
The <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> associated with the pool to be cleared.
</param><remarks>
<para>
ClearPool clears the connection pool that is associated with the connection.
If additional connections associated with connection are in use at the time of the call,
they are marked appropriately and are discarded (instead of being returned to the pool)
when Close is called on them.
</para>
</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ClearAllPools">
<summary>Clears all connection pools.</summary><remarks>
<para>
ClearAllPools essentially performs a <see cref="M:MySql.Data.MySqlClient.MySqlConnection.ClearPool(MySql.Data.MySqlClient.MySqlConnection)" /> on all current connection
pools.
</para>
</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.BeginTransactionAsync">
<summary>
Initiates the asynchronous execution of a transaction.
</summary>
<returns>An object representing the new transaction.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.BeginTransactionAsync(System.Threading.CancellationToken)">
<summary>
Asynchronous version of BeginTransaction.
</summary>
<param name="cancellationToken">The cancellation token.</param>
<returns>An object representing the new transaction.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.BeginTransactionAsync(System.Data.IsolationLevel)">
<summary>
Asynchronous version of BeginTransaction.
</summary>
<param name="iso">The isolation level under which the transaction should run. </param>
<returns>An object representing the new transaction.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.BeginTransactionAsync(System.Data.IsolationLevel,System.Threading.CancellationToken)">
<summary>
Asynchronous version of BeginTransaction.
</summary>
<param name="iso">The isolation level under which the transaction should run. </param>
<param name="cancellationToken">The cancellation token.</param>
<returns>An object representing the new transaction.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ChangeDataBaseAsync(System.String)">
<summary>
Asynchronous version of the ChangeDataBase method.
</summary>
<param name="databaseName">The name of the database to use.</param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ChangeDataBaseAsync(System.String,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the ChangeDataBase method.
</summary>
<param name="databaseName">The name of the database to use.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.CloseAsync">
<summary>
Asynchronous version of the Close method.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.CloseAsync(System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Close method.
</summary>
<param name="cancellationToken">The cancellation token.</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ClearPoolAsync(MySql.Data.MySqlClient.MySqlConnection)">
<summary>
Asynchronous version of the ClearPool method.
</summary>
<param name="connection">The connection associated with the pool to be cleared.</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ClearPoolAsync(MySql.Data.MySqlClient.MySqlConnection,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the ClearPool method.
</summary>
<param name="connection">The connection associated with the pool to be cleared.</param>
<param name="cancellationToken">The cancellation token.</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ClearAllPoolsAsync">
<summary>
Asynchronous version of the ClearAllPools method.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.ClearAllPoolsAsync(System.Threading.CancellationToken)">
<summary>
Asynchronous version of the ClearAllPools method.
</summary>
<param name="cancellationToken">The cancellation token.</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.GetSchemaCollectionAsync(System.String,System.String[])">
<summary>
Asynchronous version of the GetSchemaCollection method.
</summary>
<param name="collectionName">The name of the collection.</param>
<param name="restrictionValues">The values to restrict.</param>
<returns>A collection of schema objects.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.GetSchemaCollectionAsync(System.String,System.String[],System.Threading.CancellationToken)">
<summary>
Asynchronous version of the GetSchemaCollection method.
</summary>
<param name="collectionName">The name of the collection.</param>
<param name="restrictionValues">The values to restrict.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>A collection of schema objects.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.GetSchema">
<summary>
Returns schema information for the data source of this <see cref="T:System.Data.Common.DbConnection"/>.
</summary>
<returns>A <see cref="T:System.Data.DataTable"/> that contains schema information. </returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.GetSchema(System.String)">
<summary>
Returns schema information for the data source of this
<see cref="T:System.Data.Common.DbConnection"/> using the specified string for the schema name.
</summary>
<param name="collectionName">Specifies the name of the schema to return. </param>
<returns>A <see cref="T:System.Data.DataTable"/> that contains schema information. </returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.GetSchema(System.String,System.String[])">
<summary>
Returns schema information for the data source of this <see cref="T:System.Data.Common.DbConnection"/>
using the specified string for the schema name and the specified string array
for the restriction values.
</summary>
<param name="collectionName">Specifies the name of the schema to return.</param>
<param name="restrictionValues">Specifies a set of restriction values for the requested schema.</param>
<returns>A <see cref="T:System.Data.DataTable"/> that contains schema information.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.EnlistTransaction(System.Transactions.Transaction)">
<summary>
Enlists in the specified transaction.
</summary>
<param name="transaction">
A reference to an existing <see cref="T:System.Transactions.Transaction"/> in which to enlist.
</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlConnection.Clone">
<summary>
Creates a new MySqlConnection object with the exact same ConnectionString value
</summary>
<returns>A cloned MySqlConnection object</returns>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlInfoMessageEventHandler">
<summary>
Represents the method that will handle the <see cref="E:MySql.Data.MySqlClient.MySqlConnection.InfoMessage"/> event of a
<see cref="T:MySql.Data.MySqlClient.MySqlConnection"/>.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlInfoMessageEventArgs">
<summary>
Provides data for the InfoMessage event. This class cannot be inherited.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlInfoMessageEventArgs.errors">
<summary>
Gets or sets an array of <see cref="T:MySql.Data.MySqlClient.MySqlError"/> objects set with the errors found.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.CommandTimer">
<summary>
IDisposable wrapper around SetCommandTimeout and ClearCommandTimeout functionality.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Crypt">
<summary>
Summary description for Crypt.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Crypt.XorScramble(System.Byte[],System.Int32,System.Byte[],System.Int32,System.Byte[],System.Int32)">
<summary>
Simple XOR scramble
</summary>
<param name="from">Source array</param>
<param name="fromIndex">Index inside source array</param>
<param name="to">Destination array</param>
<param name="toIndex">Index inside destination array</param>
<param name="password">Password used to xor the bits</param>
<param name="length">Number of bytes to scramble</param>
</member>
<member name="M:MySql.Data.MySqlClient.Crypt.Get411Password(System.String,System.String)">
<summary>
Returns a byte array containing the proper encryption of the
given password/seed according to the new 4.1.1 authentication scheme.
</summary>
<param name="password"></param>
<param name="seed"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.Crypt.EncryptPassword(System.String,System.String,System.Boolean)">
<summary>
Encrypts a password using the MySql encryption scheme
</summary>
<param name="password">The password to encrypt</param>
<param name="seed">The encryption seed the server gave us</param>
<param name="new_ver">Indicates if we should use the old or new encryption scheme</param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.Crypt.Hash(System.String)">
<summary>
Hashes a password using the algorithm from Monty's code.
The first element in the return is the result of the "old" hash.
The second element is the rest of the "new" hash.
</summary>
<param name="P">Password to be hashed</param>
<returns>Two element array containing the hashed values</returns>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlDataReader">
<summary>
Provides a means of reading a forward-only stream of rows from a MySQL database. This class cannot be inherited.
</summary><remarks>
<para>
To create a <B>MySQLDataReader</B>, you must call the <see cref="M:MySql.Data.MySqlClient.MySqlCommand.ExecuteReader" />
method of the <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> object, rather than directly using a constructor.
</para>
<para>
While the <B>MySqlDataReader</B> is in use, the associated <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />
is busy serving the <B>MySqlDataReader</B>, and no other operations can be performed
on the <B>MySqlConnection</B> other than closing it. This is the case until the
<see cref="M:MySql.Data.MySqlClient.MySqlDataReader.Close" /> method of the <B>MySqlDataReader</B> is called.
</para>
<para>
<see cref="P:MySql.Data.MySqlClient.MySqlDataReader.IsClosed" /> and <see cref="P:MySql.Data.MySqlClient.MySqlDataReader.RecordsAffected" />
are the only properties that you can call after the <B>MySqlDataReader</B> is
closed. Though the <B>RecordsAffected</B> property may be accessed at any time
while the <B>MySqlDataReader</B> exists, always call <B>Close</B> before returning
the value of <B>RecordsAffected</B> to ensure an accurate return value.
</para>
<para>
For optimal performance, <B>MySqlDataReader</B> avoids creating
unnecessary objects or making unnecessary copies of data. As a result, multiple calls
to methods such as <see cref="M:MySql.Data.MySqlClient.MySqlDataReader.GetValue(System.Int32)" /> return a reference to the
same object. Use caution if you are modifying the underlying value of the objects
returned by methods such as <B>GetValue</B>.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />,
a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />, and a <B>MySqlDataReader</B>. The example reads through
the data, writing it out to the console. Finally, the example closes the <B>MySqlDataReader</B>, then the
<B>MySqlConnection</B>.
<code lang="vbnet">
Public Sub ReadMyData(myConnString As String)
Dim mySelectQuery As String = "SELECT OrderID, CustomerID FROM Orders"
Dim myConnection As New MySqlConnection(myConnString)
Dim myCommand As New MySqlCommand(mySelectQuery, myConnection)
myConnection.Open()
Dim myReader As MySqlDataReader
myReader = myCommand.ExecuteReader()
' Always call Read before accessing data.
While myReader.Read()
Console.WriteLine((myReader.GetInt32(0) & ", " & myReader.GetString(1)))
End While
' always call Close when done reading.
myReader.Close()
' Close the connection when done with it.
myConnection.Close()
End Sub 'ReadMyData
</code>
<code lang="C#">
public void ReadMyData(string myConnString) {
string mySelectQuery = "SELECT OrderID, CustomerID FROM Orders";
MySqlConnection myConnection = new MySqlConnection(myConnString);
MySqlCommand myCommand = new MySqlCommand(mySelectQuery,myConnection);
myConnection.Open();
MySqlDataReader myReader;
myReader = myCommand.ExecuteReader();
// Always call Read before accessing data.
while (myReader.Read()) {
Console.WriteLine(myReader.GetInt32(0) + ", " + myReader.GetString(1));
}
// always call Close when done reading.
myReader.Close();
// Close the connection when done with it.
myConnection.Close();
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataReader.FieldCount">
<summary>
Gets the number of columns in the current row.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataReader.HasRows">
<summary>
Gets a value indicating whether the MySqlDataReader contains one or more rows.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataReader.IsClosed">
<summary>
Gets a value indicating whether the data reader is closed.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataReader.RecordsAffected">
<summary>
Gets the number of rows changed, inserted, or deleted by execution of the SQL statement.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataReader.Item(System.Int32)">
<summary>
Overloaded. Gets the value of a column in its native format.
In C#, this property is the indexer for the MySqlDataReader class.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataReader.Item(System.String)">
<summary>
Gets the value of a column in its native format.
[C#] In C#, this property is the indexer for the MySqlDataReader class.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataReader.Depth">
<summary>
Gets a value indicating the depth of nesting for the current row. This method is not
supported currently and always returns 0.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.Close">
<summary>
Closes the MySqlDataReader object.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetBoolean(System.String)">
<summary>
Gets the value of the specified column as a Boolean.
</summary>
<param name="name"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetBoolean(System.Int32)">
<summary>
Gets the value of the specified column as a Boolean.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetByte(System.String)">
<summary>
Gets the value of the specified column as a byte.
</summary>
<param name="name"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetByte(System.Int32)">
<summary>
Gets the value of the specified column as a byte.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetSByte(System.String)">
<summary>
Gets the value of the specified column as a sbyte.
</summary>
<param name="name"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetSByte(System.Int32)">
<summary>
Gets the value of the specified column as a sbyte.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetBytes(System.Int32,System.Int64,System.Byte[],System.Int32,System.Int32)">
<summary>
Reads a stream of bytes from the specified column offset into the buffer an array starting at the given buffer offset.
</summary>
<param name="i">The zero-based column ordinal. </param>
<param name="fieldOffset">The index within the field from which to begin the read operation. </param>
<param name="buffer">The buffer into which to read the stream of bytes. </param>
<param name="bufferoffset">The index for buffer to begin the read operation. </param>
<param name="length">The maximum length to copy into the buffer. </param>
<returns>The actual number of bytes read.</returns>
<!-- No matching elements were found for the following include tag --><include file="docs/MySqlDataReader.xml" path="MyDocs/MyMembers[@name="GetBytes"]/*" />
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetChar(System.String)">
<summary>
Gets the value of the specified column as a single character.
</summary>
<param name="name"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetChar(System.Int32)">
<summary>
Gets the value of the specified column as a single character.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetChars(System.Int32,System.Int64,System.Char[],System.Int32,System.Int32)">
<summary>
Reads a stream of characters from the specified column offset into the buffer as an array starting at the given buffer offset.
</summary>
<param name="i"></param>
<param name="fieldoffset"></param>
<param name="buffer"></param>
<param name="bufferoffset"></param>
<param name="length"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetDataTypeName(System.Int32)">
<summary>
Gets the name of the source data type.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetMySqlDateTime(System.String)">
<summary>
Gets the value of the specified column as a <see cref="T:MySql.Data.Types.MySqlDateTime" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>DateTime</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetMySqlDateTime(System.Int32)">
<summary>
Gets the value of the specified column as a <see cref="T:MySql.Data.Types.MySqlDateTime" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>DateTime</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetDateTime(System.String)">
<summary>
Gets the value of the specified column as a <see cref="T:System.DateTime" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>DateTime</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
<note>
<para>
MySql allows date columns to contain the value '0000-00-00' and datetime
columns to contain the value '0000-00-00 00:00:00'. The DateTime structure cannot contain
or represent these values. To read a datetime value from a column that might
contain zero values, use <see cref="M:MySql.Data.MySqlClient.MySqlDataReader.GetMySqlDateTime(System.Int32)" />.
</para>
<para>
The behavior of reading a zero datetime column using this method is defined by the
<i>ZeroDateTimeBehavior</i> connection string option. For more information on this option,
please refer to <see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString" />.
</para>
</note>
</remarks><param name="column">The column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetDateTime(System.Int32)">
<summary>
Gets the value of the specified column as a <see cref="T:System.DateTime" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>DateTime</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
<note>
<para>
MySql allows date columns to contain the value '0000-00-00' and datetime
columns to contain the value '0000-00-00 00:00:00'. The DateTime structure cannot contain
or represent these values. To read a datetime value from a column that might
contain zero values, use <see cref="M:MySql.Data.MySqlClient.MySqlDataReader.GetMySqlDateTime(System.Int32)" />.
</para>
<para>
The behavior of reading a zero datetime column using this method is defined by the
<i>ZeroDateTimeBehavior</i> connection string option. For more information on this option,
please refer to <see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString" />.
</para>
</note>
</remarks><param name="i">The zero-based column ordinal.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetMySqlDecimal(System.String)">
<summary>
Gets the value of the specified column as a <see cref="T:MySql.Data.Types.MySqlDecimal"/>.
</summary>
<param name="column">The name of the colum.</param>
<returns>The value of the specified column as a <see cref="T:MySql.Data.Types.MySqlDecimal"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetMySqlDecimal(System.Int32)">
<summary>
Gets the value of the specified column as a <see cref="T:MySql.Data.Types.MySqlDecimal"/>.
</summary>
<param name="i">The index of the colum.</param>
<returns>The value of the specified column as a <see cref="T:MySql.Data.Types.MySqlDecimal"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetDecimal(System.String)">
<summary>
Gets the value of the specified column as a <see cref="T:System.Decimal" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>Decimal</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The column name</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetDecimal(System.Int32)">
<summary>
Gets the value of the specified column as a <see cref="T:System.Decimal" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>Decimal</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="i">The zero-based column ordinal</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetDouble(System.String)">
<summary>Gets the value of the specified column as a double-precision floating point number.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>Double</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The column name</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetDouble(System.Int32)">
<summary>Gets the value of the specified column as a double-precision floating point number.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>Double</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="i">The zero-based column ordinal.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetFieldType(System.Int32)">
<summary>
Gets the Type that is the data type of the object.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetFloat(System.String)">
<summary>
Gets the value of the specified column as a single-precision floating point number.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>Float</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The column name</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetFloat(System.Int32)">
<summary>
Gets the value of the specified column as a single-precision floating point number.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>Float</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="i">The zero-based column ordinal.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetGuid(System.String)">
<summary>
Gets the value of the specified column as a globally-unique identifier(GUID).
</summary>
<param name="column">The name of the column.</param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetGuid(System.Int32)">
<!-- No matching elements were found for the following include tag --><include file="docs/MySqlDataReader.xml" path="docs/GetGuid/*" />
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetInt16(System.String)">
<summary>Gets the value of the specified column as a 16-bit signed integer.</summary><remarks>
<para>
No conversions are performed; threfore, the data retrieved must already be a <b>16 bit integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The column name</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetInt16(System.Int32)">
<summary>Gets the value of the specified column as a 16-bit signed integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>16 bit integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="i">The zero-based column ordinal.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetInt32(System.String)">
<summary>Gets the value of the specified column as a 32-bit signed integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>32 bit integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetInt32(System.Int32)">
<summary>Gets the value of the specified column as a 32-bit signed integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>32 bit integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="i">The zero-based column ordinal.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetInt64(System.String)">
<summary>Gets the value of the specified column as a 64-bit signed integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>64 bit integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetInt64(System.Int32)">
<summary>Gets the value of the specified column as a 64-bit signed integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>64 bit integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="i">The zero-based column ordinal.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetName(System.Int32)">
<summary>
Gets the name of the specified column.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetOrdinal(System.String)">
<summary>
Gets the column ordinal, given the name of the column.
</summary>
<param name="name"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetString(System.String)">
<summary>
Gets the value of the specified column as a <see cref="T:System.String" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>String</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetString(System.Int32)">
<summary>
Gets the value of the specified column as a <see cref="T:System.String" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>String</b> object.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="i">The zero-based column ordinal.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetTimeSpan(System.String)">
<overloads /><summary>
Gets the value of the specified column as a <see cref="T:System.TimeSpan" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>Time</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetTimeSpan(System.Int32)">
<overloads /><summary>
Gets the value of the specified column as a <see cref="T:System.TimeSpan" /> object.
</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>Time</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetValue(System.Int32)">
<summary>
Gets the value of the specified column in its native format.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetValues(System.Object[])">
<summary>
Gets all attribute columns in the collection for the current row.
</summary>
<param name="values"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetUInt16(System.String)">
<summary>Gets the value of the specified column as a 16-bit unsigned integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>16 bit unsigned integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetUInt16(System.Int32)">
<summary>Gets the value of the specified column as a 16-bit unsigned integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>16 bit unsigned integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetUInt32(System.String)">
<summary>Gets the value of the specified column as a 32-bit unsigned integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>32 bit unsigned integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetUInt32(System.Int32)">
<summary>Gets the value of the specified column as a 32-bit unsigned integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>32 bit unsigned integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetUInt64(System.String)">
<summary>Gets the value of the specified column as a 64-bit unsigned integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>64 bit unsigned integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetUInt64(System.Int32)">
<summary>Gets the value of the specified column as a 64-bit unsigned integer.</summary><remarks>
<para>
No conversions are performed; therefore, the data retrieved must already be a <b>64 bit unsigned integer</b> value.
</para>
<para>
Call IsDBNull to check for null values before calling this method.
</para>
</remarks><param name="column">The zero-based column ordinal or column name.</param><returns>The value of the specified column.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.IsDBNull(System.Int32)">
<summary>
Gets a value indicating whether the column contains non-existent or missing values.
</summary>
<param name="i"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.NextResult">
<summary>
Advances the data reader to the next result, when reading the results of batch SQL statements.
</summary>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.Read">
<summary>
Advances the MySqlDataReader to the next record.
</summary>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetMySqlGeometry(System.Int32)">
<summary>
Gets the value of the specified column as a <see cref="T:MySql.Data.Types.MySqlGeometry"/>.
</summary>
<param name="i">The index of the colum.</param>
<returns>The value of the specified column as a <see cref="T:MySql.Data.Types.MySqlGeometry"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetMySqlGeometry(System.String)">
<summary>
Gets the value of the specified column as a <see cref="T:MySql.Data.Types.MySqlGeometry"/>.
</summary>
<param name="column">The name of the colum.</param>
<returns>The value of the specified column as a <see cref="T:MySql.Data.Types.MySqlGeometry"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetEnumerator">
<summary>
Returns an <see cref="T:System.Collections.IEnumerator"/> that iterates through the <see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/>.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataReader.GetSchemaTable">
<summary>
Returns a DataTable that describes the column metadata of the MySqlDataReader.
</summary>
<returns></returns>
</member>
<member name="T:MySql.Data.MySqlClient.Driver">
<summary>
Summary description for BaseDriver.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.Driver.IdleSince">
<summary>
For pooled connections, time when the driver was
put into idle queue
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Driver.LoadServerProperties(MySql.Data.MySqlClient.MySqlConnection)">
<summary>
Loads the properties from the connected server into a hashtable
</summary>
<param name="connection"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.Driver.LoadCharacterSets(MySql.Data.MySqlClient.MySqlConnection)">
<summary>
Loads all the current character set names and ids for this server
into the charSets hashtable
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlException">
<summary>
The exception that is thrown when MySQL returns an error. This class cannot be inherited.
</summary>
<remarks>
<para>
This class is created whenever the MySql Data Provider encounters an error generated from the server.
</para>
<para>
Any open connections are not automatically closed when an exception is thrown. If
the client application determines that the exception is fatal, it should close any open
<see cref="T:MySql.Data.MySqlClient.MySqlDataReader" /> objects or <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> objects.
</para>
</remarks><example>
The following example generates a <B>MySqlException</B> due to a missing server,
and then displays the exception.
<code lang="vbnet">
Public Sub ShowException()
Dim mySelectQuery As String = "SELECT column1 FROM table1"
Dim myConnection As New MySqlConnection ("Data Source=localhost;Database=Sample;")
Dim myCommand As New MySqlCommand(mySelectQuery, myConnection)
Try
myCommand.Connection.Open()
Catch e As MySqlException
MessageBox.Show( e.Message )
End Try
End Sub
</code>
<code lang="C#">
public void ShowException()
{
string mySelectQuery = "SELECT column1 FROM table1";
MySqlConnection myConnection =
new MySqlConnection("Data Source=localhost;Database=Sample;");
MySqlCommand myCommand = new MySqlCommand(mySelectQuery,myConnection);
try
{
myCommand.Connection.Open();
}
catch (MySqlException e)
{
MessageBox.Show( e.Message );
}
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlException.Number">
<summary>
Gets a number that identifies the type of error.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlException.IsFatal">
<summary>
True if this exception was fatal and cause the closing of the connection, false otherwise.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlException.SqlState">
<summary>
Gets the SQL state.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlException.Code">
<summary>
Gets an integer that representes the MySQL error code.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlField">
<summary>
Summary description for Field.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.CustomInstaller">
<summary>
We are adding a custom installer class to our assembly so our installer
can make proper changes to the machine.config file.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.CustomInstaller.Install(System.Collections.IDictionary)">
<summary>
We override Install so we can add our assembly to the proper
machine.config files.
</summary>
<param name="stateSaver"></param>
</member>
<member name="M:MySql.Data.MySqlClient.CustomInstaller.Uninstall(System.Collections.IDictionary)">
<summary>
We override Uninstall so we can remove out assembly from the
machine.config files.
</summary>
<param name="savedState"></param>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlCommandBuilder">
<summary>
Automatically generates single-table commands used to reconcile changes made to a DataSet with the associated MySQL database. This class cannot be inherited.
</summary><remarks>
<para>
The <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> does not automatically generate the SQL statements required to
reconcile changes made to a <see cref="T:System.Data.DataSet">DataSet</see> with the associated instance of MySQL.
However, you can create a <B>MySqlCommandBuilder</B> object to automatically generate SQL statements for
single-table updates if you set the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand">SelectCommand</see> property
of the <B>MySqlDataAdapter</B>. Then, any additional SQL statements that you do not set are generated by the
<B>MySqlCommandBuilder</B>.
</para>
<para>
The <B>MySqlCommandBuilder</B> registers itself as a listener for <see cref="M:MySql.Data.MySqlClient.MySqlDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)">RowUpdating</see>
events whenever you set the <see cref="P:MySql.Data.MySqlClient.MySqlCommandBuilder.DataAdapter" /> property. You can only associate one
<B>MySqlDataAdapter</B> or <B>MySqlCommandBuilder</B> object with each other at one time.
</para>
<para>
To generate INSERT, UPDATE, or DELETE statements, the <B>MySqlCommandBuilder</B> uses the
<B>SelectCommand</B> property to retrieve a required set of metadata automatically. If you change
the <B>SelectCommand</B> after the metadata has is retrieved (for example, after the first update), you
should call the <see cref="!:RefreshSchema" /> method to update the metadata.
</para>
<para>
The <B>SelectCommand</B> must also return at least one primary key or unique
column. If none are present, an <I>InvalidOperation</I> exception is generated,
and the commands are not generated.
</para>
<para>
The <B>MySqlCommandBuilder</B> also uses the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.Connection">Connection</see>,
<see cref="P:MySql.Data.MySqlClient.MySqlCommand.CommandTimeout">CommandTimeout</see>, and <see cref="P:MySql.Data.MySqlClient.MySqlCommand.Transaction">Transaction</see>
properties referenced by the <B>SelectCommand</B>. The user should call
<B>RefreshSchema</B> if any of these properties are modified, or if the
<B>SelectCommand</B> itself is replaced. Otherwise the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.InsertCommand">InsertCommand</see>,
<see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.UpdateCommand">UpdateCommand</see>, and
<see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.DeleteCommand">DeleteCommand</see> properties retain
their previous values.
</para>
<para>
If you call <i>Dispose</i>, the <B>MySqlCommandBuilder</B> is disassociated
from the <B>MySqlDataAdapter</B>, and the generated commands are no longer used.
</para>
<note>
Caution must be used when using MySqlCOmmandBuilder on MySql 4.0 systems. With MySql 4.0,
database/schema information is not provided to the connector for a query. This means that
a query that pulls columns from two identically named tables in two or more different databases
will not cause an exception to be thrown but will not work correctly. Even more dangerous
is the situation where your select statement references database X but is executed in
database Y and both databases have tables with similar layouts. This situation can cause
unwanted changes or deletes.
This note does not apply to MySQL versions 4.1 and later.
</note>
</remarks><example>
The following example uses the <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />, along
<see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />, to
select rows from a data source. The example is passed an initialized
<see cref="T:System.Data.DataSet" />, a connection string, a
query string that is a SQL SELECT statement, and a string that is the
name of the database table. The example then creates a <B>MySqlCommandBuilder</B>.
<code lang="vbnet">
Public Shared Function SelectRows(myConnection As String, mySelectQuery As String, myTableName As String) As DataSet
Dim myConn As New MySqlConnection(myConnection)
Dim myDataAdapter As New MySqlDataAdapter()
myDataAdapter.SelectCommand = New MySqlCommand(mySelectQuery, myConn)
Dim cb As SqlCommandBuilder = New MySqlCommandBuilder(myDataAdapter)
myConn.Open()
Dim ds As DataSet = New DataSet
myDataAdapter.Fill(ds, myTableName)
' Code to modify data in DataSet here
' Without the MySqlCommandBuilder this line would fail.
myDataAdapter.Update(ds, myTableName)
myConn.Close()
End Function 'SelectRows
</code>
<code lang="C#">
public static DataSet SelectRows(string myConnection, string mySelectQuery, string myTableName)
{
MySqlConnection myConn = new MySqlConnection(myConnection);
MySqlDataAdapter myDataAdapter = new MySqlDataAdapter();
myDataAdapter.SelectCommand = new MySqlCommand(mySelectQuery, myConn);
MySqlCommandBuilder cb = new MySqlCommandBuilder(myDataAdapter);
myConn.Open();
DataSet ds = new DataSet();
myDataAdapter.Fill(ds, myTableName);
//code to modify data in DataSet here
//Without the MySqlCommandBuilder this line would fail
myDataAdapter.Update(ds, myTableName);
myConn.Close();
return ds;
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommandBuilder.#ctor">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlCommandBuilder" /> class.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommandBuilder.#ctor(MySql.Data.MySqlClient.MySqlDataAdapter)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlCommandBuilder" /> class
with the associated <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> object.
</summary><param name="adapter">
The <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> to use.
</param><remarks>
<para>
The <see cref="T:MySql.Data.MySqlClient.MySqlCommandBuilder" /> registers itself as a listener for
<see cref="E:MySql.Data.MySqlClient.MySqlDataAdapter.RowUpdating" /> events that are generated by the
<see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> specified in this property.
</para>
<para>
When you create a new instance <B>MySqlCommandBuilder</B>, any existing
<B>MySqlCommandBuilder</B> associated with this <B>MySqlDataAdapter</B>
is released.
</para>
</remarks>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlCommandBuilder.DataAdapter">
<summary>
Gets or sets a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> object for which SQL statements are automatically generated.
</summary><value>
A <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> object.
</value><remarks>
<para>
The <see cref="T:MySql.Data.MySqlClient.MySqlCommandBuilder" /> registers itself as a listener for
<see cref="E:MySql.Data.MySqlClient.MySqlDataAdapter.RowUpdating" /> events that are generated by the
<see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> specified in this property.
</para>
<para>
When you create a new instance <B>MySqlCommandBuilder</B>, any existing
<B>MySqlCommandBuilder</B> associated with this <B>MySqlDataAdapter</B>
is released.
</para>
</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommandBuilder.DeriveParameters(MySql.Data.MySqlClient.MySqlCommand)">
<summary>
Retrieves parameter information from the stored procedure specified
in the MySqlCommand and populates the Parameters collection of the
specified MySqlCommand object.
This method is not currently supported since stored procedures are
not available in MySql.
</summary>
<param name="command">The MySqlCommand referencing the stored
procedure from which the parameter information is to be derived.
The derived parameters are added to the Parameters collection of the
MySqlCommand.</param>
<exception cref="T:System.InvalidOperationException">The command text is not
a valid stored procedure name.</exception>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommandBuilder.GetDeleteCommand">
<summary>
Gets the delete command.
</summary>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommandBuilder.GetUpdateCommand">
<summary>
Gets the update command.
</summary>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommandBuilder.GetInsertCommand">
<summary>
Gets the insert command.
</summary>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlCommandBuilder.GetParameterName(System.String)">
<summary>
</summary>
<param name="parameterName"></param>
<returns></returns>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlDataAdapter">
<summary>
Represents a set of data commands and a database connection that are used to fill a dataset and update a MySQL database. This class cannot be inherited.
</summary><remarks>
<para>
The <B>MySQLDataAdapter</B>, serves as a bridge between a <see cref="T:System.Data.DataSet" />
and MySQL for retrieving and saving data. The <B>MySQLDataAdapter</B> provides this
bridge by mapping <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" />, which changes the data in the
<B>DataSet</B> to match the data in the data source, and <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />,
which changes the data in the data source to match the data in the <B>DataSet</B>,
using the appropriate SQL statements against the data source.
</para>
<para>
When the <B>MySQLDataAdapter</B> fills a <B>DataSet</B>, it will create the necessary
tables and columns for the returned data if they do not already exist. However, primary
key information will not be included in the implicitly created schema unless the
<see cref="T:System.Data.MissingSchemaAction" /> property is set to <see cref="F:System.Data.MissingSchemaAction.AddWithKey" />.
You may also have the <B>MySQLDataAdapter</B> create the schema of the <B>DataSet</B>,
including primary key information, before filling it with data using <see cref="M:System.Data.Common.DbDataAdapter.FillSchema(System.Data.DataTable,System.Data.SchemaType)" />.
</para>
<para>
<B>MySQLDataAdapter</B> is used in conjunction with <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />
and <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> to increase performance when connecting to a MySQL database.
</para>
<para>
The <B>MySQLDataAdapter</B> also includes the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" />,
<see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.InsertCommand" />, <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.DeleteCommand" />,
<see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.UpdateCommand" />, and <see cref="P:System.Data.Common.DataAdapter.TableMappings" />
properties to facilitate the loading and updating of data.
</para>
<para>
When an instance of <B>MySQLDataAdapter</B> is created, the read/write properties
are set to initial values. For a list of these values, see the <B>MySQLDataAdapter</B>
constructor.
</para>
<note>
Please be aware that the <see cref="T:System.Data.DataColumn" /> class allows only
Int16, Int32, and Int64 to have the AutoIncrement property set.
If you plan to use autoincremement columns with MySQL, you should consider
using signed integer columns.
</note>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> and a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />.
The <B>MySqlConnection</B> is opened and set as the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.Connection" /> for the
<B>MySqlCommand</B>. The example then calls <see cref="M:MySql.Data.MySqlClient.MySqlCommand.ExecuteNonQuery" />, and closes
the connection. To accomplish this, the <B>ExecuteNonQuery</B> is
passed a connection string and a query string that is a SQL INSERT
statement.
<code lang="vbnet">
Public Function SelectRows(dataSet As DataSet, connection As String, query As String) As DataSet
Dim conn As New MySqlConnection(connection)
Dim adapter As New MySqlDataAdapter()
adapter.SelectCommand = new MySqlCommand(query, conn)
adapter.Fill(dataset)
Return dataset
End Function
</code>
<code lang="C#">
public DataSet SelectRows(DataSet dataset,string connection,string query)
{
MySqlConnection conn = new MySqlConnection(connection);
MySqlDataAdapter adapter = new MySqlDataAdapter();
adapter.SelectCommand = new MySqlCommand(query, conn);
adapter.Fill(dataset);
return dataset;
}
</code>
</example>
</member>
<member name="E:MySql.Data.MySqlClient.MySqlDataAdapter.RowUpdating">
<summary>
Occurs during Update before a command is executed against the data source. The attempt to update is made, so the event fires.
</summary>
</member>
<member name="E:MySql.Data.MySqlClient.MySqlDataAdapter.RowUpdated">
<summary>
Occurs during Update after a command is executed against the data source. The attempt to update is made, so the event fires.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.#ctor">
<overloads /><summary>
Initializes a new instance of the MySqlDataAdapter class.
</summary><remarks>
<para>
When an instance of <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> is created,
the following read/write properties are set to the following initial
values.
</para>
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="T:System.Data.MissingMappingAction" />
</term>
<term>
<B>MissingMappingAction.Passthrough</B>
</term>
</item>
<item>
<term>
<see cref="T:System.Data.MissingSchemaAction" />
</term>
<term>
<B>MissingSchemaAction.Add</B>
</term>
</item>
</list>
<para>
You can change the value of any of these properties through a separate call
to the property.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and sets some of
its properties.
<code lang="vbnet">
Public Sub CreateSqlDataAdapter()
Dim conn As MySqlConnection = New MySqlConnection("Data Source=localhost;" & _
"database=test")
Dim da As MySqlDataAdapter = New MySqlDataAdapter
da.MissingSchemaAction = MissingSchemaAction.AddWithKey
da.SelectCommand = New MySqlCommand("SELECT id, name FROM mytable", conn)
da.InsertCommand = New MySqlCommand("INSERT INTO mytable (id, name) " & _
"VALUES (@id, @name)", conn)
da.UpdateCommand = New MySqlCommand("UPDATE mytable SET id=@id, name=@name " & _
"WHERE id=@oldId", conn)
da.DeleteCommand = New MySqlCommand("DELETE FROM mytable WHERE id=@id", conn)
da.InsertCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
da.InsertCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name")
da.UpdateCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
da.UpdateCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name")
da.UpdateCommand.Parameters.Add("@oldId", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original
da.DeleteCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original
End Sub
</code>
<code lang="C#">
public static void CreateSqlDataAdapter()
{
MySqlConnection conn = new MySqlConnection("Data Source=localhost;database=test");
MySqlDataAdapter da = new MySqlDataAdapter();
da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
da.SelectCommand = new MySqlCommand("SELECT id, name FROM mytable", conn);
da.InsertCommand = new MySqlCommand("INSERT INTO mytable (id, name) " +
"VALUES (@id, @name)", conn);
da.UpdateCommand = new MySqlCommand("UPDATE mytable SET id=@id, name=@name " +
"WHERE id=@oldId", conn);
da.DeleteCommand = new MySqlCommand("DELETE FROM mytable WHERE id=@id", conn);
da.InsertCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
da.InsertCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name");
da.UpdateCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
da.UpdateCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name");
da.UpdateCommand.Parameters.Add("@oldId", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original;
da.DeleteCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original;
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.#ctor(MySql.Data.MySqlClient.MySqlCommand)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> class with
the specified <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> as the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" />
property.
</summary><param name="selectCommand">
<see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> that is a SQL SELECT statement or stored procedure and is set
as the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> property of the <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" />.
</param><remarks>
<para>
When an instance of <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> is created,
the following read/write properties are set to the following initial
values.
</para>
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="T:System.Data.MissingMappingAction" />
</term>
<term>
<B>MissingMappingAction.Passthrough</B>
</term>
</item>
<item>
<term>
<see cref="T:System.Data.MissingSchemaAction" />
</term>
<term>
<B>MissingSchemaAction.Add</B>
</term>
</item>
</list>
<para>
You can change the value of any of these properties through a separate call
to the property.
</para>
<para>
When <B>SelectCommand</B> (or any of the other command properties) is assigned
to a previously created <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />, the <B>MySqlCommand</B> is not cloned.
The <B>SelectCommand</B> maintains a reference to the previously created <B>MySqlCommand</B>
object.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and sets some of
its properties.
<code lang="vbnet">
Public Sub CreateSqlDataAdapter()
Dim conn As MySqlConnection = New MySqlConnection("Data Source=localhost;" & _
"database=test")
Dim cmd as new MySqlCommand("SELECT id, name FROM mytable", conn)
Dim da As MySqlDataAdapter = New MySqlDataAdapter(cmd)
da.MissingSchemaAction = MissingSchemaAction.AddWithKey
da.InsertCommand = New MySqlCommand("INSERT INTO mytable (id, name) " & _
"VALUES (@id, @name)", conn)
da.UpdateCommand = New MySqlCommand("UPDATE mytable SET id=@id, name=@name " & _
"WHERE id=@oldId", conn)
da.DeleteCommand = New MySqlCommand("DELETE FROM mytable WHERE id=@id", conn)
da.InsertCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
da.InsertCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name")
da.UpdateCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
da.UpdateCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name")
da.UpdateCommand.Parameters.Add("@oldId", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original
da.DeleteCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original
End Sub
</code>
<code lang="C#">
public static void CreateSqlDataAdapter()
{
MySqlConnection conn = new MySqlConnection("Data Source=localhost;database=test");
MySqlCommand cmd = new MySqlCommand("SELECT id, name FROM mytable", conn);
MySqlDataAdapter da = new MySqlDataAdapter(cmd);
da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
da.InsertCommand = new MySqlCommand("INSERT INTO mytable (id, name) " +
"VALUES (@id, @name)", conn);
da.UpdateCommand = new MySqlCommand("UPDATE mytable SET id=@id, name=@name " +
"WHERE id=@oldId", conn);
da.DeleteCommand = new MySqlCommand("DELETE FROM mytable WHERE id=@id", conn);
da.InsertCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
da.InsertCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name");
da.UpdateCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
da.UpdateCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name");
da.UpdateCommand.Parameters.Add("@oldId", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original;
da.DeleteCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original;
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.#ctor(System.String,MySql.Data.MySqlClient.MySqlConnection)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> class with
a <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> and a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> object.
</summary><param name="selectCommandText">
A <b>String</b> that is a SQL SELECT statement or stored procedure to be used by
the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> property of the <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" />.
</param><param name="connection">
A <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> that represents the connection.
</param><remarks>
<para>
This implementation of the <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> opens and closes a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" />
if it is not already open. This can be useful in a an application that must call the
<see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> method for two or more <B>MySqlDataAdapter</B> objects.
If the <B>MySqlConnection</B> is already open, you must explicitly call
<see cref="M:MySql.Data.MySqlClient.MySqlConnection.Close" /> or <see cref="M:MySql.Data.MySqlClient.MySqlConnection.Dispose" /> to close it.
</para>
<para>
When an instance of <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> is created,
the following read/write properties are set to the following initial
values.
</para>
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="T:System.Data.MissingMappingAction" />
</term>
<term>
<B>MissingMappingAction.Passthrough</B>
</term>
</item>
<item>
<term>
<see cref="T:System.Data.MissingSchemaAction" />
</term>
<term>
<B>MissingSchemaAction.Add</B>
</term>
</item>
</list>
<para>
You can change the value of any of these properties through a separate call
to the property.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and sets some of
its properties.
<code lang="vbnet">
Public Sub CreateSqlDataAdapter()
Dim conn As MySqlConnection = New MySqlConnection("Data Source=localhost;" & _
"database=test")
Dim da As MySqlDataAdapter = New MySqlDataAdapter("SELECT id, name FROM mytable", conn)
da.MissingSchemaAction = MissingSchemaAction.AddWithKey
da.InsertCommand = New MySqlCommand("INSERT INTO mytable (id, name) " & _
"VALUES (@id, @name)", conn)
da.UpdateCommand = New MySqlCommand("UPDATE mytable SET id=@id, name=@name " & _
"WHERE id=@oldId", conn)
da.DeleteCommand = New MySqlCommand("DELETE FROM mytable WHERE id=@id", conn)
da.InsertCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
da.InsertCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name")
da.UpdateCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
da.UpdateCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name")
da.UpdateCommand.Parameters.Add("@oldId", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original
da.DeleteCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original
End Sub
</code>
<code lang="C#">
public static void CreateSqlDataAdapter()
{
MySqlConnection conn = new MySqlConnection("Data Source=localhost;database=test");
MySqlDataAdapter da = new MySqlDataAdapter("SELECT id, name FROM mytable", conn);
da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
da.InsertCommand = new MySqlCommand("INSERT INTO mytable (id, name) " +
"VALUES (@id, @name)", conn);
da.UpdateCommand = new MySqlCommand("UPDATE mytable SET id=@id, name=@name " +
"WHERE id=@oldId", conn);
da.DeleteCommand = new MySqlCommand("DELETE FROM mytable WHERE id=@id", conn);
da.InsertCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
da.InsertCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name");
da.UpdateCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
da.UpdateCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name");
da.UpdateCommand.Parameters.Add("@oldId", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original;
da.DeleteCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original;
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.#ctor(System.String,System.String)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> class with
a <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> and a connection string.
</summary><param name="selectCommandText">
A <see cref="T:System.String" /> that is a SQL SELECT statement or stored procedure to
be used by the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> property of the <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" />.
</param><param name="selectConnString">The connection string</param><remarks>
<para>
When an instance of <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> is created,
the following read/write properties are set to the following initial
values.
</para>
<list type="table">
<listheader>
<term>Properties</term>
<term>Initial Value</term>
</listheader>
<item>
<term>
<see cref="T:System.Data.MissingMappingAction" />
</term>
<term>
<B>MissingMappingAction.Passthrough</B>
</term>
</item>
<item>
<term>
<see cref="T:System.Data.MissingSchemaAction" />
</term>
<term>
<B>MissingSchemaAction.Add</B>
</term>
</item>
</list>
<para>
You can change the value of any of these properties through a separate call
to the property.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and sets some of
its properties.
<code lang="vbnet">
Public Sub CreateSqlDataAdapter()
Dim da As MySqlDataAdapter = New MySqlDataAdapter("SELECT id, name FROM mytable", "Data Source=localhost;database=test")
Dim conn As MySqlConnection = da.SelectCommand.Connection
da.MissingSchemaAction = MissingSchemaAction.AddWithKey
da.InsertCommand = New MySqlCommand("INSERT INTO mytable (id, name) " & _
"VALUES (@id, @name)", conn)
da.UpdateCommand = New MySqlCommand("UPDATE mytable SET id=@id, name=@name " & _
"WHERE id=@oldId", conn)
da.DeleteCommand = New MySqlCommand("DELETE FROM mytable WHERE id=@id", conn)
da.InsertCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
da.InsertCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name")
da.UpdateCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
da.UpdateCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name")
da.UpdateCommand.Parameters.Add("@oldId", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original
da.DeleteCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original
End Sub
</code>
<code lang="C#">
public static void CreateSqlDataAdapter()
{
MySqlDataAdapter da = new MySqlDataAdapter("SELECT id, name FROM mytable", "Data Source=localhost;database=test");
MySqlConnection conn = da.SelectCommand.Connection;
da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
da.InsertCommand = new MySqlCommand("INSERT INTO mytable (id, name) " +
"VALUES (@id, @name)", conn);
da.UpdateCommand = new MySqlCommand("UPDATE mytable SET id=@id, name=@name " +
"WHERE id=@oldId", conn);
da.DeleteCommand = new MySqlCommand("DELETE FROM mytable WHERE id=@id", conn);
da.InsertCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
da.InsertCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name");
da.UpdateCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
da.UpdateCommand.Parameters.Add("@name", MySqlDbType.VarChar, 40, "name");
da.UpdateCommand.Parameters.Add("@oldId", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original;
da.DeleteCommand.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id").SourceVersion = DataRowVersion.Original;
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataAdapter.DeleteCommand">
<summary>
Gets or sets a SQL statement or stored procedure used to delete records from the data set.
</summary><value>
A <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> used during <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> to delete records in the
database that correspond to deleted rows in the <see cref="T:System.Data.DataSet" />.
</value><remarks>
<para>
During <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, if this property is not set and primary key information
is present in the <see cref="T:System.Data.DataSet" />, the <B>DeleteCommand</B> can be generated
automatically if you set the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> property and use the
<see cref="T:MySql.Data.MySqlClient.MySqlCommandBuilder" />. Then, any additional commands that you do not set are
generated by the <B>MySqlCommandBuilder</B>. This generation logic requires key column
information to be present in the <B>DataSet</B>.
</para>
<para>
When <B>DeleteCommand</B> is assigned to a previously created <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />,
the <B>MySqlCommand</B> is not cloned. The <B>DeleteCommand</B> maintains a reference
to the previously created <B>MySqlCommand</B> object.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and sets the
<see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> and <B>DeleteCommand</B> properties. It assumes you have already
created a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> object.
<code lang="vbnet">
Public Shared Function CreateCustomerAdapter(conn As MySqlConnection) As MySqlDataAdapter
Dim da As MySqlDataAdapter = New MySqlDataAdapter()
Dim cmd As MySqlCommand
Dim parm As MySqlParameter
' Create the SelectCommand.
cmd = New MySqlCommand("SELECT * FROM mytable WHERE id=@id AND name=@name", conn)
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15)
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15)
da.SelectCommand = cmd
' Create the DeleteCommand.
cmd = New MySqlCommand("DELETE FROM mytable WHERE id=@id", conn)
parm = cmd.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id")
parm.SourceVersion = DataRowVersion.Original
da.DeleteCommand = cmd
Return da
End Function
</code>
<code lang="C#">
public static MySqlDataAdapter CreateCustomerAdapter(MySqlConnection conn)
{
MySqlDataAdapter da = new MySqlDataAdapter();
MySqlCommand cmd;
MySqlParameter parm;
// Create the SelectCommand.
cmd = new MySqlCommand("SELECT * FROM mytable WHERE id=@id AND name=@name", conn);
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15);
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15);
da.SelectCommand = cmd;
// Create the DeleteCommand.
cmd = new MySqlCommand("DELETE FROM mytable WHERE id=@id", conn);
parm = cmd.Parameters.Add("@id", MySqlDbType.VarChar, 5, "id");
parm.SourceVersion = DataRowVersion.Original;
da.DeleteCommand = cmd;
return da;
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataAdapter.InsertCommand">
<summary>
Gets or sets a SQL statement or stored procedure used to insert records into the data set.
</summary><value>
A <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> used during <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> to insert records into the
database that correspond to new rows in the <see cref="T:System.Data.DataSet" />.
</value><remarks>
<para>
During <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, if this property is not set and primary key information
is present in the <see cref="T:System.Data.DataSet" />, the <B>InsertCommand</B> can be generated
automatically if you set the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> property and use the
<see cref="T:MySql.Data.MySqlClient.MySqlCommandBuilder" />. Then, any additional commands that you do not set are
generated by the <B>MySqlCommandBuilder</B>. This generation logic requires key column
information to be present in the <B>DataSet</B>.
</para>
<para>
When <B>InsertCommand</B> is assigned to a previously created <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />,
the <B>MySqlCommand</B> is not cloned. The <B>InsertCommand</B> maintains a reference
to the previously created <B>MySqlCommand</B> object.
</para>
<note>
If execution of this command returns rows, these rows may be added to the <B>DataSet</B>
depending on how you set the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.UpdatedRowSource" /> property of the <B>MySqlCommand</B> object.
</note>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and sets the
<see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> and <B>InsertCommand</B> properties. It assumes you have already
created a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> object.
<code lang="vbnet">
Public Shared Function CreateCustomerAdapter(conn As MySqlConnection) As MySqlDataAdapter
Dim da As MySqlDataAdapter = New MySqlDataAdapter()
Dim cmd As MySqlCommand
Dim parm As MySqlParameter
' Create the SelectCommand.
cmd = New MySqlCommand("SELECT * FROM mytable WHERE id=@id AND name=@name", conn)
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15)
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15)
da.SelectCommand = cmd
' Create the InsertCommand.
cmd = New MySqlCommand("INSERT INTO mytable (id,name) VALUES (@id, @name)", conn)
cmd.Parameters.Add( "@id", MySqlDbType.VarChar, 15, "id" )
cmd.Parameters.Add( "@name", MySqlDbType.VarChar, 15, "name" )
da.InsertCommand = cmd
Return da
End Function
</code>
<code lang="C#">
public static MySqlDataAdapter CreateCustomerAdapter(MySqlConnection conn)
{
MySqlDataAdapter da = new MySqlDataAdapter();
MySqlCommand cmd;
MySqlParameter parm;
// Create the SelectCommand.
cmd = new MySqlCommand("SELECT * FROM mytable WHERE id=@id AND name=@name", conn);
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15);
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15);
da.SelectCommand = cmd;
// Create the InsertCommand.
cmd = new MySqlCommand("INSERT INTO mytable (id,name) VALUES (@id,@name)", conn);
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15, "id" );
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15, "name" );
da.InsertCommand = cmd;
return da;
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand">
<summary>
Gets or sets a SQL statement or stored procedure used to select records in the data source.
</summary><value>
A <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> used during <see cref="M:System.Data.Common.DbDataAdapter.Fill(System.Data.DataSet)" /> to select records from the
database for placement in the <see cref="T:System.Data.DataSet" />.
</value><remarks>
<para>
When <B>SelectCommand</B> is assigned to a previously created <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />,
the <B>MySqlCommand</B> is not cloned. The <B>SelectCommand</B> maintains a reference to the
previously created <B>MySqlCommand</B> object.
</para>
<para>
If the <B>SelectCommand</B> does not return any rows, no tables are added to the
<see cref="T:System.Data.DataSet" />, and no exception is raised.
</para>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and sets the
<see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> and <B>InsertCommand</B> properties. It assumes you have already
created a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> object.
<code lang="vbnet">
Public Shared Function CreateCustomerAdapter(conn As MySqlConnection) As MySqlDataAdapter
Dim da As MySqlDataAdapter = New MySqlDataAdapter()
Dim cmd As MySqlCommand
Dim parm As MySqlParameter
' Create the SelectCommand.
cmd = New MySqlCommand("SELECT * FROM mytable WHERE id=@id AND name=@name", conn)
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15)
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15)
da.SelectCommand = cmd
' Create the InsertCommand.
cmd = New MySqlCommand("INSERT INTO mytable (id,name) VALUES (@id, @name)", conn)
cmd.Parameters.Add( "@id", MySqlDbType.VarChar, 15, "id" )
cmd.Parameters.Add( "@name", MySqlDbType.VarChar, 15, "name" )
da.InsertCommand = cmd
Return da
End Function
</code>
<code lang="C#">
public static MySqlDataAdapter CreateCustomerAdapter(MySqlConnection conn)
{
MySqlDataAdapter da = new MySqlDataAdapter();
MySqlCommand cmd;
MySqlParameter parm;
// Create the SelectCommand.
cmd = new MySqlCommand("SELECT * FROM mytable WHERE id=@id AND name=@name", conn);
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15);
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15);
da.SelectCommand = cmd;
// Create the InsertCommand.
cmd = new MySqlCommand("INSERT INTO mytable (id,name) VALUES (@id,@name)", conn);
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15, "id" );
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15, "name" );
da.InsertCommand = cmd;
return da;
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlDataAdapter.UpdateCommand">
<summary>
Gets or sets a SQL statement or stored procedure used to updated records in the data source.
</summary><value>
A <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> used during <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" /> to update records in the
database with data from the <see cref="T:System.Data.DataSet" />.
</value><remarks>
<para>
During <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)" />, if this property is not set and primary key information
is present in the <see cref="T:System.Data.DataSet" />, the <B>UpdateCommand</B> can be generated
automatically if you set the <see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> property and use the
<see cref="T:MySql.Data.MySqlClient.MySqlCommandBuilder" />. Then, any additional commands that you do not set are
generated by the <B>MySqlCommandBuilder</B>. This generation logic requires key column
information to be present in the <B>DataSet</B>.
</para>
<para>
When <B>UpdateCommand</B> is assigned to a previously created <see cref="T:MySql.Data.MySqlClient.MySqlCommand" />,
the <B>MySqlCommand</B> is not cloned. The <B>UpdateCommand</B> maintains a reference
to the previously created <B>MySqlCommand</B> object.
</para>
<note>
If execution of this command returns rows, these rows may be merged with the DataSet
depending on how you set the <see cref="P:MySql.Data.MySqlClient.MySqlCommand.UpdatedRowSource" /> property of the <B>MySqlCommand</B> object.
</note>
</remarks><example>
The following example creates a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" /> and sets the
<see cref="P:MySql.Data.MySqlClient.MySqlDataAdapter.SelectCommand" /> and <B>UpdateCommand</B> properties. It assumes you have already
created a <see cref="T:MySql.Data.MySqlClient.MySqlConnection" /> object.
<code lang="vbnet">
Public Shared Function CreateCustomerAdapter(conn As MySqlConnection) As MySqlDataAdapter
Dim da As MySqlDataAdapter = New MySqlDataAdapter()
Dim cmd As MySqlCommand
Dim parm As MySqlParameter
' Create the SelectCommand.
cmd = New MySqlCommand("SELECT * FROM mytable WHERE id=@id AND name=@name", conn)
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15)
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15)
da.SelectCommand = cmd
' Create the UpdateCommand.
cmd = New MySqlCommand("UPDATE mytable SET id=@id, name=@name WHERE id=@oldId", conn)
cmd.Parameters.Add( "@id", MySqlDbType.VarChar, 15, "id" )
cmd.Parameters.Add( "@name", MySqlDbType.VarChar, 15, "name" )
parm = cmd.Parameters.Add("@oldId", MySqlDbType.VarChar, 15, "id")
parm.SourceVersion = DataRowVersion.Original
da.UpdateCommand = cmd
Return da
End Function
</code>
<code lang="C#">
public static MySqlDataAdapter CreateCustomerAdapter(MySqlConnection conn)
{
MySqlDataAdapter da = new MySqlDataAdapter();
MySqlCommand cmd;
MySqlParameter parm;
// Create the SelectCommand.
cmd = new MySqlCommand("SELECT * FROM mytable WHERE id=@id AND name=@name", conn);
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15);
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15);
da.SelectCommand = cmd;
// Create the UpdateCommand.
cmd = new MySqlCommand("UPDATE mytable SET id=@id, name=@name WHERE id=@oldId", conn);
cmd.Parameters.Add("@id", MySqlDbType.VarChar, 15, "id" );
cmd.Parameters.Add("@name", MySqlDbType.VarChar, 15, "name" );
parm = cmd.Parameters.Add( "@oldId", MySqlDbType.VarChar, 15, "id" );
parm.SourceVersion = DataRowVersion.Original;
da.UpdateCommand = cmd;
return da;
}
</code>
</example>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.OpenConnectionIfClosed(System.Data.DataRowState,System.Collections.Generic.List{MySql.Data.MySqlClient.MySqlConnection})">
<summary>
Open connection if it was closed.
Necessary to workaround "connection must be open and valid" error
with batched updates.
</summary>
<param name="state">Row state</param>
<param name="openedConnections"> list of opened connections
If connection is opened by this function, the list is updated
</param>
<returns>true if connection was opened</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.CreateRowUpdatedEvent(System.Data.DataRow,System.Data.IDbCommand,System.Data.StatementType,System.Data.Common.DataTableMapping)">
<summary>
Overridden. See <see cref="M:System.Data.Common.DbDataAdapter.CreateRowUpdatedEvent(System.Data.DataRow,System.Data.IDbCommand,System.Data.StatementType,System.Data.Common.DataTableMapping)"/>.
</summary>
<param name="dataRow"></param>
<param name="command"></param>
<param name="statementType"></param>
<param name="tableMapping"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.CreateRowUpdatingEvent(System.Data.DataRow,System.Data.IDbCommand,System.Data.StatementType,System.Data.Common.DataTableMapping)">
<summary>
Overridden. See <see cref="M:System.Data.Common.DbDataAdapter.CreateRowUpdatingEvent(System.Data.DataRow,System.Data.IDbCommand,System.Data.StatementType,System.Data.Common.DataTableMapping)"/>.
</summary>
<param name="dataRow"></param>
<param name="command"></param>
<param name="statementType"></param>
<param name="tableMapping"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.OnRowUpdating(System.Data.Common.RowUpdatingEventArgs)">
<summary>
Overridden. Raises the RowUpdating event.
</summary>
<param name="value">A MySqlRowUpdatingEventArgs that contains the event data.</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.OnRowUpdated(System.Data.Common.RowUpdatedEventArgs)">
<summary>
Overridden. Raises the RowUpdated event.
</summary>
<param name="value">A MySqlRowUpdatedEventArgs that contains the event data. </param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill records with.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill records with.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataTable)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataTable">The name of the <see cref="T:System.Data.DataTable"/> to use for table mapping.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataTable,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataTable">The name of the <see cref="T:System.Data.DataTable"/> to use for table mapping.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.String)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill with records.</param>
<param name="srcTable">The name of the source table to use for table mapping.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.String,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill with records.</param>
<param name="srcTable">The name of the source table to use for table mapping.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataTable,System.Data.IDataReader)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataTable">The <see cref="T:System.Data.DataTable"/> to fill with records.</param>
<param name="dataReader">An instance of <see cref="T:System.Data.IDataReader"/>.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataTable,System.Data.IDataReader,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataTable">The <see cref="T:System.Data.DataTable"/> to fill with records.</param>
<param name="dataReader">An instance of <see cref="T:System.Data.IDataReader"/>.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataTable,System.Data.IDbCommand,System.Data.CommandBehavior)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataTable">The <see cref="T:System.Data.DataTable"/> to fill with records.</param>
<param name="command">The SQL SELECT statement used to retrieve rows from the data source.</param>
<param name="behavior">One of the <see cref="T:System.Data.CommandBehavior"/> values.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataTable,System.Data.IDbCommand,System.Data.CommandBehavior,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataTable">The <see cref="T:System.Data.DataTable"/> to fill with records.</param>
<param name="command">The SQL SELECT statement used to retrieve rows from the data source.</param>
<param name="behavior">One of the <see cref="T:System.Data.CommandBehavior"/> values.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Int32,System.Int32,System.Data.DataTable[])">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="dataTables">The <see cref="T:System.Data.DataTable"/>s to fill with records.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Int32,System.Int32,System.Threading.CancellationToken,System.Data.DataTable[])">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="cancellationToken">The cancellation token.</param>
<param name="dataTables">The <see cref="T:System.Data.DataTable"/>s to fill with records.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.Int32,System.Int32,System.String)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill with records.</param>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="srcTable">The name of the source table to use for table mapping.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.Int32,System.Int32,System.String,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill with records.</param>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="srcTable">The name of the source table to use for table mapping.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.String,System.Data.IDataReader,System.Int32,System.Int32)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill with records.</param>
<param name="srcTable">The name of the source table to use for table mapping.</param>
<param name="dataReader">An instance of <see cref="T:System.Data.IDataReader"/>.</param>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.String,System.Data.IDataReader,System.Int32,System.Int32,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill with records.</param>
<param name="srcTable">The name of the source table to use for table mapping.</param>
<param name="dataReader">An instance of <see cref="T:System.Data.IDataReader"/>.</param>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataSet"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataTable[],System.Int32,System.Int32,System.Data.IDbCommand,System.Data.CommandBehavior)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataTables">The <see cref="T:System.Data.DataTable"/>s to fill with records.</param>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="command">The SQL SELECT statement used to retrieve rows from the data source.</param>
<param name="behavior">One of the <see cref="T:System.Data.CommandBehavior"/> values.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>s.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataTable[],System.Int32,System.Int32,System.Data.IDbCommand,System.Data.CommandBehavior,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataTables">The <see cref="T:System.Data.DataTable"/>s to fill with records.</param>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="command">The SQL SELECT statement used to retrieve rows from the data source.</param>
<param name="behavior">One of the <see cref="T:System.Data.CommandBehavior"/> values.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>s.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.Int32,System.Int32,System.String,System.Data.IDbCommand,System.Data.CommandBehavior)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill with records.</param>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="srcTable">The name of the source table to use for table mapping.</param>
<param name="command">The SQL SELECT statement used to retrieve rows from the data source.</param>
<param name="behavior">One of the <see cref="T:System.Data.CommandBehavior"/> values.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillAsync(System.Data.DataSet,System.Int32,System.Int32,System.String,System.Data.IDbCommand,System.Data.CommandBehavior,System.Threading.CancellationToken)">
<summary>
Asynchronous version of the Fill method.
</summary>
<param name="dataSet">The <see cref="T:System.Data.DataSet"/> to fill with records.</param>
<param name="startRecord">The start record.</param>
<param name="maxRecords">The max number of affected records.</param>
<param name="srcTable">The name of the source table to use for table mapping.</param>
<param name="command">The SQL SELECT statement used to retrieve rows from the data source.</param>
<param name="behavior">One of the <see cref="T:System.Data.CommandBehavior"/> values.</param>
<param name="cancellationToken">The cancellation token.</param>
<returns>The number of rows successfully added to or refreshed in the <see cref="T:System.Data.DataTable"/>.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillSchemaAsync(System.Data.DataSet,System.Data.SchemaType)">
<summary>
Async version of FillSchema
</summary>
<param name="dataSet">DataSet to use</param>
<param name="schemaType">Schema Type</param>
<returns>DataTable[]</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillSchemaAsync(System.Data.DataSet,System.Data.SchemaType,System.String)">
<summary>
Async version of FillSchema
</summary>
<param name="dataSet">DataSet to use</param>
<param name="schemaType">Schema Type</param>
<param name="srcTable">Source Table</param>
<returns>DataTable[]</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillSchemaAsync(System.Data.DataSet,System.Data.SchemaType,System.String,System.Data.IDataReader)">
<summary>
Async version of FillSchema
</summary>
<param name="dataSet">DataSet to use</param>
<param name="schemaType">Schema Type</param>
<param name="srcTable">Source Table</param>
<param name="dataReader">DataReader to use</param>
<returns>DataTable[]</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillSchemaAsync(System.Data.DataSet,System.Data.SchemaType,System.Data.IDbCommand,System.String,System.Data.CommandBehavior)">
<summary>
Async version of FillSchema
</summary>
<param name="dataSet">DataSet to use</param>
<param name="schemaType">Schema Type</param>
<param name="command">DBCommand to use</param>
<param name="srcTable">Source Table</param>
<param name="behavior">Command Behavior</param>
<returns>DataTable[]</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillSchemaAsync(System.Data.DataTable,System.Data.SchemaType)">
<summary>
Async version of FillSchema
</summary>
<param name="dataTable">DataTable to use</param>
<param name="schemaType">Schema Type</param>
<returns>DataTable</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillSchemaAsync(System.Data.DataTable,System.Data.SchemaType,System.Data.IDataReader)">
<summary>
Async version of FillSchema
</summary>
<param name="dataTable">DataTable to use</param>
<param name="schemaType">Schema Type</param>
<param name="dataReader">DataReader to use</param>
<returns>DataTable</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.FillSchemaAsync(System.Data.DataTable,System.Data.SchemaType,System.Data.IDbCommand,System.Data.CommandBehavior)">
<summary>
Async version of FillSchema
</summary>
<param name="dataTable">DataTable to use</param>
<param name="schemaType">Schema Type</param>
<param name="command">DBCommand to use</param>
<param name="behavior">Command Behavior</param>
<returns>DataTable</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.UpdateAsync(System.Data.DataRow[])">
<summary>
Async version of Update
</summary>
<param name="dataRows">DataRow[] to use</param>
<returns>int</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.UpdateAsync(System.Data.DataSet)">
<summary>
Async version of Update
</summary>
<param name="dataSet">DataSet to use</param>
<returns>int</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.UpdateAsync(System.Data.DataTable)">
<summary>
Async version of Update
</summary>
<param name="dataTable">DataTable to use</param>
<returns>int</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.UpdateAsync(System.Data.DataRow[],System.Data.Common.DataTableMapping)">
<summary>
Async version of Update
</summary>
<param name="dataRows">DataRow[] to use</param>
<param name="tableMapping">Data Table Mapping</param>
<returns>int</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlDataAdapter.UpdateAsync(System.Data.DataSet,System.String)">
<summary>
Async version of Update
</summary>
<param name="dataSet">DataSet to use</param>
<param name="srcTable">Source Table</param>
<returns></returns>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlRowUpdatingEventHandler">
<summary>
Represents the method that will handle the <see cref="E:MySql.Data.MySqlClient.MySqlDataAdapter.RowUpdating"/> event of a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter"/>.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlRowUpdatedEventHandler">
<summary>
Represents the method that will handle the <see cref="E:MySql.Data.MySqlClient.MySqlDataAdapter.RowUpdated"/> event of a <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter"/>.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlRowUpdatingEventArgs">
<summary>
Provides data for the RowUpdating event. This class cannot be inherited.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlRowUpdatingEventArgs.#ctor(System.Data.DataRow,System.Data.IDbCommand,System.Data.StatementType,System.Data.Common.DataTableMapping)">
<summary>
Initializes a new instance of the MySqlRowUpdatingEventArgs class.
</summary>
<param name="row">The <see cref="T:System.Data.DataRow"/> to
<see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)"/>.</param>
<param name="command">The <see cref="T:System.Data.IDbCommand"/> to execute during <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)"/>.</param>
<param name="statementType">One of the <see cref="T:System.Data.StatementType"/> values that specifies the type of query executed.</param>
<param name="tableMapping">The <see cref="T:System.Data.Common.DataTableMapping"/> sent through an <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)"/>.</param>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlRowUpdatingEventArgs.Command">
<summary>
Gets or sets the MySqlCommand to execute when performing the Update.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlRowUpdatedEventArgs">
<summary>
Provides data for the RowUpdated event. This class cannot be inherited.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlRowUpdatedEventArgs.#ctor(System.Data.DataRow,System.Data.IDbCommand,System.Data.StatementType,System.Data.Common.DataTableMapping)">
<summary>
Initializes a new instance of the MySqlRowUpdatedEventArgs class.
</summary>
<param name="row">The <see cref="T:System.Data.DataRow"/> sent through an <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)"/>.</param>
<param name="command">The <see cref="T:System.Data.IDbCommand"/> executed when <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)"/> is called.</param>
<param name="statementType">One of the <see cref="T:System.Data.StatementType"/> values that specifies the type of query executed.</param>
<param name="tableMapping">The <see cref="T:System.Data.Common.DataTableMapping"/> sent through an <see cref="M:System.Data.Common.DbDataAdapter.Update(System.Data.DataSet)"/>.</param>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlRowUpdatedEventArgs.Command">
<summary>
Gets or sets the MySqlCommand executed when Update is called.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlClientPermission">
<summary>
Enables the provider to help ensure that a user has a security level adequate for accessing data.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlClientPermission.Add(System.String,System.String,System.Data.KeyRestrictionBehavior)">
<summary>
Adds a new connection string with set of restricted keywords to the MySqlClientPermission object
</summary>
<param name="connectionString">Settings to be used for the connection</param>
<param name="restrictions">Keywords to define the restrictions</param>
<param name="behavior">KeyRestrictionBehavior to be used</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlClientPermission.Copy">
<summary>
Returns MySqlClientPermission as an IPermission
</summary>
<returns></returns>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlClientPermissionAttribute">
<summary>
Associates a security action with a custom security attribute.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlConfiguration">
<summary>
Represents a section within a configuration file.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConfiguration.Settings">
<summary>
Gets the MySQL configuations associated to the current configuration.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConfiguration.ExceptionInterceptors">
<summary>
Gets a collection of the exception interceptors available in the current configuration.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConfiguration.CommandInterceptors">
<summary>
Gets a collection of the command interceptors available in the current configuration.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConfiguration.AuthenticationPlugins">
<summary>
Gets a collection of the authentication plugins available in the current configuration.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlConfiguration.Replication">
<summary>
Gets or sets the replication configurations.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.AuthenticationPluginConfigurationElement">
<summary>
Defines the configurations allowed for an authentication plugin.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.AuthenticationPluginConfigurationElement.Name">
<summary>
Gets or sets the name of the authentication plugin.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.AuthenticationPluginConfigurationElement.Type">
<summary>
Gets or sets the type of the authentication plugin.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.InterceptorConfigurationElement">
<summary>
Defines the configurations allowed for an interceptor.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.InterceptorConfigurationElement.Name">
<summary>
Gets or sets the name of the interceptor.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.InterceptorConfigurationElement.Type">
<summary>
Gets or sets the type of the interceptor.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.GenericConfigurationElementCollection`1">
<summary>
Represents a generic configuration element.
</summary>
<typeparam name="T"></typeparam>
</member>
<member name="M:MySql.Data.MySqlClient.GenericConfigurationElementCollection`1.GetEnumerator">
<summary>
Gets an enumerator that iterates through the returned list.
</summary>
<returns>An enumerator that iterates through the returned list.</returns>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlHelper">
<summary>
Helper class that makes it easier to work with the provider.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDataRowAsync(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Asynchronous version of ExecuteDataRow.
</summary>
<param name="connectionString">The settings to be used for the connection.</param>
<param name="commandText">The command to execute.</param>
<param name="parms">The parameters to use for the command.</param>
<returns>The DataRow containing the first row of the resultset.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDataRowAsync(System.String,System.String,System.Threading.CancellationToken,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Asynchronous version of ExecuteDataRow.
</summary>
<param name="connectionString">The settings to be used for the connection.</param>
<param name="commandText">The command to execute.</param>
<param name="cancellationToken">The cancellation token.</param>
<param name="parms">The parameters to use for the command.</param>
<returns>The DataRow containing the first row of the resultset.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDataRow(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Executes a single SQL command and returns the first row of the resultset. A new MySqlConnection object
is created, opened, and closed during this method.
</summary>
<param name="connectionString">Settings to be used for the connection</param>
<param name="commandText">Command to execute</param>
<param name="parms">Parameters to use for the command</param>
<returns>DataRow containing the first row of the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDataset(System.String,System.String)">
<summary>
Executes a single SQL command and returns the resultset in a <see cref="T:System.Data.DataSet"/>.
A new MySqlConnection object is created, opened, and closed during this method.
</summary>
<param name="connectionString">Settings to be used for the connection</param>
<param name="commandText">Command to execute</param>
<returns><see cref="T:System.Data.DataSet"/> containing the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDataset(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Executes a single SQL command and returns the resultset in a <see cref="T:System.Data.DataSet"/>.
A new MySqlConnection object is created, opened, and closed during this method.
</summary>
<param name="connectionString">Settings to be used for the connection</param>
<param name="commandText">Command to execute</param>
<param name="commandParameters">Parameters to use for the command</param>
<returns><see cref="T:System.Data.DataSet"/> containing the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDataset(MySql.Data.MySqlClient.MySqlConnection,System.String)">
<summary>
Executes a single SQL command and returns the resultset in a <see cref="T:System.Data.DataSet"/>.
The state of the <see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object remains unchanged after execution
of this method.
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">Command to execute</param>
<returns><see cref="T:System.Data.DataSet"/> containing the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDataset(MySql.Data.MySqlClient.MySqlConnection,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Executes a single SQL command and returns the resultset in a <see cref="T:System.Data.DataSet"/>.
The state of the <see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object remains unchanged after execution
of this method.
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">Command to execute</param>
<param name="commandParameters">Parameters to use for the command</param>
<returns><see cref="T:System.Data.DataSet"/> containing the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.UpdateDataSet(System.String,System.String,System.Data.DataSet,System.String)">
<summary>
Updates the given table with data from the given <see cref="T:System.Data.DataSet"/>
</summary>
<param name="connectionString">Settings to use for the update</param>
<param name="commandText">Command text to use for the update</param>
<param name="ds"><see cref="T:System.Data.DataSet"/> containing the new data to use in the update</param>
<param name="tablename">Tablename in the dataset to update</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDatasetAsync(System.String,System.String)">
<summary>
Async version of ExecuteDataset
</summary>
<param name="connectionString">Settings to be used for the connection</param>
<param name="commandText">Command to execute</param>
<returns><see cref="T:System.Data.DataSet"/> containing the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDatasetAsync(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Async version of ExecuteDataset
</summary>
<param name="connectionString">Settings to be used for the connection</param>
<param name="commandText">Command to execute</param>
<param name="commandParameters">Parameters to use for the command</param>
<returns><see cref="T:System.Data.DataSet"/> containing the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDatasetAsync(MySql.Data.MySqlClient.MySqlConnection,System.String)">
<summary>
Async version of ExecuteDataset
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">Command to execute</param>
<returns><see cref="T:System.Data.DataSet"/> containing the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteDatasetAsync(MySql.Data.MySqlClient.MySqlConnection,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Async version of ExecuteDataset
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">Command to execute</param>
<param name="commandParameters">Parameters to use for the command</param>
<returns><see cref="T:System.Data.DataSet"/> containing the resultset</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.UpdateDataSetAsync(System.String,System.String,System.Data.DataSet,System.String)">
<summary>
Async version of UpdateDataset
</summary>
<param name="connectionString">Settings to use for the update</param>
<param name="commandText">Command text to use for the update</param>
<param name="ds"><see cref="T:System.Data.DataSet"/> containing the new data to use in the update</param>
<param name="tablename">Tablename in the dataset to update</param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteNonQuery(MySql.Data.MySqlClient.MySqlConnection,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Executes a single command against a MySQL database. The <see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> is assumed to be
open when the method is called and remains open after the method completes.
</summary>
<param name="connection">The <see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">The SQL command to be executed.</param>
<param name="commandParameters">An array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command.</param>
<returns>The number of affected records.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteNonQuery(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Executes a single command against a MySQL database.
</summary>
<param name="connectionString"><see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString"/> to use.</param>
<param name="commandText">The SQL command to be executed.</param>
<param name="parms">An rray of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command.</param>
<returns>The number of affected records.</returns>
<remarks>A new <see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> is created using the <see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString"/> given.</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReader(MySql.Data.MySqlClient.MySqlConnection,MySql.Data.MySqlClient.MySqlTransaction,System.String,MySql.Data.MySqlClient.MySqlParameter[],System.Boolean)">
<summary>
Executes a single command against a MySQL database, possibly inside an existing transaction.
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use for the command</param>
<param name="transaction"><see cref="T:MySql.Data.MySqlClient.MySqlTransaction"/> object to use for the command</param>
<param name="commandText">Command text to use</param>
<param name="commandParameters">Array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command</param>
<param name="externalConn">True if the connection should be preserved, false if not</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReader(System.String,System.String)">
<summary>
Executes a single command against a MySQL database.
</summary>
<param name="connectionString">Settings to use for this command</param>
<param name="commandText">Command text to use</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReader(MySql.Data.MySqlClient.MySqlConnection,System.String)">
<summary>
Executes a single command against a MySQL database.
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use for the command</param>
<param name="commandText">Command text to use</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReader(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Executes a single command against a MySQL database.
</summary>
<param name="connectionString">Settings to use for this command</param>
<param name="commandText">Command text to use</param>
<param name="commandParameters">Array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReader(MySql.Data.MySqlClient.MySqlConnection,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Executes a single command against a MySQL database.
</summary>
<param name="connection">Connection to use for the command</param>
<param name="commandText">Command text to use</param>
<param name="commandParameters">Array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteScalar(System.String,System.String)">
<summary>
Execute a single command against a MySQL database.
</summary>
<param name="connectionString">Settings to use for the update</param>
<param name="commandText">Command text to use for the update</param>
<returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteScalar(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Execute a single command against a MySQL database.
</summary>
<param name="connectionString">Settings to use for the command</param>
<param name="commandText">Command text to use for the command</param>
<param name="commandParameters">Parameters to use for the command</param>
<returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteScalar(MySql.Data.MySqlClient.MySqlConnection,System.String)">
<summary>
Execute a single command against a MySQL database.
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">Command text to use for the command</param>
<returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteScalar(MySql.Data.MySqlClient.MySqlConnection,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Execute a single command against a MySQL database.
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">Command text to use for the command</param>
<param name="commandParameters">Parameters to use for the command</param>
<returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.EscapeString(System.String)">
<summary>
Escapes the string.
</summary>
<param name="value">The string to escape.</param>
<returns>The string with all quotes escaped.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.DoubleQuoteString(System.String)">
<summary>
Replaces quotes with double quotes.
</summary>
<param name="value">The string to modidify.</param>
<returns>A string containing double quotes instead of single quotes.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteNonQueryAsync(MySql.Data.MySqlClient.MySqlConnection,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Async version of ExecuteNonQuery
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">SQL command to be executed</param>
<param name="commandParameters">Array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command.</param>
<returns>Rows affected</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteNonQueryAsync(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Asynchronous version of the ExecuteNonQuery method.
</summary>
<param name="connectionString"><see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString"/> to use.</param>
<param name="commandText">The SQL command to be executed.</param>
<param name="commandParameters">An array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command.</param>
<returns>The number of rows affected.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteNonQueryAsync(System.String,System.String,System.Threading.CancellationToken,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Asynchronous version of the ExecuteNonQuery method.
</summary>
<param name="connectionString"><see cref="P:MySql.Data.MySqlClient.MySqlConnection.ConnectionString"/> to use.</param>
<param name="commandText">The SQL command to be executed.</param>
<param name="cancellationToken">The cancellation token.</param>
<param name="commandParameters">An array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command.</param>
<returns>The number of rows affected.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReaderAsync(MySql.Data.MySqlClient.MySqlConnection,MySql.Data.MySqlClient.MySqlTransaction,System.String,MySql.Data.MySqlClient.MySqlParameter[],System.Boolean)">
<summary>
Async version of ExecuteReader
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use for the command</param>
<param name="transaction"><see cref="T:MySql.Data.MySqlClient.MySqlTransaction"/> object to use for the command</param>
<param name="commandText">Command text to use</param>
<param name="commandParameters">Array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command</param>
<param name="ExternalConn">True if the connection should be preserved, false if not</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReaderAsync(System.String,System.String)">
<summary>
Async version of ExecuteReader
</summary>
<param name="connectionString">Settings to use for this command</param>
<param name="commandText">Command text to use</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReaderAsync(MySql.Data.MySqlClient.MySqlConnection,System.String)">
<summary>
Async version of ExecuteReader
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use for the command</param>
<param name="commandText">Command text to use</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReaderAsync(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Async version of ExecuteReader
</summary>
<param name="connectionString">Settings to use for this command</param>
<param name="commandText">Command text to use</param>
<param name="commandParameters">Array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteReaderAsync(MySql.Data.MySqlClient.MySqlConnection,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Async version of ExecuteReader
</summary>
<param name="connection">Connection to use for the command</param>
<param name="commandText">Command text to use</param>
<param name="commandParameters">Array of <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> objects to use with the command</param>
<returns><see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object ready to read the results of the command</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteScalarAsync(System.String,System.String)">
<summary>
Async version of ExecuteScalar
</summary>
<param name="connectionString">Settings to use for the update</param>
<param name="commandText">Command text to use for the update</param>
<returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteScalarAsync(System.String,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Async version of ExecuteScalar
</summary>
<param name="connectionString">Settings to use for the command</param>
<param name="commandText">Command text to use for the command</param>
<param name="commandParameters">Parameters to use for the command</param>
<returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteScalarAsync(MySql.Data.MySqlClient.MySqlConnection,System.String)">
<summary>
Async version of ExecuteScalar
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">Command text to use for the command</param>
<returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlHelper.ExecuteScalarAsync(MySql.Data.MySqlClient.MySqlConnection,System.String,MySql.Data.MySqlClient.MySqlParameter[])">
<summary>
Async version of ExecuteScalar
</summary>
<param name="connection"><see cref="T:MySql.Data.MySqlClient.MySqlConnection"/> object to use</param>
<param name="commandText">Command text to use for the command</param>
<param name="commandParameters">Parameters to use for the command</param>
<returns>The first column of the first row in the result set, or a null reference if the result set is empty.</returns>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlParameter">
<summary>
Represents a parameter to a <see cref="T:MySql.Data.MySqlClient.MySqlCommand"/>, This class cannot be inherited.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.SourceVersion">
<summary>
Gets or sets the <see cref="T:System.Data.DataRowVersion"/> to use when loading <see cref="P:MySql.Data.MySqlClient.MySqlParameter.Value"/>.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameter.Clone">
<summary>
CLoses this object.
</summary>
<returns>An object that is a clone of this object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameter.#ctor(System.String,MySql.Data.MySqlClient.MySqlDbType,System.Int32,System.String)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> class with the parameter name, the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.MySqlDbType"/>, the size, and the source column name.
</summary>
<param name="parameterName">The name of the parameter to map. </param>
<param name="dbType">One of the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.MySqlDbType"/> values. </param>
<param name="size">The length of the parameter. </param>
<param name="sourceColumn">The name of the source column. </param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameter.#ctor(System.String,System.Object)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> class with the parameter name and a value of the new MySqlParameter.
</summary>
<param name="parameterName">The name of the parameter to map. </param>
<param name="value">An <see cref="T:System.Object"/> that is the value of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/>. </param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameter.#ctor(System.String,MySql.Data.MySqlClient.MySqlDbType)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> class with the parameter name and the data type.
</summary>
<param name="parameterName">The name of the parameter to map. </param>
<param name="dbType">One of the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.MySqlDbType"/> values. </param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameter.#ctor(System.String,MySql.Data.MySqlClient.MySqlDbType,System.Int32)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> class with the parameter name, the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.MySqlDbType"/>, and the size.
</summary>
<param name="parameterName">The name of the parameter to map. </param>
<param name="dbType">One of the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.MySqlDbType"/> values. </param>
<param name="size">The length of the parameter. </param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameter.#ctor(System.String,MySql.Data.MySqlClient.MySqlDbType,System.Int32,System.Data.ParameterDirection,System.Boolean,System.Byte,System.Byte,System.String,System.Data.DataRowVersion,System.Object)">
<summary>
Initializes a new instance of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> class with the parameter name, the type of the parameter, the size of the parameter, a <see cref="T:System.Data.ParameterDirection"/>, the precision of the parameter, the scale of the parameter, the source column, a <see cref="T:System.Data.DataRowVersion"/> to use, and the value of the parameter.
</summary>
<param name="parameterName">The name of the parameter to map. </param>
<param name="dbType">One of the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.MySqlDbType"/> values. </param>
<param name="size">The length of the parameter. </param>
<param name="direction">One of the <see cref="T:System.Data.ParameterDirection"/> values. </param>
<param name="isNullable">true if the value of the field can be null, otherwise false. </param>
<param name="precision">The total number of digits to the left and right of the decimal point to which <see cref="P:MySql.Data.MySqlClient.MySqlParameter.Value"/> is resolved.</param>
<param name="scale">The total number of decimal places to which <see cref="P:MySql.Data.MySqlClient.MySqlParameter.Value"/> is resolved. </param>
<param name="sourceColumn">The name of the source column. </param>
<param name="sourceVersion">One of the <see cref="T:System.Data.DataRowVersion"/> values. </param>
<param name="value">An <see cref="T:System.Object"/> that is the value of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/>. </param>
<exception cref="T:System.ArgumentException"/>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.Direction">
<summary>
Gets or sets a value indicating whether the parameter is input-only, output-only, bidirectional, or a stored procedure return value parameter.
As of MySql version 4.1 and earlier, input-only is the only valid choice.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.IsNullable">
<summary>
Gets or sets a value indicating whether the parameter accepts null values.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.MySqlDbType">
<summary>
Gets or sets the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.MySqlDbType"/> of the parameter.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.Precision">
<summary>
Gets or sets the maximum number of digits used to represent the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.Value"/> property.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.Scale">
<summary>
Gets or sets the number of decimal places to which <see cref="P:MySql.Data.MySqlClient.MySqlParameter.Value"/> is resolved.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.Size">
<summary>
Gets or sets the maximum size, in bytes, of the data within the column.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.Value">
<summary>
Gets or sets the value of the parameter.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.PossibleValues">
<summary>
Returns the possible values for this parameter if this parameter is of type
SET or ENUM. Returns null otherwise.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.SourceColumn">
<summary>
Gets or sets the name of the source column that is mapped to the <see cref="T:System.Data.DataSet"/> and used for loading or returning the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.Value"/>.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.SourceColumnNullMapping">
<summary>
Sets or gets a value which indicates whether the source column is nullable.
This allows <see cref="T:System.Data.Common.DbCommandBuilder"/> to correctly generate Update statements
for nullable columns.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameter.DbType">
<summary>
Gets or sets the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.DbType"/> of the parameter.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameter.ToString">
<summary>
Overridden. Gets a string containing the <see cref="P:MySql.Data.MySqlClient.MySqlParameter.ParameterName"/>.
</summary>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameter.ResetDbType">
<summary>
Resets the <b>DbType</b> property to its original settings.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlParameterCollection">
<summary>
Represents a collection of parameters relevant to a <see cref="T:MySql.Data.MySqlClient.MySqlCommand" /> as well as their respective mappings to columns in a <see cref="T:System.Data.DataSet" />. This class cannot be inherited.
</summary>
<remarks>
The number of the parameters in the collection must be equal to the number of
parameter placeholders within the command text, or an exception will be generated.
</remarks><example>
The following example creates multiple instances of <see cref="T:MySql.Data.MySqlClient.MySqlParameter" />
through the <B>MySqlParameterCollection</B> collection within the <see cref="T:MySql.Data.MySqlClient.MySqlDataAdapter" />.
These parameters are used to select data within the data source and place the data in
the <see cref="T:System.Data.DataSet" />. This code assumes that a <B>DataSet</B> and a <B>MySqlDataAdapter</B>
have already been created with the appropriate schema, commands, and connection.
<code lang="vbnet">
Public Sub AddParameters()
' ...
' create myDataSet and myDataAdapter
' ...
myDataAdapter.SelectCommand.Parameters.Add("@CategoryName", MySqlDbType.VarChar, 80).Value = "toasters"
myDataAdapter.SelectCommand.Parameters.Add("@SerialNum", MySqlDbType.Long).Value = 239
myDataAdapter.Fill(myDataSet)
End Sub 'AddSqlParameters
</code>
<code lang="C#">
public void AddSqlParameters()
{
// ...
// create myDataSet and myDataAdapter
// ...
myDataAdapter.SelectCommand.Parameters.Add("@CategoryName", MySqlDbType.VarChar, 80).Value = "toasters";
myDataAdapter.SelectCommand.Parameters.Add("@SerialNum", MySqlDbType.Long).Value = 239;
myDataAdapter.Fill(myDataSet);
}
</code>
</example>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameterCollection.IsFixedSize">
<summary>
Gets a value that indicates whether the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/>
has a fixed size.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameterCollection.IsReadOnly">
<summary>
Gets a value that indicates whether the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/>
is read-only.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameterCollection.IsSynchronized">
<summary>
Gets a value that indicates whether the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/>
is synchronized.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameterCollection.Count">
<summary>
Gets the number of MySqlParameter objects in the collection.
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameterCollection.Item(System.Int32)">
<summary>
Gets the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> at the specified index.
</summary>
<overloads>Gets the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> with a specified attribute.
[C#] In C#, this property is the indexer for the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/> class.
</overloads>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameterCollection.Item(System.String)">
<summary>
Gets the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> with the specified name.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Add(System.String,MySql.Data.MySqlClient.MySqlDbType,System.Int32,System.String)">
<summary>
Adds a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> to the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/> with the parameter name, the data type, the column length, and the source column name.
</summary>
<param name="parameterName">The name of the parameter.</param>
<param name="dbType">One of the <see cref="T:MySql.Data.MySqlClient.MySqlDbType"/> values. </param>
<param name="size">The length of the column.</param>
<param name="sourceColumn">The name of the source column.</param>
<returns>The newly added <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Add(MySql.Data.MySqlClient.MySqlParameter)">
<summary>
Adds the specified <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object to the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/>.
</summary>
<param name="value">The <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> to add to the collection.</param>
<returns>The newly added <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Add(System.String,System.Object)">
<summary>
Adds a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> to the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/> given the specified parameter name and value.
</summary>
<param name="parameterName">The name of the parameter.</param>
<param name="value">The <see cref="P:MySql.Data.MySqlClient.MySqlParameter.Value"/> of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> to add to the collection.</param>
<returns>The newly added <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.AddWithValue(System.String,System.Object)">
<summary>
Adds a parameter and its value.
</summary>
<param name="parameterName">The name of the parameter.</param>
<param name="value">The value of the parameter.</param>
<returns>A <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object representing the provided values.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Add(System.String,MySql.Data.MySqlClient.MySqlDbType)">
<summary>
Adds a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> to the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/> given the parameter name and the data type.
</summary>
<param name="parameterName">The name of the parameter.</param>
<param name="dbType">One of the <see cref="T:MySql.Data.MySqlClient.MySqlDbType"/> values. </param>
<returns>The newly added <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Add(System.String,MySql.Data.MySqlClient.MySqlDbType,System.Int32)">
<summary>
Adds a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> to the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/> with the parameter name, the data type, and the column length.
</summary>
<param name="parameterName">The name of the parameter.</param>
<param name="dbType">One of the <see cref="T:MySql.Data.MySqlClient.MySqlDbType"/> values. </param>
<param name="size">The length of the column.</param>
<returns>The newly added <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Clear">
<summary>
Removes all items from the collection.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.IndexOf(System.String)">
<summary>
Gets the location of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> in the collection with a specific parameter name.
</summary>
<param name="parameterName">The name of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object to retrieve. </param>
<returns>The zero-based location of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> in the collection.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.IndexOf(System.Object)">
<summary>
Gets the location of a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> in the collection.
</summary>
<param name="value">The <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object to locate. </param>
<returns>The zero-based location of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> in the collection.</returns>
<overloads>Gets the location of a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> in the collection.</overloads>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.AdjustHashes(System.Int32,System.Boolean)">
<summary>
This method will update all the items in the index hashes when
we insert a parameter somewhere in the middle
</summary>
<param name="keyIndex"></param>
<param name="addEntry"></param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.AddRange(System.Array)">
<summary>
Adds an array of values to the end of the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/>.
</summary>
<param name="values"></param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.GetParameter(System.String)">
<summary>
Retrieve the parameter with the given name.
</summary>
<param name="parameterName"></param>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Add(System.Object)">
<summary>
Adds the specified <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object to the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/>.
</summary>
<param name="value">The <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> to add to the collection.</param>
<returns>The index of the new <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Contains(System.String)">
<summary>
Gets a value indicating whether a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> with the specified parameter name exists in the collection.
</summary>
<param name="parameterName">The name of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object to find.</param>
<returns>true if the collection contains the parameter; otherwise, false.</returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Contains(System.Object)">
<summary>
Gets a value indicating whether a MySqlParameter exists in the collection.
</summary>
<param name="value">The value of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object to find. </param>
<returns>true if the collection contains the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object; otherwise, false.</returns>
<overloads>Gets a value indicating whether a <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> exists in the collection.</overloads>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.CopyTo(System.Array,System.Int32)">
<summary>
Copies MySqlParameter objects from the MySqlParameterCollection to the specified array.
</summary>
<param name="array"></param>
<param name="index"></param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.GetEnumerator">
<summary>
Returns an enumerator that iterates through the <see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/>.
</summary>
<returns></returns>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Insert(System.Int32,System.Object)">
<summary>
Inserts a MySqlParameter into the collection at the specified index.
</summary>
<param name="index"></param>
<param name="value"></param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.Remove(System.Object)">
<summary>
Removes the specified MySqlParameter from the collection.
</summary>
<param name="value"></param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.RemoveAt(System.String)">
<summary>
Removes the specified <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> from the collection using the parameter name.
</summary>
<param name="parameterName">The name of the <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> object to retrieve. </param>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlParameterCollection.RemoveAt(System.Int32)">
<summary>
Removes the specified <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> from the collection using a specific index.
</summary>
<param name="index">The zero-based index of the parameter. </param>
<overloads>Removes the specified <see cref="T:MySql.Data.MySqlClient.MySqlParameter"/> from the collection.</overloads>
</member>
<member name="P:MySql.Data.MySqlClient.MySqlParameterCollection.SyncRoot">
<summary>
Gets an object that can be used to synchronize access to the
<see cref="T:MySql.Data.MySqlClient.MySqlParameterCollection"/>.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlTransactionScope">
<summary>
Represents a single(not nested) TransactionScope
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.MySqlSecurityPermission">
<summary>
Defines security permissions assigned to a MySQL object.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.MySqlSecurityPermission.CreatePermissionSet(System.Boolean)">
<summary>
Creates a set of permissions.
</summary>
<param name="includeReflectionPermission">A flag indicating if the reflection permission should be included.</param>
<returns>A <see cref="T:System.Security.PermissionSet"/> object representing a collection of permissions.</returns>
</member>
<member name="T:MySql.Data.MySqlClient.BaseCommandInterceptor">
<summary>
BaseCommandInterceptor is the base class that should be used for all userland
command interceptors
</summary>
</member>
<member name="P:MySql.Data.MySqlClient.BaseCommandInterceptor.ActiveConnection">
<summary>
Gets the active connection.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.BaseCommandInterceptor.ExecuteScalar(System.String,System.Object@)">
<summary>
Executes an SQL statements that returns a scalar value such as a calculation.
</summary>
<param name="sql">The SQL statement to execute.</param>
<param name="returnValue">A scalar value that represents the result returned by the execution of the SQL statement.</param>
<returns><c>false</c>.</returns>
<remarks>This method is intended to be overriden.</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.BaseCommandInterceptor.ExecuteNonQuery(System.String,System.Int32@)">
<summary>
Executes an SQL statement that returns the number of affected rows.
</summary>
<param name="sql">The SQL statement to execute.</param>
<param name="returnValue">The number of affected rows.</param>
<returns><c>false</c>.</returns>
<remarks>This method is intended to be overriden.</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.BaseCommandInterceptor.ExecuteReader(System.String,System.Data.CommandBehavior,MySql.Data.MySqlClient.MySqlDataReader@)">
<summary>
Executes an SQL statement that will return a resultset.
</summary>
<param name="sql">The SQL statement to execute.</param>
<param name="behavior">A value that describes the results of the query and its effect on the database.</param>
<param name="returnValue">A <see cref="T:MySql.Data.MySqlClient.MySqlDataReader"/> object containing the result of the statement execution.</param>
<returns><c>false</c>.</returns>
<remarks>This method is intended to be overriden.</remarks>
</member>
<member name="M:MySql.Data.MySqlClient.BaseCommandInterceptor.Init(MySql.Data.MySqlClient.MySqlConnection)">
<summary>
Sets the active connection.
</summary>
<param name="connection">The active connection.</param>
</member>
<member name="T:MySql.Data.MySqlClient.CommandInterceptor">
<summary>
CommandInterceptor is the "manager" class that keeps the list of registered interceptors
for the given connection.
</summary>
</member>
<member name="T:MySql.Data.MySqlClient.Interceptors.BaseExceptionInterceptor">
<summary>
BaseExceptionInterceptor is the base class that should be used for all userland
exception interceptors.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Interceptors.BaseExceptionInterceptor.InterceptException(System.Exception)">
<summary>
Returns the received exception.
</summary>
<param name="exception">The exception to be returned.</param>
<returns>The exception originally received.</returns>
</member>
<member name="P:MySql.Data.MySqlClient.Interceptors.BaseExceptionInterceptor.ActiveConnection">
<summary>
Gets the active connection.
</summary>
</member>
<member name="M:MySql.Data.MySqlClient.Interceptors.BaseExceptionInterceptor.Init(MySql.Data.MySqlClient.MySqlConnection)">
<summary>
Initilizes this object by setting the active