[+/-]
Represents an open connection to a MySQL Server database. This class cannot be inherited.
A MySqlConnection
object represents a session
to a MySQL Server data source. When you create an instance of
MySqlConnection
, all properties are set to
their initial values. For a list of these values, see the
MySqlConnection
constructor.
If the MySqlConnection
goes out of scope, it
is not closed. Therefore, you must explicitly close the
connection by calling MySqlConnection.Close
or MySqlConnection.Dispose
.
Examples
The following example creates a MySqlCommand
and a MySqlConnection
. The
MySqlConnection
is opened and set as the
MySqlCommand.Connection
for the
MySqlCommand
. The example then calls
MySqlCommand.ExecuteNonQuery
, and closes the
connection. To accomplish this, the
ExecuteNonQuery
is passed a connection string
and a query string that is a SQL INSERT statement.
Visual Basic example:
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# example:
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(); }
Initializes a new instance of the
MySqlConnection
class.
When a new instance of 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 ConnectionString
property.
Properties | Initial Value |
ConnectionString |
empty string ("") |
ConnectionTimeout |
15 |
Database |
empty string ("") |
DataSource |
empty string ("") |
ServerVersion |
empty string ("") |
You can change the value for these properties only by using
the ConnectionString
property.
Examples
Overload methods for MySqlConnection
Initializes a new instance of the
MySqlConnection
class.
Initializes a new instance of the
MySqlConnection
class when given a string
containing the connection string.
When a new instance of 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 ConnectionString
property.
Properties | Initial Value |
ConnectionString |
empty string ("") |
ConnectionTimeout |
15 |
Database |
empty string ("") |
DataSource |
empty string ("") |
ServerVersion |
empty string ("") |
You can change the value for these properties only by using
the ConnectionString
property.
Examples
Parameters: The connection properties used to open the MySQL database.
Opens a database connection with the property settings specified by the ConnectionString.
Exception: Cannot open a connection without specifying a data source or server.
Exception: A connection-level error occurred while opening the connection.
The MySqlConnection
draws an open
connection from the connection pool if one is available.
Otherwise, it establishes a new connection to an instance of
MySQL.
Examples
The following example creates a
MySqlConnection
, opens it, displays some of
its properties, then closes the connection.
Visual Basic example:
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
C# example:
public void CreateMySqlConnection(string myConnString) { MySqlConnection myConnection = new MySqlConnection(myConnString); myConnection.Open(); MessageBox.Show("ServerVersion: " + myConnection.ServerVersion + "\nState: " + myConnection.State.ToString()); myConnection.Close(); }
Gets the name of the current database or the database to be used after a connection is opened.
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.
The Database
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
ChangeDatabase
method, this property is
updated to reflect the new database.
Examples
The following example creates a
MySqlConnection
and displays some of its
read-only properties.
Visual Basic example:
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
C# example:
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(); }
Gets the current state of the connection.
Returns: A bitwise
combination of the
System.Data.ConnectionState
values. The
default is Closed
.
The allowed state changes are:
From Closed
to
Open
, using the
Open
method of the connection object.
From Open
to
Closed
, using either the
Close
method or the
Dispose
method of the connection
object.
Examples
The following example creates a
MySqlConnection
, opens it, displays some of
its properties, then closes the connection.
Visual Basic example:
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
C# example:
public void CreateMySqlConnection(string myConnString) { MySqlConnection myConnection = new MySqlConnection(myConnString); myConnection.Open(); MessageBox.Show("ServerVersion: " + myConnection.ServerVersion + "\nState: " + myConnection.State.ToString()); myConnection.Close(); }
Gets a string containing the version of the MySQL server to which the client is connected.
Returns: The version of the instance of MySQL.
Exception: The connection is closed.
Examples
The following example creates a
MySqlConnection
, opens it, displays some of
its properties, then closes the connection.
Visual Basic example:
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
C# example:
public void CreateMySqlConnection(string myConnString) { MySqlConnection myConnection = new MySqlConnection(myConnString); myConnection.Open(); MessageBox.Show("ServerVersion: " + myConnection.ServerVersion + "\nState: " + myConnection.State.ToString()); myConnection.Close(); }
Closes the connection to the database. This is the preferred method of closing any open connection.
The Close
method rolls back any pending
transactions. It then releases the connection to the
connection pool, or closes the connection if connection
pooling is disabled.
An application can call Close
more than one
time. No exception is generated.
Examples
The following example creates a
MySqlConnection
, opens it, displays some of
its properties, then closes the connection.
Visual Basic example:
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
C# example:
public void CreateMySqlConnection(string myConnString) { MySqlConnection myConnection = new MySqlConnection(myConnString); myConnection.Open(); MessageBox.Show("ServerVersion: " + myConnection.ServerVersion + "\nState: " + myConnection.State.ToString()); myConnection.Close(); }
Creates and returns a MySqlCommand
object
associated with the MySqlConnection
.
Returns: A
MySqlCommand
object.
Begins a database transaction.
Returns: An object representing the new transaction.
Exception: Parallel transactions are not supported.
This command is equivalent to the MySQL BEGIN TRANSACTION command.
You must explicitly commit or roll back the transaction using
the MySqlTransaction.Commit
or
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 BeginTransaction
method, use the
overload that takes the iso
parameter.
Examples
The following example creates a
MySqlConnection
and a
MySqlTransaction
. It also demonstrates how
to use the BeginTransaction
, a
MySqlTransaction.Commit
, and
MySqlTransaction.Rollback
methods.
Visual Basic example:
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
C# example:
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(); } }
Begins a database transaction with the specified isolation level.
Parameters: The isolation level under which the transaction should run.
Returns: An object representing the new transaction.
Exception: Parallel exceptions are not supported.
This command is equivalent to the MySQL BEGIN TRANSACTION command.
You must explicitly commit or roll back the transaction using
the MySqlTransaction.Commit
or
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 BeginTransaction
method, use the
overload that takes the iso
parameter.
Examples
The following example creates a
MySqlConnection
and a
MySqlTransaction
. It also demonstrates how
to use the BeginTransaction
, a
MySqlTransaction.Commit
, and
MySqlTransaction.Rollback
methods.
Visual Basic example:
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
C# example:
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(); } }
Changes the current database for an open MySqlConnection.
Parameters: The name of the database to use.
The value supplied in the database
parameter must be a valid database name. The
database
parameter cannot contain a null
value, an empty string, or a string with only blank
characters.
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.
Exception: The database name is not valid.
Exception: The connection is not open.
Exception: Cannot change the database.
Examples
The following example creates a
MySqlConnection
and displays some of its
read-only properties.
Visual Basic example:
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
C# example:
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(); }
Occurs when the state of the connection changes.
The StateChange
event fires whenever the
State
changes from closed to opened, or
from opened to closed. StateChange
fires
immediately after the MySqlConnection
transitions.
If an event handler throws an exception from within the
StateChange
event, the exception propagates
to the caller of the Open
or
Close
method.
The StateChange
event is not raised unless
you explicitly call Close
or
Dispose
.
The event handler receives an argument of type
System.Data.StateChangeEventArgs
containing
data related to this event. The following
StateChangeEventArgs
properties provide
information specific to this event.
Property | Description |
System.Data.StateChangeEventArgs.CurrentState
|
Gets the new state of the connection. The connection object will be in the new state already when the event is fired. |
System.Data.StateChangeEventArgs.OriginalState
|
Gets the original state of the connection. |
Occurs when MySQL returns warnings as a result of executing a command or query.
Gets the time to wait while trying to establish a connection before terminating the attempt and generating an error.
Exception: The value set is less than 0.
A value of 0 indicates no limit, and should be avoided in a
MySqlConnection.ConnectionString
because an
attempt to connect will wait indefinitely.
Examples
The following example creates a MySqlConnection and sets some of its properties in the connection string.
Visual Basic example:
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
C# example:
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(); }
Gets or sets the string used to connect to a MySQL Server database.
The ConnectionString
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.
You can use the ConnectionString
property
to connect to a database. The following example illustrates a
typical connection string.
"Persist Security Info=False;database=MyDB;server=MySqlServer;user id=myUser;Password=myPass"
The ConnectionString
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.
MySqlConnection
properties return only
those settings contained in the
ConnectionString
.
To connect to a local machine, specify "localhost" for the server. If you do not specify a server, localhost is assumed.
Resetting the ConnectionString
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
MySqlConnection.Database
property is no
longer set to MyDb.
The connection string is parsed immediately after being set.
If errors in syntax are found when parsing, a runtime
exception, such as ArgumentException
, is
generated. Other errors can be found only when an attempt is
made to open the connection.
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.
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.
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
"key==word=value"
the keyword is "key=word" and the value is "value".
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.
Keywords are not case sensitive.
The following table lists the valid names for keyword values
within the ConnectionString
.
Name | Default | Description |
Connect Timeout , Connection
Timeout
|
15 | The length of time (in seconds) to wait for a connection to the server before terminating the attempt and generating an error. |
Host , Server , Data
Source , DataSource ,
Address , Addr ,
Network Address
|
localhost | 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. 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. |
Ignore Prepare |
true | When true, instructs the provider to ignore any calls to MySqlCommand.Prepare(). This option is provided to prevent issues with corruption of the statements when use with server side prepared statements. If you want to use server-side prepare statements, set this option to false. This option was added in Connector/NET 5.0.3. |
Port |
3306 | The port MySQL is using to listen for connections. Specify -1 for this value to use a named pipe connection (Windows only). This value is ignored if Unix socket is used. |
Protocol |
socket | Specifies the type of connection to make to the server.Values can be: socket or tcp for a socket connection pipe for a named pipe connection unix for a Unix socket connection memory to use MySQL shared memory |
CharSet , Character Set
|
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. | |
Logging |
false | When true, various pieces of information is output to any configured TraceListeners. |
Allow Batch |
true | When true, multiple SQL statements can be sent with one command execution. -Note- Starting with MySQL 4.1.1, batch statements should be separated by the server-defined seperator character. Commands sent to earlier versions of MySQL should be seperated with ';'. |
Encrypt |
false | For Connector/NET 5.0.3 and later, when true , SSL
encryption is used for all data sent between the
client and server if the server has a certificate
installed. Recognized values are
true , false ,
yes , and no . In
versions before 5.0.3, this option had no effect. |
Initial Catalog , Database
|
mysql | The name of the database to use intially |
Password , pwd
|
The password for the MySQL account being used. | |
Persist Security Info |
false | When set to false or no (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
true , false ,
yes , and no . |
User Id , Username ,
Uid , User name
|
The MySQL login account being used. | |
Shared Memory Name |
MYSQL | The name of the shared memory object to use for communication if the connection protocol is set to memory. |
Allow Zero Datetime |
false | True to have MySqlDataReader.GetValue() return a MySqlDateTime for date
or datetime columns that have illegal values. False
will cause a System.DateTime object
to be returned for legal values and an exception will
be thrown for illegal values. |
Convert Zero Datetime |
false | True to have MySqlDataReader.GetValue() and
MySqlDataReader.GetDateTime()
return DateTime.MinValue for date or datetime columns
that have illegal values. |
Old Syntax , OldSyntax
|
false | Allows use of '@' symbol as a parameter marker. See
MySqlCommand for more info. This is
for compatibility only. All future code should be
written to use the new '?' parameter marker. |
Pipe Name , Pipe
|
mysql | When set to the name of a named pipe, the
MySqlConnection will attempt to
connect to MySQL on that named pipe.This settings only
applies to the Windows platform. |
The following table lists the valid names for connection
pooling values within the ConnectionString
.
For more information about connection pooling, see Connection
Pooling for the MySql Data Provider.
Name | Default | Description |
Connection Lifetime |
0 | 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 Connection Lifetime .
This is useful in clustered configurations to force
load balancing between a running server and a server
just brought online. A value of zero (0) causes pooled
connections to have the maximum connection timeout. |
Max Pool Size |
100 | The maximum number of connections allowed in the pool. |
Min Pool Size |
0 | The minimum number of connections allowed in the pool. |
Pooling |
true | When true , the MySqlConnection
object is drawn from the appropriate pool, or if
necessary, is created and added to the appropriate
pool. Recognized values are true ,
false , yes , and
no . |
Reset Pooled Connections ,
ResetConnections ,
ResetPooledConnections
|
true | Specifies whether a ping and a reset should be sent to the server before a pooled connection is returned. Not resetting will yeild faster connection opens but also will not clear out session items such as temp tables. |
Cache Server Configuration ,
CacheServerConfiguration ,
CacheServerConfig
|
false | Specifies whether server variables should be updated when a pooled connection is returned. Turning this one will yeild faster opens but will also not catch any server changes made by other connections. |
When setting keyword or connection pooling values that require a Boolean value, you can use 'yes' instead of 'true', and 'no' instead of 'false'.
Note
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.
CAUTION
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).
Examples
The following example creates a
MySqlConnection
and sets some of its
properties
Visual Basic example:
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
C# example:
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(); }
Examples
The following example creates a
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.
Visual Basic example:
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
C# example:
public void CreateConnection() { MySqlConnection myConnection = new MySqlConnection(); myConnection.ConnectionString = "database=myDB;server=/var/lib/mysql/mysql.sock;user id=myUser; pwd=myPass"; myConnection.Open(); }
Ésta es una traducción del manual de referencia de MySQL, que puede encontrarse en dev.mysql.com. El manual de referencia original de MySQL está escrito en inglés, y esta traducción no necesariamente está tan actualizada como la versión original. Para cualquier sugerencia sobre la traducción y para señalar errores de cualquier tipo, no dude en dirigirse a mysql-es@vespito.com.