Table of Contents
CALL
StatementsMySQL Connectors provide connectivity to the MySQL server for client programs. APIs provide low-level access to the MySQL protocol and MySQL resources. Both Connectors and the APIs enable you to connect and execute MySQL statements from another language or environment, including Java (JDBC), ODBC, Perl, Python, PHP, Ruby, and native C and embedded MySQL instances.
Connector version numbers do not correlate with MySQL Server version numbers. See also Table 21.2, “MySQL Connector Versions and MySQL Server Versions”.
A number of connectors are developed by MySQL:
Connector/ODBC provides driver support for connecting to a MySQL server using the Open Database Connectivity (ODBC) API. Support is available for ODBC connectivity from Windows, Unix and Mac OS X platforms.
Connector/NET enables developers to create .NET applications that use data stored in a MySQL database. Connector/NET implement a fully functional ADO.NET interface and provides support for use with ADO.NET aware tools. Applications that want to use Connector/NET can be written in any of the supported .NET languages.
The MySQL Visual Studio Plugin works with Connector/NET and Visual Studio 2005. The plugin is a MySQL DDEX Provider, which means that you can use the schema and data manipulation tools within Visual Studio to create and edit objects within a MySQL database.
Connector/J provides driver support for connecting to MySQL from a Java application using the standard Java Database Connectivity (JDBC) API.
Connector/MXJ is a tool that enables easy deployment and management of MySQL server and database through your Java application.
Connector/C++ is a tool that enables easy deployment and management of MySQL server and database through your C++ application.
Connector/C is a stand-alone replacement for the MySQL Client
Library (libmysql
).
Connector/OpenOffice.org is a tool that enables OpenOffice.org applications to connect to MySQL server.
There are two direct access methods for using MySQL natively within a C application:
The C API provides low-level access to the MySQL protocol
through the libmysql
client library; this is
the primary method used to connect to an instance of the MySQL
server, and is used both by MySQL command line clients and many
of the APIs also detailed in this section. MySQL Connector/C can now also be
used for this purpose.
libmysqld
is an embedded MySQL server library
that enables you to embed an instance of the MySQL server into
your C applications.
If you need to access MySQL from a C application, or build an interface to MySQL for a language not supported by the Connectors or APIs in this chapter, the C API is where you would start. A number of programmers utilities are available to help with the process, and also covered in this section.
The remaining APIs provide an interface to MySQL from specific application langauges. These solutions are not developed or supported by MySQL. Basic information on their usage and abilities is provided here for reference purposes only.
All the language APIs are developed using one of two methods, using
libmysql
or by building a native
driver. The two solutions offer different benefits:
Using libmysql
offers
complete compatibility with MySQL as it uses the same libraries
as the MySQL client applications. However, the feature set is
limited to the implementation and interfaces exposed through
libmysql
and the performance may be lower as
data is copied between the native langiage, and the MySQL API
components. MySQL Connector/C is a possible alternative to using
libmysql
.
Native drivers are an implementation of the MySQL network protocol entirely within the host language or environment. Native drivers are fast, as there is less copying of data between components, and they can offer advanced functionality not available through the standard MySQL API. Native drivers are also easier to build and deploy, as you do not need a copy of the MySQL client libraries to build the native driver components.
A list of many of the libraries and interfaces available for MySQL are shown in the table. See Table 21.1, “MySQL APIs and Interfaces”.
Table 21.1. MySQL APIs and Interfaces
Environment | API | Type | Notes |
---|---|---|---|
Ada | MySQL Bindings for GNU Ada | libmysql | See MySQL Bindings for GNU Ada |
C | Connector/C | Replacement for libmysql | See Section 21.6, “MySQL Connector/C”. |
C++ | Connector/C++ | libmysql | See Section 21.5, “MySQL Connector/C++”. |
MySQL++ | libmysql | See MySQL++ Web site. | |
MySQL wrapped | libmysql | See MySQL wrapped. | |
Cocoa | MySQL-Cocoa | libmysql | Compatible with the Objective-C Cocoa environment. See http://mysql-cocoa.sourceforge.net/ |
D | MySQL for D | libmysql | See MySQL for D. |
Eiffel | Eiffel MySQL | libmysql | See Section 21.15, “MySQL Eiffel Wrapper”. |
Erlang | erlang-mysql-driver | libmysql | See
erlang-mysql-driver . |
Haskell | Haskell MySQL Bindings | Native Driver | See Brian O'Sullivan's pure Haskell MySQL bindings. |
hsql-mysql | libmysql | See MySQL driver for Haskell . | |
Java/JDBC | Connector/J | Native Driver | See Section 21.3, “MySQL Connector/J”. |
Kaya | MyDB | libmysql | See MyDB. |
Lua | LuaSQL | libmysql | See LuaSQL. |
.NET/Mono | Connector/NET | Native Driver | See Section 21.2, “MySQL Connector/NET”. |
Objective Caml | MySQL Bindings for OBjective Caml | libmysql | See MySQL Bindings for Objective Caml. |
Octave | Database bindings for GNU Octave | libmysql | See Database bindings for GNU Octave. |
ODBC | Connector/ODBC | libmysql | See Section 21.1, “MySQL Connector/ODBC”. |
OpenOffice | MySQL Connector/OpenOffice.org | libmysql | Direct connectivity, without using JDBC/ODBC. See Section 21.7, “MySQL Connector/OpenOffice.org”. |
Perl | DBI /DBD::mysql | libmysql | See Section 21.11, “MySQL Perl API”. |
Net::MySQL | Native Driver | See
Net::MySQL
at CPAN | |
PHP | mysql , ext/mysql interface
(deprecated) | libmysql | See Section 21.10.1, “MySQL”. |
mysqli , ext/mysqli interface | libmysql | See Section 21.10.2, “MySQL Improved Extension (Mysqli )”. | |
PDO_MYSQL | libmysql | See Section 21.10.4, “MySQL Functions (PDO_MYSQL)”. | |
PDO mysqlnd | Native Driver | See PHP PDO
mysqlnd . | |
Python | MySQLdb | libmysql | See Section 21.12, “MySQL Python API”. |
Ruby | MySQL/Ruby | libmysql | Uses libmysql . See
Section 21.13.1, “The MySQL/Ruby API”. |
Ruby/MySQL | Native Driver | See Section 21.13.2, “The Ruby/MySQL API”. | |
Scheme | Myscsh | libmysql | See
Myscsh . |
SPL | sql_mysql | libmysql | See
sql_mysql
for SPL. |
Tcl | MySQLtcl | libmysql | See Section 21.14, “MySQL Tcl API”. |
Table 21.2. MySQL Connector Versions and MySQL Server Versions
Connector | Connector version | MySQL Server version |
---|---|---|
Connector/C++ | 1.0.5 GA | 5.1, 5.4, 5.5, 5.6 |
Connector/OpenOffice.org | 1.0 GA | 5.0, 5.1, 5.4, 5.5, 5.6 |
Connector/J | 5.1.8 | 4.1, 5.0, 5.1, 5.4, 5.5, 5.6 |
Connector/NET | 1.0 (No longer supported) | 4.0, 5.0 |
Connector/NET | 5.2 | 5.0, 5.1, 5.4, 5.5, 5.6 |
Connector/NET | 6.0 | 5.0, 5.1, 5.4, 5.5, 5.6 |
Connector/NET | 6.1 | 5.0, 5.1, 5.4, 5.5, 5.6 |
Connector/ODBC | 3.51 (Unicode not supported) | 4.1, 5.0, 5.1, 5.4, 5.5, 5.6 |
Connector/ODBC | 5.1 | 4.1.1+, 5.0, 5.1, 5.4, 5.5, 5.6 |
The MySQL Connector/ODBC is the name for the family of MySQL ODBC drivers (previously called MyODBC drivers) that provide access to a MySQL database using the industry standard Open Database Connectivity (ODBC) API. This reference covers Connector/ODBC 3.51 and Connector/ODBC 5.1. Both releases provide an ODBC compliant interface to MySQL Server.
MySQL Connector/ODBC provides both driver-manager based and native interfaces to the MySQL database, which full support for MySQL functionality, including stored procedures, transactions and, with Connector/ODBC 5.1, full Unicode compliance.
For more information on the ODBC API standard and how to use it, refer to http://support.microsoft.com/kb/110093.
The application development part of this reference assumes a good working knowledge of C, general DBMS knowledge, and finally, but not least, familiarity with MySQL. For more information about MySQL functionality and its syntax, refer to http://dev.mysql.com/doc/.
Typically, you need to install Connector/ODBC only on Windows machines. For Unix and Mac OS X you can use the native MySQL network or named pipe to communicate with your MySQL database. You may need Connector/ODBC for Unix or Mac OS X if you have an application that requires an ODBC interface to communicate with the database. Applications that require ODBC to communicate with MySQL include ColdFusion, Microsoft Office, and Filemaker Pro.
Key topics:
For help installing Connector/ODBC see Section 21.1.3, “Connector/ODBC Installation”.
For information on the configuration options, see Section 21.1.4.2, “Connector/ODBC Connection Parameters”.
For more information on connecting to a MySQL database from a Windows host using Connector/ODBC see Section 21.1.5.2, “Step-by-step Guide to Connecting to a MySQL Database through Connector/ODBC”.
If you want to use Microsoft Access as an interface to a MySQL database using Connector/ODBC see Section 21.1.5.4, “Using Connector/ODBC with Microsoft Access”.
General tips on using Connector/ODBC, including obtaining the last auto-increment ID see Section 21.1.7.1, “Connector/ODBC General Functionality”.
For tips and common questions on using Connector/ODBC with specific application see Section 21.1.7.2, “Connector/ODBC Application Specific Tips”.
For a general list of Frequently Asked Questions see Section 21.1.7.3, “Connector/ODBC Errors and Resolutions (FAQ)”.
Additional support when using Connector/ODBC is available, see Section 21.1.8, “Connector/ODBC Support”.
There are currently two version of Connector/ODBC available:
Connector/ODBC 5.1, currently in GA status, is a partial rewrite of the of the 3.51 code base and is designed to work with all versions of MySQL from 4.1.1. It does not work with versions of MySQL Server prior to 4.1.1.
Connector/ODBC 5.1 also includes the following changes and improvements over the 3.51 release:
Improved support on Windows 64-bit platforms.
Full Unicode support at the driver level. This includes
support for the SQL_WCHAR
data type,
and support for Unicode login, password and DSN
configurations. For more information,. see
Microsoft
Knowledgebase Article #716246.
Support for the SQL_NUMERIC_STRUCT
data
type, which provides easier access to the precise
definition of numeric values. For more information, see
Microsoft
Knowledgebase Article #714556
Native Windows setup library. This replaces the Qt library based interface for configuring DSN information within the ODBC Data Sources application.
Support for the ODBC descriptor, which improves the handling and metadata of columns and parameter data. For more information, see Microsoft Knowledgebase Article #716339.
Connector/ODBC 3.51 is the current release of the 32-bit ODBC driver, also known as the MySQL ODBC 3.51 driver. Connector/ODBC 3.51 has support for ODBC 3.5x specification level 1 (complete core API + level 2 features) to continue to provide all functionality of ODBC for accessing MySQL.
The manual for versions of Connector/ODBC older than 3.51 can be located in the corresponding binary or source distribution. Please note that versions of Connector/ODBC earlier than the 3.51 revision were not fully compliant with the ODBC specification.
From this section onward, the primary focus of this guide is the Connector/ODBC 3.51 and Connector/ODBC 5.1 drivers.
Version numbers for MySQL products are formatted as X.X.X. However, Windows tools (Control Panel, properties display) may show the version numbers as XX.XX.XX. For example, the official MySQL formatted version number 5.0.9 may be displayed by Windows tools as 5.00.09. The two versions are the same; only the number display format is different.
ODBC (Open Database Connectivity) provides a way for client programs to access a wide range of databases or data sources. ODBC is a standardized API that enables connections to SQL database servers. It was developed according to the specifications of the SQL Access Group and defines a set of function calls, error codes, and data types that can be used to develop database-independent applications. ODBC usually is used when database independence or simultaneous access to different data sources is required.
For more information about ODBC, refer to http://support.microsoft.com/kb/110093.
Open Database Connectivity (ODBC) is a widely accepted application-programming interface (API) for database access. It is based on the Call-Level Interface (CLI) specifications from X/Open and ISO/IEC for database APIs and uses Structured Query Language (SQL) as its database access language.
A survey of ODBC functions supported by Connector/ODBC is given at Section 21.1.6.1, “Connector/ODBC API Reference”. For general information about ODBC, see http://support.microsoft.com/kb/110093.
The Connector/ODBC architecture is based on five components, as shown in the following diagram:
Application:
The Application uses the ODBC API to access the data from the MySQL server. The ODBC API in turn uses the communicates with the Driver Manager. The Application communicates with the Driver Manager using the standard ODBC calls. The Application does not care where the data is stored, how it is stored, or even how the system is configured to access the data. It needs to know only the Data Source Name (DSN).
A number of tasks are common to all applications, no matter how they use ODBC. These tasks are:
Selecting the MySQL server and connecting to it
Submitting SQL statements for execution
Retrieving results (if any)
Processing errors
Committing or rolling back the transaction enclosing the SQL statement
Disconnecting from the MySQL server
Because most data access work is done with SQL, the primary tasks for applications that use ODBC are submitting SQL statements and retrieving any results generated by those statements.
Driver manager:
The Driver Manager is a library that manages communication between application and driver or drivers. It performs the following tasks:
Resolves Data Source Names (DSN). The DSN is a configuration string that identifies a given database driver, database, database host and optionally authentication information that enables an ODBC application to connect to a database using a standardized reference.
Because the database connectivity information is identified by the DSN, any ODBC compliant application can connect to the data source using the same DSN reference. This eliminates the need to separately configure each application that needs access to a given database; instead you instruct the application to use a pre-configured DSN.
Loading and unloading of the driver required to access a specific database as defined within the DSN. For example, if you have configured a DSN that connects to a MySQL database then the driver manager will load the Connector/ODBC driver to enable the ODBC API to communicate with the MySQL host.
Processes ODBC function calls or passes them to the driver for processing.
Connector/ODBC Driver:
The Connector/ODBC driver is a library that implements the functions supported by the ODBC API. It processes ODBC function calls, submits SQL requests to MySQL server, and returns results back to the application. If necessary, the driver modifies an application's request so that the request conforms to syntax supported by MySQL.
DSN Configuration:
The ODBC configuration file stores the driver and database information required to connect to the server. It is used by the Driver Manager to determine which driver to be loaded according to the definition in the DSN. The driver uses this to read connection parameters based on the DSN specified. For more information, Section 21.1.4, “Connector/ODBC Configuration”.
MySQL Server:
The MySQL database where the information is stored. The database is used as the source of the data (during queries) and the destination for data (during inserts and updates).
An ODBC Driver Manager is a library that manages communication between the ODBC-aware application and any drivers. Its main functionality includes:
Resolving Data Source Names (DSN).
Driver loading and unloading.
Processing ODBC function calls or passing them to the driver.
Both Windows and Mac OS X include ODBC driver managers with the operating system. Most ODBC Driver Manager implementations also include an administration application that makes the configuration of DSN and drivers easier. Examples and information on these managers, including Unix ODBC driver managers are listed below:
Microsoft Windows ODBC Driver Manager
(odbc32.dll
),
http://support.microsoft.com/kb/110093.
Mac OS X includes ODBC Administrator
,
a GUI application that provides a simpler configuration
mechanism for the Unix iODBC Driver Manager. You can
configure DSN and driver information either through ODBC
Administrator or through the iODBC configuration files.
This also means that you can test ODBC Administrator
configurations using the iodbctest
command. http://www.apple.com.
unixODBC
Driver Manager for Unix
(libodbc.so
). See
http://www.unixodbc.org, for more
information. The unixODBC
Driver
Manager includes the Connector/ODBC driver 3.51 in the
installation package, starting with version
unixODBC
2.1.2.
iODBC
ODBC Driver Manager for Unix
(libiodbc.so
), see
http://www.iodbc.org, for more information.
You can install the Connector/ODBC drivers using two different methods, a binary installation and a source installation. The binary installation is the easiest and most straightforward method of installation. Using the source installation methods should only be necessary on platforms where a binary installation package is not available, or in situations where you want to customize or modify the installation process or Connector/ODBC drivers before installation.
Where to Get Connector/ODBC
You can get a copy of the latest version of Connector/ODBC binaries and sources from our Web site at http://dev.mysql.com/downloads/connector/odbc/.
For more information about Connector/ODBC, visit http://www.mysql.com/products/myodbc/.
For more information about licensing, visit http://www.mysql.com/company/legal/licensing/.
Supported Platforms
Connector/ODBC can be used on all major platforms supported by MySQL. You can install it on:
Windows 95, 98, Me, NT, 2000, XP, and 2003
All Unix-like Operating Systems, including: AIX, Amiga, BSDI, DEC, FreeBSD, HP-UX 10/11, Linux, NetBSD, OpenBSD, OS/2, SGI Irix, Solaris, SunOS, SCO OpenServer, SCO UnixWare, Tru64 Unix
Mac OS X and Mac OS X Server
Using a binary distribution offers the most straightforward method for installing Connector/ODBC. If you want more control over the driver, the installation location and or to customize elements of the driver you will need to build and install from the source.
If a binary distribution is not available for a particular
platform build the driver from the original source code. You can
contribute the binaries you create to MySQL by sending a mail
message to <myodbc@lists.mysql.com>
, so that it
becomes available for other users.
On all non-Windows platforms except Mac OS X, the driver is
built against unixODBC
and is expecting a
2-byte SQLWCHAR
, not 4 bytes as
iODBC
is using. For this reason, the binaries
are only compatible with
unixODBC
and you will need to recompile the
driver against iODBC
if you wish to use them
together. For further information see
Section 21.1.2.1.2, “ODBC Driver Managers”.
For further instructions:
Platform | Binary | Source |
---|---|---|
Windows | Installation Instructions | Build Instructions |
Unix/Linux | Installation Instructions | Build Instructions |
Mac OS X | Installation Instructions |
Before installing the Connector/ODBC drivers on Windows you should ensure that your Microsoft Data Access Components (MDAC) are up to date. You can obtain the latest version from the Microsoft Data Access and Storage Web site.
There are three available distribution types to use when installing for Windows. The contents in each case are identical, it is only the installation method which is different.
Zipped installer consists of a Zipped package containing a standalone installation application. To install from this package, you must unzip the installer, and then run the installation application. See Section 21.1.3.1.1, “Installing the Windows Connector/ODBC Driver using an installer” to complete the installation.
MSI installer, an installation file that can be used with the installer included in Windows 2000, Windows XP and Windows Server 2003. See Section 21.1.3.1.1, “Installing the Windows Connector/ODBC Driver using an installer” to complete the installation.
Zipped DLL package, containing the DLL files that need must be manually installed. See Section 21.1.3.1.2, “Installing the Windows Connector/ODBC Driver using the Zipped DLL package” to complete the installation.
An OLEDB/ODBC driver for Windows 64-bit is available from Microsoft Downloads.
The installer packages offer a very simple method for installing the Connector/ODBC drivers. If you have downloaded the zipped installer then you must extract the installer application. The basic installation process is identical for both installers.
You should follow these steps to complete the installation:
Double-click the standalone installer that you extracted, or the MSI file you downloaded.
The MySQL Connector/ODBC 3.51 - Setup Wizard will start. Click the
button to begin the installation process.You will need to choose the installation type. The Typical installation provides the standard files you will need to connect to a MySQL database using ODBC. The Complete option installs all the available files, including debug and utility components. It is recommended you choose one of these two options to complete the installation. If choose one of these methods, click
and then proceed to step 5.You may also choose a Custom installation, which enables you to select the individual components that you want to install. You have chosen this method, click
and then proceed to step 4.If you have chosen a custom installation, use the pop-ups to select which components to install and then click
to install the necessary files.Once the files have copied to your machine, the installation is complete. Click
to exit the installer.Now the installation is complete, you can continue to configure your ODBC connections using Section 21.1.4, “Connector/ODBC Configuration”.
If you have downloaded the Zipped DLL package then you must install the individual files required for Connector/ODBC operation manually. Once you have unzipped the installation files, you can either perform this operation by hand, executing each statement individually, or you can use the included Batch file to perform an installation to the default locations.
The following instructions will only work for 32-bit Windows systems. If you have a 64-bit Windows system you are advised to use the MSI installer, which will install both the 32-bit and 64-bit drivers to the correct locations.
To install using the Batch file:
Unzip the Connector/ODBC Zipped DLL package.
Open a Command Prompt.
Change to the directory created when you unzipped the Connector/ODBC Zipped DLL package.
Run Install.bat:
C:\> Install.bat
This will copy the necessary files into the default location, and then register the Connector/ODBC driver with the Windows ODBC manager.
If you want to copy the files to an alternative location - for example, to run or test different versions of the Connector/ODBC driver on the same machine, then you must copy the files by hand. It is however not recommended to install these files in a nonstandard location. To copy the files by hand to the default installation location use the following steps:
Unzip the Connector/ODBC Zipped DLL package.
Open a Command Prompt.
Change to the directory created when you unzipped the Connector/ODBC Zipped DLL package.
Copy the library files to a suitable directory. The
default is to copy them into the default Windows system
directory \Windows\System32
:
C:\>copy lib\myodbc3S.dll \Windows\System32
C:\>copy lib\myodbc3S.lib \Windows\System32
C:\>copy lib\myodbc3.dll \Windows\System32
C:\>copy lib\myodbc3.lib \Windows\System32
Copy the Connector/ODBC tools. These must be placed into a
directory that is in the system PATH
.
The default is to install these into the Windows system
directory \Windows\System32
:
C:\>copy bin\myodbc3i.exe \Windows\System32
C:\>copy bin\myodbc3m.exe \Windows\System32
C:\>copy bin\myodbc3c.exe \Windows\System32
Optionally copy the help files. For these files to be accessible through the help system, they must be installed in the Windows system directory:
C:\> copy doc\*.hlp \Windows\System32
Finally, you must register the Connector/ODBC driver with the ODBC manager:
C:\> myodbc3i -a -d -t"MySQL ODBC 3.51 Driver;\
DRIVER=myodbc3.dll;SETUP=myodbc3S.dll"
You must change the references to the DLL files and command location in the above statement if you have not installed these files into the default location.
There are two methods available for installing Connector/ODBC on Unix from a binary distribution. For most Unix environments you will need to use the tarball distribution. For Linux systems, there is also an RPM distribution available.
To install Connector/ODBC 5.1 on Unix you require unixODBC 2.2.12 or later to be installed.
To install the driver from a tarball distribution
(.tar.gz
file), download the latest
version of the driver for your operating system and follow
these steps that demonstrate the process using the Linux
version of the tarball:
shell>su root
shell>gunzip mysql-connector-odbc-3.51.11-i686-pc-linux.tar.gz
shell>tar xvf mysql-connector-odbc-3.51.11-i686-pc-linux.tar
shell>cd mysql-connector-odbc-3.51.11-i686-pc-linux
Read the installation instructions in the
INSTALL
file and execute these commands.
Then proceed on to
Section 21.1.4.5, “Configuring a Connector/ODBC DSN on Unix”, to
configure the DSN for Connector/ODBC. For more information,
refer to the INSTALL
file that comes with
your distribution.
To install or upgrade Connector/ODBC from an RPM distribution
on Linux, simply download the RPM distribution of the latest
version of Connector/ODBC and follow the instructions below.
Use su root to become
root
, then install the RPM file.
If you are installing for the first time:
shell>su root
shell>rpm -ivh mysql-connector-odbc-3.51.12.i386.rpm
If the driver exists, upgrade it like this:
shell>su root
shell>rpm -Uvh mysql-connector-odbc-3.51.12.i386.rpm
If there is any dependency error for MySQL client library,
libmysqlclient
, simply ignore it by
supplying the --nodeps
option, and then make
sure the MySQL client shared library is in the path or set
through LD_LIBRARY_PATH
.
This installs the driver libraries and related documents to
/usr/local/lib
and
/usr/share/doc/MyODBC
, respectively.
Proceed onto
Section 21.1.4.5, “Configuring a Connector/ODBC DSN on Unix”.
To uninstall the driver,
become root
and execute an
rpm command:
shell>su root
shell>rpm -e mysql-connector-odbc
Mac OS X is based on the FreeBSD operating system, and you can normally use the MySQL network port for connecting to MySQL servers on other hosts. Installing the Connector/ODBC driver enables you to connect to MySQL databases on any platform through the ODBC interface. You should only need to install the Connector/ODBC driver when your application requires an ODBC interface. Applications that require or can use ODBC (and therefore the Connector/ODBC driver) include ColdFusion, Filemaker Pro, 4th Dimension and many other applications.
Mac OS X includes its own ODBC manager, based on the
iODBC
manager. Mac OS X includes an
administration tool that provides easier administration of ODBC
drivers and configuration, updating the underlying
iODBC
configuration files.
The method for installing Connector/ODBC on Mac OS X depends on
the version on Connector/ODBC you are using. For Connector/ODBC
3.51.14 and later, the package is provided as a compressed tar
archive that you must manually install. For Connector/ODBC
3.51.13 and earlier the software was provided on a compressed
disk image (.dmg
) file and included an
installer.
In either case, the driver is designed to work with the iODBC driver manager included with Mac OS X.
To install Connector/ODBC 3.51.14 and later:
Download the installation file. Note that versions are available for both PowerPC and Intel platforms.
Extract the archive:
shell> tar zxf mysql-connector-odbc-3.51.16
-osx10.4-x86-32bit.tar.gz
The directory created will contain two subdirectories,
lib
and bin
. You
need to copy these to a suitable location such as
/usr/local
:
shell> cp bin/* /usr/local/bin shell> cp lib/* /usr/local/lib
Finally, you must register the driver with iODBC using the myodbc3i tool you just installed:
shell> myodbc3i -a -d -t"MySQL ODBC 3.51 Driver;Driver=/usr/local/lib/libmyodbc3.so;Setup=/usr/local/lib/libmyodbc3S.so"
You can verify the installed drivers either by using the ODBC Administrator application or the myodbc3i utility:
shell> myodbc3i -q -d
To install Connector/ODBC 3.51.13 and earlier, follow these steps:
Download the file to your computer and double-click the downloaded image file.
Within the disk image you will find an installer package
(with the .pkg
extension). Double-click
on this file to start the Mac OS X installer.
You will be presented with the installer welcome message. Click the
button to begin the installation process.Please take the time to read the Important Information as it contains guidance on how to complete the installation process. Once you have read the notice and collected the necessary information, click
.Connector/ODBC drivers are made available under the GNU General Public License. Please read the license if you are not familiar with it before continuing installation. Click
to approve the license (you will be asked to confirm that decision) and continue the installation.Choose a location to install the Connector/ODBC drivers and the ODBC Administrator application. You must install the files onto a drive with an operating system and you may be limited in the choices available. Select the drive you want to use, and then click
.The installer will automatically select the files that need to be installed on your machine. Click
to continue. The installer will copy the necessary files to your machine. A progress bar will be shown indicating the installation progress.When installation has been completed you will get a window like the one shown below. Click
to close and quit the installer.You should only need to install Connector/ODBC from source on Windows if you want to change or modify the source or installation. If you are unsure whether to install from source, please use the binary installation detailed in Section 21.1.3.1, “Installing Connector/ODBC from a Binary Distribution on Windows”.
Installing Connector/ODBC from source on Windows requires a number of different tools and packages:
MDAC, Microsoft Data Access SDK from http://support.microsoft.com/kb/110093.
Suitable C compiler, such as Microsoft Visual C++ or the C compiler included with Microsoft Visual Studio.
Compatible make
tool. Microsoft's
nmake
is used in the examples in this
section.
MySQL client libraries and include files from MySQL 4.0.0 or higher. (Preferably MySQL 4.0.16 or higher). This is required because Connector/ODBC uses new calls and structures that exist only starting from this version of the library. To get the client libraries and include files, visit http://dev.mysql.com/downloads/.
Connector/ODBC source distributions include
Makefiles
that require the
nmake or other make
utility. In the distribution, you can find
Makefile
for building the release version
and Makefile_debug
for building debugging
versions of the driver libraries and DLLs.
To build the driver, use this procedure:
Download and extract the sources to a folder, then change
directory into that folder. The following command assumes
the folder is named myodbc3-src
:
C:\> cd myodbc3-src
Edit Makefile
to specify the correct
path for the MySQL client libraries and header files. Then
use the following commands to build and install the
release version:
C:\>nmake -f Makefile
C:\>nmake -f Makefile install
nmake -f Makefile builds the release
version of the driver and places the binaries in
subdirectory called Release
.
nmake -f Makefile install installs
(copies) the driver DLLs and libraries
(myodbc3.dll
,
myodbc3.lib
) to your system
directory.
To build the debug version, use
Makefile_Debug
rather than
Makefile
, as shown below:
C:\>nmake -f Makefile_debug
C:\>nmake -f Makefile_debug install
You can clean and rebuild the driver by using:
C:\>nmake -f Makefile clean
C:\>nmake -f Makefile install
Make sure to specify the correct MySQL client libraries
and header files path in the Makefiles (set the
MYSQL_LIB_PATH
and
MYSQL_INCLUDE_PATH
variables). The
default header file path is assumed to be
C:\mysql\include
. The default
library path is assumed to be
C:\mysql\lib\opt
for release DLLs
and C:\mysql\lib\debug
for debug
versions.
For the complete usage of nmake, visit http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dv_vcce4/html/evgrfRunningNMAKE.asp.
If you are using the Subversion tree for compiling, all
Windows-specific Makefiles
are
named as Win_Makefile*
.
You need the following tools to build MySQL from source on Unix:
A working ANSI C++ compiler. gcc 2.95.2 or later, SGI C++, and SunPro C++ are some of the compilers that are known to work.
A good make program. GNU make is always recommended and is sometimes required.
MySQL client libraries and include files from MySQL 4.0.0 or higher. (Preferably MySQL 4.0.16 or higher). This is required because Connector/ODBC uses new calls and structures that exist only starting from this version of the library. To get the client libraries and include files, visit http://dev.mysql.com/downloads/.
If you have built your own MySQL server or client libraries
from source, you must have used the
--enable-thread-safe-client
option to configure
when the libraries
were built.
You should also ensure that the
libmysqlclient
library were built and
installed as a shared library.
A compatible ODBC manager must be installed. Connector/ODBC
is known to work with the iODBC
and
unixODBC
managers. See
Section 21.1.2.1.2, “ODBC Driver Managers”, for more
information.
If you are using a character set that isn't compiled into
the MySQL client library then you need to install the MySQL
character definitions from the charsets
directory into SHAREDIR
(by
default,
/usr/local/mysql/share/mysql/charsets
).
These should be in place if you have installed the MySQL
server on the same machine. See Section 9.1, “Character Set Support”,
for more information on character set support.
Once you have all the required files, unpack the source files to a separate directory, you then have to run configure and build the library using make.
The configure script gives you a great deal of control over how you configure your Connector/ODBC build. Typically you do this using options on the configure command line. You can also affect configure using certain environment variables. For a list of options and environment variables supported by configure, run this command:
shell> ./configure --help
Some of the more commonly used configure options are described here:
To compile Connector/ODBC, you need to supply the MySQL
client include and library files path using the
--with-mysql-path=
option, where DIR
DIR
is the
directory where MySQL is installed.
MySQL compile options can be determined by running
.
DIR
/bin/mysql_config
Supply the standard header and library files path for your
ODBC Driver Manager (iODBC
or
unixODBC
).
If you are using iODBC
and
iODBC
is not installed in its
default location (/usr/local
),
you might have to use the
--with-iodbc=
option, where DIR
DIR
is the
directory where iODBC
is installed.
If the iODBC
headers do not reside
in
,
you can use the
DIR
/include--with-iodbc-includes=
option to specify their location.
INCDIR
The applies to libraries. If they are not in
,
you can use the
DIR
/lib--with-iodbc-libs=
option.
LIBDIR
If you are using unixODBC
, use the
--with-unixODBC=
option (case sensitive) to make
configure look for
DIR
unixODBC
instead of
iODBC
by default,
DIR
is the directory where
unixODBC
is installed.
If the unixODBC
headers and
libraries aren't located in
and
DIR
/include
,
use the
DIR
/lib--with-unixODBC-includes=
and
INCDIR
--with-unixODBC-libs=
options.
LIBDIR
You might want to specify an installation prefix other
than /usr/local
. For example, to
install the Connector/ODBC drivers in
/usr/local/odbc/lib
, use the
--prefix=/usr/local/odbc
option.
The final configuration command looks something like this:
shell>./configure --prefix=/usr/local \
--with-iodbc=/usr/local \
--with-mysql-path=/usr/local/mysql
There are a number of other options that you need, or want, to set when configuring the Connector/ODBC driver before it is built.
To link the driver with MySQL thread safe client libraries
libmysqlclient_r.so
or
libmysqlclient_r.a
, you must specify
the following configure option:
--enable-thread-safe
and can be disabled (default) using
--disable-thread-safe
This option enables the building of the driver thread-safe
library libmyodbc3_r.so
from by
linking with MySQL thread-safe client library
libmysqlclient_r.so
(The extensions
are OS dependent).
If the compilation with the thread-safe option fails, it
may be because the correct thread-libraries on the system
could not be located. You should set the value of
LIBS
to point to the correct thread
library for your system.
LIBS="-lpthread" ./configure ..
You can enable or disable the shared and static versions of Connector/ODBC using these options:
--enable-shared[=yes/no] --disable-shared --enable-static[=yes/no] --disable-static
By default, all the binary distributions are built as
nondebugging versions (configured with
--without-debug
).
To enable debugging information, build the driver from
source distribution and use the
--with-debug
option when
you run configure.
This option is available only for source trees that have been obtained from the Subversion repository. This option does not apply to the packaged source distributions.
By default, the driver is built with the
--without-docs
option. If you would like
the documentation to be built, then execute
configure with:
--with-docs
To build the driver libraries, you have to just execute make.
shell> make
If any errors occur, correct them and continue the build
process. If you aren't able to build, then send a detailed
email to <myodbc@lists.mysql.com>
for further
assistance.
On most platforms, MySQL does not build or support
.so
(shared) client libraries by default.
This is based on our experience of problems when building
shared libraries.
In cases like this, you have to download the MySQL distribution and configure it with these options:
--without-server --enable-shared
To build shared driver libraries, you must specify the
--enable-shared
option for
configure. By default,
configure does not enable this option.
If you have configured with the
--disable-shared
option, you can build the
.so
file from the static libraries using
the following commands:
shell>cd mysql-connector-odbc-3.51.01
shell>make
shell>cd driver
shell>CC=/usr/bin/gcc \
$CC -bundle -flat_namespace -undefined error \
-o .libs/libmyodbc3-3.51.01.so \
catalog.o connect.o cursor.o dll.o error.o execute.o \
handle.o info.o misc.o myodbc3.o options.o prepare.o \
results.o transact.o utility.o \
-L/usr/local/mysql/lib/mysql/ \
-L/usr/local/iodbc/lib/ \
-lz -lc -lmysqlclient -liodbcinst
Make sure to change -liodbcinst
to
-lodbcinst
if you are using
unixODBC
instead of
iODBC
, and configure the library paths
accordingly.
This builds and places the
libmyodbc3-3.51.01.so
file in the
.libs
directory. Copy this file to the
Connector/ODBC library installation directory
(/usr/local/lib
(or the
lib
directory under the installation
directory that you supplied with the
--prefix
).
shell>cd .libs
shell>cp libmyodbc3-3.51.01.so /usr/local/lib
shell>cd /usr/local/lib
shell>ln -s libmyodbc3-3.51.01.so libmyodbc3.so
To build the thread-safe driver library:
shell>CC=/usr/bin/gcc \
$CC -bundle -flat_namespace -undefined error
-o .libs/libmyodbc3_r-3.51.01.so
catalog.o connect.o cursor.o dll.o error.o execute.o
handle.o info.o misc.o myodbc3.o options.o prepare.o
results.o transact.o utility.o
-L/usr/local/mysql/lib/mysql/
-L/usr/local/iodbc/lib/
-lz -lc -lmysqlclient_r -liodbcinst
To install the driver libraries, execute the following command:
shell> make install
That command installs one of the following sets of libraries:
For Connector/ODBC 3.51:
libmyodbc3.so
libmyodbc3-3.51.01.so
, where 3.51.01
is the version of the driver
libmyodbc3.a
For thread-safe Connector/ODBC 3.51:
libmyodbc3_r.so
libmyodbc3-3_r.51.01.so
libmyodbc3_r.a
For more information on build process, refer to the
INSTALL
file that comes with the source
distribution. Note that if you are trying to use the
make from Sun, you may end up with errors.
On the other hand, GNU gmake should work
fine on all platforms.
To run the basic samples provided in the distribution with the libraries that you built, use the following command:
shell> make test
Before running the tests, create the DSN 'myodbc3' in
odbc.ini
and set the environment variable
ODBCINI
to the correct
odbc.ini
file; and MySQL server is
running. You can find a sample odbc.ini
with the driver distribution.
You can even modify the
samples/run-samples
script to pass the
desired DSN, UID, and PASSWORD values as the command-line
arguments to each sample.
To build the driver on Mac OS X (Darwin), make use of the following configure example:
shell>./configure --prefix=/usr/local
--with-unixODBC=/usr/local
--with-mysql-path=/usr/local/mysql
--disable-shared
--enable-gui=no
--host=powerpc-apple
The command assumes that the unixODBC
and
MySQL are installed in the default locations. If not,
configure accordingly.
On Mac OS X, --enable-shared
builds
.dylib
files by default. You can build
.so
files like this:
shell>make
shell>cd driver
shell>CC=/usr/bin/gcc \
$CC -bundle -flat_namespace -undefined error
-o .libs/libmyodbc3-3.51.01.so *.o
-L/usr/local/mysql/lib/
-L/usr/local/iodbc/lib
-liodbcinst -lmysqlclient -lz -lc
To build the thread-safe driver library:
shell>CC=/usr/bin/gcc \
$CC -bundle -flat_namespace -undefined error
-o .libs/libmyodbc3-3.51.01.so *.o
-L/usr/local/mysql/lib/
-L/usr/local/iodbc/lib
-liodbcinst -lmysqlclienti_r -lz -lc -lpthread
Make sure to change the -liodbcinst
to
-lodbcinst
in case of using
unixODBC
instead of
iODBC
and configure the libraries path
accordingly.
In Apple's version of GCC, both cc and gcc are actually symbolic links to gcc3.
Copy this library to the $prefix/lib
directory and symlink to libmyodbc3.so
.
You can cross-check the output shared-library properties using this command:
shell> otool -LD .libs/libmyodbc3-3.51.01.so
To build the driver on HP-UX 10.x or 11.x, make use of the following configure example:
If using cc:
shell>CC="cc" \
CFLAGS="+z" \
LDFLAGS="-Wl,+b:-Wl,+s" \
./configure --prefix=/usr/local
--with-unixodbc=/usr/local
--with-mysql-path=/usr/local/mysql/lib/mysql
--enable-shared
--enable-thread-safe
If using gcc:
shell>CC="gcc" \
LDFLAGS="-Wl,+b:-Wl,+s" \
./configure --prefix=/usr/local
--with-unixodbc=/usr/local
--with-mysql-path=/usr/local/mysql
--enable-shared
--enable-thread-safe
Once the driver is built, cross-check its attributes using
chatr .libs/libmyodbc3.sl to determine
whether you need to have set the MySQL client library path
using the SHLIB_PATH
environment variable.
For static versions, ignore all shared-library options and run
configure with the
--disable-shared
option.
To build the driver on AIX, make use of the following configure example:
shell>./configure --prefix=/usr/local
--with-unixodbc=/usr/local
--with-mysql-path=/usr/local/mysql
--disable-shared
--enable-thread-safe
For more information about how to build and set up the static and shared libraries across the different platforms refer to ' Using static and shared libraries across platforms'.
You should read this section only if you are interested in helping us test our new code. If you just want to get MySQL Connector/ODBC up and running on your system, you should use a standard release distribution.
To obtain the most recent development source tree, you first need to download and install Bazaar. You can obtain Bazaar from the Bazaar VCS Web site. Bazaar is supported by any platform that supports Python, and is therefore compatible with any Linux, Unix, Windows or Mac OS X host. Instructions for downloading and installing Bazaar on the different platforms are available on the Bazaar Web site.
To build from the source trees, you need the following tools:
autoconf 2.52 (or newer)
automake 1.4 (or newer)
libtool 1.4 (or newer)
m4
The most recent development source tree is available from our public Subversion trees at http://dev.mysql.com/tech-resources/sources.html.
To check out out the Connector/ODBC sources, change to the directory where you want the copy of the Connector/ODBC tree to be stored, then use the following command:
shell> bzr branch lp:myodbc
You should now have a copy of the entire Connector/ODBC source
tree in the directory connector-odbc3
. To
build from this source tree on Unix or Linux follow these steps:
shell>cd myodbc
shell>aclocal
shell>autoheader
shell>libtoolize -c -f
shell>autoconf
shell>automake;
shell>./configure # Add your favorite options here
shell>make
For more information on how to build, refer to the
INSTALL
file located in the same directory.
For more information on options to configure,
see
Section 21.1.3.5.1, “Typical configure Options”
When the build is done, run make install to install the Connector/ODBC 3.51 driver on your system.
If you have gotten to the make stage and the
distribution does not compile, please report it to
<myodbc@lists.mysql.com>
.
On Windows, make use of Windows Makefiles
WIN-Makefile
and
WIN-Makefile_debug
in building the driver.
For more information, see
Section 21.1.3.4, “Installing Connector/ODBC from a Source Distribution on Windows”.
After the initial checkout operation to get the source tree, you should run bzr pull periodically to update your source according to the latest version.
Before you connect to a MySQL database using the Connector/ODBC driver you must configure an ODBC Data Source Name. The DSN associates the various configuration parameters required to communicate with a database to a specific name. You use the DSN in an application to communicate with the database, rather than specifying individual parameters within the application itself. DSN information can be user specific, system specific, or provided in a special file. ODBC data source names are configured in different ways, depending on your platform and ODBC driver.
A Data Source Name associates the configuration parameters for communicating with a specific database. Generally a DSN consists of the following parameters:
In addition, different ODBC drivers, including Connector/ODBC, may accept additional driver-specific options and parameters.
There are three types of DSN:
A System DSN is a global DSN definition that is available to any user and application on a particular system. A System DSN can normally only be configured by a systems administrator, or by a user who has specific permissions that let them create System DSNs.
A User DSN is specific to an individual user, and can be used to store database connectivity information that the user regularly uses.
A File DSN uses a simple file to define the DSN configuration. File DSNs can be shared between users and machines and are therefore more practical when installing or deploying DSN information as part of an application across many machines.
DSN information is stored in different locations depending on your platform and environment.
You can specify the parameters in the following tables for
Connector/ODBC when configuring a DSN. Users on Windows can use
the Options and Advanced panels when configuring a DSN to set
these parameters; see the table for information on which options
relate to which fields and checkboxes. On Unix and Mac OS X, use
the parameter name and value as the keyword/value pair in the
DSN configuration. Alternatively, you can set these parameters
within the InConnectionString
argument in the
SQLDriverConnect()
call.
Parameter | Default Value | Comment |
---|---|---|
user | ODBC | The user name used to connect to MySQL. |
uid | ODBC | Synonymous with user . Added in 3.51.16. |
server | localhost | The host name of the MySQL server. |
database | The default database. | |
option | 0 | Options that specify how Connector/ODBC should work. See below. |
port | 3306 | The TCP/IP port to use if server is not
localhost . |
initstmt | Initial statement. A statement to execute when connecting to MySQL. In
version 3.51 the parameter is called
stmt . Note, the driver supports the
initial statement being executed only at the time of the
initial connection. | |
password | The password for the user account on
server . | |
pwd | Synonymous with password . Added in 3.51.16. | |
socket | The Unix socket file or Windows named pipe to connect to if
server is
localhost . | |
sslca | The path to a file with a list of trust SSL CAs. Added in 3.51.16. | |
sslcapath | The path to a directory that contains trusted SSL CA certificates in PEM format. Added in 3.51.16. | |
sslcert | The name of the SSL certificate file to use for establishing a secure connection. Added in 3.51.16. | |
sslcipher | A list of permissible ciphers to use for SSL encryption. The cipher list
has the same format as the openssl
ciphers command Added in 3.51.16. | |
sslkey | The name of the SSL key file to use for establishing a secure connection. Added in 3.51.16. | |
charset | The character set to use for the connection. Added in 3.51.17. | |
sslverify | If set to 1, the SSL certificate will be verified when used with the MySQL connection. If not set, then the default behavior is to ignore SSL certificate verification. | |
readtimeout | The timeout in seconds for attempts to read from the server. Each
attempt uses this timeout value and there are retries if
necessary, so the total effective timeout value is three
times the option value. You can set the value so that a
lost connection can be detected earlier than the TCP/IP
Close_Wait_Timeout value of 10
minutes. This option works only for TCP/IP connections,
and only for Windows prior to MySQL 5.1.12. Corresponds
to the MYSQL_OPT_READ_TIMEOUT option
of the MySQL Client Library. This option was added in
Connector/ODBC 3.51.27. | |
writetimeout | The timeout in seconds for attempts to write to the server. Each attempt
uses this timeout value and there are
net_retry_count retries if necessary,
so the total effective timeout value is
net_retry_count times the option
value. This option works only for TCP/IP connections,
and only for Windows prior to MySQL 5.1.12. Corresponds
to the MYSQL_OPT_WRITE_TIMEOUT option
of the MySQL Client Library. This option was added in
Connector/ODBC 3.51.27. |
The SSL configuration parameters can also be automatically
loaded from a my.ini
or
my.cnf
file.
The option
argument is used to tell
Connector/ODBC that the client isn't 100% ODBC compliant. On
Windows, you normally select options by toggling the checkboxes
in the connection screen, but you can also select them in the
option
argument. The following options are
listed in the order in which they appear in the Connector/ODBC
connect screen.
Value | Flagname | GUI Option | Description |
---|---|---|---|
1 | FLAG_FIELD_LENGTH | Do not Optimize Column Width | The client cannot handle that Connector/ODBC returns the real width of a column. This option was removed in 3.51.18. |
2 | FLAG_FOUND_ROWS | Return Matching Rows | The client cannot handle that MySQL returns the true value of affected rows. If this flag is set, MySQL returns “found rows” instead. You must have MySQL 3.21.14 or newer to get this to work. |
4 | FLAG_DEBUG | Trace Driver Calls To myodbc.log | Make a debug log in C:\myodbc.log on Windows, or
/tmp/myodbc.log on Unix variants.
This option was removed in Connector/ODBC 3.51.18. |
8 | FLAG_BIG_PACKETS | Allow Big Results | Do not set any packet limit for results and bind parameters. Without this option, parameter binding will be truncated to 255 characters. |
16 | FLAG_NO_PROMPT | Do not Prompt Upon Connect | Do not prompt for questions even if driver would like to prompt. |
32 | FLAG_DYNAMIC_CURSOR | Enable Dynamic Cursor | Enable or disable the dynamic cursor support. |
64 | FLAG_NO_SCHEMA | Ignore # in Table Name | Ignore use of database name in
db_name.tbl_name.col_name . |
128 | FLAG_NO_DEFAULT_CURSOR | User Manager Cursors | Force use of ODBC manager cursors (experimental). |
256 | FLAG_NO_LOCALE | Do not Use Set Locale | Disable the use of extended fetch (experimental). |
512 | FLAG_PAD_SPACE | Pad Char To Full Length | Pad CHAR columns to full column length. |
1024 | FLAG_FULL_COLUMN_NAMES | Return Table Names for SQLDescribeCol | SQLDescribeCol() returns fully qualified column
names. |
2048 | FLAG_COMPRESSED_PROTO | Use Compressed Protocol | Use the compressed client/server protocol. |
4096 | FLAG_IGNORE_SPACE | Ignore Space After Function Names | Tell server to ignore space after function name and before
“( ” (needed by
PowerBuilder). This makes all function names keywords. |
8192 | FLAG_NAMED_PIPE | Force Use of Named Pipes | Connect with named pipes to a mysqld server running on NT. |
16384 | FLAG_NO_BIGINT | Change BIGINT Columns to Int | Change BIGINT columns to
INT columns (some
applications cannot handle
BIGINT ). |
32768 | FLAG_NO_CATALOG | No Catalog | Forces results from the catalog functions, such as
SQLTables , to always return
NULL and the driver to report that
catalogs are not supported. |
65536 | FLAG_USE_MYCNF | Read Options From my.cnf | Read parameters from the [client] and
[odbc] groups from
my.cnf . |
131072 | FLAG_SAFE | Safe | Add some extra safety checks. |
262144 | FLAG_NO_TRANSACTIONS | Disable transactions | Disable transactions. |
524288 | FLAG_LOG_QUERY | Save queries to myodbc.sql | Enable query logging to
c:\myodbc.sql (/tmp/myodbc.sql )
file. (Enabled only in debug mode.) |
1048576 | FLAG_NO_CACHE | Do not Cache Result (forward only cursors) | Do not cache the results locally in the driver, instead read from server
(mysql_use_result() ).
This works only for forward-only cursors. This option is
very important in dealing with large tables when you do
not want the driver to cache the entire result set. |
2097152 | FLAG_FORWARD_CURSOR | Force Use Of Forward Only Cursors | Force the use of Forward-only cursor type. In case of
applications setting the default static/dynamic cursor
type, and one wants the driver to use noncache result
sets, then this option ensures the forward-only cursor
behavior. |
4194304 | FLAG_AUTO_RECONNECT | Enable auto-reconnect. | Enables auto-reconnection functionality. You should not use this option with transactions, since a auto reconnection during a incomplete transaction may cause corruption. Note that an auto-reconnected connection will not inherit the same settings and environment as the original. This option was added in Connector/ODBC 3.51.13. |
8388608 | FLAG_AUTO_IS_NULL | Flag Auto Is Null |
When
When Thus, omitting the flag disables the compatibility option and forces SQL standard behavior.
See |
16777216 | FLAG_ZERO_DATE_TO_MIN | Flag Zero Date to Min | Translates zero dates (XXXX-00-00 ) into the minimum
date values supported by ODBC,
XXXX-01-01 . This resolves an issue
where some statements will not work because the date
returned and the minimum ODBC date value are
incompatible. This option was added in Connector/ODBC
3.51.17. |
33554432 | FLAG_MIN_DATE_TO_ZERO | Flag Min Date to Zero | Translates the minimum ODBC date value (XXXX-01-01 )
to the zero date format supported by MySQL
(XXXX-00-00 ). This resolves an issue
where some statements will not work because the date
returned and the minimum ODBC date value are
incompatible. This option was added in Connector/ODBC
3.51.17. |
67108864 | FLAG_MULTI_STATEMENTS | Allow multiple statements | Enables support for batched statements. This option was added in Connector/ODBC 3.51.18. |
134217728 | FLAG_COLUMN_SIZE_S32 | Limit column size to 32-bit value | Limits the column size to a signed 32-bit value to prevent problems with larger column sizes in applications that do not support them. This option is automatically enabled when working with ADO applications. This option was added in Connector/ODBC 3.51.22. |
268435456 | FLAG_NO_BINARY_RESULT | Always handle binary function results as character data | When set this option disables charset 63 for columns with an empty
org_table . This option was added in
Connector/ODBC 3.51.26. |
To select multiple options, add together their values. For
example, setting option
to 12 (4+8) gives you
debugging without packet limits.
From version of MySQL Connector/ODBC 5.1.6 onwards, it is possible to use
the flag name directly as a parameter in the connection
string, by using the flag name without the FLAG_ prefix. So,
in addition to using the options
parameter
with various flags set, it is now possible to use the flags
directly as parameters. For example,
FIELD_LENGTH
, FOUND_ROWS
and DEBUG
could all be used as parameters.
The following table shows some recommended
option
values for various configurations.
Configuration | Option Value |
---|---|
Microsoft Access, Visual Basic | 3 |
Driver trace generation (Debug mode) | 4 |
Microsoft Access (with improved DELETE queries) | 35 |
Large tables with too many rows | 2049 |
Sybase PowerBuilder | 135168 |
Query log generation (Debug mode) | 524288 |
Generate driver trace as well as query log (Debug mode) | 524292 |
Large tables with no-cache results | 3145731 |
The ODBC Data Source Administrator
within
Windows enables you to create DSNs, check driver installation
and configure ODBC systems such as tracing (used for debugging)
and connection pooling.
Different editions and versions of Windows store the
ODBC Data Source Administrator
in different
locations depending on the version of Windows that you are
using.
To open the ODBC Data Source Administrator
in
Windows Server 2003:
Because it is possible to create DSN using either the 32-bit
or 64-bit driver, but using the same DNS identifier, it is
advisable to include the driver being used within the DSN
identifier. This will help you to identify the DSN when using
it from applications such as Excel that are only compatible
with the 32-bit driver. For example, you might add
Using32bitCODBC
to the DSN identifier for
the 32-bit interface and Using64bitCODBC
for those using the 64-bit Connector/ODBC driver.
On the Start
menu, choose
Administrative Tools
, and then click
Data Sources (ODBC)
.
To open the ODBC Data Source Administrator
in
Windows 2000 Server or Windows 2000 Professional:
On the Start
menu, choose
Settings
, and then click Control
Panel
.
In Control Panel
, click
Administrative Tools
.
In Administrative Tools
, click
Data Sources (ODBC)
.
To open the ODBC Data Source Administrator
on
Windows XP:
On the Start
menu, click Control
Panel
.
In the Control Panel
when in
Category View
click Performance
and Maintenance
and then click
Administrative Tools.
. If you are viewing
the Control Panel
in Classic
View
, click Administrative
Tools
.
In Administrative Tools
, click
Data Sources (ODBC)
.
Irrespective of your Windows version, you should be presented
the ODBC Data Source Administrator
window:
Within Windows XP, you can add the Administrative
Tools
folder to your menu
to make it easier to locate the ODBC Data Source Administrator.
To do this:
Right-click the
menu.
Select Properties
.
Click
.Select the
tab.
Within Start menu items
, within the
System Administrative Tools
section,
select Display on the All Programs menu
.
Within both Windows Server 2003 and Windows XP you may want to
permanently add the ODBC Data Source
Administrator
to your
menu. To do this, locate the Data Sources
(ODBC)
icon using the methods shown, then right-click
on the icon and then choose .
The interfaces for the 3.51 and 5.1 versions of the Connector/ODBC driver are different, although the fields and information that you need to enter remain the same.
To configure a DSN using Connector/ODBC 3.51.x or Connector/ODBC 5.1.0, see Section 21.1.4.3.1, “Configuring a Connector/ODBC 3.51 DSN on Windows”.
To configure a DSN using Connector/ODBC 5.1.1 or later, see Section 21.1.4.3.2, “Configuring a Connector/ODBC 5.1 DSN on Windows”.
To add and configure a new Connector/ODBC data source on
Windows, use the ODBC Data Source
Administrator
:
Open the ODBC Data Source
Administrator
.
To create a System DSN (which will be available to all
users) , select the System DSN
tab. To
create a User DSN, which will be unique only to the
current user, click the
button.
You will need to select the ODBC driver for this DSN.
Select MySQL ODBC 3.51 Driver
, then
click .
You now need to configure the specific fields for the DSN
you are creating through the Add Data Source
Name
dialog.
In the Data Source Name box, enter the name of the data source you want to access. It can be any valid name that you choose.
In the Description box, enter some text to help identify the connection.
In the Server field, enter the name
of the MySQL server host that you want to access. By
default, it is localhost
.
In the User field, enter the user name to use for this connection.
In the Password field, enter the corresponding password for this connection.
The Database pop-up should automatically populate with the list of databases that the user has permissions to access.
Click
to save the DSN.A completed DSN configuration may look like this:
You can verify the connection using the parameters you have
entered by clicking the Success; connection was
made!
dialog.
If the connection failed, you can obtain more information on the test and why it may have failed by clicking the
button to show additional error messages.You can configure a number of options for a specific DSN by using either the
or tabs in the DSN configuration dialog.The three options you can configure are:
Port sets the TCP/IP port number to use when communicating with MySQL. Communication with MySQL uses port 3306 by default. If your server is configured to use a different TCP/IP port, you must specify that port number here.
Socket sets the name or location of a specific socket or Windows pipe to use when communicating with MySQL.
Initial Statement defines an SQL statement that will be executed when the connection to MySQL is opened. You can use this to set MySQL options for your connection, such as disabling autocommit.
Character Set is a pop-up list from which you can select the default character set to be used with this connection. The Character Set option was added in 3.5.17.
The Section 21.1.4.2, “Connector/ODBC Connection Parameters”, for information about the meaning of these options.
tab enables you to configure Connector/ODBC connection parameters. Refer toThe DSN configuration when using Connector/ODBC 5.1.1 and later has a slightly different layout. Also, due to the native Unicode support within Connector/ODBC 5.1, you no longer need to specify the initial character set to be used with your connection.
To configure a DSN using the Connector/ODBC 5.1.1 or later driver:
Open the ODBC Data Source
Administrator
.
To create a System DSN (which will be available to all users) , select the System DSN tab. To create a User DSN, which will be unique only to the current user, click the button.
You will need to select the ODBC driver for this DSN.
Select MySQL ODBC 5.1 Driver
, then
click .
You now need to configure the specific fields for the DSN
you are creating through the Connection
Parameters
dialog.
In the Data Source Name box, enter the name of the data source you want to access. It can be any valid name that you choose.
In the Description box, enter some text to help identify the connection.
In the Server field, enter the name
of the MySQL server host that you want to access. By
default, it is localhost
.
In the User field, enter the user name to use for this connection.
In the Password field, enter the corresponding password for this connection.
The Database pop-up should automatically populate with the list of databases that the user has permissions to access.
To communicate over a different TCP/IP port than the default (3306), change the value of the Port.
Click
to save the DSN.
You can verify the connection using the parameters you have
entered by clicking the Success; connection was
made!
dialog.
You can configure a number of options for a specific DSN by using the
button.The Details button opens a tabbed display which enables you to set additional options:
Flags 1, Flags 2, and Flags 3 enable you to select the additional flags for the DSN connection. For more information on these flags, see Section 21.1.4.2, “Connector/ODBC Connection Parameters”.
Debug enables you to enable ODBC
debugging to record the queries you execute through the
DSN to the myodbc.sql
file. For more
information, see
Section 21.1.4.8, “Getting an ODBC Trace File”.
SSL Settings configures the additional options required for using the Secure Sockets Layer (SSL) when communicating with MySQL server. Note that you must have enabled SSL and configured the MySQL server with suitable certificates to communicate over SSL.
The Section 21.1.4.2, “Connector/ODBC Connection Parameters”, for information about the meaning of these options.
tab enables you to configure Connector/ODBC connection parameters. Refer toThis section answers Connector/ODBC connection-related questions.
While configuring a Connector/ODBC
DSN, a Could Not Load Translator or Setup
Library
error occurs
For more information, refer to
MS
KnowledgeBase Article(Q260558). Also, make sure
you have the latest valid ctl3d32.dll
in your system directory.
On Windows, the default myodbc3.dll
is compiled for optimal performance. If you want to debug
Connector/ODBC 3.51 (for example, to enable tracing), you
should instead use myodbc3d.dll
. To
install this file, copy myodbc3d.dll
over the installed myodbc3.dll
file.
Make sure to revert back to the release version of the
driver DLL once you are done with the debugging because
the debug version may cause performance issues. Note that
the myodbc3d.dll
isn't included in
Connector/ODBC 3.51.07 through 3.51.11. If you are using
one of these versions, you should copy that DLL from a
previous version (for example, 3.51.06).
To configure a DSN on Mac OS X you can either use the
myodbc3i utility, edit the
odbc.ini
file within the
Library/ODBC
directory of the user or the
should use the ODBC Administrator. If you have Mac OS X 10.2 or
earlier, refer to
Section 21.1.4.5, “Configuring a Connector/ODBC DSN on Unix”. Select
whether you want to create a User DSN or a System DSN. If you
want to add a System DSN, you may need to authenticate with the
system. You must click the padlock and enter a user and password
with administrator privileges.
For correct operation of ODBC Administrator, you should ensure
that the /Library/ODBC/odbc.ini
file used
to set up ODBC connectivity and DSNs are writable by the
admin
group. If this file is not writable by
this group then the ODBC Administrator may fail, or may appear
to have worked but not generated the correct entry.
There are known issues with the OS X ODBC Administrator and
Connector/ODBC that may prevent you from creating a DSN using
this method. In this case you should use the command-line or
edit the odbc.ini
file directly. Note
that existing DSNs or those that you create using the
myodbc3i or
myodbc-installer tool can still be checked
and edited using ODBC Administrator.
To create a DSN using the myodbc3i utility, you need only specify the DSN type and the DSN connection string. For example:
shell> myodbc3i -a -s -t"DSN=mydb;DRIVER=MySQL ODBC 3.51 Driver;SERVER=mysql;USER=username;PASSWORD=pass"
To use ODBC Administrator:
Open the ODBC Administrator from the
Utilities
folder in the
Applications
folder.
On the User DSN or System DSN panel, click
Select the Connector/ODBC driver and click
.
You will be presented with the Data Source
Name
dialog. Enter The Data Source
Name
and an optional
Description
for the DSN.
Click server
,
username
, password
and
database
connection parameters. See
Section 21.1.4.2, “Connector/ODBC Connection Parameters”.
Click
to add the DSN to the list of configured data source names.A completed DSN configuration may look like this:
You can configure other ODBC options in your DSN by adding further keyword/value pairs and setting the corresponding values. See Section 21.1.4.2, “Connector/ODBC Connection Parameters”.
On Unix
, you configure DSN entries directly
in the odbc.ini
file. Here is a typical
odbc.ini
file that configures
myodbc3
as the DSN name for Connector/ODBC
3.51:
; ; odbc.ini configuration for Connector/ODBC and Connector/ODBC 3.51 drivers ; [ODBC Data Sources] myodbc3 = MyODBC 3.51 Driver DSN [myodbc3] Driver = /usr/local/lib/libmyodbc3.so Description = Connector/ODBC 3.51 Driver DSN SERVER = localhost PORT = USER = root Password = Database = test OPTION = 3 SOCKET = [Default] Driver = /usr/local/lib/libmyodbc3.so Description = Connector/ODBC 3.51 Driver DSN SERVER = localhost PORT = USER = root Password = Database = test OPTION = 3 SOCKET =
Refer to the Section 21.1.4.2, “Connector/ODBC Connection Parameters”, for the list of connection parameters that can be supplied.
If you are using unixODBC
, you can use the
following tools to set up the DSN:
ODBCConfig GUI tool(HOWTO: ODBCConfig)
odbcinst
In some cases when using unixODBC
, you might
get this error:
Data source name not found and no default driver specified
If this happens, make sure the ODBCINI
and
ODBCSYSINI
environment variables are pointing
to the right odbc.ini
file. For example, if
your odbc.ini
file is located in
/usr/local/etc
, set the environment
variables like this:
export ODBCINI=/usr/local/etc/odbc.ini export ODBCSYSINI=/usr/local/etc
You can connect to the MySQL server using SQLDriverConnect, by
specifying the DRIVER
name field. Here are
the connection strings for Connector/ODBC using DSN-Less
connections:
For Connector/ODBC 3.51:
ConnectionString = "DRIVER={MySQL ODBC 3.51 Driver};\ SERVER=localhost;\ DATABASE=test;\ USER=venu;\ PASSWORD=venu;\ OPTION=3;"
If your programming language converts backslash followed by whitespace to a space, it is preferable to specify the connection string as a single long string, or to use a concatenation of multiple strings that does not add spaces in between. For example:
ConnectionString = "DRIVER={MySQL ODBC 3.51 Driver};" "SERVER=localhost;" "DATABASE=test;" "USER=venu;" "PASSWORD=venu;" "OPTION=3;"
Note. Note that on Mac OS X you may need to specify the full path to the Connector/ODBC driver library.
Refer to the Section 21.1.4.2, “Connector/ODBC Connection Parameters”, for the list of connection parameters that can be supplied.
Connection pooling enables the ODBC driver to re-use existing connections to a given database from a pool of connections, instead of opening a new connection each time the database is accessed. By enabling connection pooling you can improve the overall performance of your application by lowering the time taken to open a connection to a database in the connection pool.
For more information about connection pooling: http://support.microsoft.com/default.aspx?scid=kb;EN-US;q169470.
If you encounter difficulties or problems with Connector/ODBC,
you should start by making a log file from the ODBC
Manager
and Connector/ODBC. This is called
tracing, and is enabled through the ODBC
Manager. The procedure for this differs for Windows, Mac OS X
and Unix.
To enable the trace option on Windows:
The Tracing
tab of the ODBC Data Source
Administrator dialog box enables you to configure the way
ODBC function calls are traced.
When you activate tracing from the
Tracing
tab, the Driver
Manager
logs all ODBC function calls for all
subsequently run applications.
ODBC function calls from applications running before tracing is activated are not logged. ODBC function calls are recorded in a log file you specify.
Tracing ceases only after you click Stop Tracing
Now
. Remember that while tracing is on, the log
file continues to increase in size and that tracing
affects the performance of all your ODBC applications.
To enable the trace option on Mac OS X 10.3 or later you
should use the Tracing
tab within
ODBC Administrator .
Open the ODBC Administrator.
Select the Tracing
tab.
Select the Enable Tracing
checkbox.
Enter the location where you want to save the Tracing log. If you want to append information to an existing log file, click the
button.
To enable the trace option on Mac OS X 10.2 (or earlier) or
Unix you must add the trace
option to the
ODBC configuration:
On Unix, you need to explicitly set the
Trace
option in the
ODBC.INI
file.
Set the tracing ON
or
OFF
by using
TraceFile
and Trace
parameters in odbc.ini
as shown
below:
TraceFile = /tmp/odbc.trace Trace = 1
TraceFile
specifies the name and full
path of the trace file and Trace
is set
to ON
or OFF
. You
can also use 1
or
YES
for ON
and
0
or NO
for
OFF
. If you are using
ODBCConfig from
unixODBC
, then follow the instructions
for tracing unixODBC
calls at
HOWTO-ODBCConfig.
To generate a Connector/ODBC log, do the following:
Within Windows, enable the Trace
Connector/ODBC
option flag in the Connector/ODBC
connect/configure screen. The log is written to file
C:\myodbc.log
. If the trace option is
not remembered when you are going back to the above
screen, it means that you are not using the
myodbcd.dll
driver, see
Section 21.1.4.3.3, “Errors and Debugging”.
On Mac OS X, Unix, or if you are using DSN-Less
connection, then you need to supply
OPTION=4
in the connection string or
set the corresponding keyword/value pair in the DSN.
Start your application and try to get it to fail. Then check the Connector/ODBC trace file to find out what could be wrong.
If you need help determining what is wrong, see Section 21.1.8.1, “Connector/ODBC Community Support”.
Once you have configured a DSN to provide access to a database, how you access and use that connection is dependent on the application or programming language. As ODBC is a standardized interface, any application or language that supports ODBC can use the DSN and connect to the configured database.
Interacting with a MySQL server from an applications using the Connector/ODBC typically involves the following operations:
Configure the Connector/ODBC DSN
Connect to MySQL server
Initialization operations
Execute SQL statements
Retrieve results
Perform Transactions
Disconnect from the server
Most applications use some variation of these steps. The basic application steps are shown in the following diagram:
A typical installation situation where you would install Connector/ODBC is when you want to access a database on a Linux or Unix host from a Windows machine.
As an example of the process required to set up access between
two machines, the steps below take you through the basic steps.
These instructions assume that you want to connect to system
ALPHA from system BETA with a user name and password of
myuser
and mypassword
.
On system ALPHA (the MySQL server) follow these steps:
Start the MySQL server.
Use GRANT
to set up an
account with a user name of myuser
that
can connect from system BETA using a password of
myuser
to the database
test
:
GRANT ALL ON test.* to 'myuser'@'BETA' IDENTIFIED BY 'mypassword';
For more information about MySQL privileges, refer to Section 5.5, “MySQL User Account Management”.
On system BETA (the Connector/ODBC client), follow these steps:
Configure a Connector/ODBC DSN using parameters that match the server, database and authentication information that you have just configured on system ALPHA.
Parameter | Value | Comment |
---|---|---|
DSN | remote_test | A name to identify the connection. |
SERVER | ALPHA | The address of the remote server. |
DATABASE | test | The name of the default database. |
USER | myuser | The user name configured for access to this database. |
PASSWORD | mypassword | The password for myuser . |
Using an ODBC-capable application, such as Microsoft Office, connect to the MySQL server using the DSN you have just created. If the connection fails, use tracing to examine the connection process. See Section 21.1.4.8, “Getting an ODBC Trace File”, for more information.
Once you have configured your Connector/ODBC DSN, you can access your MySQL database through any application that supports the ODBC interface, including programming languages and third-party applications. This section contains guides and help on using Connector/ODBC with various ODBC-compatible tools and applications, including Microsoft Word, Microsoft Excel and Adobe/Macromedia ColdFusion.
Connector/ODBC has been tested with the following applications.
Publisher | Application | Notes |
---|---|---|
Adobe | ColdFusion | Formerly Macromedia ColdFusion |
Borland | C++ Builder | |
Builder 4 | ||
Delphi | ||
Business Objects | Crystal Reports | |
Claris | Filemaker Pro | |
Corel | Paradox | |
Computer Associates | Visual Objects | Also known as CAVO |
AllFusion ERwin Data Modeler | ||
Gupta | Team Developer | Previously known as Centura Team Developer; Gupta SQL/Windows |
Gensym | G2-ODBC Bridge | |
Inline | iHTML | |
Lotus | Notes | Versions 4.5 and 4.6 |
Microsoft | Access | |
Excel | ||
Visio Enterprise | ||
Visual C++ | ||
Visual Basic | ||
ODBC.NET | Using C#, Visual Basic, C++ | |
FoxPro | ||
Visual Interdev | ||
OpenOffice.org | OpenOffice.org | |
Perl | DBD::ODBC | |
Pervasive Software | DataJunction | |
Sambar Technologies | Sambar Server | |
SPSS | SPSS | |
SoftVelocity | Clarion | |
SQLExpress | SQLExpress for Xbase++ | |
Sun | StarOffice | |
SunSystems | Vision | |
Sybase | PowerBuilder | |
PowerDesigner | ||
theKompany.com | Data Architect |
If you know of any other applications that work with
Connector/ODBC, please send mail to
<myodbc@lists.mysql.com>
about them.
You can use MySQL database with Microsoft Access using Connector/ODBC. The MySQL database can be used as an import source, an export source, or as a linked table for direct use within an Access application, so you can use Access as the front-end interface to a MySQL database.
To export a table of data from an Access database to MySQL, follow these instructions:
When you open an Access database or an Access project, a Database window appears. It displays shortcuts for creating new database objects and opening existing objects.
Click the name of the table
or
query
you want to export, and then in
the File
menu, select
Export
.
In the Export Object Type
dialog box, in the
Object
name
ToSave As Type
box, select ODBC
Databases ()
as shown here:
In the Export
dialog box, enter a name
for the file (or use the suggested name), and then select
OK
.
The Select Data Source dialog box is displayed; it lists the defined data sources for any ODBC drivers installed on your computer. Click either the File Data Source or Machine Data Source tab, and then double-click the Connector/ODBC or Connector/ODBC 3.51 data source that you want to export to. To define a new data source for Connector/ODBC, please Section 21.1.4.3, “Configuring a Connector/ODBC DSN on Windows”.
Ensure that the information that you are exporting to the MySQL table is valid for the corresponding MySQL data types. Values that are outside of the supported range of the MySQL data type but valid within Access may trigger an “overflow” error during the export.
Microsoft Access connects to the MySQL Server through this data source and exports new tables and or data.
To import a table or tables from MySQL to Access, follow these instructions:
Open a database, or switch to the Database window for the open database.
To import tables, on the File
menu,
point to Get External Data
, and then
click Import
.
In the Import
dialog box, in the Files
Of Type box, select ODBC Databases
(). The Select Data Source dialog box lists the
defined data sources The Select Data
Source dialog box is displayed; it lists the
defined data source names.
If the ODBC data source that you selected requires you to
log on, enter your login ID and password (additional
information might also be required), and then click
OK
.
Microsoft Access connects to the MySQL server through
ODBC data source
and displays the list
of tables that you can import
.
Click each table that you want to
import
, and then click
OK
.
You can use Microsoft Access as a front end to a MySQL database by linking tables within your Microsoft Access database to tables that exist within your MySQL database. When a query is requested on a table within Access, ODBC is used to execute the queries on the MySQL database instead.
To create a linked table:
Open the Access database that you want to link to MySQL.
From the
, choose .From the browser, choose ODBC Databases () from the Files of type pop-up.
In the Select Data Source window, choose an existing DSN, either from a File Data Source or Machine Data Source.You can also create a new DSN using the button. For more information on creating a DSN see Section 21.1.4.3, “Configuring a Connector/ODBC DSN on Windows”.
In the Link Tables dialog, select one or more tables from the MySQL database. A link will be created to each table that you select from this list.
If Microsoft Access is unable to determine the unique record identifier for a table automatically then it may ask you to confirm the column, or combination of columns, to be used to uniquely identify each row from the source table. Select the columns you want to use and click
.Once the process has been completed, you can now build interfaces and queries to the linked tables just as you would for any Access database.
Use the following procedure to view or to refresh links when the structure or location of a linked table has changed. The Linked Table Manager lists the paths to all currently linked tables.
To view or refresh links:
Open the database that contains links to MySQL tables.
On the Tools
menu, point to
Add-ins
(Database
Utilities
in Access 2000 or newer), and then
click Linked Table Manager
.
Select the check box for the tables whose links you want to refresh.
Click OK to refresh the links.
Microsoft Access confirms a successful refresh or, if the
table wasn't found, displays the Select New Location
of
<table name> dialog box in which you can
specify its the table's new location. If several selected
tables have moved to the new location that you specify, the
Linked Table Manager searches that location for all selected
tables, and updates all links in one step.
To change the path for a set of linked tables:
Open the database that contains links to tables.
On the Tools
menu, point to
Add-ins
(Database
Utilities
in Access 2000 or newer), and then
click Linked Table Manager
.
Select the Always Prompt For A New
Location
check box.
Select the check box for the tables whose links you want
to change, and then click OK
.
In the Select New Location of
<table
name> dialog box, specify the new location, click
Open
, and then click
OK
.
You can use Microsoft Word and Microsoft Excel to access information from a MySQL database using Connector/ODBC. Within Microsoft Word, this facility is most useful when importing data for mailmerge, or for tables and data to be included in reports. Within Microsoft Excel, you can execute queries on your MySQL server and import the data directly into an Excel Worksheet, presenting the data as a series of rows and columns.
With both applications, data is accessed and imported into the application using Microsoft Query , which enables you to execute a query though an ODBC source. You use Microsoft Query to build the SQL statement to be executed, selecting the tables, fields, selection criteria and sort order. For example, to insert information from a table in the World test database into an Excel spreadsheet, using the DSN samples shown in Section 21.1.4, “Connector/ODBC Configuration”:
Create a new Worksheet.
From the Data
menu, choose
Import External Data
, and then select
New Database Query
.
Microsoft Query will start. First, you need to choose the data source, by selecting an existing Data Source Name.
Within the Query Wizard
, you must choose
the columns that you want to import. The list of tables
available to the user configured through the DSN is shown on
the left, the columns that will be added to your query are
shown on the right. The columns you choose are equivalent to
those in the first section of a
SELECT
query. Click
to continue.
You can filter rows from the query (the equivalent of a
WHERE
clause) using the Filter
Data
dialog. Click to
continue.
Select an (optional) sort order for the data. This is
equivalent to using a ORDER BY
clause in
your SQL query. You can select up to three fields for
sorting the information returned by the query. Click
to continue.
Select the destination for your query. You can select to return the data Microsoft Excel, where you can choose a worksheet and cell where the data will be inserted; you can continue to view the query and results within Microsoft Query, where you can edit the SQL query and further filter and sort the information returned; or you can create an OLAP Cube from the query, which can then be used directly within Microsoft Excel. Click
.The same process can be used to import data into a Word document, where the data will be inserted as a table. This can be used for mail merge purposes (where the field data is read from a Word table), or where you want to include data and reports within a report or other document.
Crystal Reports can use an ODBC DSN to connect to a database from which you to extract data and information for reporting purposes.
There is a known issue with certain versions of Crystal Reports where the application is unable to open and browse tables and fields through an ODBC connection. Before using Crystal Reports with MySQL, please ensure that you have update to the latest version, including any outstanding service packs and hotfixes. For more information on this issue, see the Business) Objects Knowledgebase for more information.
For example, to create a simple crosstab report within Crystal Reports XI, you should follow these steps:
Create a DSN using the Data Sources
(ODBC)
tool. You can either specify a complete
database, including user name and password, or you can build
a basic DSN and use Crystal Reports to set the user name and
password.
For the purposes of this example, a DSN that provides a connection to an instance of the MySQL Sakila sample database has been created.
Open Crystal Reports and create a new project, or an open an existing reporting project into which you want to insert data from your MySQL data source.
Start the Cross-Tab Report Wizard, either by clicking the option on the Start Page. Expand the Create New Connection folder, then expand the ODBC (RDO) folder to obtain a list of ODBC data sources.
You will be asked to select a data source.
When you first expand the ODBC (RDO) folder you will be presented the Data Source Selection screen. From here you can select either a pre-configured DSN, open a file-based DSN or enter and manual connection string. For this example, the Sakila DSN will be used.
If the DSN contains a user name/password combination, or you want to use different authentication credentials, click
to enter the user name and password that you want to use. Otherwise, click to continue the data source selection wizard.
You will be returned the Cross-Tab Report Creation Wizard.
You now need to select the database and tables that you want
to include in your report. For our example, we will expand
the selected Sakila database. Click the
city
table and use the
button to add the table to the
report. Then repeat the action with the
country
table. Alternatively you can
select multiple tables and add them to the report.
Finally, you can select the parent Sakila resource and add of the tables to the report.
Once you have selected the tables you want to include, click
to continue.Crystal Reports will now read the table definitions and automatically identify the links between the tables. The identification of links between tables enables Crystal Reports to automatically lookup and summarize information based on all the tables in the database according to your query. If Crystal Reports is unable to perform the linking itself, you can manually create the links between fields in the tables you have selected.
Click
to continue the process.You can now select the columns and rows that you wish to include within the Cross-Tab report. Drag and drop or use the
buttons to add fields to each area of the report. In the example shown, we will report on cities, organized by country, incorporating a count of the number of cities within each country. If you want to browse the data, select a field and click the button.Click
to create a graph of the results. Since we are not creating a graph from this data, click to generate the report.The finished report will be shown, a sample of the output from the Sakila sample database is shown below.
Once the ODBC connection has been opened within Crystal Reports, you can browse and add any fields within the available tables into your reports.
With a suitable ODBC Manager and the Connector/ODBC driver installed, any programming language or environment that can support ODBC should be able to connect to a MySQL database through Connector/ODBC.
This includes, but is certainly not limited to, Microsoft support languages (including Visual Basic, C# and interfaces such as ODBC.NET), Perl (through the DBI module, and the DBD::ODBC driver).
This section contains simple examples of the use of MySQL ODBC 3.51 Driver with ADO, DAO and RDO.
The following ADO (ActiveX Data Objects) example creates a
table my_ado
and demonstrates the use of
rs.addNew
, rs.delete
,
and rs.update
.
Private Sub myodbc_ado_Click() Dim conn As ADODB.Connection Dim rs As ADODB.Recordset Dim fld As ADODB.Field Dim sql As String 'connect to MySQL server using MySQL ODBC 3.51 Driver Set conn = New ADODB.Connection conn.ConnectionString = "DRIVER={MySQL ODBC 3.51 Driver};"_ & "SERVER=localhost;"_ & " DATABASE=test;"_ & "UID=venu;PWD=venu; OPTION=3" conn.Open 'create table conn.Execute "DROP TABLE IF EXISTS my_ado" conn.Execute "CREATE TABLE my_ado(id int not null primary key, name varchar(20)," _ & "txt text, dt date, tm time, ts timestamp)" 'direct insert conn.Execute "INSERT INTO my_ado(id,name,txt) values(1,100,'venu')" conn.Execute "INSERT INTO my_ado(id,name,txt) values(2,200,'MySQL')" conn.Execute "INSERT INTO my_ado(id,name,txt) values(3,300,'Delete')" Set rs = New ADODB.Recordset rs.CursorLocation = adUseServer 'fetch the initial table .. rs.Open "SELECT * FROM my_ado", conn Debug.Print rs.RecordCount rs.MoveFirst Debug.Print String(50, "-") & "Initial my_ado Result Set " & String(50, "-") For Each fld In rs.Fields Debug.Print fld.Name, Next Debug.Print Do Until rs.EOF For Each fld In rs.Fields Debug.Print fld.Value, Next rs.MoveNext Debug.Print Loop rs.Close 'rs insert rs.Open "select * from my_ado", conn, adOpenDynamic, adLockOptimistic rs.AddNew rs!Name = "Monty" rs!txt = "Insert row" rs.Update rs.Close 'rs update rs.Open "SELECT * FROM my_ado" rs!Name = "update" rs!txt = "updated-row" rs.Update rs.Close 'rs update second time.. rs.Open "SELECT * FROM my_ado" rs!Name = "update" rs!txt = "updated-second-time" rs.Update rs.Close 'rs delete rs.Open "SELECT * FROM my_ado" rs.MoveNext rs.MoveNext rs.Delete rs.Close 'fetch the updated table .. rs.Open "SELECT * FROM my_ado", conn Debug.Print rs.RecordCount rs.MoveFirst Debug.Print String(50, "-") & "Updated my_ado Result Set " & String(50, "-") For Each fld In rs.Fields Debug.Print fld.Name, Next Debug.Print Do Until rs.EOF For Each fld In rs.Fields Debug.Print fld.Value, Next rs.MoveNext Debug.Print Loop rs.Close conn.Close End Sub
The following DAO (Data Access Objects) example creates a
table my_dao
and demonstrates the use of
rs.addNew
, rs.update
,
and result set scrolling.
Private Sub myodbc_dao_Click() Dim ws As Workspace Dim conn As Connection Dim queryDef As queryDef Dim str As String 'connect to MySQL using MySQL ODBC 3.51 Driver Set ws = DBEngine.CreateWorkspace("", "venu", "venu", dbUseODBC) str = "odbc;DRIVER={MySQL ODBC 3.51 Driver};"_ & "SERVER=localhost;"_ & " DATABASE=test;"_ & "UID=venu;PWD=venu; OPTION=3" Set conn = ws.OpenConnection("test", dbDriverNoPrompt, False, str) 'Create table my_dao Set queryDef = conn.CreateQueryDef("", "drop table if exists my_dao") queryDef.Execute Set queryDef = conn.CreateQueryDef("", "create table my_dao(Id INT AUTO_INCREMENT PRIMARY KEY, " _ & "Ts TIMESTAMP(14) NOT NULL, Name varchar(20), Id2 INT)") queryDef.Execute 'Insert new records using rs.addNew Set rs = conn.OpenRecordset("my_dao") Dim i As Integer For i = 10 To 15 rs.AddNew rs!Name = "insert record" & i rs!Id2 = i rs.Update Next i rs.Close 'rs update.. Set rs = conn.OpenRecordset("my_dao") rs.Edit rs!Name = "updated-string" rs.Update rs.Close 'fetch the table back... Set rs = conn.OpenRecordset("my_dao", dbOpenDynamic) str = "Results:" rs.MoveFirst While Not rs.EOF str = " " & rs!Id & " , " & rs!Name & ", " & rs!Ts & ", " & rs!Id2 Debug.Print "DATA:" & str rs.MoveNext Wend 'rs Scrolling rs.MoveFirst str = " FIRST ROW: " & rs!Id & " , " & rs!Name & ", " & rs!Ts & ", " & rs!Id2 Debug.Print str rs.MoveLast str = " LAST ROW: " & rs!Id & " , " & rs!Name & ", " & rs!Ts & ", " & rs!Id2 Debug.Print str rs.MovePrevious str = " LAST-1 ROW: " & rs!Id & " , " & rs!Name & ", " & rs!Ts & ", " & rs!Id2 Debug.Print str 'free all resources rs.Close queryDef.Close conn.Close ws.Close End Sub
The following RDO (Remote Data Objects) example creates a
table my_rdo
and demonstrates the use of
rs.addNew
and
rs.update
.
Dim rs As rdoResultset Dim cn As New rdoConnection Dim cl As rdoColumn Dim SQL As String 'cn.Connect = "DSN=test;" cn.Connect = "DRIVER={MySQL ODBC 3.51 Driver};"_ & "SERVER=localhost;"_ & " DATABASE=test;"_ & "UID=venu;PWD=venu; OPTION=3" cn.CursorDriver = rdUseOdbc cn.EstablishConnection rdDriverPrompt 'drop table my_rdo SQL = "drop table if exists my_rdo" cn.Execute SQL, rdExecDirect 'create table my_rdo SQL = "create table my_rdo(id int, name varchar(20))" cn.Execute SQL, rdExecDirect 'insert - direct SQL = "insert into my_rdo values (100,'venu')" cn.Execute SQL, rdExecDirect SQL = "insert into my_rdo values (200,'MySQL')" cn.Execute SQL, rdExecDirect 'rs insert SQL = "select * from my_rdo" Set rs = cn.OpenResultset(SQL, rdOpenStatic, rdConcurRowVer, rdExecDirect) rs.AddNew rs!id = 300 rs!Name = "Insert1" rs.Update rs.Close 'rs insert SQL = "select * from my_rdo" Set rs = cn.OpenResultset(SQL, rdOpenStatic, rdConcurRowVer, rdExecDirect) rs.AddNew rs!id = 400 rs!Name = "Insert 2" rs.Update rs.Close 'rs update SQL = "select * from my_rdo" Set rs = cn.OpenResultset(SQL, rdOpenStatic, rdConcurRowVer, rdExecDirect) rs.Edit rs!id = 999 rs!Name = "updated" rs.Update rs.Close 'fetch back... SQL = "select * from my_rdo" Set rs = cn.OpenResultset(SQL, rdOpenStatic, rdConcurRowVer, rdExecDirect) Do Until rs.EOF For Each cl In rs.rdoColumns Debug.Print cl.Value, Next rs.MoveNext Debug.Print Loop Debug.Print "Row count="; rs.RowCount 'close rs.Close cn.Close End Sub
This section contains simple examples that demonstrate the use of Connector/ODBC drivers with ODBC.NET.
The following sample creates a table
my_odbc_net
and demonstrates its use in
C#.
/**
* @sample : mycon.cs
* @purpose : Demo sample for ODBC.NET using Connector/ODBC
* @author : Venu, <myodbc@lists.mysql.com>
*
* (C) Copyright MySQL AB, 1995-2006
*
**/
/* build command
*
* csc /t:exe
* /out:mycon.exe mycon.cs
* /r:Microsoft.Data.Odbc.dll
*/
using Console = System.Console;
using Microsoft.Data.Odbc;
namespace myodbc3
{
class mycon
{
static void Main(string[] args)
{
try
{
//Connection string for Connector/ODBC 3.51
string MyConString = "DRIVER={MySQL ODBC 3.51 Driver};" +
"SERVER=localhost;" +
"DATABASE=test;" +
"UID=venu;" +
"PASSWORD=venu;" +
"OPTION=3";
//Connect to MySQL using Connector/ODBC
OdbcConnection MyConnection = new OdbcConnection(MyConString);
MyConnection.Open();
Console.WriteLine("\n !!! success, connected successfully !!!\n");
//Display connection information
Console.WriteLine("Connection Information:");
Console.WriteLine("\tConnection String:" +
MyConnection.ConnectionString);
Console.WriteLine("\tConnection Timeout:" +
MyConnection.ConnectionTimeout);
Console.WriteLine("\tDatabase:" +
MyConnection.Database);
Console.WriteLine("\tDataSource:" +
MyConnection.DataSource);
Console.WriteLine("\tDriver:" +
MyConnection.Driver);
Console.WriteLine("\tServerVersion:" +
MyConnection.ServerVersion);
//Create a sample table
OdbcCommand MyCommand =
new OdbcCommand("DROP TABLE IF EXISTS my_odbc_net",
MyConnection);
MyCommand.ExecuteNonQuery();
MyCommand.CommandText =
"CREATE TABLE my_odbc_net(id int, name varchar(20), idb bigint)";
MyCommand.ExecuteNonQuery();
//Insert
MyCommand.CommandText =
"INSERT INTO my_odbc_net VALUES(10,'venu', 300)";
Console.WriteLine("INSERT, Total rows affected:" +
MyCommand.ExecuteNonQuery());;
//Insert
MyCommand.CommandText =
"INSERT INTO my_odbc_net VALUES(20,'mysql',400)";
Console.WriteLine("INSERT, Total rows affected:" +
MyCommand.ExecuteNonQuery());
//Insert
MyCommand.CommandText =
"INSERT INTO my_odbc_net VALUES(20,'mysql',500)";
Console.WriteLine("INSERT, Total rows affected:" +
MyCommand.ExecuteNonQuery());
//Update
MyCommand.CommandText =
"UPDATE my_odbc_net SET id=999 WHERE id=20";
Console.WriteLine("Update, Total rows affected:" +
MyCommand.ExecuteNonQuery());
//COUNT(*)
MyCommand.CommandText =
"SELECT COUNT(*) as TRows FROM my_odbc_net";
Console.WriteLine("Total Rows:" +
MyCommand.ExecuteScalar());
//Fetch
MyCommand.CommandText = "SELECT * FROM my_odbc_net";
OdbcDataReader MyDataReader;
MyDataReader = MyCommand.ExecuteReader();
while (MyDataReader.Read())
{
if(string.Compare(MyConnection.Driver,"myodbc3.dll") == 0) {
//Supported only by Connector/ODBC 3.51
Console.WriteLine("Data:" + MyDataReader.GetInt32(0) + " " +
MyDataReader.GetString(1) + " " +
MyDataReader.GetInt64(2));
}
else {
//BIGINTs not supported by Connector/ODBC
Console.WriteLine("Data:" + MyDataReader.GetInt32(0) + " " +
MyDataReader.GetString(1) + " " +
MyDataReader.GetInt32(2));
}
}
//Close all resources
MyDataReader.Close();
MyConnection.Close();
}
catch (OdbcException MyOdbcException) //Catch any ODBC exception ..
{
for (int i=0; i < MyOdbcException.Errors.Count; i++)
{
Console.Write("ERROR #" + i + "\n" +
"Message: " +
MyOdbcException.Errors[i].Message + "\n" +
"Native: " +
MyOdbcException.Errors[i].NativeError.ToString() + "\n" +
"Source: " +
MyOdbcException.Errors[i].Source + "\n" +
"SQL: " +
MyOdbcException.Errors[i].SQLState + "\n");
}
}
}
}
}
The following sample creates a table
my_vb_net
and demonstrates the use in VB.
' @sample : myvb.vb
' @purpose : Demo sample for ODBC.NET using Connector/ODBC
' @author : Venu, <myodbc@lists.mysql.com>
'
' (C) Copyright MySQL AB, 1995-2006
'
'
'
' build command
'
' vbc /target:exe
' /out:myvb.exe
' /r:Microsoft.Data.Odbc.dll
' /r:System.dll
' /r:System.Data.dll
'
Imports Microsoft.Data.Odbc
Imports System
Module myvb
Sub Main()
Try
'Connector/ODBC 3.51 connection string
Dim MyConString As String = "DRIVER={MySQL ODBC 3.51 Driver};" & _
"SERVER=localhost;" & _
"DATABASE=test;" & _
"UID=venu;" & _
"PASSWORD=venu;" & _
"OPTION=3;"
'Connection
Dim MyConnection As New OdbcConnection(MyConString)
MyConnection.Open()
Console.WriteLine("Connection State::" & MyConnection.State.ToString)
'Drop
Console.WriteLine("Dropping table")
Dim MyCommand As New OdbcCommand()
MyCommand.Connection = MyConnection
MyCommand.CommandText = "DROP TABLE IF EXISTS my_vb_net"
MyCommand.ExecuteNonQuery()
'Create
Console.WriteLine("Creating....")
MyCommand.CommandText = "CREATE TABLE my_vb_net(id int, name varchar(30))"
MyCommand.ExecuteNonQuery()
'Insert
MyCommand.CommandText = "INSERT INTO my_vb_net VALUES(10,'venu')"
Console.WriteLine("INSERT, Total rows affected:" & _
MyCommand.ExecuteNonQuery())
'Insert
MyCommand.CommandText = "INSERT INTO my_vb_net VALUES(20,'mysql')"
Console.WriteLine("INSERT, Total rows affected:" & _
MyCommand.ExecuteNonQuery())
'Insert
MyCommand.CommandText = "INSERT INTO my_vb_net VALUES(20,'mysql')"
Console.WriteLine("INSERT, Total rows affected:" & _
MyCommand.ExecuteNonQuery())
'Insert
MyCommand.CommandText = "INSERT INTO my_vb_net(id) VALUES(30)"
Console.WriteLine("INSERT, Total rows affected:" & _
MyCommand.ExecuteNonQuery())
'Update
MyCommand.CommandText = "UPDATE my_vb_net SET id=999 WHERE id=20"
Console.WriteLine("Update, Total rows affected:" & _
MyCommand.ExecuteNonQuery())
'COUNT(*)
MyCommand.CommandText = "SELECT COUNT(*) as TRows FROM my_vb_net"
Console.WriteLine("Total Rows:" & MyCommand.ExecuteScalar())
'Select
Console.WriteLine("Select * FROM my_vb_net")
MyCommand.CommandText = "SELECT * FROM my_vb_net"
Dim MyDataReader As OdbcDataReader
MyDataReader = MyCommand.ExecuteReader
While MyDataReader.Read
If MyDataReader("name") Is DBNull.Value Then
Console.WriteLine("id = " & _
CStr(MyDataReader("id")) & " name = " & _
"NULL")
Else
Console.WriteLine("id = " & _
CStr(MyDataReader("id")) & " name = " & _
CStr(MyDataReader("name")))
End If
End While
'Catch ODBC Exception
Catch MyOdbcException As OdbcException
Dim i As Integer
Console.WriteLine(MyOdbcException.ToString)
'Catch program exception
Catch MyException As Exception
Console.WriteLine(MyException.ToString)
End Try
End Sub
This section provides reference material for the Connector/ODBC API, showing supported functions and methods, supported MySQL column types and the corresponding native type in Connector/ODBC, and the error codes returned by Connector/ODBC when a fault occurs.
This section summarizes ODBC routines, categorized by functionality.
For the complete ODBC API reference, please refer to the ODBC Programmer's Reference at http://msdn.microsoft.com/en-us/library/ms714177.aspx.
An application can call SQLGetInfo
function
to obtain conformance information about Connector/ODBC. To
obtain information about support for a specific function in the
driver, an application can call
SQLGetFunctions
.
For backward compatibility, the Connector/ODBC 3.51 driver supports all deprecated functions.
The following tables list Connector/ODBC API calls grouped by task:
Connecting to a data source
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLAllocHandle | Yes | ISO 92 | Obtains an environment, connection, statement, or descriptor handle. |
SQLConnect | Yes | ISO 92 | Connects to a specific driver by data source name, user ID, and password. |
SQLDriverConnect | Yes | ODBC | Connects to a specific driver by connection string or requests that the Driver Manager and driver display connection dialog boxes for the user. |
SQLAllocEnv | Yes | Deprecated | Obtains an environment handle allocated from driver. |
SQLAllocConnect | Yes | Deprecated | Obtains a connection handle |
Obtaining information about a driver and data source
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLDataSources | No | ISO 92 | Returns the list of available data sources, handled by the Driver Manager |
SQLDrivers | No | ODBC | Returns the list of installed drivers and their attributes, handles by Driver Manager |
SQLGetInfo | Yes | ISO 92 | Returns information about a specific driver and data source. |
SQLGetFunctions | Yes | ISO 92 | Returns supported driver functions. |
SQLGetTypeInfo | Yes | ISO 92 | Returns information about supported data types. |
Setting and retrieving driver attributes
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLSetConnectAttr | Yes | ISO 92 | Sets a connection attribute. |
SQLGetConnectAttr | Yes | ISO 92 | Returns the value of a connection attribute. |
SQLSetConnectOption | Yes | Deprecated | Sets a connection option |
SQLGetConnectOption | Yes | Deprecated | Returns the value of a connection option |
SQLSetEnvAttr | Yes | ISO 92 | Sets an environment attribute. |
SQLGetEnvAttr | Yes | ISO 92 | Returns the value of an environment attribute. |
SQLSetStmtAttr | Yes | ISO 92 | Sets a statement attribute. |
SQLGetStmtAttr | Yes | ISO 92 | Returns the value of a statement attribute. |
SQLSetStmtOption | Yes | Deprecated | Sets a statement option |
SQLGetStmtOption | Yes | Deprecated | Returns the value of a statement option |
Preparing SQL requests
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLAllocStmt | Yes | Deprecated | Allocates a statement handle |
SQLPrepare | Yes | ISO 92 | Prepares an SQL statement for later execution. |
SQLBindParameter | Yes | ODBC | Assigns storage for a parameter in an SQL statement. |
SQLGetCursorName | Yes | ISO 92 | Returns the cursor name associated with a statement handle. |
SQLSetCursorName | Yes | ISO 92 | Specifies a cursor name. |
SQLSetScrollOptions | Yes | ODBC | Sets options that control cursor behavior. |
Submitting requests
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLExecute | Yes | ISO 92 | Executes a prepared statement. |
SQLExecDirect | Yes | ISO 92 | Executes a statement |
SQLNativeSql | Yes | ODBC | Returns the text of an SQL statement as translated by the driver. |
SQLDescribeParam | Yes | ODBC | Returns the description for a specific parameter in a statement. |
SQLNumParams | Yes | ISO 92 | Returns the number of parameters in a statement. |
SQLParamData | Yes | ISO 92 | Used in conjunction with SQLPutData to supply
parameter data at execution time. (Useful for long data
values.) |
SQLPutData | Yes | ISO 92 | Sends part or all of a data value for a parameter. (Useful for long data values.) |
Retrieving results and information about results
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLRowCount | Yes | ISO 92 | Returns the number of rows affected by an insert, update, or delete request. |
SQLNumResultCols | Yes | ISO 92 | Returns the number of columns in the result set. |
SQLDescribeCol | Yes | ISO 92 | Describes a column in the result set. |
SQLColAttribute | Yes | ISO 92 | Describes attributes of a column in the result set. |
SQLColAttributes | Yes | Deprecated | Describes attributes of a column in the result set. |
SQLFetch | Yes | ISO 92 | Returns multiple result rows. |
SQLFetchScroll | Yes | ISO 92 | Returns scrollable result rows. |
SQLExtendedFetch | Yes | Deprecated | Returns scrollable result rows. |
SQLSetPos | Yes | ODBC | Positions a cursor within a fetched block of data and enables an application to refresh data in the rowset or to update or delete data in the result set. |
SQLBulkOperations | Yes | ODBC | Performs bulk insertions and bulk bookmark operations, including update, delete, and fetch by bookmark. |
Retrieving error or diagnostic information
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLError | Yes | Deprecated | Returns additional error or status information |
SQLGetDiagField | Yes | ISO 92 | Returns additional diagnostic information (a single field of the diagnostic data structure). |
SQLGetDiagRec | Yes | ISO 92 | Returns additional diagnostic information (multiple fields of the diagnostic data structure). |
Obtaining information about the data source's system tables (catalog functions) item
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLColumnPrivileges | Yes | ODBC | Returns a list of columns and associated privileges for one or more tables. |
SQLColumns | Yes | X/Open | Returns the list of column names in specified tables. |
SQLForeignKeys | Yes | ODBC | Returns a list of column names that make up foreign keys, if they exist for a specified table. |
SQLPrimaryKeys | Yes | ODBC | Returns the list of column names that make up the primary key for a table. |
SQLSpecialColumns | Yes | X/Open | Returns information about the optimal set of columns that uniquely identifies a row in a specified table, or the columns that are automatically updated when any value in the row is updated by a transaction. |
SQLStatistics | Yes | ISO 92 | Returns statistics about a single table and the list of indexes associated with the table. |
SQLTablePrivileges | Yes | ODBC | Returns a list of tables and the privileges associated with each table. |
SQLTables | Yes | X/Open | Returns the list of table names stored in a specific data source. |
Performing transactions
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLTransact | Yes | Deprecated | Commits or rolls back a transaction |
SQLEndTran | Yes | ISO 92 | Commits or rolls back a transaction. |
Terminating a statement
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLFreeStmt | Yes | ISO 92 | Ends statement processing, discards pending results, and, optionally, frees all resources associated with the statement handle. |
SQLCloseCursor | Yes | ISO 92 | Closes a cursor that has been opened on a statement handle. |
SQLCancel | Yes | ISO 92 | Cancels an SQL statement. |
Terminating a connection
Function name | C/ODBC 3.51 | Standard | Purpose |
---|---|---|---|
SQLDisconnect | Yes | ISO 92 | Closes the connection. |
SQLFreeHandle | Yes | ISO 92 | Releases an environment, connection, statement, or descriptor handle. |
SQLFreeConnect | Yes | Deprecated | Releases connection handle |
SQLFreeEnv | Yes | Deprecated | Releases an environment handle |
The following table illustrates how driver maps the server data types to default SQL and C data types.
Native Value | SQL Type | C Type |
---|---|---|
bigint unsigned | SQL_BIGINT | SQL_C_UBIGINT |
bigint | SQL_BIGINT | SQL_C_SBIGINT |
bit | SQL_BIT | SQL_C_BIT |
bit | SQL_CHAR | SQL_C_CHAR |
blob | SQL_LONGVARBINARY | SQL_C_BINARY |
bool | SQL_CHAR | SQL_C_CHAR |
char | SQL_CHAR | SQL_C_CHAR |
date | SQL_DATE | SQL_C_DATE |
datetime | SQL_TIMESTAMP | SQL_C_TIMESTAMP |
decimal | SQL_DECIMAL | SQL_C_CHAR |
double precision | SQL_DOUBLE | SQL_C_DOUBLE |
double | SQL_FLOAT | SQL_C_DOUBLE |
enum | SQL_VARCHAR | SQL_C_CHAR |
float | SQL_REAL | SQL_C_FLOAT |
int unsigned | SQL_INTEGER | SQL_C_ULONG |
int | SQL_INTEGER | SQL_C_SLONG |
integer unsigned | SQL_INTEGER | SQL_C_ULONG |
integer | SQL_INTEGER | SQL_C_SLONG |
long varbinary | SQL_LONGVARBINARY | SQL_C_BINARY |
long varchar | SQL_LONGVARCHAR | SQL_C_CHAR |
longblob | SQL_LONGVARBINARY | SQL_C_BINARY |
longtext | SQL_LONGVARCHAR | SQL_C_CHAR |
mediumblob | SQL_LONGVARBINARY | SQL_C_BINARY |
mediumint unsigned | SQL_INTEGER | SQL_C_ULONG |
mediumint | SQL_INTEGER | SQL_C_SLONG |
mediumtext | SQL_LONGVARCHAR | SQL_C_CHAR |
numeric | SQL_NUMERIC | SQL_C_CHAR |
real | SQL_FLOAT | SQL_C_DOUBLE |
set | SQL_VARCHAR | SQL_C_CHAR |
smallint unsigned | SQL_SMALLINT | SQL_C_USHORT |
smallint | SQL_SMALLINT | SQL_C_SSHORT |
text | SQL_LONGVARCHAR | SQL_C_CHAR |
time | SQL_TIME | SQL_C_TIME |
timestamp | SQL_TIMESTAMP | SQL_C_TIMESTAMP |
tinyblob | SQL_LONGVARBINARY | SQL_C_BINARY |
tinyint unsigned | SQL_TINYINT | SQL_C_UTINYINT |
tinyint | SQL_TINYINT | SQL_C_STINYINT |
tinytext | SQL_LONGVARCHAR | SQL_C_CHAR |
varchar | SQL_VARCHAR | SQL_C_CHAR |
year | SQL_SMALLINT | SQL_C_SHORT |
The following tables lists the error codes returned by the driver apart from the server errors.
Native Code | SQLSTATE 2 | SQLSTATE 3 | Error Message |
---|---|---|---|
500 | 01000 | 01000 | General warning |
501 | 01004 | 01004 | String data, right truncated |
502 | 01S02 | 01S02 | Option value changed |
503 | 01S03 | 01S03 | No rows updated/deleted |
504 | 01S04 | 01S04 | More than one row updated/deleted |
505 | 01S06 | 01S06 | Attempt to fetch before the result set returned the first row set |
506 | 07001 | 07002 | SQLBindParameter not used for all parameters |
507 | 07005 | 07005 | Prepared statement not a cursor-specification |
508 | 07009 | 07009 | Invalid descriptor index |
509 | 08002 | 08002 | Connection name in use |
510 | 08003 | 08003 | Connection does not exist |
511 | 24000 | 24000 | Invalid cursor state |
512 | 25000 | 25000 | Invalid transaction state |
513 | 25S01 | 25S01 | Transaction state unknown |
514 | 34000 | 34000 | Invalid cursor name |
515 | S1000 | HY000 | General driver defined error |
516 | S1001 | HY001 | Memory allocation error |
517 | S1002 | HY002 | Invalid column number |
518 | S1003 | HY003 | Invalid application buffer type |
519 | S1004 | HY004 | Invalid SQL data type |
520 | S1009 | HY009 | Invalid use of null pointer |
521 | S1010 | HY010 | Function sequence error |
522 | S1011 | HY011 | Attribute can not be set now |
523 | S1012 | HY012 | Invalid transaction operation code |
524 | S1013 | HY013 | Memory management error |
525 | S1015 | HY015 | No cursor name available |
526 | S1024 | HY024 | Invalid attribute value |
527 | S1090 | HY090 | Invalid string or buffer length |
528 | S1091 | HY091 | Invalid descriptor field identifier |
529 | S1092 | HY092 | Invalid attribute/option identifier |
530 | S1093 | HY093 | Invalid parameter number |
531 | S1095 | HY095 | Function type out of range |
532 | S1106 | HY106 | Fetch type out of range |
533 | S1117 | HY117 | Row value out of range |
534 | S1109 | HY109 | Invalid cursor position |
535 | S1C00 | HYC00 | Optional feature not implemented |
0 | 21S01 | 21S01 | Column count does not match value count |
0 | 23000 | 23000 | Integrity constraint violation |
0 | 42000 | 42000 | Syntax error or access violation |
0 | 42S02 | 42S02 | Base table or view not found |
0 | 42S12 | 42S12 | Index not found |
0 | 42S21 | 42S21 | Column already exists |
0 | 42S22 | 42S22 | Column not found |
0 | 08S01 | 08S01 | Communication link failure |
Here are some common notes and tips for using Connector/ODBC within different environments, applications and tools. The notes provided here are based on the experiences of Connector/ODBC developers and users.
This section provides help with common queries and areas of functionality in MySQL and how to use them with Connector/ODBC.
Obtaining the value of column that uses
AUTO_INCREMENT
after an
INSERT
statement can be
achieved in a number of different ways. To obtain the value
immediately after an INSERT
,
use a SELECT
query with the
LAST_INSERT_ID()
function.
For example, using Connector/ODBC you would execute two
separate statements, the INSERT
statement and the SELECT
query
to obtain the auto-increment value.
INSERT INTO tbl (auto,text) VALUES(NULL,'text'); SELECT LAST_INSERT_ID();
If you do not require the value within your application, but
do require the value as part of another
INSERT
, the entire process can
be handled by executing the following statements:
INSERT INTO tbl (auto,text) VALUES(NULL,'text'); INSERT INTO tbl2 (id,text) VALUES(LAST_INSERT_ID(),'text');
Certain ODBC applications (including Delphi and Access) may have trouble obtaining the auto-increment value using the previous examples. In this case, try the following statement as an alternative:
SELECT * FROM tbl WHERE auto IS NULL;
This alternative method requires that
sql_auto_is_null
variable is
not set to 0. See Section 5.1.4, “Server System Variables”.
See also Section 21.9.10.3, “How to Get the Unique ID for the Last Inserted Row”.
Support for the dynamic cursor
is provided
in Connector/ODBC 3.51, but dynamic cursors are not enabled by
default. You can enable this function within Windows by
selecting the Enable Dynamic Cursor
checkbox within the ODBC Data Source Administrator.
On other platforms, you can enable the dynamic cursor by
adding 32
to the OPTION
value when creating the DSN.
The Connector/ODBC driver has been optimized to provide very fast performance. If you experience problems with the performance of Connector/ODBC, or notice a large amount of disk activity for simple queries, there are a number of aspects you should check:
Ensure that ODBC Tracing
is not
enabled. With tracing enabled, a lot of information is
recorded in the tracing file by the ODBC Manager. You can
check, and disable, tracing within Windows using the
panel of the ODBC Data
Source Administrator. Within Mac OS X, check the
panel of ODBC
Administrator. See
Section 21.1.4.8, “Getting an ODBC Trace File”.
Make sure you are using the standard version of the driver, and not the debug version. The debug version includes additional checks and reporting measures.
Disable the Connector/ODBC driver trace and query logs. These options are enabled for each DSN, so make sure to examine only the DSN that you are using in your application. Within Windows, you can disable the Connector/ODBC and query logs by modifying the DSN configuration. Within Mac OS X and Unix, ensure that the driver trace (option value 4) and query logging (option value 524288) are not enabled.
For more information on how to set the query timeout on Microsoft Windows when executing queries through an ODBC connection, read the Microsoft knowledgebase document at http://support.microsoft.com/default.aspx?scid=kb%3Ben-us%3B153756.
Most programs should work with Connector/ODBC, but for each of those listed here, there are specific notes and tips to improve or enhance the way you work with Connector/ODBC and these applications.
With all applications you should ensure that you are using the latest Connector/ODBC drivers, ODBC Manager and any supporting libraries and interfaces used by your application. For example, on Windows, using the latest version of Microsoft Data Access Components (MDAC) will improve the compatibility with ODBC in general, and with the Connector/ODBC driver.
The majority of Microsoft applications have been tested with Connector/ODBC, including Microsoft Office, Microsoft Access and the various programming languages supported within ASP and Microsoft Visual Studio.
To improve the integration between Microsoft Access and MySQL through Connector/ODBC:
For all versions of Access, you should enable the
Connector/ODBC Return matching rows
option. For Access 2.0, you should additionally enable
the Simulate ODBC 1.0
option.
You should have a
TIMESTAMP
column in all
tables that you want to be able to update. For maximum
portability, do not use a length specification in the
column declaration (which is unsupported within MySQL in
versions earlier than 4.1).
You should have a primary key in each MySQL table you
want to use with Access. If not, new or updated rows may
show up as #DELETED#
.
Use only DOUBLE
float
fields. Access fails when comparing with
single-precision floats. The symptom usually is that new
or updated rows may show up as
#DELETED#
or that you cannot find or
update rows.
If you are using Connector/ODBC to link to a table that
has a BIGINT
column, the
results are displayed as #DELETED#
.
The work around solution is:
Have one more dummy column with
TIMESTAMP
as the data
type.
Select the Change BIGINT columns to
INT
option in the connection dialog in
ODBC DSN Administrator.
Delete the table link from Access and re-create it.
Old records may still display as
#DELETED#
, but newly added/updated
records are displayed properly.
If you still get the error Another user has
changed your data
after adding a
TIMESTAMP
column, the
following trick may help you:
Do not use a table
data sheet view.
Instead, create a form with the fields you want, and use
that form
data sheet view. You should
set the DefaultValue
property for the
TIMESTAMP
column to
NOW()
. It may be a good
idea to hide the
TIMESTAMP
column from
view so your users are not confused.
In some cases, Access may generate SQL statements that
MySQL cannot understand. You can fix this by selecting
"Query|SQLSpecific|Pass-Through"
from
the Access menu.
On Windows NT, Access reports
BLOB
columns as
OLE OBJECTS
. If you want to have
MEMO
columns instead, you should
change BLOB
columns to
TEXT
with
ALTER TABLE
.
Access cannot always handle the MySQL
DATE
column properly. If
you have a problem with these, change the columns to
DATETIME
.
If you have in Access a column defined as
BYTE
, Access tries to export this as
TINYINT
instead of
TINYINT UNSIGNED
. This gives you
problems if you have values larger than 127 in the
column.
If you have very large (long) tables in Access, it might
take a very long time to open them. Or you might run low
on virtual memory and eventually get an ODBC
Query Failed
error and the table cannot open.
To deal with this, select the following options:
Return Matching Rows (2)
Allow BIG Results (8).
These add up to a value of 10
(OPTION=10
).
Some external articles and tips that may be useful when using Access, ODBC and Connector/ODBC:
Optimizing Access ODBC Applications
For a list of tools that can be used with Access and ODBC data sources, refer to http://www.mysql.com/portal/software/convertors/ section for list of available tools.
If you have problems importing data into Microsoft Excel, particularly numeric, date, and time values, this is probably because of a bug in Excel, where the column type of the source data is used to determine the data type when that data is inserted into a cell within the worksheet. The result is that Excel incorrectly identifies the content and this affects both the display format and the data when it is used within calculations.
To address this issue, use the
CONCAT()
function in your
queries. The use of CONCAT()
forces Excel to treat the value as a string, which Excel
will then parse and usually correctly identify the embedded
information.
However, even with this option, some data may be incorrectly
formatted, even though the source data remains unchanged.
Use the Format Cells
option within Excel
to change the format of the displayed information.
To be able to update a table, you must define a primary key for the table.
Visual Basic with ADO cannot handle big integers. This means
that some queries like SHOW
PROCESSLIST
do not work properly. The fix is to
use OPTION=16384
in the ODBC connect
string or to select the Change BIGINT columns to
INT
option in the Connector/ODBC connect screen.
You may also want to select the Return matching
rows
option.
If you have a BIGINT
in your
result, you may get the error [Microsoft][ODBC
Driver Manager] Driver does not support this
parameter
. Try selecting the Change
BIGINT columns to INT
option in the Connector/ODBC
connect screen.
When you are coding with the ADO API and Connector/ODBC, you
need to pay attention to some default properties that aren't
supported by the MySQL server. For example, using the
CursorLocation Property
as
adUseServer
returns a result of –1
for the RecordCount Property
. To have the
right value, you need to set this property to
adUseClient
, as shown in the VB code
here:
Dim myconn As New ADODB.Connection Dim myrs As New Recordset Dim mySQL As String Dim myrows As Long myconn.Open "DSN=MyODBCsample" mySQL = "SELECT * from user" myrs.Source = mySQL Set myrs.ActiveConnection = myconn myrs.CursorLocation = adUseClient myrs.Open myrows = myrs.RecordCount myrs.Close myconn.Close
Another workaround is to use a SELECT
COUNT(*)
statement for a similar query to get the
correct row count.
To find the number of rows affected by a specific SQL
statement in ADO, use the RecordsAffected
property in the ADO execute method. For more information on
the usage of execute method, refer to
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ado270/htm/mdmthcnnexecute.asp.
For information, see ActiveX Data Objects(ADO) Frequently Asked Questions.
You should select the Return matching
rows
option in the DSN.
For more information about how to access MySQL through ASP using Connector/ODBC, refer to the following articles:
A Frequently Asked Questions list for ASP can be found at http://support.microsoft.com/default.aspx?scid=/Support/ActiveServer/faq/data/adofaq.asp.
Some articles that may help with Visual Basic and ASP:
MySQL
BLOB columns and Visual Basic 6 by Mike Hillyer
(<mike@openwin.org>
).
How
to map Visual basic data type to MySQL types by
Mike Hillyer (<mike@openwin.org>
).
With all Borland applications where the Borland Database Engine (BDE) is used, follow these steps to improve compatibility:
Update to BDE 3.2 or newer.
Enable the Don't optimize column widths
option in the DSN.
Enabled the Return matching rows
option
in the DSN.
When you start a query, you can use the
Active
property or the
Open
method. Note that
Active
starts by automatically issuing a
SELECT * FROM ...
query. That may not be
a good thing if your tables are large.
Also, here is some potentially useful Delphi code that sets
up both an ODBC entry and a BDE entry for Connector/ODBC.
The BDE entry requires a BDE Alias Editor that is free at a
Delphi Super Page near you. (Thanks to Bryan Brunton
<bryan@flesherfab.com>
for this):
fReg:= TRegistry.Create; fReg.OpenKey('\Software\ODBC\ODBC.INI\DocumentsFab', True); fReg.WriteString('Database', 'Documents'); fReg.WriteString('Description', ' '); fReg.WriteString('Driver', 'C:\WINNT\System32\myodbc.dll'); fReg.WriteString('Flag', '1'); fReg.WriteString('Password', ''); fReg.WriteString('Port', ' '); fReg.WriteString('Server', 'xmark'); fReg.WriteString('User', 'winuser'); fReg.OpenKey('\Software\ODBC\ODBC.INI\ODBC Data Sources', True); fReg.WriteString('DocumentsFab', 'MySQL'); fReg.CloseKey; fReg.Free; Memo1.Lines.Add('DATABASE NAME='); Memo1.Lines.Add('USER NAME='); Memo1.Lines.Add('ODBC DSN=DocumentsFab'); Memo1.Lines.Add('OPEN MODE=READ/WRITE'); Memo1.Lines.Add('BATCH COUNT=200'); Memo1.Lines.Add('LANGDRIVER='); Memo1.Lines.Add('MAX ROWS=-1'); Memo1.Lines.Add('SCHEMA CACHE DIR='); Memo1.Lines.Add('SCHEMA CACHE SIZE=8'); Memo1.Lines.Add('SCHEMA CACHE TIME=-1'); Memo1.Lines.Add('SQLPASSTHRU MODE=SHARED AUTOCOMMIT'); Memo1.Lines.Add('SQLQRYMODE='); Memo1.Lines.Add('ENABLE SCHEMA CACHE=FALSE'); Memo1.Lines.Add('ENABLE BCD=FALSE'); Memo1.Lines.Add('ROWSET SIZE=20'); Memo1.Lines.Add('BLOBS TO CACHE=64'); Memo1.Lines.Add('BLOB SIZE=32'); AliasEditor.Add('DocumentsFab','MySQL',Memo1.Lines);
The following information is taken from the ColdFusion documentation:
Use the following information to configure ColdFusion Server
for Linux to use the unixODBC
driver with
Connector/ODBC for MySQL data sources. You can download
Connector/ODBC at
http://dev.mysql.com/downloads/connector/odbc/.
ColdFusion version 4.5.1 enables you to use the ColdFusion
Administrator to add the MySQL data source. However, the
driver is not included with ColdFusion version 4.5.1. Before
the MySQL driver appears in the ODBC data sources drop-down
list, you must build and copy the Connector/ODBC driver to
/opt/coldfusion/lib/libmyodbc.so
.
The Contrib directory contains the program
mydsn-
which enables you to build and remove the DSN registry file
for the Connector/ODBC driver on ColdFusion applications.
xxx
.zip
For more information and guides on using ColdFusion and Connector/ODBC, see the following external sites:
Open Office (http://www.openoffice.org) How-to: MySQL + OpenOffice. How-to: OpenOffice + MyODBC + unixODBC.
Sambar Server (http://www.sambarserver.info) How-to: MyODBC + SambarServer + MySQL.
The following section details some common errors and their suggested fix or alternative solution. If you are still experiencing problems, use the Connector/ODBC mailing list; see Section 21.1.8.1, “Connector/ODBC Community Support”.
Many problems can be resolved by upgrading your Connector/ODBC drivers to the latest available release. On Windows, you should also make sure that you have the latest versions of the Microsoft Data Access Components (MDAC) installed.
Questions
22.1.7.3.1:
I have installed Connector/ODBC on Windows XP x64 Edition
or Windows Server 2003 R2 x64. The installation completed
successfully, but the Connector/ODBC driver does not
appear in ODBC Data Source
Administrator
.
22.1.7.3.2:
When connecting or using the
button in ODBC Data Source
Administrator
I get error 10061 (Cannot connect
to server)
22.1.7.3.3:
The following error is reported when using transactions:
Transactions are not enabled
22.1.7.3.4:
Access reports records as #DELETED#
when inserting or updating records in linked tables.
22.1.7.3.5: How do I handle Write Conflicts or Row Location errors?
22.1.7.3.6:
Exporting data from Access 97 to MySQL reports a
Syntax Error
.
22.1.7.3.7:
Exporting data from Microsoft DTS to MySQL reports a
Syntax Error
.
22.1.7.3.8: Using ODBC.NET with Connector/ODBC, while fetching empty string (0 length), it starts giving the SQL_NO_DATA exception.
22.1.7.3.9:
Using SELECT COUNT(*) FROM
within
Visual Basic and ASP returns an error.
tbl_name
22.1.7.3.10:
Using the AppendChunk()
or
GetChunk()
ADO methods, the
Multiple-step operation generated errors. Check
each status value
error is returned.
22.1.7.3.11:
Access Returns Another user had modified the
record that you have modified
while editing
records on a Linked Table.
22.1.7.3.12: When linking an application directly to the Connector/ODBC library under Unix/Linux, the application crashes.
22.1.7.3.13:
Applications in the Microsoft Office suite are unable to
update tables that have
DATE
or
TIMESTAMP
columns.
22.1.7.3.14:
When connecting Connector/ODBC 5.x (Beta) to a MySQL 4.x
server, the error 1044 Access denied for user
'xxx'@'%' to database 'information_schema'
is
returned.
22.1.7.3.15:
When calling SQLTables
, the error
S1T00
is returned, but I cannot find
this in the list of error numbers for Connector/ODBC.
22.1.7.3.16: When linking to tables in Access 2000 and generating links to tables programmatically, rather than through the table designer interface, you may get errors about tables not existing.
22.1.7.3.17: When I try to use batched statements, the excution of the batched statements fails.
22.1.7.3.18:
When connecting to a MySQL server using ADODB and Excel,
occasionally the application fails to communicate with the
server and the error Got an error reading
communication packets
appears in the error log.
22.1.7.3.19: When using some applications to access a MySQL server using C/ODBC and outer joins, an error is reported regarding the Outer Join Escape Sequence.
22.1.7.3.20: I can correctly store extended characters in the database (Hebrew/CJK) using C/ODBC 5.1, but when I retrieve the data, the text is not formatted correctly and I get garbled characters.
22.1.7.3.21: I have a duplicate MySQL Connector/ODBC entry within my Installed Programs list, but I cannot delete one of them.
22.1.7.3.22:
When submitting queries with parameter binding using
UPDATE
, my field values are
being truncated to 255 characters.
22.1.7.3.23: Is it possible to disable data-at-execution using a flag?
22.1.7.3.24:
When you call SQLColumns()
for a table
column that is AUTO_INCREMENT
, the
NULLABLE
column of the result set is
always SQL_NULLABLE (1)
.
Questions and Answers
22.1.7.3.1:
I have installed Connector/ODBC on Windows XP x64 Edition
or Windows Server 2003 R2 x64. The installation completed
successfully, but the Connector/ODBC driver does not
appear in ODBC Data Source
Administrator
.
This is not a bug, but is related to the way Windows x64
editions operate with the ODBC driver. On Windows x64
editions, the Connector/ODBC driver is installed in the
%SystemRoot%\SysWOW64
folder.
However, the default ODBC Data Source
Administrator
that is available through the
Administrative Tools
or
Control Panel
in Windows x64 Editions
is located in the
%SystemRoot%\system32
folder, and
only searches this folder for ODBC drivers.
On Windows x64 editions, you should use the ODBC
administration tool located at
%SystemRoot%\SysWOW64\odbcad32.exe
,
this will correctly locate the installed Connector/ODBC
drivers and enable you to create a Connector/ODBC DSN.
This issue was originally reported as Bug#20301.
22.1.7.3.2:
When connecting or using the ODBC Data Source
Administrator
I get error 10061 (Cannot connect
to server)
button in
This error can be raised by a number of different issues,
including server problems, network problems, and firewall
and port blocking problems. For more information, see
Section C.5.2.2, “Can't connect to [local] MySQL server
”.
22.1.7.3.3:
The following error is reported when using transactions:
Transactions are not enabled
This error indicates that you are trying to use
transactions with a MySQL table that does not support
transactions. Transactions are supported within MySQL when
using the InnoDB
database engine. In
versions of MySQL before Mysql 5.1 you may also use the
BDB
engine.
You should check the following before continuing:
Verify that your MySQL server supports a transactional
database engine. Use SHOW
ENGINES
to obtain a list of the available
engine types.
Verify that the tables you are updating use a transaction database engine.
Ensure that you have not enabled the disable
transactions
option in your DSN.
22.1.7.3.4:
Access reports records as #DELETED#
when inserting or updating records in linked tables.
If the inserted or updated records are shown as
#DELETED#
in the access, then:
If you are using Access 2000, you should get and
install the newest (version 2.6 or higher) Microsoft
MDAC (Microsoft Data Access
Components
) from
http://support.microsoft.com/kb/110093.
This fixes a bug in Access that when you export data
to MySQL, the table and column names aren't specified.
You should also get and apply the Microsoft Jet 4.0
Service Pack 5 (SP5) which can be found at
http://support.microsoft.com/default.aspx?scid=kb;EN-US;q239114.
This fixes some cases where columns are marked as
#DELETED#
in Access.
For all versions of Access, you should enable the
Connector/ODBC Return matching rows
option. For Access 2.0, you should additionally enable
the Simulate ODBC 1.0
option.
You should have a timestamp in all tables that you want to be able to update.
You should have a primary key in the table. If not,
new or updated rows may show up as
#DELETED#
.
Use only DOUBLE
float
fields. Access fails when comparing with
single-precision floats. The symptom usually is that
new or updated rows may show up as
#DELETED#
or that you cannot find
or update rows.
If you are using Connector/ODBC to link to a table
that has a BIGINT
column, the results are displayed as
#DELETED
. The work around solution
is:
Have one more dummy column with
TIMESTAMP
as the
data type.
Select the Change BIGINT columns to
INT
option in the connection dialog in
ODBC DSN Administrator.
Delete the table link from Access and re-create it.
Old records still display as
#DELETED#
, but newly added/updated
records are displayed properly.
22.1.7.3.5: How do I handle Write Conflicts or Row Location errors?
If you see the following errors, select the
Return Matching Rows
option in the DSN
configuration dialog, or specify
OPTION=2
, as the connection parameter:
Write Conflict. Another user has changed your data. Row cannot be located for updating. Some values may have been changed since it was last read.
22.1.7.3.6:
Exporting data from Access 97 to MySQL reports a
Syntax Error
.
This error is specific to Access 97 and versions of Connector/ODBC earlier than 3.51.02. Update to the latest version of the Connector/ODBC driver to resolve this problem.
22.1.7.3.7:
Exporting data from Microsoft DTS to MySQL reports a
Syntax Error
.
This error occurs only with MySQL tables using the
TEXT
or
VARCHAR
data types. You can
fix this error by upgrading your Connector/ODBC driver to
version 3.51.02 or higher.
22.1.7.3.8: Using ODBC.NET with Connector/ODBC, while fetching empty string (0 length), it starts giving the SQL_NO_DATA exception.
You can get the patch that addresses this problem from http://support.microsoft.com/default.aspx?scid=kb;EN-US;q319243.
22.1.7.3.9:
Using SELECT COUNT(*) FROM
within
Visual Basic and ASP returns an error.
tbl_name
This error occurs because the
COUNT(*)
expression is
returning a BIGINT
, and ADO
cannot make sense of a number this big. Select the
Change BIGINT columns to INT
option
(option value 16384).
22.1.7.3.10:
Using the AppendChunk()
or
GetChunk()
ADO methods, the
Multiple-step operation generated errors. Check
each status value
error is returned.
The GetChunk()
and
AppendChunk()
methods from ADO
doesn't work as expected when the cursor location is
specified as adUseServer
. On the other
hand, you can overcome this error by using
adUseClient
.
A simple example can be found from http://www.dwam.net/iishelp/ado/docs/adomth02_4.htm
22.1.7.3.11:
Access Returns Another user had modified the
record that you have modified
while editing
records on a Linked Table.
In most cases, this can be solved by doing one of the following things:
Add a primary key for the table if one doesn't exist.
Add a timestamp column if one doesn't exist.
Only use double-precision float fields. Some programs may fail when they compare single-precision floats.
If these strategies do not help, you should start by making a log file from the ODBC manager (the log you get when requesting logs from ODBCADMIN) and a Connector/ODBC log to help you figure out why things go wrong. For instructions, see Section 21.1.4.8, “Getting an ODBC Trace File”.
22.1.7.3.12: When linking an application directly to the Connector/ODBC library under Unix/Linux, the application crashes.
Connector/ODBC 3.51 under Unix/Linux is not compatible with direct application linking. You must use a driver manager, such as iODBC or unixODBC to connect to an ODBC source.
22.1.7.3.13:
Applications in the Microsoft Office suite are unable to
update tables that have
DATE
or
TIMESTAMP
columns.
This is a known issue with Connector/ODBC. You must ensure
that the field has a default value (rather than
NULL
and that the default value is
nonzero (that is, the default value is not
0000-00-00 00:00:00
).
22.1.7.3.14:
When connecting Connector/ODBC 5.x (Beta) to a MySQL 4.x
server, the error 1044 Access denied for user
'xxx'@'%' to database 'information_schema'
is
returned.
Connector/ODBC 5.x is designed to work with MySQL 5.0 or
later, taking advantage of the
INFORMATION_SCHEMA
database to
determine data definition information. Support for MySQL
4.1 is planned for the final release.
22.1.7.3.15:
When calling SQLTables
, the error
S1T00
is returned, but I cannot find
this in the list of error numbers for Connector/ODBC.
The S1T00
error indicates that a
general timeout has occurred within the ODBC system and is
not a MySQL error. Typically it indicates that the
connection you are using is stale, the server is too busy
to accept your request or that the server has gone away.
22.1.7.3.16: When linking to tables in Access 2000 and generating links to tables programmatically, rather than through the table designer interface, you may get errors about tables not existing.
There is a known issue with a specific version of the
msjet40.dll
that exhibits this issue.
The version affected is 4.0.9025.0. Reverting to an older
version will enable you to create the links. If you have
recently updated your version, check your
WINDOWS
directory for the older
version of the file and copy it to the drivers directory.
22.1.7.3.17: When I try to use batched statements, the excution of the batched statements fails.
Batched statement support was added in 3.51.18. Support
for batched statements is not enabled by default. You must
enable option FLAG_MULTI_STATEMENTS
,
value 67108864, or select the Allow multiple
statements flag within a GUI configuration.
22.1.7.3.18:
When connecting to a MySQL server using ADODB and Excel,
occasionally the application fails to communicate with the
server and the error Got an error reading
communication packets
appears in the error log.
This error may be related to Keyboard Logger 1.1 from PanteraSoft.com, which is known to interfere with the network communication between MySQL Connector/ODBC and MySQL.
22.1.7.3.19: When using some applications to access a MySQL server using C/ODBC and outer joins, an error is reported regarding the Outer Join Escape Sequence.
This is a known issue with MySQL Connector/ODBC which is
not correctly parsing the "Outer Join Escape Sequence", as
per the specs at
Microsoft
ODBC Specs. Currently, Connector/ODBC will return
value > 0 when asked for
SQL_OJ_CAPABILITIES
even though no
parsing takes place in the driver to handle the outer join
escape sequence.
22.1.7.3.20: I can correctly store extended characters in the database (Hebrew/CJK) using C/ODBC 5.1, but when I retrieve the data, the text is not formatted correctly and I get garbled characters.
When using ASP and UTF8 characters you should add the following to your ASP files to ensure that the data returned is correctly encoded:
Response.CodePage = 65001 Response.CharSet = "utf-8"
22.1.7.3.21: I have a duplicate MySQL Connector/ODBC entry within my Installed Programs list, but I cannot delete one of them.
This problem can occur when you upgrade an existing Connector/ODBC installation, rather than removing and then installing the updated version.
To fix the problem you should use any working uninstallers to remove existing installations and then may have to edit the contents of the registry. Make sure you have a backup of your registry information before attempting any editing of the registry contents.
22.1.7.3.22:
When submitting queries with parameter binding using
UPDATE
, my field values are
being truncated to 255 characters.
You should ensure that the
FLAG_BIG_PACKETS
option is set for your
connection. This removes the 255 character limitation on
bound parameters.
22.1.7.3.23: Is it possible to disable data-at-execution using a flag?
If you do not wish to use data-at-execution, simply remove the corresponding calls. For example:
SQLLEN ylen = SQL_LEN_DATA_AT_EXEC(10); SQLBindCol(hstmt,2,SQL_C_BINARY, buf, 10, &ylen);
Would become:
SQLBindCol(hstmt,2,SQL_C_BINARY, buf, 10, NULL);
Note that in the call to SQLBindCol()
,
&ylen has been replaced by NULL.
For further information please refer to the
MSDN
documentation for SQLBindCol()
.
22.1.7.3.24:
When you call SQLColumns()
for a table
column that is AUTO_INCREMENT
, the
NULLABLE
column of the result set is
always SQL_NULLABLE (1)
.
This is because MySQL reports the
DEFAULT
value for such a column as
NULL
. It means, if you insert a
NULL
value into the column, you will
get the next integer value for the table's
auto_increment
counter.
There are many different places where you can get support for using Connector/ODBC. You should always try the Connector/ODBC Mailing List or Connector/ODBC Forum. See Section 21.1.8.1, “Connector/ODBC Community Support”, for help before reporting a specific bug or issue to MySQL.
Oracle provides assistance to the user community by means of its
mailing lists. For Connector/ODBC-related issues, you can get
help from experienced users by using the
<myodbc@lists.mysql.com>
mailing list. Archives are
available online at
http://lists.mysql.com/myodbc.
For information about subscribing to MySQL mailing lists or to browse list archives, visit http://lists.mysql.com/. See Section 1.6.1, “MySQL Mailing Lists”.
Community support from experienced users is also available through the ODBC Forum. You may also find help from other users in the other MySQL Forums, located at http://forums.mysql.com. See Section 1.6.2, “MySQL Community Support at the MySQL Forums”.
If you encounter difficulties or problems with Connector/ODBC,
you should start by making a log file from the ODBC
Manager
(the log you get when requesting logs from
ODBC ADMIN
) and Connector/ODBC. The procedure
for doing this is described in
Section 21.1.4.8, “Getting an ODBC Trace File”.
Check the Connector/ODBC trace file to find out what could be
wrong. You should be able to determine what statements were
issued by searching for the string
>mysql_real_query
in the
myodbc.log
file.
You should also try issuing the statements from the
mysql client program or from
admndemo
. This helps you determine whether
the error is in Connector/ODBC or MySQL.
If you find out something is wrong, please only send the
relevant rows (maximum 40 rows) to the myodbc
mailing list. See Section 1.6.1, “MySQL Mailing Lists”. Please never
send the whole Connector/ODBC or ODBC log file!
You should ideally include the following information with the email:
Operating system and version
Connector/ODBC version
ODBC Driver Manager type and version
MySQL server version
ODBC trace from Driver Manager
Connector/ODBC log file from Connector/ODBC driver
Simple reproducible sample
Remember that the more information you can supply to us, the more likely it is that we can fix the problem!
Also, before posting the bug, check the MyODBC mailing list archive at http://lists.mysql.com/myodbc.
If you are unable to find out what is wrong, the last option is
to create an archive in tar or Zip format
that contains a Connector/ODBC trace file, the ODBC log file,
and a README
file that explains the
problem. You can send this to ftp://ftp.mysql.com/pub/mysql/upload/.
Only MySQL engineers have access to the files you upload, and we
are very discreet with the data.
If you can create a program that also demonstrates the problem, please include it in the archive as well.
If the program works with another SQL server, you should include an ODBC log file where you perform exactly the same SQL statements so that we can compare the results between the two systems.
Remember that the more information you can supply to us, the more likely it is that we can fix the problem.
You can send a patch or suggest a better solution for any
existing code or problems by sending a mail message to
<myodbc@lists.mysql.com>
.
The Connector/ODBC Change History (Changelog) is located with the main Changelog for MySQL. See Section D.3, “MySQL Connector/ODBC (MyODBC) Change History”.
Connector/NET enables developers to easily create .NET applications that require secure, high-performance data connectivity with MySQL. It implements the required ADO.NET interfaces and integrates into ADO.NET aware tools. Developers can build applications using their choice of .NET languages. Connector/NET is a fully managed ADO.NET driver written in 100% pure C#.
Connector/NET includes full support for:
Features provided by MySQL Server up to and including MySQL Server version 5.5.
Large-packet support for sending and receiving rows and BLOBs up to 2 gigabytes in size.
Protocol compression which enables compressing the data stream between the client and server.
Support for connecting using TCP/IP sockets, named pipes, or shared memory on Windows.
Support for connecting using TCP/IP sockets or Unix sockets on Unix.
Support for the Open Source Mono framework developed by Novell.
Fully managed, does not utilize the MySQL client library.
This document is intended as a user's guide to Connector/NET and
includes a full syntax reference. Syntax information is also
included within the Documentation.chm
file
included with the Connector/NET distribution.
If you are using MySQL 5.0 or later, and Visual Studio as your development environment, you may want also want to use the MySQL Visual Studio Plugin. The plugin acts as a DDEX (Data Designer Extensibility) provider, enabling you to use the data design tools within Visual Studio to manipulate the schema and objects within a MySQL database. For more information, see Section 21.2.3, “Connector/NET Visual Studio Integration”.
Connector/NET 5.1.2 and later include the Visual Studio Plugin by default.
MySQL Connector/NET supports full versions of Visual Studio 2005, 2008, and 2010, although certain features are only available in Visual Studio 2010 when using MySQL Connector/NET version 6.3.2 and later. Note that MySQL Connector/NET does not currently support Express versions of Microsoft products, including Microsoft Visual Web Developer.
Key topics:
For connection string properties when using the
MySqlConnection
class, see
Section 21.2.6, “Connector/NET Connection String Options Reference”.
There are several versions of Connector/NET available:
Connector/NET 1.0 includes support for MySQL Server 4.0, 4.1, and 5.0 features, and full compatibility with the ADO.NET driver interface.
This version of Connector/NET is no longer supported.
Connector/NET 5.0 includes support for MySQL Server 4.0, 4.1, 5.0 and 5.1 features. Connector/NET 5.0 also includes full support for the ADO.Net 2.0 interfaces and subclasses, includes support for the usage advisor and performance monitor (PerfMon) hooks.
This version of Connector/NET is no longer supported.
Connector/NET 5.1 includes support for MySQL Server 4.0, 4.1,
5.0, 5.1, 5.4 and 5.5 features. Connector/NET 5.1 also includes
support for a new membership/role provider, Compact Framework
2.0, a new stored procedure parser and improvements to
GetSchema
. Connector/NET 5.1 also includes
the Visual Studio Plugin as a standard installable component.
This version of Connector/NET is no longer supported.
Connector/NET 5.2 includes support for MySQL Server 4.1, 5.0,
5.1, 5.4, and 5.5 features. Connector/NET 5.2 also includes
support for a new membership/role provider, Compact Framework
2.0, a new stored procedure parser and improvements to
GetSchema
. Connector/NET 5.2 also includes
the Visual Studio Plugin as a standard installable component.
This version of Connector/NET is no longer supported.
Connector/NET 6.0 includes support for MySQL Server 4.1, 5.0, 5.1, 5.4 and 5.5.
This version of Connector/NET is no longer supported.
Connector/NET 6.1 includes support for MySQL Server 4.1, 5.0, 5.1, 5.4, and 5.5. Important new features include the MySQL Website Configuration Tool and a Session State Provider.
Connector/NET 6.2 includes support for MySQL Server 4.1, 5.0, 5.1, 5.4, and 5.5. Important new features include a new logging system and client SSL certificates. Connector/NET 6.2 is currently available as a Beta release.
Connector/NET 6.3 includes support for MySQL Server 5.0, 5.1, 5.4, and 5.5. Important new features include integration with Visual Studio 2010, such as availability of DDL T4 template for Entity Framework, and a custom MySQL SQL Editor. Other features include refactored transaction scope: Connector/NET now supports nested transactions in a scope where they use the same connection string. Connector/NET 6.3 is available as a Beta release.
The latest source code for Connector/NET can be downloaded from the MySQL public Subversion server. For further details see Section 21.2.2.3, “Installing Connector/NET from the source code”.
The following table shows the .NET Framework version required, and MySQL Server version supported by Connector/NET:
Connector/NET version | ADO.NET version supported | .NET Framework version required | MySQL Server version supported | Currently supported |
---|---|---|---|---|
1.0 | 1.x | 1.x | 4.0, 4.1, 5.0 | No |
5.0 | 2.x+ | 2.x+ | 4.0, 4.1, 5.0 | No |
5.1 | 2.x+ | 2.x+ | 4.0, 4.1, 5.0, 5.1, 5.4, 5.5 | No |
5.2 | 2.x+ | 2.x+ | 4.1, 5.0, 5.1, 5.4, 5.5 | No |
6.0 | 2.x+ | 2.x+ | 4.1, 5.0, 5.1, 5.4, 5.5 | Critical issues only |
6.1 | 2.x+ | 2.x+ | 4.1, 5.0, 5.1, 5.4, 5.5 | Yes |
6.2 | 2.x+ | 2.x+ | 4.1, 5.0, 5.1, 5.4, 5.5 | Yes |
6.3 | 2.x+ | 2.x+, 4.x+ for VS 2010 support | 5.0, 5.1, 5.4, 5.5 | Yes |
Version numbers for MySQL products are formatted as X.Y.Z, where Z=0 indicates alpha, Z=1 indicates beta, and Z>=2 indicates GA. However, Windows tools (Control Panel, properties display) may show the version numbers as XX.YY.ZZ. For example, the official MySQL formatted version number 5.0.9 may be displayed by Windows tools as 5.00.09. The two versions are the same; only the number display format is different.
Connector/NET runs on any platform that supports the .NET framework. The .NET framework is primarily supported on recent versions of Microsoft Windows, and is supported on Linux through the Open Source Mono framework (see http://www.mono-project.com).
Connector/NET is available for download from http://dev.mysql.com/downloads/connector/net/5.2.html.
On Windows, installation is supported either through a binary installation process or by downloading a Zip file with the Connector/NET components.
Before installing, you should ensure that your system is up to date, including installing the latest version of the .NET Framework.
Using the installer is the most straightforward method of installing Connector/NET on Windows and the installed components include the source code, test code and full reference documentation.
Connector/NET is installed through the use of a Windows
Installer (.msi
) installation package, which
can be used to install Connector/NET on all Windows operating
systems. The MSI package in contained within a ZIP archive named
mysql-connector-net-
,
where version
.zipversion
indicates the
Connector/NET version.
To install Connector/NET:
Double-click the MSI installer file extracted from the Zip you downloaded. Click
to start the installation.You must choose the type of installation that you want to perform.
For most situations, the Typical installation will be suitable. Click the
button and proceed to Step 5. A Complete installation installs all the available files. To conduct a Complete installation, click the button and proceed to step 5. If you want to customize your installation, including choosing the components to install and some installation options, click the button and proceed to Step 3.The Connector/NET installer will register the connector within the Global Assembly Cache (GAC) - this will make the Connector/NET component available to all applications, not just those where you explicitly reference the Connector/NET component. The installer will also create the necessary links in the Start menu to the documentation and release notes.
If you have chosen a custom installation, you can select the individual components that you want to install, including the core interface component, supporting documentation (a CHM file) samples and examples and the source code. Select the items, and their installation level, and then click
to continue the installation.For Connector/NET 1.0.8 or lower and Connector 5.0.4 and lower the installer will attempt to install binaries for both 1.x and 2.x of the .NET Framework. If you only have one version of the framework installed, the connector installation may fail. If this happens, you can choose the framework version to be installed through the custom installation step.
You will be given a final opportunity to confirm the installation. Click
to copy and install the files onto your machine.Once the installation has been completed, click
to exit the installer.
Unless you choose otherwise, Connector/NET is installed in
C:\Program Files\MySQL\MySQL Connector Net
, where
X.X.X
X.X.X
is replaced with the version of
Connector/NET you are installing. New installations do not
overwrite existing versions of Connector/NET.
Depending on your installation type, the installed components will include some or all of the following components:
bin
- Connector/NET MySQL libraries for
different versions of the .NET environment.
docs
- contains a CHM of the
Connector/NET documentation.
samples
- sample code and applications
that use the Connector/NET component.
src
- the source code for the
Connector/NET component.
You may also use the /quiet
or
/q
command-line option with the
msiexec
tool to install the Connector/NET
package automatically (using the default options) with no
notification to the user. Using this method the user cannot
select options. Additionally, no prompts, messages or dialog
boxes will be displayed.
C:\> msiexec /package conector-net.msi /quiet
To provide a progress bar to the user during automatic
installation, use the /passive
option.
If you are having problems running the installer, you can
download a Zip file without an installer as an alternative. That
file is called
mysql-connector-net-
.
Once downloaded, you can extract the files to a location of your
choice.
version
-noinstall.zip
The file contains the following directories:
bin
- Connector/NET MySQL libraries for
different versions of the .NET environment.
Docs
- contains a CHM of the
Connector/NET documentation.
Samples
- sample code and applications
that use the Connector/NET component.
Connector/NET 6.0.x has a different directory structure:
Assemblies
- contains a collection of
DLLs that make up the connector functionality.
Documentation
- contains the
Connector/NET documentation as a CHM file.
Samples
- sample code and applications
that use the Connector/NET component.
There is also another Zip file available for download called
mysql-connector-net-
.
This file contains the source code distribution.
version
-src.zip
The file contains the following directories:
Documentation
- This folder contains
the source files to build the documentation into the
compiled HTML (CHM) format.
Installer
- This folder contains the
source files to build the Connector/NET installer program.
MySql.Data
- This folder contains the
source files for the core data provider.
MySql.VisualStudio
- This folder
contains the source files for the Microsoft Visual Studio
extensions.
MySql.Web
- This folder contains the
source files for the web providers. This includes code for
the membership provider, role provider and profile provider.
These are used in ASP.NET web sites.
Samples
- This folder contains the
source files for several example applications.
Tests
- Ths folder contains a
spreadsheet listing test cases.
VisualStudio
- Contains resources used
by the Visual Studio plug in.
Finally, you need to ensure that
MySql.Data.dll
is accessible to your
program at build time (and run time). If using Microsoft Visual
Studio you will need to add MySql.Data
as a
Reference to your project.
If using MySQL Connector/NET 6.3.5 and above, the
MySql.Data
file provided will work with
both .NET Framework 2.x and 4.x.
There is no installer available for installing the Connector/NET component on your Unix installation. Before installing, please ensure that you have a working Mono project installation. You can test whether your system has Mono installed by typing:
shell> mono --version
The version of the Mono JIT compiler will be displayed.
To compile C# source code you will also need to make sure a Mono
C# compiler, is installed. Note that there are two Mono C#
compilers available, mcs
, which accesses the
1.0-profile libraries, and gmcs
, which acesses
the 2.0-profile libraries.
To install Connector/NET on Unix/Mono:
Download the
mysql-connector-net-
and extract the contents to a directory of your choice, for
example: version
-noinstall.zip~/connector-net/
.
In the directory where you unzipped the connector to, change
into the bin
directory. Ensure the file
MySql.Data.dll
is present.
You must register the Connector/NET component,
MySql.Data
, in the Global Assembly Cache
(GAC). In the current directory enter the
gacutil
command:
root-shell> gacutil /i MySql.Data.dll
This will register MySql.Data
into the GAC.
You can check this by listing the contents of
/usr/lib/mono/gac
, where you will find
MySql.Data
if the registration has been
successful.
You are now ready to compile your application. You must ensure
that when you compile your application you include the
Connector/NET component using the -r:
command-line option. For example:
shell> gmcs -r:System.dll -r:System.Data.dll -r:MySql.Data.dll HelloWorld.cs
Note, the assemblies that need to be referenced will depend on the
requirements of the application, but applications using
Connector/NET will need to provide -r:MySql.Data
as a minimum.
You can further check your installation by running the compiled program, for example:
shell> mono HelloWorld.exe
You should read this section only if you are interested in helping us test our new code. If you just want to get Connector/NET up and running on your system, you should use a standard release distribution.
Obtaining the source code
To obtain the most recent development source tree, you first need to download and install Bazaar. You can obtain Bazaar from the Bazaar VCS Website. Bazaar is supported by any platform that supports Python, and is therefore compatible with any Linux, Unix, Windows or Mac OS X host. Instructions for downloading and installing Bazaar on the different platforms are available on the Bazaar Web site.
The most recent development source tree is available from our public Subversion trees at http://dev.mysql.com/tech-resources/sources.html.
To check out out the Connector/NET sources, change to the directory where you want the copy of the Connector/NET tree to be stored, then use the following command:
shell> bzr branch lp:connectornet/trunk
To download a specific version of Connector/NET, specify the
version number instead of trunk
. For example,
to obtain a copy of the 6.0 version of the source tree:
shell> bzr branch lp:connectornet/6.0
Source packages are also available on the downloads page.
Building the source code on Windows
The following procedure can be used to build the connector on Microsoft Windows.
Obtain the source code, either from the Subversion server, or through one of the prepared source code packages.
Navigate to the root of the source code tree.
A Microsoft Visual Studio 2005 solution file is available to
build the connector, this is called
MySQL-VS2005.sln
. Click this file to load
the solution into Visual Studio.
Select
, from the main menu to build the solution.Building the source code on Unix
Support for building Connector/NET on Mono/Unix is currently not available.
When MySQL Connector/NET is installed on Microsoft Windows, Visual Studio integration components are also installed and initialized. This enables the developer to work seamlessly with MySQL Connector/NET in the familiar Visual Studio environment, as described in the following sections of the manual.
MySQL Connector/NET supports Visual Studio versions 2005, 2008, and 2010. However, only MySQL Connector/NET version 6.3 fully integrates with Visual Studio 2010, although applications using earlier versions of the connector can be built with the Visual Studio 2010 environment using .NET 2.x frameworks.
Visual Studio 2010 support was introduced with MySQL Connector/NET 6.3.2. From
version 6.3.2 the connector ships with both .NET 2.x and .NET 4.x
versions of the entity framework support files,
mysql.data.ef.dll
and
mysql.visualstudio.dll
. The .NET 4.x versions need to be
shipped to enable new integration features supported in Visual
Studio 2010, including:
New DDL T4 template for the Entity Framework (EF) - This enables
developers to design an EF model from scratch and use the native
Visual Studio 2010 facility to generate MySQL DDL from that
model. This is done by creating the model, and with the model
open, choosing the SSDLToMySQL template in the properties
window. The correct DDL is then generated. The developer can
then save this code as a .mysql
file in
their project and execute it against the MySQL server.
New SQL Editor - A new SQL editor has been included that enables
connections to servers to execute SQL. This is activated by
creating a new file with a .mysql
extension. A new template is also included to allow creation of
this file type using the Visual Studio 2010 main menu item
, . Note that the
MySQL SQL Editor is also available in 2005 and 2008.
Once the connector is installed, you can use it to create, modify, and delete connections to MySQL databases. To create a connection with a MySQL database, perform the following steps:
Start Visual Studio, and open the Server Explorer window (Ctrl+W, L hot keys).
, option in the main Visual Studio menu, orRight-click the Data Connections node, and choose the
menu item.Add Connection dialog opens. Press the
button to choose MySQL Database as a data source.
Change Data Source dialog opens. Choose MySQL Database in the
list of data sources (or the <other>
option, if MySQL Database is absent), and then choose .NET
Framework Data Provider for MySQL in the combo box of data
providers.
Input the connection settings: the server host name (for example, localhost if the MySQL server is installed on the local machine), the user name, the password, and the default schema name. Note that you must specify the default schema name to open the connection.
You can also set the port to connect with the MySQL server by pressing the
button. To test connection with the MySQL server, set the server host name, the user name, and the password, and press the button. If the test succeeds, the success confirmation dialog opens.After you set all settings and test the connection, press
. The newly created connection is displayed in Server Explorer. Now you can work with the MySQL server through standard Server Explorer GUI.
After the connection is successfully established, all settings are saved for future use. When you start Visual Studio for the next time, just open the connection node in Server Explorer to establish a connection to the MySQL server again.
To modify and delete a connection, use the Server Explorer context menu for the corresponding node. You can modify any of the settings just by overwriting the existing values with new ones. Note that the connection may be modified or deleted only if no active editor for its objects is opened: otherwise you may loose your data.
Connector/Net contains a table editor, which enables the visual creation and modification of tables.
The Table Designer can be accessed through a mouse action on table-type node of Server Explorer. To create a new table, right-click the Tables node (under the connection node) and choose the command from the context menu.
To modify an existing table, double-click the node of the table you wish to modify, or right-click this node and choose the
item from the context menu. Either of the commands opens the Table Designer.The table editor is implemented in the manner of the well-known Query Browser Table Editor, but with minor differences.
Table Designer consists of the following parts:
Columns Editor - a data grid on top of the Table Designer. Use the Columns grid for column creation, modification, and deletion.
Indexes tab - a tab on bottom of the Table Designer. Use the Indexes tab for indexes management.
Foreign Keys tab - a tab on bottom of the Table Designer. Use the Foreign Keys tab for foreign keys management.
Column Details tab - a tab on bottom of the Table Designer. Use the Column Details tab to set advanced column options.
Properties window - a standard Visual Studio Properties window, where the properties of the edited table are displayed. Use the Properties window to set the table properties.
Each of these areas is discussed in more detail in subsequent sections.
To save changes you have made in the Table Designer, use either Ctrl+S. If you have not already named the table you will be prompted to do so.
or button of the Visual Studio main toolbar, or just pressOnce created you can view the table in the Server Explorer.
The Table Designer main menu enables you to set a Primary Key column, edit Relationships such as Foreign Keys, and create Indexes.
You can use the Column Editor to set or change the name, data type, default value, and other properties of a table column. To set the focus to a needed cell of a grid, use the mouse click. Also you can move through the grid using Tab and Shift+Tab keys.
To set or change the name, data type, default value and comment of a column, activate the appropriate cell and type the desired value.
To set or unset flag-type column properties (NOT
NULL
, auto incremented, flags), check or uncheck the
corresponding check boxes. Note that the set of column flags
depends on its data type.
To reorder columns, index columns or foreign key columns in the Column Editor, select the whole column you wish to reorder by clicking the selector column on the left of the column grid. Then move the column by using Ctrl+Up (to move the column up) or Ctrl+Down (to move the column down) keys.
To delete a column, select it by clicking the selector column on the left of the column grid, then press the Delete button on a keyboard.
Indexes management is performed using the Indexes/Keys dialog.
To add an index, select
, from the main menu, and click to add a new index. You can then set the index name, index kind, index type, and a set of index columns.To remove an index, select it in the list box on the left, and click the
button.To change index settings, select the needed index in the list box on the left. The detailed information about the index is displayed in the panel on the right hand side. Change the desired values.
Foreign Keys management is performed using the Foreign Key Relationships dialog.
To add a foreign key, select Foreign Key Relationship dialog. Click . You can then set the foreign key name, referenced table name, foreign key columns, and actions upon update and delete.
, from the main menu. This displays theTo remove a foreign key, select it in the list box on the left, and click the
button.To change foreign key settings, select the required foreign key in the list box on the left. The detailed information about the foreign key is displayed in the right hand panel. Change the desired values.
The Column Properties tab can be used to set column options. In addition to the general column properties presented in the Column Editor, in the Column Properties tab you can set additional properties such as Character Set, Collation and Precision.
To bring up Table Properties select the table and right-click to activate the context menu. Select Table Properties dockable window will be displayed.
. TheThe following table properties can be set:
Auto Increment
Average Row Length
Character Set
Collation
Comment
Data Directory
Index Directory
Maximum Rows
Minimum Rows
Name
Row Format
Schema
Storage Engine
The property Schema
is read only.
To create a new view, right-click the Views node under the connection node in Server Explorer. From the node's context menu, choose the
command. This command opens the SQL Editor.You can then enter the SQL for your view.
To modify an existing view, double-click a node of the view you wish to modify, or right-click this node and choose the
command from a context menu. Either of the commands opens the SQL Editor.All other view properties can be set in the Properties window. These properties are:
Catalog
Check Option
Definer
Definition
Definer
Is Updateable
Name
Schema
Security Type
Some of these properties can have arbitrary text values, others accept values from a predefined set. In the latter case you set the desired value with an embedded combobox.
The properties Is Updatable
and
Schema
are readonly.
To save changes you have made, use either Ctrl+S.
or buttons of the Visual Studio main toolbar, or just pressTo create a new stored procedure, right-click the Stored Procedures node under the connection node in Server Explorer. From the node's context menu, choose the Create Routine command. This command opens the SQL Editor.
To create a new stored function, right-click the Functions node under the connection node in Server Explorer. From the node's context menu, choose the Create Routine command.
To modify an existing stored routine (procedure or function), double-click the node of the routine you wish to modify, or right-click this node and choose the Alter Routine command from the context menu. Either of the commands opens the SQL Editor.
To create or alter the routine definition using SQL Editor, type this definition in the SQL Editor using standard SQL. All other routine properties can be set in the Properties window. These properties are:
Body
Catalog
Comment
Creation Time
Data Access
Definer
Definition
External Name
External Language
Is Deterministic
Last Modified
Name
Parameter Style
Returns
Schema
Security Type
Specific Name
SQL Mode
SQL Path
Type
Some of these properties can have arbitrary text values, others accept values from a predefined set. In the latter case set the desired value using the embedded combo box.
You can also set all the options directly in the SQL Editor, using
the standard CREATE PROCEDURE
or
CREATE FUNCTION
statement. However, it is
recommended to use the Properties window instead.
To save changes you have made, use either Save or Save All buttons of the Visual Studio main toolbar, or just press Ctrl+S.
To create a new trigger, right-click the node of the table, for which you wish to add a trigger. From the node's context menu, choose the Create Trigger command. This command opens the SQL Editor.
To modify an existing trigger, double-click the node of the trigger you wish to modify, or right-click this node and choose the Alter Trigger command from the context menu. Either of the commands opens the SQL Editor.
To create or alter the trigger definition using SQL Editor, type the trigger statement in the SQL Editor using standard SQL.
You should enter only the trigger statement, that is, the part
of the CREATE TRIGGER
query that is placed
after the FOR EACH ROW
clause.
All other trigger properties are set in the Properties window. These properties are:
Definer
Event Manipulation
Name
Timing
Some of these properties can have arbitrary text values, others accept values from a predefined set. In the latter case set the desired value using the embedded combo box.
The properties Event Table
,
Schema
, and Server
in the
Properties window are read only.
To save changes you have made, use either Ctrl+S. Before changes are saved, you will be asked to confirm the execution of the corresponding SQL query in a confirmation dialog.
or buttons of the Visual Studio main toolbar, or just pressTo create a new User Defined Function (UDF), right-click the UDFs node under the connection node in Server Explorer. From the node's context menu, choose the command. This command opens the UDF Editor.
To modify an existing UDF, double-click the node of the UDF you wish to modify, or right-click this node and choose the
command from the context menu. Either of the commands opens the UDF Editor.The UDF editor enables you to set the following properties:
Name
So-name (DLL name)
Return type
Is Aggregate
There are text fields for both names, a combo box for the return type, and a check box to indicate if the UDF is aggregate. All these options are also accessible using the Properties window.
The property Server
in the Properties window is
read only.
To save changes you have made, use either Ctrl+S. Before changes are saved, you will be asked to confirm the execution of the corresponding SQL query in a confirmation dialog.
or buttons of the Visual Studio main toolbar, or just pressTables, views, stored procedures, and functions can be cloned using the appropriate Clone command from the context menu: Table Editor for cloning a table, and the SQL Editor for cloning a view or a routine.
, , . The clone commands open the corresponding editor for a new object: theThe editor is filled with values of the original object. You can modify these values in a usual manner.
To save the cloned object, use either Save or Save All buttons of the Visual Studio main toolbar, or just press Ctrl+S. Before changes are saved, you will be asked to confirm the execution of the corresponding SQL query in a confirmation dialog.
Tables, views, stored routines, triggers, and UDFs can be dropped with the appropriate Drop command selected from its context menu:
, , , , .You will be asked to confirm the execution of the corresponding drop query in a confirmation dialog.
Dropping of multiple objects is not supported.
Connector/NET 6.0 introduced support for the ADO.NET Entity Framework. ADO.NET Entity Framework was included with .NET Framework 3.5 Service Pack 1, and Visual Studio 2008 Service Pack 1. ADO.NET Entity Framework was released on 11th August 2008.
ADO.NET Entity Framework provides an Object Relational Mapping (ORM) service, mapping the relational database schema to objects. The ADO.NET Entity Framework defines several layers, these can be summarized as:
Logical - this layer defines the relational data and is defined by the Store Schema Definition Language (SSDL).
Conceptual - this layer defines the .NET classes and is defined by the Conceptual Schema Definition Language (CSDL)
Mapping - this layer defines the mapping from .NET classes to relational tables and associations, and is defined by Mapping Specification Language (MSL).
Connector/NET integrates with Visual Studio 2008 to provide a range of helpful tools to assist the developer.
A full treatment of ADO.NET Entity Framework is beyond the scope of this manual. You are encouraged to review the Microsoft ADO.NET Entity Framework documentation.
Tutorials on getting started with ADO.NET Entity Framework are available. See Section 21.2.4.5, “Tutorial: Using an Entity Framework Entity as a Windows Forms Data Source” and Section 21.2.4.6, “Tutorial: Databinding in ASP.NET using LINQ on Entities”.
MySQL Connector/NET 6.1 introduced the MySQL Website Configuration Tool. This
is a facility available in Visual Studio that enables you to
configure the Membership, Role, Session State and Profile
Provider, without having to resort to editing configuration files.
You simply run the tool, set your configuration options, and the
tool will modify your web.config
file
accordingly.
The MySQL Website Configuration Tool appears as a small icon on the Solution Explorer toolbar in Visual Studio, as show by the following screenshot:
Clicking the Website Configuration Tool icon launches the wizard and displays the first screen:
This allows you to enable use of the MySQL Membership Provider. Simply click the checkbox to enable this. You can now enter the name of the application that you are creating the configuration for. You can also enter a description for the application.
You can then click the
button to launch the Connection String Editor:
Note that if you have already defined a connection string for the
providers manually in web.config
, or
previously using the tool, this will be automatically loaded and
displayed, and can then be modified in this dialog.
You can also ensure that the necessary schema are created automatically for you by selecting the Autogenerate Schema checkbox. These schema are used to store membership information. The database used to storage is the one specified in the connection string.
You can also ensure that exceptions generated by the application will be written to the event log by selecting the Write excpetions to event log checkbox.
Clicking the
button launches a dialog that enables you to set Membership Options. These options dictate such variables as password length required when a user signs up, whether the password is encrypted and whether the user can reset their password or not.Once information has been set up as required for configuration of the Membership Provider the
button can be clicked to display the Roles Provider screen:Again the connection string can be edited, a description added and Autogenerate Schema can be enabled before clicking
to go to the Profiles Provider screen:This screen display similar options to the previous screens.
Click
to proceed to the Session State configuration page:Once you have set up the Session State Provider as required, click
to exit the wizard.At this point it is necessary to select the Authentication Type to From Internet. This can be done by launching the ASP.NET Configuration Tool, and selecting the Security tab. Click the Select authentication type link and ensure that the From the internet radio button is selected. You can now examine the database you created to store membership information. All the necessary tables will have been created for you:
MySQL Connector/NET 6.3.2 introduced a new MySQL SQL Editor. The easiest way to invoke the editor is by selecting the New File dialog:
, menu item from the Visual Studio main menu. This displays theFrom the New File dialog select the MySQL template, and then double-click the MySQL SQL Script document, or click the button.
The MySQL SQL Editor will be displayed. You can now enter SQL code as required, or connect to a MySQL server. Click the Connect to MySQL dialog that is displayed. You can enter the server name, user id, password and database to connect to, or click the button to select other connection string options. Click the button to connect to the MySQL server. It is now possible to execute your SQL code against the server by clicking the button on the toolbar.
button in the MySQL SQL Editor toolbar. You can enter the connection details into theThe results from any queries are displayed on the Results tab. Any errors are displayed on the Messages tab.
MySQL Connector/NET 6.3 introduced the ability to convert an Entity Framework model to MySQL DDL code. Starting with a blank model, an entity model can be developed in Visual Studio's designer. Once the model has been created, the model's properties can be selected, and in the Database Script Generation category of the model's properties, the property DDL Generation can be found. The value SSDLToMySQL.tt(VS) can then be selected from the drop-down listbox.
Right-clicking the model design area will display a context-sensitive menu. Selecting Generate Database from Model from the menu will display the Generate Database Wizard. The wizard can then be used to generate MySQL DDL code.
This section provides a gentle introduction to programming with Connector/NET. The example code is written in C#, and is designed to work on both Microsoft .NET Framework and Mono.
This tutorial is designed to get you up and running with Connector/NET as quickly as possible, it does not go into detail on any particular topic. However, the following sections of this manual describe each of the topics introduced in this tutorial in more detail. In this tutorial you are encouraged to type in and run the code, modifying it as required for your setup.
This tutorial assumes you have MySQL and Connector/NET already installed. It also assumes that you have installed the World example database, which can be downloaded from the MySQL Documentation page. You can also find details on how to install the database on the same page.
Before compiling the example code make sure that you have added
References to your project as required. The References required
are System
, System.Data
and
MySql.Data
.
For your Connector/NET application to connect to a MySQL database
it needs to establish a connection. This is achieved through the
use of a MySqlConnection
object.
The MySqlConnection constructor takes a connection string as one of its parameters. The connection string provides necessary information to make the connection to the MySQL database. The connection string is discussed more fully in Section 21.2.5.1, “Connecting to MySQL Using Connector/NET”. A reference containing a list of supported connection string options can also be found in Section 21.2.6, “Connector/NET Connection String Options Reference”.
The following code shows how to create a connection object.
using System; using System.Data; using MySql.Data; using MySql.Data.MySqlClient; public class Tutorial1 { public static void Main() { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); // Perform databse operations } catch (Exception ex) { Console.WriteLine(ex.ToString()); } conn.Close(); Console.WriteLine("Done."); } }
When the MySqlConnection
constructor is invoked
it returns a connection object, which is used for subsequent
database operations. The first operation in this example is to
open the connection. This needs to be done before further
operations take place. Before the application exits the connection
to the database needs to be closed by calling
Close
on the connection object.
Sometimes an attempt to perform an Open
on a
connection object can fail, this will generate an exception that
can be handled using standard exception handling code.
In this section you have learned how to create a connection to a MySQL database, and open and close the corresponding connection object.
Once a connection has been established with the MySQL database,
the next step is do carry out the desired database operations.
This can be achieved through the use of the
MySqlCommand
object.
You will see how to create a MySqlCommand
object. Once it has been created there are three main methods of
interest that you can call:
ExecuteReader - used to query
the database. Results are usually returned in a
MySqlDataReader
object, created by
ExecuteReader
.
ExecuteNonQuery - used to insert and delete data.
ExecuteScalar - used to return a single value.
Once a MySqlCommand
object has been created,
you will call one of the above methods on it to carry out a
database operation, such as perform a query. The results are
usually returned into a MySqlDataReader
object,
and then processed, for example the results might be displayed.
The following code demonstrates how this could be done.
using System; using System.Data; using MySql.Data; using MySql.Data.MySqlClient; public class Tutorial2 { public static void Main() { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); string sql = "SELECT Name, HeadOfState FROM Country WHERE Continent='Oceania'"; MySqlCommand cmd = new MySqlCommand(sql, conn); MySqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { Console.WriteLine(rdr[0]+" -- "+rdr[1]); } rdr.Close(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } conn.Close(); Console.WriteLine("Done."); } }
When a connection has been created and opened, the code then
creates a MySqlCommand
object. Note that the
SQL query to be executed is passed to the
MySqlCommand
constructor. The
ExecuteReader
method is then used to generate a
MySqlReader
object. The
MySqlReader
object contains the results
generated by the SQL executed on the command object. Once the
results have been obtained in a MySqlReader
object, the results can be processed. In this case the information
is simply printed out as part of a while
loop.
Finally, the MySqlReader
object is displosed of
by running its Close
method on it.
In the next example you will see how to use the
ExecuteNonQuery
method.
The procedure for performing an ExecuteNonQuery
method call is simpler, as there is no need to create an object to
store results. This is because ExecuteNonQuery
is only used for inserting, updating and deleting data. The
following example illustrates a simple update to the Country
table:
using System; using System.Data; using MySql.Data; using MySql.Data.MySqlClient; public class Tutorial3 { public static void Main() { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); string sql = "INSERT INTO Country (Name, HeadOfState, Continent) VALUES ('Disneyland','Mickey Mouse', 'North America')"; MySqlCommand cmd = new MySqlCommand(sql, conn); cmd.ExecuteNonQuery(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } conn.Close(); Console.WriteLine("Done."); } }
The query is constructed, the command object created and the
ExecuteNonQuery
method called on the command
object. You can access your MySQL database with the MySQL Client
program and verify that the update was carried out correctly.
Finally, you will see how the ExecuteScalar
method can be used to return a single value. Again, this is
straightforward, as a MySqlDataReader
object is
not required to store results, a simple variable will do. The
following code illustrates how to use
ExecuteScalar
:
using System; using System.Data; using MySql.Data; using MySql.Data.MySqlClient; public class Tutorial4 { public static void Main() { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); string sql = "SELECT COUNT(*) FROM Country"; MySqlCommand cmd = new MySqlCommand(sql, conn); object result = cmd.ExecuteScalar(); if (result != null) { int r = Convert.ToInt32(result); Console.WriteLine("Number of countries in the World database is: " + r); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); } conn.Close(); Console.WriteLine("Done."); } }
This example uses a simple query to count the rows in the Country
table. The result is obtained by calling
ExecuteScaler
on the command object.
Previously, when using MySqlDataReader, the connection to the database was continually maintained, unless explicitly closed. It is also possible to work in a manner where a connection is only established when needed. For example, in this mode, a connection could be established to read a chunk of data, the data could then be modified by the application as required. A connection could then be reestablished only if and when the application needs to write data back to the database. This decouples the working data set from the database.
This decouple mode of working with data is supported by Connector/NET. There are several parts involved in allowing this method to work:
Data Set - The Data Set is
the area in which data is loaded to read or modify it. A
DataSet
object is instantiated, which can
store multiple tables of data.
Data Adapter - The Data
Adapter is the interface between the Data Set and the database
itself. The Data Adapter is responsible for efficiently
managing connections to the database, opening and closing them
as required. The Data Adapter is created by instantiating an
object of the MySqlDataAdapter
class. The
MySqlDataAdapter
object has two main
methods: Fill
which reads data into the
Data Set, and Update
, which writes data
from the Data Set to the database.
Command Builder - The Command
Builder is a support object. The Command Builder works in
conjunction with the Data Adapter. When a
MySqlDataAdapter
object is created it is
typically given an initial SELECT statement. From this SELECT
statement the Command Builder can work out the corresponding
INSERT, UPDATE and DELETE statements that would be required
should the database need to be updated. To create the Command
Builder an object of the class
MySqlCommandBuilder
is created.
Each of these classes will now be discussed in more detail.
Instantiating a DataSet object
A DataSet
object can be created simply, as
shown in the following example code snippet:
DataSet dsCountry; ... dsCountry = new DataSet();
Although this creates the DataSet
object it has
not yet filled it with data. For that a Data Adapter is required.
Instantiating a MySqlDataAdapter object
The MySqlDataAdapter
can be created as
illustrated by the following example:
MySqlDataAdapter daCountry; ... string sql = "SELECT Code, Name, HeadOfState FROM Country WHERE Continent='North America'"; daCountry = new MySqlDataAdapter (sql, conn);
Note, the MySqlDataAdapter
is given the SQL
specifying the data you wish to work with.
Instantiating a MySqlCommandBuilder object
Once the MySqlDataAdapter
has been created, it
is necessary to generate the additional statements required for
inserting, updating and deleting data. There are several ways to
do this, but in this tutorial you will see how this can most
easily be done with MySqlCommandBuilder
. The
following code snippet ilustrates how this is done:
MySqlCommandBuilder cb = new MySqlCommandBuilder(daCountry);
Note that the MySqlDataAdapter
object is passed
as a parameter to the command builder.
Filling the Data Set
To do anything useful with the data from your datbase, you need to
load it into a Data Set. This is one of the jobs of the
MySqlDataAdapter
object, and is carried out
with its Fill
method. The following example
code illustrates this:
DataSet dsCountry; ... dsCountry = new DataSet(); ... daCountry.Fill(dsCountry, "Country");
Note the Fill
method is a
MySqlDataAdapter
method, the Data Adapter knows
how to establish a connec tion with the database and retrieve the
required data, and then populates the Data Set when the
Fill
method is called. The second parameter
“Country” is the table in the Data Set to update.
Updating the Data Set
The data in the Data Set can now be manipulated by the application
as required. At some point, changes to data will need to be
written back to the database. This is achieved through a
MySqlDataAdapter
method, the
Update
method.
daCountry.Update(dsCountry, "Country");
Again, the Data Set and the table within the Data Set to update are specified.
Working Example
The interactions between the DataSet
,
MySqlDataAdapter
and
MySqlCommandBuilder
classes can be a little
confusing, so their operation can perhaps be best illustrated by
working code.
In this example, data from the World database is read into a Data Grid View control. Here, the data can be viewed and changed before clicking an update button. The update button then activates code to write changes back to the database. The code uses the principles explained above. The application was built using the Microsoft Visual Studio to place and create the user interface controls, but the main code that uses the key classes descibed above is shown below, and is portable.
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using MySql.Data; using MySql.Data.MySqlClient; namespace WindowsFormsApplication5 { public partial class Form1 : Form { MySqlDataAdapter daCountry; DataSet dsCountry; public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { label2.Text = "Connecting to MySQL..."; string sql = "SELECT Code, Name, HeadOfState FROM Country WHERE Continent='North America'"; daCountry = new MySqlDataAdapter (sql, conn); MySqlCommandBuilder cb = new MySqlCommandBuilder(daCountry); dsCountry = new DataSet(); daCountry.Fill(dsCountry, "Country"); dataGridView1.DataSource = dsCountry; dataGridView1.DataMember = "Country"; } catch (Exception ex) { label2.Text = ex.ToString(); } } private void button1_Click(object sender, EventArgs e) { daCountry.Update(dsCountry, "Country"); label2.Text = "MySQL Database Updated!"; } } }
The application running is shown below:
This part of the tutorial shows you how to use parameters in your Connector/NET application.
Although it is possible to build SQL query strings directly from user input, this is not advisable as it does not prevent erroneous or malicious information being entered. It is safer to use parameters as they will be processed as field data only. For example, imagine the following query was contructed from user input:
string sql = "SELECT Name, HeadOfState FROM Country WHERE Continent = "+user_continent;
If the string user_continent
came from a Text
Box control, there would potentially be no control over the string
entered by the user. The user could enter a string that generates
a run time error, or in the worst case actually harms the system.
When using parameters it is not possible to do this because a
parameter is only ever treated as a field parameter, rather than
an arbitrary piece of SQL code.
The same query written user a parameter for user input would be:
string sql = "SELECT Name, HeadOfState FROM Country WHERE Continent = @Continent";
Note that the parameter is preceded by an '@' symbol to indicate it is to be treated as a parameter.
As well as marking the position of the parameter in the query string, it is necessary to add a parameter to the Command object. This is illustrated by the following code snippet:
cmd.Parameters.AddWithValue("@Continent", "North America");
In this example the string "North America" is supplied as the parameter value statically, but in a more practical example it would come from a user input control.
A further example illustrates the complete process:
using System; using System.Data; using MySql.Data; using MySql.Data.MySqlClient; public class Tutorial5 { public static void Main() { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); string sql = "SELECT Name, HeadOfState FROM Country WHERE Continent=@Continent"; MySqlCommand cmd = new MySqlCommand(sql, conn); Console.WriteLine("Enter a continent e.g. 'North America', 'Europe': "); string user_input = Console.ReadLine(); cmd.Parameters.AddWithValue("@Continent", user_input); MySqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { Console.WriteLine(rdr["Name"]+" --- "+rdr["HeadOfState"]); } rdr.Close(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } conn.Close(); Console.WriteLine("Done."); } }
In this part of the tutorial you have see how to use parameters to make your code more secure.
In this section you will see how to work with Stored Procedures. This section assumes you have a basic understanding of what a Stored Procedure is, and how to create one.
For the purposes of this tutorial, you will create a simple Stored Procedure to see how it can be called from Connector/NET. In the MySQL Client program, connect to the World database and enter the following Stored Procedure:
DELIMITER // CREATE PROCEDURE country_hos (IN con CHAR(20)) BEGIN SELECT Name, HeadOfState FROM Country WHERE Continent = con; END // DELIMITER ;
Test the Stored Procedure works as expected by typing the following into the MySQL Client program:
CALL country_hos('Europe');
Note that The Stored Routine takes a single parameter, which is the continent you wish to restrict your search to.
Having confirmed that the Stored Procedure is present and correct you can now move on to seeing how it can be accessed from Connector/NET.
Calling a Stored Procedure from your Connector/NET application is
similar to techniques you have seen earlier in this tutorial. A
MySqlCommand
object is created, but rather than
taking a SQL query as a parameter it takes the name of the Stored
Procedure to call. The MySqlCommand
object also
needs to be set to the type of Stored Procedure. This is
illustrated by the following code snippet:
string rtn = "country_hos"; MySqlCommand cmd = new MySqlCommand(rtn, conn); cmd.CommandType = CommandType.StoredProcedure;
In this case you also need to pass a parameter to the Stored Procedure. This can be achieved using the techniques seen in the previous section on parameters, Section 21.2.4.1.4, “Working with Parameters”. This is shown in the following code snippet:
cmd.Parameters.AddWithValue("@con", "Europe");
The value of the parameter @con
could more
realistically have come from a user input control, but for
simplicity it is set as a static string in this example.
At this point everything is set up and all that now needs to be
done is to call the routine. This can be achieved using techniques
also learned in earlier sections, but in this case the
ExecuteReader
method of the
MySqlCommand
object is used.
Complete working code for the Stored Procedure example is shown below:
using System; using System.Data; using MySql.Data; using MySql.Data.MySqlClient; public class Tutorial6 { public static void Main() { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); string rtn = "country_hos"; MySqlCommand cmd = new MySqlCommand(rtn, conn); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@con", "Europe"); MySqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { Console.WriteLine(rdr[0] + " --- " + rdr[1]); } rdr.Close(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } conn.Close(); Console.WriteLine("Done."); } }
In this section you have seen how to call a Stored Procedure from Connector/NET. For the moment, this concludes our introductory tutorial on programming with Connector/NET.
Many web sites feature the facility for the user to create a user account. They can then log into the web site and enjoy a personalized experience. This requires that the developer creates database tables to store user information, along with code to gather and process this data. This represents a burden on the developer, and there is the possibility for security issues to creep into the developed code. However, ASP.NET 2.0 introduced the Membership system. This system is designed around the concept of Membership, Profile and Role Providers, which together provide all of the functionality to implement a user system, that previously would have to have been created by the developer from scratch.
Currently, MySQL Connector/NET provides Membership, Role, Profile and Session State Providers.
This tutorial shows you how to set up your ASP.NET web application to use the MySQL Connector/NET Membership and Role Providers. It assumes that you have MySQL Server installed, along with MySQL Connector/NET and Microsoft Visual Studio. This tutorial was tested with MySQL Connector/NET 6.0.4 and Microsoft Visual Studio 2008 Professional Edition. It is recommmended you use 6.0.4 or above for this tutorial.
Create a new database in the MySQL Server using the MySQL
Command Line Client program (mysql
), or
other suitable tool. It does not matter what name is used for
the database, but it should be noted down so that it can be
specified in the connection string constructed later in this
tutorial. This database will contain the tables, automatically
created for you later, used to store data about users and
roles.
Create a new ASP.NET Web Site in Visual Studio. If you are not sure how to do this, refer to the following tutorial: Section 21.2.4.6, “Tutorial: Databinding in ASP.NET using LINQ on Entities”, which demonstrates how to create a simple ASP.NET web site.
Add References to MySql.Data
and
MySql.Web
to the web site project.
Locate the machine.config
file on your
system, which is the configuration file for the .NET
Framework.
Search the machine.config
file to find
the membership provider
MySQLMembershipProvider
.
Add the attribute
autogenerateschema="true"
. The appropriate
section should now resemble the following (note: for the sake
of brevity some information has been excluded):
<membership> <providers> <add name="AspNetSqlMembershipProvider" type="System.Web.Security.SqlMembershipProvider" ... connectionStringName="LocalSqlServer" ... /> <add name="MySQLMembershipProvider" autogenerateschema="true" type="MySql.Web.Security.MySQLMembershipProvider, MySql.Web, Version=6.0.4.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" connectionStringName="LocalMySqlServer" ... /> </providers> </membership>
Note that the name for the connection string to be used to
connect to the server that contains the membership database is
LocalMySqlServer
.
The autogenerateschema="true"
attribute
will cause MySQL Connector/NET to silently create, or upgrade, the schema
on the database server, to contain the required tables for
storing membership information.
It is now necessary to create the connection string referenced
in the previous step. Load the web site's
web.config
file into Visual Studio.
Locate the section marked
<connectionStrings>
. Add the
following connection string information:
<connectionStrings> <remove name="LocalMySqlServer"/> <add name="LocalMySqlServer" connectionString="Datasource=localhost;Database=users;uid=root;pwd=password;" providerName="MySql.Data.MySqlClient"/> </connectionStrings>
The database specified is the one created in the first step. You could alternatively have used an existing database.
At this point build the solution to ensure no errors are present. This can be done by selecting F6.
, from the main menu, or pressingASP.NET supports the concept of locally and remotely authenticated users. With local authentication the user is validated using their Windows credentials when they attempt to access the web site. This can be useful in an Intranet environment. With remote authentication a user is prompted for their login details when accessing the web site, and these credentials are checked aganst the membership information stored in a database server such as MySQL Server. You will now see how to choose this form of authentication.
Start the ASP.NET Web Site Administration Tool. This can be done quickly by clicking the small hammer/Earth icon in the Solution Explorer. You can also launch this tool by selecting
, from the main menu.In the ASP.NET Web Site Administration Tool click the Security tab.
Now click the User Authentication Type link.
Select the From the internet radio button. The web site will now need to provide a form to allow the user to enter their login details. These will be checked against membership information stored in the MySQL database.
You now need to specify the Role and Membership Provider to be used. Click the Provider tab.
Click the Select a different provider for each feature (advanced) link.
Now select the MySQLMembershipProvider and the MySQLRoleProvider radio buttons.
In Visual Studio rebuild the solution by selecting
, from the main menu.Check that the necessary schema has been created. This can be achieved using the MySQL Command Line Client program.
Assuming all is present and correct you can now create users and roles for your web application. The easiest way to do this is with the ASP.NET Web Site Administration Tool. However, many web applications contain their own modules for creating roles and users. For simplicity the ASP.NET Web Site Administration Tool will be used in this tutorial.
In the ASP.NET Web Site Administration Tool, click the Security tab. Now that both the Membership and Role Provider are enabled you will see links for creating roles and users. Click the Create or Manage Roles link.
You can now enter the name of a new Role and click
to create the new Role. Create new Roles as required.Click the
button.Click the Create User link. You can now fill in information about the user to be created, and also allocate that user to one or more Roles.
Using the MySQL Command Line Client program you can check that your database has been correctly populated with the Membership and Role data.
In this tutorial you have seen how to set up the MySQL Connector/NET Membership and Role Providers for use in your ASP.NET web application.
MySQL Connector/NET from version 6.1 has included a MySQL Session State
Provider. This provider enables you to store session state in a
MySQL database. The following tutorial shows you how to prepare to
use the MySQL Session State Provider, and then store session data
into the MySQL database. This tutorial uses Microsoft Visual
Studio 2008 Professional Edition, MySQL Connector/NET 6.1.1 and MySQL Server
5.1. This tutorial also assumes you have created an empty
database, for example test
, where you will
store session data. You could do this using the MySQL Command Line
Client tool.
In Visual Studio create a new ASP.NET web site. If you are not sure how to do this refer to the tutorial Section 21.2.4.6, “Tutorial: Databinding in ASP.NET using LINQ on Entities” which demonstrates how to do this.
Launch the MySQL MySQL Website Configuration tool. Due to a bug in 6.1.1 this may not appear unless you are connected to a server in the Server Explorer. If you are unfamiliar with the MySQL Website Configuration tool it is suggested that you first work through the following tutorial Section 21.2.3.10, “MySQL Website Configuration Tool”.
Navigate through the wizard to the Session State page. Make sure the checkbox Use MySQL to manage my ASP.NET session data is seected.
On the same page configure the connection string to the database that will contain your session data. This database can be empty as MySQL Connector/NET will create the schema required to store session data.
Ensure that the checkbox Autogenerate Schema is selected so that MySQL Connector/NET will create the schema in your database to store the session data correctly.
Enter the name of your application.
Click web.config
file with information about
the connection string and default providers to be used. In
this case we have selected the MySQL Session State Provider.
At this point you are ready to use the MySQL database to store session data. To test that the set up has worked you can write a simple program that uses session variables.
Open Default.aspx.cs
. In the Page_Load
method add the following code:
Session["SessionVariable1"] = "Test string";
Build your solution.
Run the solution (without debugging). When the application runs, the provider will autogenerate tables required in the database you chose when setting up the application.
Check that the schema was in fact created. Using the MySQL
Command Line Client use the target database and then type
SHOW TABLES;
. You will see that MySQL Connector/NET has
created the required schema automatically, as we selected this
to happen in the MySQL Website Configuration tool.
Now view the contents of these tables by typing
SELECT * FROM my_aspnet_sessions;
in the
MySQL Command Line Client. This will display the session data
our application used. Note that this is stored in binary
format so some data may not display as expected.
At this point you have installed the Session State Provider and carried out a preliminary test of the installation. You will now work a bit more with the Session State Provider.
In this part of the tutorial you will set and retrieve a session variable. You can work with your existing project.
Select the Default.aspx
and switch to
Design View. Add a text box and three buttons. Change the text
property for the buttons to “Store Session
Variable”, “Clear Textbox”, and
“Show Session Variable”. These will be
Button1
, Button2
and
Button3
respectively. Build your solution
to ensure that no errors have been introduced.
Still in the Design View, double-click
Button1
. Now to the
Button1_Click
event handler add code some
the handler resembles the following:
protected void Button1_Click(object sender, EventArgs e) { Session["SessionString"] = TextBox1.Text; }
You have created a new Session variable accessed using the key
“SessionString”. This will be set to the text
that was entered into the text box when
Button1
is clicked.
In Design View double-click Button2
to add
its click event handler. This button needs to clear text from
the text box. The code to do this is as follows:
protected void Button2_Click(object sender, EventArgs e) { TextBox1.Text = ""; }
The code simply assigns an empty string to the
Text
property of the text box.
In the Design View double-click Button3
and
modify the click handler as follows:
protected void Button3_Click(object sender, EventArgs e) { TextBox1.Text = (String)Session["SessionString"]; }
This will retrieve the session string and display it in the text box.
Now modify the Page_Load
method as follows:
protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { TextBox1.Text = "Enter some text"; } }
This ensures that when the page loads the text box
Text
property is reset.
Ensure that the solution is saved and then rebuild the solution.
Run the solution without debugging.
The form will be displayed. Enter some text into the text box. Now click
. At this point you have stored the string in a session variable.Now click
to clear the text box.Now click
to retrieve and display the session variable.Refresh the page to destroy the form and display a new form.
Click
the text box will display the stored session variable, demonstrating that the refreshing the page does not destroy the session variable.This illustrates that the session state data is not destroyed when a page is reloaded.
This tutorial shows you how to use the MySQL Profile Provider to store user profile information in a MySQL database. The tutorial uses MySQL Connector/NET 6.1.1, MySQL Server 5.1 and Microsoft Visual Studio 2008 Professional Edition.
Many modern web sites allow the user to create a personal profile. This requires a significant amount of code, but ASP.NET reduces this considerable by including the functionality in its Profile classes. The Profile Provider provides an abstraction between these classes and a data source. The MySQL Profile Provider enables profile data to be stored in a MySQL database. This enables the profile properties to be written to a persistent store, and be retrieved when required. The Profile Provider also enables profile data to be managed effectively, for example it enables profiles that have not been accessed since a specific date to be deleted.
The following steps show you how you can select the MySQL Profile Provider.
Create a new ASP.NET web project.
Select the MySQL Website Configuration tool. Due to a bug in 6.1.1 you may have to first connect to a server in Server Explorer before the tool's icon will display in the toolbar of the Solution Explorer.
In the MySQL Website Configuration tool navigate through the tool to the Profiles page.
Select the Use MySQL to manage my profiles checkbox.
Select the Autogenerate Schema checkbox.
Click the
button and configure a connection string for the database that will be used to store user profile information.Navigate to the last page of the tool and click
to save your changes and exit the tool.At this point you are now ready to start using the MySQL Profile Provider. With the following steps you can carry out a preliminary test of your installation.
Open your web.config
file.
Add a simple profile such as the following:
<system.web> <anonymousIdentification enabled="true"/> <profile defaultProvider="MySQLProfileProvider"> ... <properties> <add name="Name" allowAnonymous="true"/> <add name="Age" allowAnonymous="true" type="System.UInt16"/> <group name="UI"> <add name="Color" allowAnonymous="true" defaultValue="Blue"/> <add name="Style" allowAnonymous="true" defaultValue="Plain"/> </group> </properties> </profile> ...
Note that anonymousIdentification
has been
set to true. This enables users who have not been
authenticated to use profiles. They are identified by a GUID
in a cookie rather than by user name.
Now that the simple profile has been defined in
web.config
, the next step is to write some
code to test the profile.
In Design View design a simple page with the following controls:
These will allow the user to enter some profile information. The user can also use the buttons to save their profile, clear the page, and restore their profile data.
In the Code View add code as follows:
... protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { TextBox1.Text = Profile.Name; TextBox2.Text = Profile.Age.ToString(); Label1.Text = Profile.UI.Color; } } // Store Profile protected void Button1_Click(object sender, EventArgs e) { Profile.Name = TextBox1.Text; Profile.Age = UInt16.Parse(TextBox2.Text); } // Clear Form protected void Button2_Click(object sender, EventArgs e) { TextBox1.Text = ""; TextBox2.Text = ""; Label1.Text = ""; } // Retrieve Profile protected void Button3_Click(object sender, EventArgs e) { TextBox1.Text = Profile.Name; TextBox2.Text = Profile.Age.ToString(); Label1.Text = Profile.UI.Color; } protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs e) { Profile.UI.Color = DropDownList1.SelectedValue; } ...
Save all files and build the solution to check that no errors have been introduced.
Run the application.
Enter your name, age and select a color from the listbox. Now
store this information in your profile by clicking
Blue
that was specified in
the web.config
file.
Click
to clear text from the textboxes and the label that displays your chosen color.Now click
to restore your profile data from the MySQL database.Now exit the browser to terminate the application.
Run the application again. Note that when the page loads your profile information is restored from the MySQL database.
In this tutorial you have seen how to using the MySQL Profile Provider with MySQL Connector/NET.
In this tutorial you will learn how to create a Windows Forms Data Source from an Entity in an Entity Data Model. This tutorial assumes that you have installed the World example database, which can be downloaded from the MySQL Documentation page. You can also find details on how to install the database on the same page. It will also be convenient for you to create a connection to the World database after it is installed. For instructions on how to do this see Section 21.2.3.1, “Making a connection”.
Creating a new Windows Forms application
The first step is to create a new Windows Forms application.
In Visual Studio, select
, , from the main menu.Choose the Windows Forms Application installed template. Click . The solution is created.
Adding an Entity Data Model
You will now add an Entity Data Model to your solution.
In the Solution Explorer, right-click your application and select Visual Studio installed templates select ADO.NET Entity Data Model. Click .
, . FromYou will now see the Entity Data Model Wizard. You will use the wizard to generate the Entity Data Model from the world example database. Select the icon Generate from database. Click .
You can now select the connection you made earlier to the World database. If you have not already done so, you can create the new connection at this time by clicking Section 21.2.3.1, “Making a connection”.
. For further instructions on creating a connection to a database seeMake a note of the entity connection settings to be used in App.Config, as these will be used later to write the necessary control code.
Click
.The Entity Data Model Wizard connects to the database. You are then presented with a tree structure of the database. From this you can select the object you would like to include in your model. If you had created Views and Stored Routines these will be displayed along with any tables. In this example you just need to select the tables. Click
to create the model and exit the wizard.Visual Studio will generate the model and then display it.
From the Visual Studio main menu select
, , to ensure that everything compiles correctly so far.Adding a new Data Source
You will now add a new Data Source to your project and see how it can be used to read and write to the database.
From the Visual Studio main menu select
, . You will be presented with the Data Source Configuration Wizard.Select the Object icon. Click .
You will now select the Object you wish to bind to. Expand the tree. In this tutorial you will select the city table. Once the city table has been selected click
.The wizard will confirm that the city object is to be added. Click
.The city object will be display in the Data Sources panel. If the Data Sources panel is not displayed, select
, from the Visual Studio main menu. The docked panel will then be displayed.Using the Data Source in a Windows Form
You will now learn how to use the Data Source in a Windows Form.
In the Data Sources panel select the Data Source you just
created and drag and drop it onto the Form Designer. By
default the Data Source object will be added as a Data Grid
View control. Note that the Data Grid View control is bound to
the cityBindingSource
and the Navigator
control is bound to cityBindingNavigator
.
Save and rebuild the solution before continuing.
Adding Code to Populate the Data Grid View
You are now ready to add code to ensure that the Data Grid View control will be populated with data from the City database table.
Double-click the form to access its code.
Add code to instatiate the Entity Data Model's EntityContainer object and retrieve data from the database to populate the control.
Save and rebuild the solution.
Run the solution. Ensure the grid is populated and you can navigate the database.
Adding Code to Save Changes to the Database
You will now add code to enable you to save changes to the database.
The Binding source component ensures that changes made in the Data Grid View control are also made to the Entity classes bound to it. However, that data needs to be saved back from the entities to the database itself. This can be achieved by the enabling of the Save button in the Navigator control, and the addition of some code.
In the Form Designer, click the Save icon in the Form toolbar and ensure that its Enabled property is set to True.
Double-click the Save icon in the Form toolbar to display its code.
You now need to add code to ensure that data is saved to the database when the save button is clicked in the application.
Once the code has been added, save the solution and rebuild it. Run the application and verify that changes made in the grid are saved.
In this tutorial you create an ASP.NET web page that binds LINQ queries to entities using the Entity Framework mapping.
If you have not already done so, you should install the World example database prior to attempting this tutorial. Instructions on where to obtain the database and instructions on how to install it where given in the tutorial Section 21.2.4.5, “Tutorial: Using an Entity Framework Entity as a Windows Forms Data Source”.
Creating an ASP.NET web site
In this part of the tutorial you will create an ASP.NET web site. The web site will use the World database. The main web page will feature a drop down list from which you can select a country, data about that country's cities will then be displayed in a grid view control.
From the Visual Studio main menu select
, , .From the Visual Studio installed templates select ASP.NET Web Site. Click . You will be presented with the Source view of your web page by default.
Click the Design view tab situated underneath the Source view panel.
In the Design view panel, enter some text to decorate the blank web page.
Click Toolbox. From the list of controls select DropDownList. Drag and drop the control to a location beneath the text on your web page.
From the DropDownList control's context menu, ensure that the Enable AutoPostBack check box is enabled. This will ensure the control's event handler is called when an item is selected. The user's choice will in turn be used to populate the GridView control.
From the Toolbox select the GridView control.
Drag and drop the Grid Vew control to a location just below the Drop Down List you already placed.
At this point it is recommended that you save your solution, and build the solution to ensure that there are no errors.
If you run the solution you will see that the text and drop down list are displayed, but the list is empty. Also, the grid view does not appear at all. Adding this functionality is described in the following sections.
At this stage you have a web site that will build, but further functionality is required. The next step will be to use the Entity Framework to create a mapping from the World database into entities that you can control programmatically.
Creating an ADO.NET Entity Data Model
In this stage of the tutorial you will add an ADO.NET Entity Data Model to your project, using the World database at the storage level. The procedure for doing this is described in the tutorial Section 21.2.4.5, “Tutorial: Using an Entity Framework Entity as a Windows Forms Data Source”, and so will not be repeated here.
Populating a Drop Data List Box with using the results of a entity LINQ query
In this part of the tutorial you will write code to populate the DropDownList control. When the web page loads the data to populate the list will be achieved by using the results of a LINQ query on the model created previously.
In the Design view panel, double-click any blank area. This
brings up the Page_Load
method.
Modify the relevant section of code according to the following listing:
... public partial class _Default : System.Web.UI.Page { worldModel.worldEntities we; protected void Page_Load(object sender, EventArgs e) { we = new worldModel.worldEntities(); if (!IsPostBack) { var countryQuery = from c in we.country orderby c.Name select new { c.Code, c.Name }; DropDownList1.DataValueField = "Code"; DropDownList1.DataTextField = "Name"; DropDownList1.DataSource = countryQuery; DataBind(); } } ...
Note that the list control only needs to be populated when the page first loads. The conditional code ensures that if the page is subsequently reloaded, the list control is not repopulated, which would cause the user selection to be lost.
Save the solution, build it and run it. You should see the list control has been populated. You can select an item, but as yet the grid view control does not apear.
At this point you have a working Drop Down List control, populated by a LINQ query on your entity data model.
Populating a Grid View control using an entity LINQ query
In the last part of this tutorial you will populate the Grid View Control using a LINQ query on your entity data model.
In the Design view, double-click the
DropDownList control. This causes its
SelectedIndexChanged
code to be
displayed. This method is called when a user selects an item
in the list control and thus fires an AutoPostBack event.
Modify the relevant section of code accordingly to the following listing:
... protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs e) { var cityQuery = from c in we.city where c.CountryCode == DropDownList1.SelectedValue orderby c.Name select new { c.Name, c.Population, c.CountryCode }; GridView1.DataSource = cityQuery; DataBind(); } ...
The grid view control is populated from the result of the LINQ query on the entity data model.
As a check compare your code to that shown in the following screenshot:
Save, build and run the solution. As you select a country you will see its cities are displayed in the grid view control.
In this tutorial you have seen how to create an ASP.NET web site, you have also seen how you can access a MySQL database using LINQ queries on an entity data model.
In this tutorial you will learn how you can use MySQL Connector/NET to connect to a MySQL server configured to use SSL. Support for SSL client certificates was added with MySQL Connector/NET 6.2.
MySQL Server uses the PEM format for certificates and private keys.
This tutorial will use the test certificates from the server test
suite by way of example. You can obtain the MySQL Server source code
from
MySQL
Downloads. The certificates can be found in the directory
./mysql-test/std_data
.
To carry out the steps in this tutorial you will also need to have Open SSL installed. This can be downloaded for Microsoft Windows at no charge from Shining Light Productions.
Further details on the connection string options used in this tutorial can be found at Section 21.2.6, “Connector/NET Connection String Options Reference”.
Configuring the MySQL Server to use SSL
In the MySQL Server configuration file, set the SSL parameters as follows:
ssl-ca=path/to/repo/mysql-test/std_data/cacert.pem ssl-cert=path/to/repo/mysql-test/std_data/server-cert.pem ssl-key=path/to/repo/mysql-test/std_data/server-key.pem
Adjust the directories according to the location in which you installed the MySQL source code.
In this step you create a test user and set the user to require SSL.
Using the MySQL Command Line Client, connect as root and create
the user sslclient
.
To set privileges and requirements, issue the following command:
GRANT ALL PRIVILEGES ON *.* TO sslclient@'%' REQUIRE SSL;
Creating a certificate file to use with the .NET client
The .NET client does not use the PEM file format, as .NET does
not support this format natively. You will be using test client
certificates from the same server repository, for the purposes
of this example. You will need to convert these to PFX format
first. This format is also known as PKCS#12. An article
describing this procedure can be found at the
Citrix
website. From the directory
,
issue the following command:
server-repository-root
/mysql-test/std_data
openssl pkcs12 -export -in client-cert.pem -inkey client-key.pem -certfile cacert.pem -out client.pfx
When asked for an export password, enter the password
“pass”. The file client.pfx
will be generated. This file is used in the remainder of the
tutorial.
Connecting to the server using a file-based certificate
You will use PFX file, client.pfx
you
created in the previous step to authenticate the client. The
following example demonstrates how to connect using the
SSL Mode
, CertificateFile
and CertificatePassword
connection string
options:
using (MySqlConnection connection = new MySqlConnection( "database=test;user=sslclient;" + "CertificateFile=H:\\bzr\\mysql-trunk\\mysqlest\\std_data\\client.pfx" + "CertificatePassword=pass;" + "SSL Mode=Required ")) { connection.Open(); }
The path to the certificate file will need to be changed to reflect your individual installation.
Connecting to the server using a store-based certificate
The first step is to import the PFX file,
client.pfx
, into the Personal Store.
Double-click the file in Windows explorer. This launches the
Certificate Import Wizard.
Follow the steps dictated by the wizard, and when prompted for the password for the PFX file, enter “pass”.
Click
to close the wizard and import the certificate into the personal store.Examine certificates in the Personal Store
Start the Microsoft Management Console by entering
mmc.exe
at a command prompt.
Select Certificates from the list of available snap-ins in the dialog.
, . Click . SelectClick My user account radio button. This is used for personal certificates.
button in the dialog, and select theClick the
button.Click
to close the Add/Remove Snap-in dialog.You will now have Certificates – Current User displayed in the left panel of the Microsoft Management Console. Expand the Certificates - Current User tree item and select Personal, Certificates. The right-hand panel will display a certificate issued to MySQL. This is the certificate that was previously imported. Double-click the certificate to display its details.
After you have imported the certificate to the Personal Store, you can use a more succint connection string to connect to the database, as illustrated by the following code:
using (MySqlConnection connection = new MySqlConnection( "database=test;user=sslclient;" + "Certificate Store Location=CurrentUser;" + "SSL Mode=Required")) { connection.Open(); }
Certificate Thumbprint Parameter
If you have a large number of certificates in your store, and many
have the same Issuer, this can be a source of confusion and result
in the wrong certificate being used. To alleviate this situation,
there is an optional Certificate Thumbprint parameter that can
additionally be specified as part of the connection string. As
mentioned before, you can double-click a certificate in the
Microsoft Management Console to display the certificate's details.
When the Certificate dialog is displayed click the
Details tab and scroll down to see the
thumbprint. The thumbprint will typically be a number such as
47 94 36 00 9a 40 f3 01 7a 14 5c f8 47 9e 76 94 d7 aa de
f0
. This thumbprint can be used in the connection string,
as the following code illustrates:
using (MySqlConnection connection = new MySqlConnection( "database=test;user=sslclient;" + "Certificate Store Location=CurrentUser;" + "Certificate Thumbprint=479436009a40f3017a145cf8479e7694d7aadef0;"+ "SSL Mode=Required")) { connection.Open(); }
Spaces in the thumbprint parameter are optional and the value is case-insensitive.
In this tutorial you will learn how to use the
MySqlScript
class. This class enables you to
execute a series of statements. Depending on the circumstances, this
can be more convenient than using the
MySqlCommand
approach.
Further details of the MySqlScript
class can
be found in the reference documentation supplied with MySQL Connector/NET.
If you wish to run the example programs in this tutorial, you will need to set up a simple test database and table. This can be achived using the MySQL Command Line Client or MySql Workbench. Commands for the MySQL Command Line Client are given here:
CREATE DATABASE TestDB;
USE TestDB;
CREATE TABLE TestTable (id INT NOT NULL PRIMARY KEY
AUTO_INCREMENT, name VARCHAR(100));
The main method of the MySqlScript
class is
the Execute
method. This method causes the
script (sequence of statements) assigned to the
Query property of the MySqlScript object to be
executed. Note the Query property can be set
through the MySqlScript
constructor or using
the Query property.
Execute
returns the number of statements
executed.
The MySqlScript
object will execute the
specified script on the connection set using the
Connection property. Again, this property can
be set directly or through the MySqlScript
constructor. The following code snipets illustrate this:
string sql = "SELECT * FROM TestTable"; ... MySqlScript script = new MySqlScript(conn, sql); ... MySqlScript script = new MySqlScript(); script.Query = sql; script.Connection = conn; ... script.Execute();
The MySqlScript class has several events associated with it. There are:
Error - generated in an error occurs.
ScriptCompleted - generated when the script successfully completes execution.
StatementExecuted - generated after each statement is executed.
It is possible to assign event handlers to each of these events. These user-provided routies will be called back should the connected event occur. The following code shows how the event handlers are set up.
script.Error += new MySqlScriptErrorEventHandler(script_Error); script.ScriptCompleted += new EventHandler(script_ScriptCompleted); script.StatementExecuted += new MySqlStatementExecutedEventHandler(script_StatementExecuted);
In VisualStudio you can use tab completion to fill out stub routines for you, to save typing. To do this start by typing, for example, “script.Error +=”. Then press TAB, and then press TAB again. The assignment will be completed, and a stub event handler created. A complete working example is shown below:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data; using MySql.Data; using MySql.Data.MySqlClient; namespace MySqlScriptTest { class Program { static void Main(string[] args) { string connStr = "server=localhost;user=root;database=TestDB;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); string sql = "INSERT INTO TestTable(name) VALUES ('Superman');" + "INSERT INTO TestTable(name) VALUES ('Batman');" + "INSERT INTO TestTable(name) VALUES ('Wolverine');" + "INSERT INTO TestTable(name) VALUES ('Storm');"; MySqlScript script = new MySqlScript(conn, sql); script.Error += new MySqlScriptErrorEventHandler(script_Error); script.ScriptCompleted += new EventHandler(script_ScriptCompleted); script.StatementExecuted += new MySqlStatementExecutedEventHandler(script_StatementExecuted); int count = script.Execute(); Console.WriteLine("Executed " + count + " statement(s)."); Console.WriteLine("Delimiter: " + script.Delimiter); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } conn.Close(); Console.WriteLine("Done."); } static void script_StatementExecuted(object sender, MySqlScriptEventArgs args) { Console.WriteLine("script_StatementExecuted"); } static void script_ScriptCompleted(object sender, EventArgs e) { /// EventArgs e will be EventArgs.Empty for this method Console.WriteLine("script_ScriptCompleted!"); } static void script_Error(Object sender, MySqlScriptErrorEventArgs args) { Console.WriteLine("script_Error: " + args.Exception.ToString()); } } }
Note that in the script_ScriptCompleted
event handler, the EventArgs
parameter
e
will be EventArgs.Empty
. In
the case of the ScriptCompleted
event there is no
additional data to be obtained, which is why the event object is
EventArgs.Empty
.
Depending on the nature of the script, you made need control of the delimiter used to separate the statements that will make up a script. The most common example of this is where you have a multi-statement stored routine as part of your script. In this case if the default delimiter of “;” is used you will get an error when you attempt to execute the script. For example, consider the following stored routine:
CREATE PROCEDURE test_routine() BEGIN SELECT name FROM TestTable ORDER BY name; SELECT COUNT(name) FROM TestTable; END
This routine actually needs to be executed on the MySQL Server as
a single statement. However, with the default delimiter of
“;”, the MySqlScript
class
would interpret the above as two statements, the first being:
CREATE PROCEDURE test_routine() BEGIN SELECT name FROM TestTable ORDER BY name;
Executing this as a statement would generate an error. To solve
this problem MySqlScript
supports the
ability to set a different delimiter. This is achieved through the
Delimiter property. For example, you could
set the delimiter to “??”, in which case the above
stored routine would no longer generate an error when executed.
Multiple statements can be delimited in the script, so for
example, you could have a three statement script such as:
string sql = "DROP PROCEDURE IF EXISTS test_routine??" + "CREATE PROCEDURE test_routine() " + "BEGIN " + "SELECT name FROM TestTable ORDER BY name;" + "SELECT COUNT(name) FROM TestTable;" + "END??" + "CALL test_routine()";
You can change the delimiter back at any point by setting the Delimiter property. The following code shows a complete working example:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using MySql.Data; using MySql.Data.MySqlClient; namespace ConsoleApplication8 { class Program { static void Main(string[] args) { string connStr = "server=localhost;user=root;database=TestDB;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); string sql = "DROP PROCEDURE IF EXISTS test_routine??" + "CREATE PROCEDURE test_routine() " + "BEGIN " + "SELECT name FROM TestTable ORDER BY name;" + "SELECT COUNT(name) FROM TestTable;" + "END??" + "CALL test_routine()"; MySqlScript script = new MySqlScript(conn); script.Query = sql; script.Delimiter = "??"; int count = script.Execute(); Console.WriteLine("Executed " + count + " statement(s)"); script.Delimiter = ";"; Console.WriteLine("Delimiter: " + script.Delimiter); Console.WriteLine("Query: " + script.Query); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } conn.Close(); Console.WriteLine("Done."); } } }
In this tutorial you will learn how to create MySQL DDL from an Entity Framework model. You will need to use Visual Studio 2010 and MySQL Connector/NET 6.3 to carry out this tutorial.
Create a new console application in Visual Studio 2010.
Using the Solution Explorer add a reference
to MySql.Data.Entity
.
From the Solution Explorer select , . In the Add New Item dialog select Online Templates. Select ADO.NET Entity Data Model and click . The Entity Data Model dialog will be displayed.
In the Entity Data Model dialog select Empty Model. Click . A blank model will be created.
Create a simple model. A single Entity will do for the purposes of this tutorial.
In the Properties panel select from the drop-down listbox.
In the Properties panel, locate the DDL Generation Template in the category Database Script Generation.
For the DDL Generation property select from the drop-down listbox.
Save the solution.
Right-click an empty space in the model design area. The context-sensitive menu will be displayed.
From the context-sensitive menu select Generate Database Wizard dialog will be displayed.
. TheIn the Generate Database Wizard dialog select an existing connection, or create a new connection to a server. Select an appropriate radio button to show or hide sensitive data. For the purposes of this tutorial you can select Yes (although you may not want to do this for commercial applications).
Click
. MySQL compatible DDL code will be generated. Click to exit the wizard.You have seen how to create MySQL DDL code from an Entity Framework model.
Connector/NET comprises several classes that are used to connect to the database, execute queries and statements, and manage query results.
The following are the major classes of Connector/NET:
MySqlCommand
: Represents an SQL statement to
execute against a MySQL database.
MySqlCommandBuilder
: Automatically generates
single-table commands used to reconcile changes made to a
DataSet with the associated MySQL database.
MySqlConnection
: Represents an open
connection to a MySQL Server database.
MySqlDataAdapter
: Represents a set of data
commands and a database connection that are used to fill a data
set and update a MySQL database.
MySqlDataReader
: Provides a means of reading
a forward-only stream of rows from a MySQL database.
MySqlException
: The exception that is thrown
when MySQL returns an error.
MySqlHelper
: Helper class that makes it
easier to work with the provider.
MySqlTransaction
: Represents an SQL
transaction to be made in a MySQL database.
In the following sections you will learn about some common use cases for Connector/NET, including BLOB handling, date handling, and using Connector/NET with common tools such as Crystal Reports.
Introduction
All interaction between a .NET application and the MySQL server is
routed through a MySqlConnection
object. Before
your application can interact with the server, a
MySqlConnection
object must be instanced,
configured, and opened.
Even when using the MySqlHelper
class, a
MySqlConnection
object is created by the helper
class.
In this section, we will describe how to connect to MySQL using
the MySqlConnection
object.
The MySqlConnection
object is configured using
a connection string. A connection string contains sever key/value
pairs, separated by semicolons. Each key/value pair is joined with
an equal sign.
The following is a sample connection string:
Server=127.0.0.1;Uid=root;Pwd=12345;Database=test;
In this example, the MySqlConnection
object is
configured to connect to a MySQL server at
127.0.0.1
, with a user name of
root
and a password of
12345
. The default database for all statements
will be the test
database.
The following options are available:
Using the '@' symbol for parameters is now the preferred approach although the old pattern of using '?' is still supported.
Please be aware however 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, which can be found
here:
Section 21.2.5.2, “Creating a Connection String”.
The Old Syntax
connection string option has
now been deprecated.
Once you have created a connection string it can be used to open a connection to the MySQL server.
The following code is used to create a
MySqlConnection
object, assign the connection
string, and open the connection.
Visual Basic Example
Dim conn As New MySql.Data.MySqlClient.MySqlConnection Dim myConnectionString as String myConnectionString = "server=127.0.0.1;" _ & "uid=root;" _ & "pwd=12345;" _ & "database=test;" Try conn.ConnectionString = myConnectionString conn.Open() Catch ex As MySql.Data.MySqlClient.MySqlException MessageBox.Show(ex.Message) End Try
C# Example
MySql.Data.MySqlClient.MySqlConnection conn; string myConnectionString; myConnectionString = "server=127.0.0.1;uid=root;" + "pwd=12345;database=test;"; try { conn = new MySql.Data.MySqlClient.MySqlConnection(); conn.ConnectionString = myConnectionString; conn.Open(); } catch (MySql.Data.MySqlClient.MySqlException ex) { MessageBox.Show(ex.Message); }
You can also pass the connection string to the constructor of
the MySqlConnection
class:
Visual Basic Example
Dim myConnectionString as String myConnectionString = "server=127.0.0.1;" _ & "uid=root;" _ & "pwd=12345;" _ & "database=test;" Try Dim conn As New MySql.Data.MySqlClient.MySqlConnection(myConnectionString) conn.Open() Catch ex As MySql.Data.MySqlClient.MySqlException MessageBox.Show(ex.Message) End Try
C# Example
MySql.Data.MySqlClient.MySqlConnection conn; string myConnectionString; myConnectionString = "server=127.0.0.1;uid=root;" + "pwd=12345;database=test;"; try { conn = new MySql.Data.MySqlClient.MySqlConnection(myConnectionString); conn.Open(); } catch (MySql.Data.MySqlClient.MySqlException ex) { MessageBox.Show(ex.Message); }
Once the connection is open it can be used by the other Connector/NET classes to communicate with the MySQL server.
Because connecting to an external server is unpredictable, it is
important to add error handling to your .NET application. When
there is an error connecting, the
MySqlConnection
class will return a
MySqlException
object. This object has two
properties that are of interest when handling errors:
Message
: A message that describes the
current exception.
Number
: The MySQL error number.
When handling errors, you can your application's response based on the error number. The two most common error numbers when connecting are as follows:
0
: Cannot connect to server.
1045
: Invalid user name and/or password.
The following code shows how to adapt the application's response based on the actual error:
Visual Basic Example
Dim myConnectionString as String myConnectionString = "server=127.0.0.1;" _ & "uid=root;" _ & "pwd=12345;" _ & "database=test;" Try Dim conn As New MySql.Data.MySqlClient.MySqlConnection(myConnectionString) conn.Open() Catch ex As MySql.Data.MySqlClient.MySqlException Select Case ex.Number Case 0 MessageBox.Show("Cannot connect to server. Contact administrator") Case 1045 MessageBox.Show("Invalid username/password, please try again") End Select End Try
C# Example
MySql.Data.MySqlClient.MySqlConnection conn; string myConnectionString; myConnectionString = "server=127.0.0.1;uid=root;" + "pwd=12345;database=test;"; try { conn = new MySql.Data.MySqlClient.MySqlConnection(myConnectionString); conn.Open(); } catch (MySql.Data.MySqlClient.MySqlException ex) { switch (ex.Number) { case 0: MessageBox.Show("Cannot connect to server. Contact administrator"); case 1045: MessageBox.Show("Invalid username/password, please try again"); } }
Note that if you are using multilanguage databases you must
specify the character set in the connection string. If you do
not specify the character set, the connection defaults to the
latin1
charset. You can specify the
character set as part of the connection string, for example:
MySqlConnection myConnection = new MySqlConnection("server=127.0.0.1;uid=root;" + "pwd=12345;database=test;Charset=latin1;");
The GetSchema()
method of the connection
object can be used to retrieve schema information about the
database currently connected to. The schema information is
returned in the form of a DataTable
. The
schema information is organised into a number of collections.
Different forms of the GetSchema()
method can
be used depending on the information required. There are three
forms of the GetSchema()
method:
GetSchema()
- This call will return a
list of available collections.
GetSchema(String)
- This call returns
information about the collection named in the string
parameter. If the string “MetaDataCollections”
is used then a list of all available collections is
returned. This is the same as calling
GetSchema()
without any parameters.
GetSchema(String, String[])
- In this
call the first string parameter represents the collection
name, and the second parameter represents a string array of
restriction values. Restriction values limit the amount of
data that will be returned. Restriction values are explained
in more detail in the
Microsoft
.NET documentation.
The collections can be broadly grouped into two types: collections that are common to all data providers, and collections specific to a particular provider.
Common
The following collections are common to all data providers:
MetaDataCollections
DataSourceInformation
DataTypes
Restrictions
ReservedWords
Provider-specific
The following are the collections currently provided by MySQL Connector/NET, in addition to the common collections above:
Databases
Tables
Columns
Users
Foreign Keys
IndexColumns
Indexes
Foreign Key Columns
UDF
Views
ViewColumns
Procedure Parameters
Procedures
Triggers
Example Code
A list of available collections can be obtained using the following code:
using System; using System.Data; using System.Text; using MySql.Data; using MySql.Data.MySqlClient; namespace ConsoleApplication2 { class Program { private static void DisplayData(System.Data.DataTable table) { foreach (System.Data.DataRow row in table.Rows) { foreach (System.Data.DataColumn col in table.Columns) { Console.WriteLine("{0} = {1}", col.ColumnName, row[col]); } Console.WriteLine("============================"); } } static void Main(string[] args) { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); DataTable table = conn.GetSchema("MetaDataCollections"); //DataTable table = conn.GetSchema("UDF"); DisplayData(table); conn.Close(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } Console.WriteLine("Done."); } } }
Further information on the GetSchema()
method and schema collections can be found in the
Microsoft
.NET documentation.
A MySqlCommand has the CommandText
and
CommandType
properties associated with it. The
CommandText
will be handled differently
depending on the setting of CommandType
.
CommandType
can be one of:
Text - A SQL text command (default)
StoredProcedure - The name of a Stored Procedure
TableDirect - The name of a table (new in Connector/NET 6.2)
The default CommandType
,
Text
, is used for executing queries and other
SQL commands. Some example of this can be found in the following
section Section 21.2.4.1.2, “The MySqlCommand Object”.
If CommandType
is set to
StoredProcedure
, CommandText
should be set to the name of the Stored Procedure to access.
If CommandType
is set to
TableDirect
, all rows and columns of the named
table will be returned when you call one of the Execute methods.
In effect, this command performs a SELECT *
on
the table specified. The CommandText
property
is set to the name of the table you wish to query. This is
illustrated by the following code snippet:
... MySqlCommand cmd = new MySqlCommand(); cmd.CommandText = "mytable"; cmd.Connection = someConnection; cmd.CommandType = CommandType.TableDirect; SqlDataReader reader = cmd.ExecuteReader(); while (reader.Read()) { Console.WriteLn(reader[0], reader[1]...); } ...
Examples of using the CommandType of StoredProcedure can be found in the section Section 21.2.5.6, “Accessing Stored Procedures with Connector/NET”.
Commands can have a timeout associated with them. This is useful
as you may not want a situation were a command takes up an
excessive amount of time. A timeout can be set using the
CommandTimeout
property. The following code
snippet sets a timeout of one minute:
MySqlCommand cmd = new MySqlCommand(); cmd.CommandTimeout = 60;
The default value is 30 secs. A value of 0 indicates an indefinite
wait and should be avoided. Note the default command timeout can
be changed using the connection string option Default
Command Timeout
.
Prior to MySQL Connector/NET 6.2,
MySqlCommand.CommandTimeout
included user
processing time, that is processing time not related to direct use
of the connector. Timeout was implemented through a .NET Timer,
that triggered after CommandTimeout
seconds.
This timer consumed a thread.
MySQL Connector/NET 6.2 introduced timeouts that are aligned with how Microsoft
handles SqlCommand.CommandTimeout
. This
property is the cumulative timeout for all network reads and
writes during command execution or processing of the results. A
timeout can still occur in the MySqlReader.Read
method after the first row is returned, and does not include user
processing time, only IO operations. The 6.2 implementation uses
the underlying stream timeout facility, so is more efficient in
that it does not require the additional timer thread as was the
case with the previous implementation.
Further details on this can be found in the relevant Microsoft documentation.
The Connector/NET supports connection pooling. This is enabled by default, but can be turned off using connection string options. See Section 21.2.5.2, “Creating a Connection String” for further information.
Connection pooling works by keeping the native connection to the
server live when the client disposes of a
MySqlConnection
. Subsequently, if a new
MySqlConnection
object is opened, it will be
created from the connection pool, rather than creating a new
native connection. This improves performance.
To work as designed, it is best to let the connection pooling
system manage all connections. You should not create a globally
accessible instance of MySqlConnection
and then
manually open and close it. This interferes with the way the
pooling works and can lead to unpredictable results or even
exceptions.
One approach that simplifies things is to avoid manually creating
a MySqlConnection
object. Instead use the
overloaded methods that take a connection string as an argument.
Using this approach, Connector/NET will automatically create,
open, close and destroy connections, using the connection pooling
system for best performance.
Typed Datasets and the MembershipProvider
and
RoleProvider
classes use this approach. Most
classes that have methods that take a
MySqlConnection
as an argument, also have
methods that take a connection string as an argument. This
includes MySqlDataAdapter
.
Instead of manually creating MySqlCommand
objects, you can use the static methods of the
MySqlHelper
class. These take a connection
string as an argument, and they fully support connection pooling.
Starting with MySQL Connector/NET 6.2, there is a background job that runs every three minutes and removes connections from pool that have been idle (unused) for more than three minutes. The pool cleanup frees resources on both client and server side. This is because on the client side every connection uses a socket, and on the server side every connection uses a socket and a thread.
Prior to this change, connections were never removed from the
pool, and the pool always contained the peak number of open
connections. For example, a web application that peaked at 1000
concurrent database connections would consume 1000 threads and
1000 open sockets at the server, without ever freeing up those
resources from the connection pool. Note, connections, no matter
how old, will not be closed if the number of connections in the
pool is less than or equal to the value set by the Min
Pool Size
connection string parameter.
Introduction
As of MySQL 4.1, it is possible to use prepared statements with Connector/NET. Use of prepared statements can provide significant performance improvements on queries that are executed more than once.
Prepared execution is faster than direct execution for statements executed more than once, primarily because the query is parsed only once. In the case of direct execution, the query is parsed every time it is executed. Prepared execution also can provide a reduction of network traffic because for each execution of the prepared statement, it is necessary only to send the data for the parameters.
Another advantage of prepared statements is that it uses a binary protocol that makes data transfer between client and server more efficient.
To prepare a statement, create a command object and set the
.CommandText
property to your query.
After entering your statement, call the
.Prepare
method of the
MySqlCommand
object. After the statement is
prepared, add parameters for each of the dynamic elements in the
query.
After you enter your query and enter parameters, execute the
statement using the .ExecuteNonQuery()
,
.ExecuteScalar()
, or
.ExecuteReader
methods.
For subsequent executions, you need only modify the values of
the parameters and call the execute method again, there is no
need to set the .CommandText
property or
redefine the parameters.
Visual Basic Example
Dim conn As New MySqlConnection Dim cmd As New MySqlCommand conn.ConnectionString = strConnection Try conn.Open() cmd.Connection = conn cmd.CommandText = "INSERT INTO myTable VALUES(NULL, @number, @text)" cmd.Prepare() cmd.Parameters.AddWithValue("@number", 1) cmd.Parameters.AddWithValue("@text", "One") For i = 1 To 1000 cmd.Parameters("@number").Value = i cmd.Parameters("@text").Value = "A string value" cmd.ExecuteNonQuery() Next Catch ex As MySqlException MessageBox.Show("Error " & ex.Number & " has occurred: " & ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error) End Try
C# Example
MySql.Data.MySqlClient.MySqlConnection conn; MySql.Data.MySqlClient.MySqlCommand cmd; conn = new MySql.Data.MySqlClient.MySqlConnection(); cmd = new MySql.Data.MySqlClient.MySqlCommand(); conn.ConnectionString = strConnection; try { conn.Open(); cmd.Connection = conn; cmd.CommandText = "INSERT INTO myTable VALUES(NULL, @number, @text)"; cmd.Prepare(); cmd.Parameters.AddWithValue("@number", 1); cmd.Parameters.AddWithValue("@text", "One"); for (int i=1; i <= 1000; i++) { cmd.Parameters["@number"].Value = i; cmd.Parameters["@text"].Value = "A string value"; cmd.ExecuteNonQuery(); } } catch (MySql.Data.MySqlClient.MySqlException ex) { MessageBox.Show("Error " + ex.Number + " has occurred: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); }
Introduction
With the release of MySQL version 5 the MySQL server now supports stored procedures with the SQL 2003 stored procedure syntax.
A stored procedure is a set of SQL statements that can be stored in the server. Once this has been done, clients do not need to keep reissuing the individual statements but can refer to the stored procedure instead.
Stored procedures can be particularly useful in situations such as the following:
When multiple client applications are written in different languages or work on different platforms, but need to perform the same database operations.
When security is paramount. Banks, for example, use stored procedures for all common operations. This provides a consistent and secure environment, and procedures can ensure that each operation is properly logged. In such a setup, applications and users would not get any access to the database tables directly, but can only execute specific stored procedures.
Connector/NET supports the calling of stored procedures through
the MySqlCommand
object. Data can be passed in
and out of a MySQL stored procedure through use of the
MySqlCommand.Parameters
collection.
When you call a stored procedure, the command object makes an
additional SELECT
call to
determine the parameters of the stored procedure. You must
ensure that the user calling the procedure has the
SELECT
privilege on the
mysql.proc
table to enable them to verify the
parameters. Failure to do this will result in an error when
calling the procedure.
This section will not provide in-depth information on creating Stored Procedures. For such information, please refer to http://dev.mysql.com/doc/mysql/en/stored-routines.html.
A sample application demonstrating how to use stored procedures
with Connector/NET can be found in the Samples
directory of your Connector/NET installation.
Stored procedures in MySQL can be created using a variety of
tools. First, stored procedures can be created using the
mysql command-line client. Second, stored
procedures can be created using MySQL Workbench. Finally, stored
procedures can be created using the
.ExecuteNonQuery
method of the
MySqlCommand
object.
It should be noted that, unlike the command-line and GUI clients, you are not required to specify a special delimiter when creating stored procedures in Connector/NET.
To call a stored procedure using Connector/NET, you create a
MySqlCommand
object and pass the stored
procedure name as the .CommandText
property.
You then set the .CommandType
property to
CommandType.StoredProcedure
.
After the stored procedure is named, you create one
MySqlCommand
parameter for every parameter in
the stored procedure. IN
parameters are
defined with the parameter name and the object containing the
value, OUT
parameters are defined with the
parameter name and the data type that is expected to be
returned. All parameters need the parameter direction defined.
After defining the parameters, you call the stored procedure by
using the MySqlCommand.ExecuteNonQuery()
method.
Once the stored procedure is called, the values of the output
parameters can be retrieved by using the
.Value
property of the
MySqlConnector.Parameters
collection.
When a stored procedure is called using
MySqlCommand.ExecuteReader
, and the stored
procedure has output parameters, the output parameters are
only set after the MySqlDataReader
returned
by ExecuteReader
is closed.
The following C# example code demonstrates the use of stored procedures. It assumes the database 'employees' has already been created:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data; using MySql.Data; using MySql.Data.MySqlClient; namespace UsingStoredRoutines { class Program { static void Main(string[] args) { MySqlConnection conn = new MySqlConnection(); conn.ConnectionString = "server=localhost;user=root;database=employees;port=3306;password=******;"; MySqlCommand cmd = new MySqlCommand(); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); cmd.Connection = conn; cmd.CommandText = "DROP PROCEDURE IF EXISTS add_emp"; cmd.ExecuteNonQuery(); cmd.CommandText = "DROP TABLE IF EXISTS emp"; cmd.ExecuteNonQuery(); cmd.CommandText = "CREATE TABLE emp (empno INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, first_name VARCHAR(20), last_name VARCHAR(20), birthdate DATE)"; cmd.ExecuteNonQuery(); cmd.CommandText = "CREATE PROCEDURE add_emp(" + "IN fname VARCHAR(20), IN lname VARCHAR(20), IN bday DATETIME, OUT empno INT)" + "BEGIN INSERT INTO emp(first_name, last_name, birthdate) " + "VALUES(fname, lname, DATE(bday)); SET empno = LAST_INSERT_ID(); END"; cmd.ExecuteNonQuery(); } catch (MySqlException ex) { Console.WriteLine ("Error " + ex.Number + " has occurred: " + ex.Message); } conn.Close(); Console.WriteLine("Connection closed."); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); cmd.Connection = conn; cmd.CommandText = "add_emp"; cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@lname", "Jones"); cmd.Parameters["@lname"].Direction = ParameterDirection.Input; cmd.Parameters.AddWithValue("@fname", "Tom"); cmd.Parameters["@fname"].Direction = ParameterDirection.Input; cmd.Parameters.AddWithValue("@bday", "1940-06-07"); cmd.Parameters["@bday"].Direction = ParameterDirection.Input; cmd.Parameters.AddWithValue("@empno", MySqlDbType.Int32); cmd.Parameters["@empno"].Direction = ParameterDirection.Output; cmd.ExecuteNonQuery(); Console.WriteLine("Employee number: "+cmd.Parameters["@empno"].Value); Console.WriteLine("Birthday: " + cmd.Parameters["@bday"].Value); } catch (MySql.Data.MySqlClient.MySqlException ex) { Console.WriteLine("Error " + ex.Number + " has occurred: " + ex.Message); } conn.Close(); Console.WriteLine("Done."); } } }
The following code shows the same application in Visual Basic:
Imports System Imports System.Collections.Generic Imports System.Linq Imports System.Text Imports System.Data Imports MySql.Data Imports MySql.Data.MySqlClient Module Module1 Sub Main() Dim conn As New MySqlConnection() conn.ConnectionString = "server=localhost;user=root;database=world;port=3306;password=******;" Dim cmd As New MySqlCommand() Try Console.WriteLine("Connecting to MySQL...") conn.Open() cmd.Connection = conn cmd.CommandText = "DROP PROCEDURE IF EXISTS add_emp" cmd.ExecuteNonQuery() cmd.CommandText = "DROP TABLE IF EXISTS emp" cmd.ExecuteNonQuery() cmd.CommandText = "CREATE TABLE emp (empno INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY, first_name VARCHAR(20), last_name VARCHAR(20), birthdate DATE)" cmd.ExecuteNonQuery() cmd.CommandText = "CREATE PROCEDURE add_emp(" & "IN fname VARCHAR(20), IN lname VARCHAR(20), IN bday DATETIME, OUT empno INT)" & "BEGIN INSERT INTO emp(first_name, last_name, birthdate) " & "VALUES(fname, lname, DATE(bday)); SET empno = LAST_INSERT_ID(); END" cmd.ExecuteNonQuery() Catch ex As MySqlException Console.WriteLine(("Error " & ex.Number & " has occurred: ") + ex.Message) End Try conn.Close() Console.WriteLine("Connection closed.") Try Console.WriteLine("Connecting to MySQL...") conn.Open() cmd.Connection = conn cmd.CommandText = "add_emp" cmd.CommandType = CommandType.StoredProcedure cmd.Parameters.AddWithValue("@lname", "Jones") cmd.Parameters("@lname").Direction = ParameterDirection.Input cmd.Parameters.AddWithValue("@fname", "Tom") cmd.Parameters("@fname").Direction = ParameterDirection.Input cmd.Parameters.AddWithValue("@bday", "1940-06-07") cmd.Parameters("@bday").Direction = ParameterDirection.Input cmd.Parameters.AddWithValue("@empno", MySqlDbType.Int32) cmd.Parameters("@empno").Direction = ParameterDirection.Output cmd.ExecuteNonQuery() Console.WriteLine("Employee number: " & cmd.Parameters("@empno").Value) Console.WriteLine("Birthday: " & cmd.Parameters("@bday").Value) Catch ex As MySql.Data.MySqlClient.MySqlException Console.WriteLine(("Error " & ex.Number & " has occurred: ") + ex.Message) End Try conn.Close() Console.WriteLine("Done.") End Sub End Module
Introduction
One common use for MySQL is the storage of binary data in
BLOB
columns. MySQL supports four
different BLOB data types:
TINYBLOB
,
BLOB
,
MEDIUMBLOB
, and
LONGBLOB
.
Data stored in a BLOB column can be accessed using Connector/NET and manipulated using client-side code. There are no special requirements for using Connector/NET with BLOB data.
Simple code examples will be presented within this section, and a
full sample application can be found in the
Samples
directory of the Connector/NET
installation.
The first step is using MySQL with BLOB data is to configure the server. Let's start by creating a table to be accessed. In my file tables, I usually have four columns: an AUTO_INCREMENT column of appropriate size (UNSIGNED SMALLINT) to serve as a primary key to identify the file, a VARCHAR column that stores the file name, an UNSIGNED MEDIUMINT column that stores the size of the file, and a MEDIUMBLOB column that stores the file itself. For this example, I will use the following table definition:
CREATE TABLE file( file_id SMALLINT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY, file_name VARCHAR(64) NOT NULL, file_size MEDIUMINT UNSIGNED NOT NULL, file MEDIUMBLOB NOT NULL);
After creating a table, you may need to modify the max_allowed_packet system variable. This variable determines how large of a packet (that is, a single row) can be sent to the MySQL server. By default, the server will only accept a maximum size of 1MB from our client application. If you do not intend to exceed 1MB, this should be fine. If you do intend to exceed 1MB in your file transfers, this number has to be increased.
The max_allowed_packet option can be modified using MySQL
Administrator's Startup Variables screen. Adjust the Maximum
permitted option in the Memory section of the Networking tab to
an appropriate setting. After adjusting the value, click the
Service Control
screen of
MySQL Administrator. You can also adjust this value directly in
the my.cnf file (add a line that reads max_allowed_packet=xxM),
or use the SET max_allowed_packet=xxM; syntax from within MySQL.
Try to be conservative when setting max_allowed_packet, as transfers of BLOB data can take some time to complete. Try to set a value that will be adequate for your intended use and increase the value if necessary.
To write a file to a database we need to convert the file to a
byte array, then use the byte array as a parameter to an
INSERT
query.
The following code opens a file using a FileStream object, reads
it into a byte array, and inserts it into the
file
table:
Visual Basic Example
Dim conn As New MySqlConnection Dim cmd As New MySqlCommand Dim SQL As String Dim FileSize As UInt32 Dim rawData() As Byte Dim fs As FileStream conn.ConnectionString = "server=127.0.0.1;" _ & "uid=root;" _ & "pwd=12345;" _ & "database=test" Try fs = New FileStream("c:\image.png", FileMode.Open, FileAccess.Read) FileSize = fs.Length rawData = New Byte(FileSize) {} fs.Read(rawData, 0, FileSize) fs.Close() conn.Open() SQL = "INSERT INTO file VALUES(NULL, @FileName, @FileSize, @File)" cmd.Connection = conn cmd.CommandText = SQL cmd.Parameters.AddWithValue("@FileName", strFileName) cmd.Parameters.AddWithValue("@FileSize", FileSize) cmd.Parameters.AddWithValue("@File", rawData) cmd.ExecuteNonQuery() MessageBox.Show("File Inserted into database successfully!", _ "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk) conn.Close() Catch ex As Exception MessageBox.Show("There was an error: " & ex.Message, "Error", _ MessageBoxButtons.OK, MessageBoxIcon.Error) End Try
C# Example
MySql.Data.MySqlClient.MySqlConnection conn; MySql.Data.MySqlClient.MySqlCommand cmd; conn = new MySql.Data.MySqlClient.MySqlConnection(); cmd = new MySql.Data.MySqlClient.MySqlCommand(); string SQL; UInt32 FileSize; byte[] rawData; FileStream fs; conn.ConnectionString = "server=127.0.0.1;uid=root;" + "pwd=12345;database=test;"; try { fs = new FileStream(@"c:\image.png", FileMode.Open, FileAccess.Read); FileSize = fs.Length; rawData = new byte[FileSize]; fs.Read(rawData, 0, FileSize); fs.Close(); conn.Open(); SQL = "INSERT INTO file VALUES(NULL, @FileName, @FileSize, @File)"; cmd.Connection = conn; cmd.CommandText = SQL; cmd.Parameters.AddWithValue("@FileName", strFileName); cmd.Parameters.AddWithValue("@FileSize", FileSize); cmd.Parameters.AddWithValue("@File", rawData); cmd.ExecuteNonQuery(); MessageBox.Show("File Inserted into database successfully!", "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); conn.Close(); } catch (MySql.Data.MySqlClient.MySqlException ex) { MessageBox.Show("Error " + ex.Number + " has occurred: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); }
The Read
method of the
FileStream
object is used to load the file
into a byte array which is sized according to the
Length
property of the FileStream object.
After assigning the byte array as a parameter of the
MySqlCommand
object, the
ExecuteNonQuery
method is called and the BLOB
is inserted into the file
table.
Once a file is loaded into the file
table, we
can use the MySqlDataReader
class to retrieve
it.
The following code retrieves a row from the
file
table, then loads the data into a
FileStream
object to be written to disk:
Visual Basic Example
Dim conn As New MySqlConnection Dim cmd As New MySqlCommand Dim myData As MySqlDataReader Dim SQL As String Dim rawData() As Byte Dim FileSize As UInt32 Dim fs As FileStream conn.ConnectionString = "server=127.0.0.1;" _ & "uid=root;" _ & "pwd=12345;" _ & "database=test" SQL = "SELECT file_name, file_size, file FROM file" Try conn.Open() cmd.Connection = conn cmd.CommandText = SQL myData = cmd.ExecuteReader If Not myData.HasRows Then Throw New Exception("There are no BLOBs to save") myData.Read() FileSize = myData.GetUInt32(myData.GetOrdinal("file_size")) rawData = New Byte(FileSize) {} myData.GetBytes(myData.GetOrdinal("file"), 0, rawData, 0, FileSize) fs = New FileStream("C:\newfile.png", FileMode.OpenOrCreate, FileAccess.Write) fs.Write(rawData, 0, FileSize) fs.Close() MessageBox.Show("File successfully written to disk!", "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk) myData.Close() conn.Close() Catch ex As Exception MessageBox.Show("There was an error: " & ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error) End Try
C# Example
MySql.Data.MySqlClient.MySqlConnection conn; MySql.Data.MySqlClient.MySqlCommand cmd; MySql.Data.MySqlClient.MySqlDataReader myData; conn = new MySql.Data.MySqlClient.MySqlConnection(); cmd = new MySql.Data.MySqlClient.MySqlCommand(); string SQL; UInt32 FileSize; byte[] rawData; FileStream fs; conn.ConnectionString = "server=127.0.0.1;uid=root;" + "pwd=12345;database=test;"; SQL = "SELECT file_name, file_size, file FROM file"; try { conn.Open(); cmd.Connection = conn; cmd.CommandText = SQL; myData = cmd.ExecuteReader(); if (! myData.HasRows) throw new Exception("There are no BLOBs to save"); myData.Read(); FileSize = myData.GetUInt32(myData.GetOrdinal("file_size")); rawData = new byte[FileSize]; myData.GetBytes(myData.GetOrdinal("file"), 0, rawData, 0, FileSize); fs = new FileStream(@"C:\newfile.png", FileMode.OpenOrCreate, FileAccess.Write); fs.Write(rawData, 0, FileSize); fs.Close(); MessageBox.Show("File successfully written to disk!", "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); myData.Close(); conn.Close(); } catch (MySql.Data.MySqlClient.MySqlException ex) { MessageBox.Show("Error " + ex.Number + " has occurred: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); }
After connecting, the contents of the file
table are loaded into a MySqlDataReader
object. The GetBytes
method of the
MySqlDataReader is used to load the BLOB into a byte array,
which is then written to disk using a FileStream object.
The GetOrdinal
method of the MySqlDataReader
can be used to determine the integer index of a named column.
Use of the GetOrdinal method prevents errors if the column order
of the SELECT
query is changed.
Introduction
Crystal Reports is a common tool used by Windows application developers to perform reporting and document generation. In this section we will show how to use Crystal Reports XI with MySQL and Connector/NET.
When creating a report in Crystal Reports there are two options for accessing the MySQL data while designing your report.
The first option is to use Connector/ODBC as an ADO data source when designing your report. You will be able to browse your database and choose tables and fields using drag and drop to build your report. The disadvantage of this approach is that additional work must be performed within your application to produce a data set that matches the one expected by your report.
The second option is to create a data set in VB.NET and save it as XML. This XML file can then be used to design a report. This works quite well when displaying the report in your application, but is less versatile at design time because you must choose all relevant columns when creating the data set. If you forget a column you must re-create the data set before the column can be added to the report.
The following code can be used to create a data set from a query and write it to disk:
Visual Basic Example
Dim myData As New DataSet Dim conn As New MySqlConnection Dim cmd As New MySqlCommand Dim myAdapter As New MySqlDataAdapter conn.ConnectionString = "server=127.0.0.1;" _ & "uid=root;" _ & "pwd=12345;" _ & "database=world" Try conn.Open() cmd.CommandText = "SELECT city.name AS cityName, city.population AS CityPopulation, " _ & "country.name, country.population, country.continent " _ & "FROM country, city ORDER BY country.continent, country.name" cmd.Connection = conn myAdapter.SelectCommand = cmd myAdapter.Fill(myData) myData.WriteXml("C:\dataset.xml", XmlWriteMode.WriteSchema) Catch ex As Exception MessageBox.Show(ex.Message, "Report could not be created", MessageBoxButtons.OK, MessageBoxIcon.Error) End Try
C# Example
DataSet myData = new DataSet(); MySql.Data.MySqlClient.MySqlConnection conn; MySql.Data.MySqlClient.MySqlCommand cmd; MySql.Data.MySqlClient.MySqlDataAdapter myAdapter; conn = new MySql.Data.MySqlClient.MySqlConnection(); cmd = new MySql.Data.MySqlClient.MySqlCommand(); myAdapter = new MySql.Data.MySqlClient.MySqlDataAdapter(); conn.ConnectionString = "server=127.0.0.1;uid=root;" + "pwd=12345;database=test;"; try { cmd.CommandText = "SELECT city.name AS cityName, city.population AS CityPopulation, " + "country.name, country.population, country.continent " + "FROM country, city ORDER BY country.continent, country.name"; cmd.Connection = conn; myAdapter.SelectCommand = cmd; myAdapter.Fill(myData); myData.WriteXml(@"C:\dataset.xml", XmlWriteMode.WriteSchema); } catch (MySql.Data.MySqlClient.MySqlException ex) { MessageBox.Show(ex.Message, "Report could not be created", MessageBoxButtons.OK, MessageBoxIcon.Error); }
The resulting XML file can be used as an ADO.NET XML datasource when designing your report.
If you choose to design your reports using Connector/ODBC, it can be downloaded from dev.mysql.com.
For most purposes the Standard Report wizard should help with the initial creation of a report. To start the wizard, open Crystal Reports and choose the New > Standard Report option from the File menu.
The wizard will first prompt you for a data source. If you are using Connector/ODBC as your data source, use the OLEDB provider for ODBC option from the OLE DB (ADO) tree instead of the ODBC (RDO) tree when choosing a data source. If using a saved data set, choose the ADO.NET (XML) option and browse to your saved data set.
The remainder of the report creation process is done automatically by the wizard.
After the report is created, choose the Report Options... entry of the File menu. Un-check the Save Data With Report option. This prevents saved data from interfering with the loading of data within our application.
To display a report we first populate a data set with the data needed for the report, then load the report and bind it to the data set. Finally we pass the report to the crViewer control for display to the user.
The following references are needed in a project that displays a report:
CrytalDecisions.CrystalReports.Engine
CrystalDecisions.ReportSource
CrystalDecisions.Shared
CrystalDecisions.Windows.Forms
The following code assumes that you created your report using a
data set saved using the code shown in
Section 21.2.5.8.1, “Creating a Data Source”,
and have a crViewer control on your form named
myViewer
.
Visual Basic Example
Imports CrystalDecisions.CrystalReports.Engine Imports System.Data Imports MySql.Data.MySqlClient Dim myReport As New ReportDocument Dim myData As New DataSet Dim conn As New MySqlConnection Dim cmd As New MySqlCommand Dim myAdapter As New MySqlDataAdapter conn.ConnectionString = _ "server=127.0.0.1;" _ & "uid=root;" _ & "pwd=12345;" _ & "database=test" Try conn.Open() cmd.CommandText = "SELECT city.name AS cityName, city.population AS CityPopulation, " _ & "country.name, country.population, country.continent " _ & "FROM country, city ORDER BY country.continent, country.name" cmd.Connection = conn myAdapter.SelectCommand = cmd myAdapter.Fill(myData) myReport.Load(".\world_report.rpt") myReport.SetDataSource(myData) myViewer.ReportSource = myReport Catch ex As Exception MessageBox.Show(ex.Message, "Report could not be created", MessageBoxButtons.OK, MessageBoxIcon.Error) End Try
C# Example
using CrystalDecisions.CrystalReports.Engine; using System.Data; using MySql.Data.MySqlClient; ReportDocument myReport = new ReportDocument(); DataSet myData = new DataSet(); MySql.Data.MySqlClient.MySqlConnection conn; MySql.Data.MySqlClient.MySqlCommand cmd; MySql.Data.MySqlClient.MySqlDataAdapter myAdapter; conn = new MySql.Data.MySqlClient.MySqlConnection(); cmd = new MySql.Data.MySqlClient.MySqlCommand(); myAdapter = new MySql.Data.MySqlClient.MySqlDataAdapter(); conn.ConnectionString = "server=127.0.0.1;uid=root;" + "pwd=12345;database=test;"; try { cmd.CommandText = "SELECT city.name AS cityName, city.population AS CityPopulation, " + "country.name, country.population, country.continent " + "FROM country, city ORDER BY country.continent, country.name"; cmd.Connection = conn; myAdapter.SelectCommand = cmd; myAdapter.Fill(myData); myReport.Load(@".\world_report.rpt"); myReport.SetDataSource(myData); myViewer.ReportSource = myReport; } catch (MySql.Data.MySqlClient.MySqlException ex) { MessageBox.Show(ex.Message, "Report could not be created", MessageBoxButtons.OK, MessageBoxIcon.Error); }
A new data set it generated using the same query used to generate the previously saved data set. Once the data set is filled, a ReportDocument is used to load the report file and bind it to the data set. The ReportDocument is the passed as the ReportSource of the crViewer.
This same approach is taken when a report is created from a single table using Connector/ODBC. The data set replaces the table used in the report and the report is displayed properly.
When a report is created from multiple tables using Connector/ODBC, a data set with multiple tables must be created in our application. This enables each table in the report data source to be replaced with a report in the data set.
We populate a data set with multiple tables by providing
multiple SELECT
statements in our
MySqlCommand object. These SELECT
statements are based on the SQL query shown in Crystal Reports
in the Database menu's Show SQL Query option. Assume the
following query:
SELECT `country`.`Name`, `country`.`Continent`, `country`.`Population`, `city`.`Name`, `city`.`Population` FROM `world`.`country` `country` LEFT OUTER JOIN `world`.`city` `city` ON `country`.`Code`=`city`.`CountryCode` ORDER BY `country`.`Continent`, `country`.`Name`, `city`.`Name`
This query is converted to two
SELECT
queries and displayed with
the following code:
Visual Basic Example
Imports CrystalDecisions.CrystalReports.Engine Imports System.Data Imports MySql.Data.MySqlClient Dim myReport As New ReportDocument Dim myData As New DataSet Dim conn As New MySqlConnection Dim cmd As New MySqlCommand Dim myAdapter As New MySqlDataAdapter conn.ConnectionString = "server=127.0.0.1;" _ & "uid=root;" _ & "pwd=12345;" _ & "database=world" Try conn.Open() cmd.CommandText = "SELECT name, population, countrycode FROM city ORDER BY countrycode, name; " _ & "SELECT name, population, code, continent FROM country ORDER BY continent, name" cmd.Connection = conn myAdapter.SelectCommand = cmd myAdapter.Fill(myData) myReport.Load(".\world_report.rpt") myReport.Database.Tables(0).SetDataSource(myData.Tables(0)) myReport.Database.Tables(1).SetDataSource(myData.Tables(1)) myViewer.ReportSource = myReport Catch ex As Exception MessageBox.Show(ex.Message, "Report could not be created", MessageBoxButtons.OK, MessageBoxIcon.Error) End Try
C# Example
using CrystalDecisions.CrystalReports.Engine;
using System.Data;
using MySql.Data.MySqlClient;
ReportDocument myReport = new ReportDocument();
DataSet myData = new DataSet();
MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;
MySql.Data.MySqlClient.MySqlDataAdapter myAdapter;
conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();
myAdapter = new MySql.Data.MySqlClient.MySqlDataAdapter();
conn.ConnectionString = "server=127.0.0.1;uid=root;" +
"pwd=12345;database=test;";
try
{
cmd.CommandText = "SELECT name, population, countrycode FROM city ORDER " +
"BY countrycode, name; SELECT
name, population, code, continent FROM " +
"country ORDER BY continent, name";
cmd.Connection = conn;
myAdapter.SelectCommand = cmd;
myAdapter.Fill(myData);
myReport.Load(@".\world_report.rpt");
myReport.Database.Tables(0).SetDataSource(myData.Tables(0));
myReport.Database.Tables(1).SetDataSource(myData.Tables(1));
myViewer.ReportSource = myReport;
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
MessageBox.Show(ex.Message, "Report could not be created",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
It is important to order the
SELECT
queries in alphabetic
order, as this is the order the report will expect its source
tables to be in. One SetDataSource statement is needed for each
table in the report.
This approach can cause performance problems because Crystal Reports must bind the tables together on the client-side, which will be slower than using a pre-saved data set.
Introduction
MySQL and the .NET languages handle date and time information
differently, with MySQL allowing dates that cannot be represented
by a .NET data type, such as '0000-00-00
00:00:00
'. These differences can cause problems if not
properly handled.
In this section we will demonstrate how to properly handle date and time information when using Connector/NET.
The differences in date handling can cause problems for
developers who use invalid dates. Invalid MySQL dates cannot be
loaded into native .NET DateTime
objects,
including NULL
dates.
Because of this issue, .NET DataSet
objects
cannot be populated by the Fill
method of the
MySqlDataAdapter
class as invalid dates will
cause a System.ArgumentOutOfRangeException
exception to occur.
The best solution to the date problem is to restrict users from entering invalid dates. This can be done on either the client or the server side.
Restricting invalid dates on the client side is as simple as
always using the .NET DateTime
class to
handle dates. The DateTime
class will only
allow valid dates, ensuring that the values in your database are
also valid. The disadvantage of this is that it is not useful in
a mixed environment where .NET and non .NET code are used to
manipulate the database, as each application must perform its
own date validation.
Users of MySQL 5.0.2 and higher can use the new
traditional
SQL mode to restrict invalid date
values. For information on using the
traditional
SQL mode, see
Section 5.1.7, “Server SQL Modes”.
Although it is strongly recommended that you avoid the use of
invalid dates within your .NET application, it is possible to
use invalid dates by means of the
MySqlDateTime
data type.
The MySqlDateTime
data type supports the same
date values that are supported by the MySQL server. The default
behavior of Connector/NET is to return a .NET DateTime object
for valid date values, and return an error for invalid dates.
This default can be modified to cause Connector/NET to return
MySqlDateTime
objects for invalid dates.
To instruct Connector/NET to return a
MySqlDateTime
object for invalid dates, add
the following line to your connection string:
Allow Zero Datetime=True
Please note that the use of the MySqlDateTime
class can still be problematic. The following are some known
issues:
Data binding for invalid dates can still cause errors (zero dates like 0000-00-00 do not seem to have this problem).
The ToString
method return a date
formatted in the standard MySQL format (for example,
2005-02-23 08:50:25
). This differs from
the ToString
behavior of the .NET
DateTime class.
The MySqlDateTime
class supports NULL
dates, while the .NET DateTime class does not. This can
cause errors when trying to convert a MySQLDateTime to a
DateTime if you do not check for NULL first.
Because of the known issues, the best recommendation is still to use only valid dates in your application.
The .NET DateTime
data type cannot handle
NULL
values. As such, when assigning values
from a query to a DateTime
variable, you must
first check whether the value is in fact
NULL
.
When using a MySqlDataReader
, use the
.IsDBNull
method to check whether a value is
NULL
before making the assignment:
Visual Basic Example
If Not myReader.IsDBNull(myReader.GetOrdinal("mytime")) Then myTime = myReader.GetDateTime(myReader.GetOrdinal("mytime")) Else myTime = DateTime.MinValue End If
C# Example
if (! myReader.IsDBNull(myReader.GetOrdinal("mytime"))) myTime = myReader.GetDateTime(myReader.GetOrdinal("mytime")); else myTime = DateTime.MinValue;
NULL
values will work in a data set and can
be bound to form controls without special handling.
MySQL Connector/NET provides support for the ASP.NET 2.0 provider model. This model enables application developers to focus on the business logic of their application instead of having to recreate such boilerplate items as membership and roles support.
MySQL Connector/NET supplies the following providers:
Membership Provider
Role Provider
Profile Provider
Session State Provider (MySQL Connector/NET 6.1 and later)
The following tables show the supported providers, their default provider and the corresponding MySQL provider.
Membership Provider
Default Provider | MySQL Provider |
---|---|
System.Web.Security.SqlMembershipProvider | MySql.Web.Security.MySQLMembershipProvider |
Role Provider
Default Provider | MySQL Provider |
---|---|
System.Web.Security.SqlRoleProvider | MySql.Web.Security.MySQLRoleProvider |
Profile Provider
Default Provider | MySQL Provider |
---|---|
System.Web.Profile.SqlProfileProvider | MySql.Web.Profile.MySQLProfileProvider |
SessionState Provider
Default Provider | MySQL Provider |
---|---|
System.Web.SessionState.InProcSessionStateStore | MySql.Web.SessionState.MySqlSessionStateStore |
The MySQL Session State provider uses slightly different capitalization on the class name compared to the other MySQL providers.
Installing The Providers
The installation of Connector/Net 5.1 or later will install the
providers and register them in your machine's .NET configuration
file, machine.config
. The additional entries
created will result in the system.web
section
appearing similar to the following code:
<system.web> <processModel autoConfig="true" /> <httpHandlers /> <membership> <providers> <add name="AspNetSqlMembershipProvider" type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" connectionStringName="LocalSqlServer" enablePasswordRetrieval="false" enablePasswordReset="true" requiresQuestionAndAnswer="true" applicationName="/" requiresUniqueEmail="false" passwordFormat="Hashed" maxInvalidPasswordAttempts="5" minRequiredPasswordLength="7" minRequiredNonalphanumericCharacters="1" passwordAttemptWindow="10" passwordStrengthRegularExpression="" /> <add name="MySQLMembershipProvider" type="MySql.Web.Security.MySQLMembershipProvider, MySql.Web, Version=6.1.1.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" connectionStringName="LocalMySqlServer" enablePasswordRetrieval="false" enablePasswordReset="true" requiresQuestionAndAnswer="true" applicationName="/" requiresUniqueEmail="false" passwordFormat="Clear" maxInvalidPasswordAttempts="5" minRequiredPasswordLength="7" minRequiredNonalphanumericCharacters="1" passwordAttemptWindow="10" passwordStrengthRegularExpression="" /> </providers> </membership> <profile> <providers> <add name="AspNetSqlProfileProvider" connectionStringName="LocalSqlServer" applicationName="/" type="System.Web.Profile.SqlProfileProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" /> <add name="MySQLProfileProvider" type="MySql.Web.Profile.MySQLProfileProvider, MySql.Web, Version=6.1.1.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" connectionStringName="LocalMySqlServer" applicationName="/" /> </providers> </profile> <roleManager> <providers> <add name="AspNetSqlRoleProvider" connectionStringName="LocalSqlServer" applicationName="/" type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" /> <add name="AspNetWindowsTokenRoleProvider" applicationName="/" type="System.Web.Security.WindowsTokenRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" /> <add name="MySQLRoleProvider" type="MySql.Web.Security.MySQLRoleProvider, MySql.Web, Version=6.1.1.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" connectionStringName="LocalMySqlServer" applicationName="/" /> </providers> </roleManager> </system.web>
Each provider type can have multiple provider implementations. The
default provider can also be set here using the
defaultProvider
attribute, but usually this is
set in the web.config
file either manually or
by using the ASP.NET configuration tool.
At time of writing the MySqlSessionStateStore
is not added to machine.config
at install
time, and so you would need to add the following:
<sessionState> <providers> <add name="MySqlSessionStateStore" type="MySql.Web.SessionState.MySqlSessionStateStore, MySql.Web, Version=6.1.1.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d" connectionStringName="LocalMySqlServer" applicationName="/" /> </providers> </sessionState>
It should be pointed out that the SessionState Provider uses the
customProvider
attribute, rather than
defaultProvider
, to set the provider as the
default. A typical web.config
file might
contain:
<system.web> <membership defaultProvider="MySQLMembershipProvider" /> <roleManager defaultProvider="MySQLRoleProvider" /> <profile defaultProvider="MySQLProfileProvider" /> <sessionState customProvider="MySqlSessionStateStore" /> <compilation debug="false"> ...
This sets the MySQL Providers as the defaults to be used in this web application.
The providers are implemented in the file
mysql.web.dll
and this file can be found in
your MySQL Connector/NET installation folder. There is no need to run any type
of SQL script to set up the database schema as the providers
create and maintain the proper schema automatically.
Using The Providers
The easiest way to start using the providers is to use the ASP.NET configuration tool that is available on the Solution Explorer toolbar when you have a website project loaded.
In the web pages that open you will be able to select the MySQL membership and roles providers by indicating that you want to pick a custom provider for each area.
When the provider is installed, it creates a dummy connection
string named LocalMySqlServer
. This has to be
done so that the provider will work in the ASP.NET configuration
tool. However, you will want to override this connection string in
your web.config
file. You do this by first
removing the dummy connection string and then adding in the proper
one, as shown in the following example:
<connectionStrings> <remove name="LocalMySqlServer"/> <add name="LocalMySqlServer" connectionString="server=xxx;uid=xxx;pwd=xxx;database=xxx;"/> </connectionStrings>
Note the database you want to connect to must be specified.
Rather than manually editing configuration files it is recommended
that you use the MySQL Website Configuration tool to config your
desired provider setup. From MySQL Connector/NET 6.1.1 onwards all providers
can be selected and configured from this wizard. The tool will
modify your website.config
file to the
desired configuration. A tutorial on doing this is available in
the following section
Section 21.2.3.10, “MySQL Website Configuration Tool”.
A tutorial demonstrating how to use the Membership and Role Providers can be found in the following section Section 21.2.4.2, “Tutorial: MySQL Connector/NET ASP.NET Membership and Role Provider”.
Deployment
To use the providers on a production server you will need to
distribute the MySql.Data
and the
MySql.Web
assemblies and either register them
in the remote systems Global Assembly Cache or keep them in your
application's bin/
directory.
There are certain situations where MySQL will return incorrect metadata about one or more columns. More specifically, the server will sometimes report that a column is binary when it is not and vice versa. In these situations, it becomes practically impossible for the connector to be able to correctly identify the correct metadat.
Some examples of situations that may return incorrect metadata are:
Execution of SHOW PROCESSLIST
.
Some of the columns will be returned as binary even though
they only hold string data.
When a temp table is used to process a resultset, some columns may be returned with incorrect binary flags.
Some server functions such DATE_FORMAT
will
incorrectly return the column as binary.
With the availability of BINARY
and
VARBINARY
data types it is important that we
respect the metadata returned by the sever. However, we are aware
that some existing applications may break with this change so we
are creating a connection string option to enable or disable it.
By default, Connector/Net 5.1 will respect the binary flags
returned by the server. This will mean that you may need to make
small changes to your application to accomodate this change.
In the event that the changes required to your application would
be too large, you can add 'respect binary flags=false'
to your connection string. This will cause the connector to use
the prior behavior. In a nutshell, that behavior was that any
column that is marked as string, regardless of binary flags, will
be returned as string. Only columns that are specifically marked
as a BLOB
will be returned as
BLOB
.
Treating Binary Blobs As UTF8
MySQL doesn't currently support 4 byte UTF8 sequences. This makes it difficult to represent some multi-byte languages such as Japanese. To try and alleviate this, Connector/Net now supports a mode where binary blobs can be treated as strings.
To do this, you set the 'Treat Blobs As UTF8' connection string keyword to yes. This is all that needs to be done to enable conversion of all binary blobs to UTF8 strings. If you wish to convert only some of your blob columns, then you can make use of the 'BlobAsUTF8IncludePattern' and 'BlobAsUTF8ExcludePattern' keywords. These should be set to the regular expression pattern that matches the column names you wish to include or exlude respectively.
One thing to note is that the regular expression patterns can both
match a single column. When this happens, the include pattern is
applied before the exclude pattern. The result, in this case,
would be that the column would be excluded. You should also be
aware that this mode does not apply to columns of type
BINARY
or VARBINARY
and also
do not apply to nonbinary BLOB
columns.
Currently this mode only applies to reading strings out of MySQL.
To insert 4-byte UTF8 strings into blob columns you will need to
use the .NET Encoding.GetBytes
function to
convert your string to a series of bytes. You can then set this
byte array as a parameter for a BLOB
column.
.NET applications operate under a given trust level. Normal desktop applications operate under full trust while web applications that are hosted in shared environments are normally run under the medium trust level. Some hosting providers host shared applications in their own app pools and allow the application to run under full trust, but this seems to be the exception rather than the rule.
Connector/Net versions prior to 5.0.8 and 5.1.3 were not
compatible with medium trust hosting. Starting with these
versions, Connector/Net can be used under medium trust hosting
that has been modified to allow the use of sockets for
communication. By default, medium trust does not include
SocketPermission
. Connector/Net uses sockets to
talk with the MySQL server so it is required that a new trust
level be created that is an exact clone of medium trust but that
has SocketPermission
added.
MySQL Connector/NET 6.2 introduced support for .NET 2.0 compatible tracing,
using TraceSource
objects.
The .NET 2.0 tracing architecture consists of four main parts:
Source - This is the originator of the
trace information. The source is used to send trace messages.
The name of the source provided by MySQL Connector/NET is
mysql
.
Switch - This defines the level of trace
information to emit. Typically, this is specified in the
app.config
file, so that it is not
necessary to recompile an application to change the trace
level.
Listener - Trace listeners define where the trace information will be written to. Supported listeners include, for example, the Visual Studio Output window, the Windows Event Log, and the console.
Filter - Filters can be attached to listeners. Filters determine the level of trace information that will be written. While a switch defines the level of information that will be written to all listeners, a filter can be applied on a per-listener basis, giving finer grained control of trace information.
To use tracing a TraceSource
object first needs
to be created. To create a TraceSource
object
in MySQL Connector/NET you would use code similar to the following:
TraceSource ts = new TraceSource("mysql");
To enable trace messages you also need to configure a trace
switch. There are three main switch classes,
BooleanSwitch
, SourceSwitch
,
and TraceSwitch
. Trace switches also have
associated with them a trace level enumeration, these are
Off
, Error
,
Warning
, Info
, and
Verbose
. The following code snippet illustrates
creating a switch:
ts.Switch = new SourceSwitch("MySwitch", "Verbose");
This creates a SourceSwitch
, called
MySwitch
, and sets the trace level to
Verbose
, meaning that all trace messages will
be written.
It is convenient to be able to change the trace level without
having to recompile the code. This is achieved by specifying the
trace level in application configuration file,
app.config
. You then simply need to specify
the desired trace level in the configuration file and restart the
application. The trace source is configured within the
system.diagnostics
section of the file. The
following XML snippet illustrates this:
<configuration> ... <system.diagnostics> <sources> <source name="mysql" switchName="MySwitch" switchType="System.Diagnostics.SourceSwitch" /> ... </sources> <switches> <add name="MySwitch" value="Verbose"/> ... </switches> </system.diagnostics> ... </configuration>
By default trace information is written to the Output window of
Microsoft Visual Studio. However, there are a wide range of
listeners than can be attached to the trace source, so that trace
messages can be written out to various destinations. It is also
possible to create custom listeners to allow trace messages to be
written to other destinations as mobile devices and web services.
A commonly used example of a listener is
ConsoleTraceListener
, which writes trace
messages to the console.
To add a listener at run time you can use code such as the following:
ts.Listeners.Add(new ConsoleTraceListener());
You can then call methods on trace source object to generate trace
information. For example, the
TraceInformation()
,
TraceEvent()
, or TraceData()
methods can be used.
The TraceInformation()
method simply prints a
string passed as a parameter. The TraceEvent()
method, as well as the optional informational string, requires a
TraceEventType
value to be passed to indicate
the trace message type, and also an application specific ID. The
TraceEventType
can have a value of
Verbose
, Information
,
Warning
, Error
, and
Critical
. Using the
TraceData()
method you can pass any object, for
example an exception object, instead of a message.
To ensure than these generated trace messages gets flushed from
the trace source buffers to listeners, you need to invoke the
Flush()
method. When you are finished using a
trace source, you should call the Close()
method. The Close()
method first calls
Flush()
, to ensure any remaining data is
written out. It then frees up resources, and closes the listeners
associated with the trace source.
ts.TraceInformation("Informational message"); ts.TraceEvent(TraceEventType.Error, 3, "Optional error message"); ts.TraceData(TraceEventType.Error, 3, ex); // pass exception object ts.Flush(); ... ts.Close();
This section describes how to set up your application to view MySQL trace information.
The first thing you need to do is create a suitable
app.config
file for your application. An
example is shown in the following code:
<?xml version="1.0" encoding="utf-8" ?> <configuration> <system.diagnostics> <sources> <source name="mysql" switchName="SourceSwitch" switchType="System.Diagnostics.SourceSwitch" > <listeners> <add name="console" /> <remove name ="Default" /> </listeners> </source> </sources> <switches> <!-- You can set the level at which tracing is to occur --> <add name="SourceSwitch" value="Verbose" /> <!-- You can turn tracing off --> <!--add name="SourceSwitch" value="Off" --> </switches> <sharedListeners> <add name="console" type="System.Diagnostics.ConsoleTraceListener" initializeData="false"/> </sharedListeners> </system.diagnostics> </configuration>
This ensures a suitable trace source is created, along with a
switch. The switch level in this case is set to
Verbose
to display the maximum amount of
information.
In the application the only other step required is to add
logging=true
to the connection string. An
example application could be:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; using MySql.Data; using MySql.Data.MySqlClient; using MySql.Web; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { string connStr = "server=localhost;user=root;database=world;port=3306;password=******;logging=true;"; MySqlConnection conn = new MySqlConnection(connStr); try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); string sql = "SELECT Name, HeadOfState FROM Country WHERE Continent='Oceania'"; MySqlCommand cmd = new MySqlCommand(sql, conn); MySqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { Console.WriteLine(rdr[0] + " -- " + rdr[1]); } rdr.Close(); conn.Close(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } Console.WriteLine("Done."); } } }
Ths simple application will then generate the following output:
Connecting to MySQL... mysql Information: 1 : 1: Connection Opened: connection string = 'server=localhost;User Id=root;database=world;port=3306 ;password=******;logging=True' mysql Information: 3 : 1: Query Opened: SHOW VARIABLES mysql Information: 4 : 1: Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1 mysql Information: 5 : 1: Resultset Closed. Total rows=272, skipped rows=0, size (bytes)=7058 mysql Information: 6 : 1: Query Closed mysql Information: 3 : 1: Query Opened: SHOW COLLATION mysql Information: 4 : 1: Resultset Opened: field(s) = 6, affected rows = -1, inserted id = -1 mysql Information: 5 : 1: Resultset Closed. Total rows=127, skipped rows=0, size (bytes)=4102 mysql Information: 6 : 1: Query Closed mysql Information: 3 : 1: Query Opened: SET character_set_results=NULL mysql Information: 4 : 1: Resultset Opened: field(s) = 0, affected rows = 0, inserted id = 0 mysql Information: 5 : 1: Resultset Closed. Total rows=0, skipped rows=0, size (bytes)=0 mysql Information: 6 : 1: Query Closed mysql Information: 10 : 1: Set Database: world mysql Information: 3 : 1: Query Opened: SELECT Name, HeadOfState FROM Country WHERE Continent='Oceania' mysql Information: 4 : 1: Resultset Opened: field(s) = 2, affected rows = -1, inserted id = -1 American Samoa -- George W. Bush Australia -- Elisabeth II ... Wallis and Futuna -- Jacques Chirac Vanuatu -- John Bani United States Minor Outlying Islands -- George W. Bush mysql Information: 5 : 1: Resultset Closed. Total rows=28, skipped rows=0, size (bytes)=788 mysql Information: 6 : 1: Query Closed Done. mysql Information: 2 : 1: Connection Closed
The first number displayed in the trace message corresponds to the MySQL event type:
Event | Description |
---|---|
1 | ConnectionOpened: connection string |
2 | ConnectionClosed: |
3 | QueryOpened: mysql server thread id, query text |
4 | ResultOpened: field count, affected rows (-1 if select), inserted id (-1 if select) |
5 | ResultClosed: total rows read, rows skipped, size of resultset in bytes |
6 | QueryClosed: |
7 | StatementPrepared: prepared sql, statement id |
8 | StatementExecuted: statement id, mysql server thread id |
9 | StatementClosed: statement id |
10 | NonQuery: [varies] |
11 | UsageAdvisorWarning: usage advisor flag. NoIndex = 1, BadIndex = 2, SkippedRows = 3, SkippedColumns = 4, FieldConversion = 5. |
12 | Warning: level, code, message |
13 | Error: error number, error message |
The second number displayed in the trace message is the connection count.
Although this example uses the
ConsoleTraceListener
, any of the other
standard listeners could have been used. Another possibility is
to create a custom listener that uses the information passed
using the TraceEvent
method. For example, a
custom trace listener could be created to perform active
monitoring of the MySQL event messages, rather than simply
writing these to an output device.
It is also possible to add listeners to the MySQL Trace Source at run time. This can be done with the following code:
MySqlTrace.Listeners.Add(new ConsoleTraceListener());
MySQL Connector/NET 6.3.2 introduced the ability to switch tracing on and off
at run time. This can be achieved using the calls
MySqlTrace.EnableQueryAnalyzer(string host, int
postInterval)
and
MySqlTrace.DisableQueryAnalyzer()
. The
parameter host
is the URL of the MySQL
Enterprise Monitor server to monitor. The parameter
postInterval
is how often the data should be
periodically posted to MySQL Enterprise Monitor, in seconds.
To build custom listeners that work with the MySQL Connector/NET Trace Source, it is necessary to understand the key methods used, and the event data formats used.
The main method involved in passing trace messages is the
TraceSource.TraceEvent
method. This has the
prototype:
public void TraceEvent( TraceEventType eventType, int id, string format, params Object[] args )
This trace source method will process the list of attached
listeners and call the listener's TraceListener.TraceEvent
method. The prototype for the
TraceListener.TraceEvent
method is as
follows:
public virtual void TraceEvent( TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params Object[] args )
The first three parameters are used in the standard as defined by Microsoft. The last three parameters contain MySQL-specifc trace information. Each of these parameters is now discussed in more detail.
int id
This is a MySQL-specific identifier. It identifies the MySQL
event type that has occurred, resulting in a trace message being
generated. This value is defined by the
MySqlTraceEventType
public enum contained in
the MySQL Connector/NET code:
public enum MySqlTraceEventType : int { ConnectionOpened = 1, ConnectionClosed, QueryOpened, ResultOpened, ResultClosed, QueryClosed, StatementPrepared, StatementExecuted, StatementClosed, NonQuery, UsageAdvisorWarning, Warning, Error }
The MySQL event type also determines the contents passed using
the parameter params Object[] args
. The
nature of the args
parameters are described
in further detail in the following material.
string
format
This is the format string that contains zero or more format
items, which correspond to objects in the args array. This would
be used by a listener such as
ConsoleTraceListener
to write a message to
the output device.
params Object[]
args
This is a list of objects that depends on the MySQL event type,
id
. However, the first parameter passed using
this list is always the driver id. The driver id is a unique
number that is incremented each time the connector is opened.
This enables groups of queries on the same connection to be
identified. The parameters that follow driver id depend of the
MySQL event id, and are as follows:
MySQL-specific event type | Arguments (params Object[] args) |
---|---|
ConnectionOpened | Connection string |
ConnectionClosed | No additional parameters |
QueryOpened | mysql server thread id, query text |
ResultOpened | field count, affected rows (-1 if select), inserted id (-1 if select) |
ResultClosed | total rows read, rows skipped, size of resultset in bytes |
QueryClosed | No additional parameters |
StatementPrepared | prepared sql, statement id |
StatementExecuted | statement id, mysql server thread id |
StatementClosed | statement id |
NonQuery | Varies |
UsageAdvisorWarning | usage advisor flag. NoIndex = 1, BadIndex = 2, SkippedRows = 3, SkippedColumns = 4, FieldConversion = 5. |
Warning | level, code, message |
Error | error number, error message |
This information will allow you to create custom trace listeners that can actively monitor the MySQL-specific events.
MySQL Connector/NET features a bulk loader class that wraps the MySQL statement
LOAD DATA INFILE
. This gives MySQL Connector/NET the ability
to load a data file from a local or remote host to the server. The
class concerned is MySqlBulkLoader
. This class
has various methods, the main one being load
to
cause the specified file to be loaded to the server. Various
parameters can be set to control how the data file is processed.
This is achieved through setting various properties of the class.
For example, the field separator used, such as comma or tab, can
be specified, along with the record terminator, such as newline.
The following code shows a simple example of using the
MySqlBulkLoader
class. First an empty table
needs to be created, in this case in the test
database:
CREATE TABLE Career ( Name VARCHAR(100) NOT NULL, Age INTEGER, Profession VARCHAR(200) );
A simple tab-delimited data file is also created (it could use any other field delimiter such as comma):
Table Career in Test Database Name Age Profession Tony 47 Technical Writer Ana 43 Nurse Fred 21 IT Specialist Simon 45 Hairy Biker
Note that with this test file the first three lines will need to
be ignored, as they do not contain table data. This can be
achieved using the NumberOfLinesToSkip
property. This file can then be loaded and used to populate the
Career
table in the test
database:
using System; using System.Text; using MySql.Data; using MySql.Data.MySqlClient; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { string connStr = "server=localhost;user=root;database=test;port=3306;password=******;"; MySqlConnection conn = new MySqlConnection(connStr); MySqlBulkLoader bl = new MySqlBulkLoader(conn); bl.TableName = "Career"; bl.FieldTerminator = "\t"; bl.LineTerminator = "\n"; bl.FileName = "c:/career_data.txt"; bl.NumberOfLinesToSkip = 3; try { Console.WriteLine("Connecting to MySQL..."); conn.Open(); // Upload data from file int count = bl.Load(); Console.WriteLine(count + " lines uploaded."); string sql = "SELECT Name, Age, Profession FROM Career"; MySqlCommand cmd = new MySqlCommand(sql, conn); MySqlDataReader rdr = cmd.ExecuteReader(); while (rdr.Read()) { Console.WriteLine(rdr[0] + " -- " + rdr[1] + " -- " + rdr[2]); } rdr.Close(); conn.Close(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } Console.WriteLine("Done."); } } }
Further information on LOAD DATA INFILE
can be
found in Section 12.2.6, “LOAD DATA INFILE
Syntax”. Further information on
MySqlBulkLoader
can be found in the reference
documentation that was included with your connector.
Name | Default | Description |
---|---|---|
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 separator character. Commands sent to earlier versions of MySQL should be separated with ';'. |
Allow User Variables | false | Setting this to true indicates that the provider
expects user variables in the SQL. This option was added in
Connector/NET version 5.2.2. |
Allow Zero Datetime | false | If set to True ,
MySqlDataReader.GetValue() will return a
MySqlDateTime object for date or datetime
columns that have illegal values, such as zero datetime
values, and a System.DateTime object for
legal values. If set to False (the
default setting) it will cause a
System.DateTime object to be returned for
all legal values and an exception to be thrown for illegal
values, such as zero datetime values. |
AutoEnlist | true | If AutoEnlist is set to true ,
which is the default, a connection opened using
TransactionScope participates in this
scope, it commits when the scope commits and rolls back if
TransactionScope does not commit.
However, this feature is considered security sensitive and
therefore cannot be used in a medium trust environment. |
BlobAsUTF8ExcludePattern | null | |
BlobAsUTF8IncludePattern | null | |
CertificateFile | null | This option specifies the path to a certificate file in PFX format. For an example of usage see Section 21.2.4.7, “Tutorial: Using SSL with MySQL Connector/NET”. Was introduced with 6.2.1. |
CertificatePassword | null | This option enables you to specify a password which is used in
conjunction with a certificate specified using the option
CertificateFile . For an example of usage
see Section 21.2.4.7, “Tutorial: Using SSL with MySQL Connector/NET”. Was
introduced with 6.2.1. |
Certificate Store Location | null | This option enables you to access a certificate held in a personal store, rather than use a certificate file and password combination. For an example of usage see Section 21.2.4.7, “Tutorial: Using SSL with MySQL Connector/NET”. Was introduced with 6.2.1. |
Certificate Thumbprint | null | This option enables you to specify a certificate thumbprint to ensure correct identifcation of a certificate contained within a personal store. For an example of usage see Section 21.2.4.7, “Tutorial: Using SSL with MySQL Connector/NET”. Was introduced with 6.2.1. |
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. | |
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. |
Connection Reset | false | If true, the connection state will be reset when it is retrieved from the pool. If set to false this avoids making an additional server round trip when obtaining a connection, but the connection state is not reset. |
Convert Zero Datetime | false | True to have MySqlDataReader.GetValue() and
MySqlDataReader.GetDateTime() return
DateTime.MinValue for date or datetime columns that have
illegal values. |
Default Command Timeout | 30 | Sets the default value of the command timeout to be used. This does not supercede the individual command timeout property on an individual command object. If you set the command timeout property, that will be used. This option was added in Connector/NET 5.1.4 |
Encrypt , UseSSL | 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. From version 6.2.1 this option is deprecated
and is replaced by SSL Mode . However, the
option is still supported if used. If this option is set to
true it is equivalent to SSL Mode =
Preferred . |
FunctionsReturnString | false | This will cause the connector to return binary/varbinary values as strings, if they do not have a tablename in the metadata. |
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 file name. 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 and
Connector/NET 1.0.9. |
Initial Catalog , Database | mysql | The name of the database to use intially |
Interactive, InteractiveSession | false | If set to true the client is interactive. An interactive client is one
where the server variable
CLIENT_INTERACTIVE is set. If an
interactive client is set, the
wait_timeout variable is set to the value
of interactive_timeout . The client will
then timeout after this period of inactivity. More details
can be found in the server manual
Section 5.1.4, “Server System Variables”. |
Logging | false | When true, various pieces of information is output to any configured TraceListeners. See Section 21.2.5.14, “Using the MySQL Connector/NET Trace Source Object” for further details. |
Old Guids | false | This option was introduced in Connector/NET 6.1.1. The backend
representation of a GUID type was changed from
BINARY(16) to
CHAR(36) . This was done to allow
developers to use the server function
UUID() to populate a GUID table -
UUID() generates a 36-character string.
Developers of older applications can add 'Old Guids=true' to
the connection string to use a GUID of data type
BINARY(16) . |
Old Syntax , OldSyntax | false | This option was deprecated in Connector/NET 5.2.2. All code should now be written using the '@' symbol as the parameter marker. |
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 . |
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. |
Port | 3306 | The port MySQL is using to listen for connections. This value is ignored if Unix socket is used. |
Procedure Cache Size | 25 | Sets the size of the stored procedure cache. By default, Connector/NET will store the metadata (input/output data types) about the last 25 stored procedures used. To disable the stored procedure cache, set the value to zero (0). This option was added in Connector/NET 5.0.2 and Connector/NET 1.0.9. |
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. |
Respect Binary Flags | true | Setting this option to false means that Connector/NET
will ignore a column's binary flags as set by the server.
This option was added in Connector/NET version 5.1.3. |
Shared Memory Name | MYSQL | The name of the shared memory object to use for communication if the connection protocol is set to memory. |
Sql Server Mode | false | Allow SQL Server syntax. When set to true enables
Connector/NET to support square brackets around symbols
instead of backticks. This enables Visual Studio wizards
that bracket symbols with [] to work with Connector/NET.
This option incurs a performance hit, so should only be used
if necessary. This option was added in version 6.3.1. |
SSL Mode | None | This option has the following values:
This option was introduced in MySQL Connector/NET 6.2.1. |
TreatBlobsAsUTF8 | false | |
Treat Tiny As Boolean | true | Setting this value to false indicates that
TINYINT(1) will be treated as an
INT . See also
Section 10.1.1, “Overview of Numeric Types” for a further
explanation of the TINYINT
and BOOL data types. |
Use Affected Rows | false | When true the connection will report changed rows
instead of found rows. This option was added in
Connector/NET version 5.2.6. |
Use Procedure Bodies | true | When set to true , the default value, MySQL Connector/NET expects
the body of the procedure to be viewable. This enables it to
determine the parameter types and order. The option should
be set to false when the user connecting
to the database does not have the
SELECT privileges for the
mysql.proc (stored procedures) table, or
cannot view I_S.ROUTINES . In this case,
MySQL Connector/NET will not be able to determine the types and order of
the parameters, and must be alerted to this fact by setting
this option to false . When set to
false , MySQL Connector/NET will not rely on this
information being available when the procedure is called.
Because MySQL Connector/NET will not be able to determine this
information, you should explicitly set the types of all the
parameters before the call and the parameters should be
added to the command in the same order as they appear in the
procedure definition. This option was added in MySQL Connector/NET 5.0.4
and MySQL Connector/NET 1.0.10. |
User Id , Username ,
Uid , User name | The MySQL login account being used. | |
Use Compression | false |
Setting this option to Compression is used if both client and server support ZLIB compression, and the client has requested compression using this option. A compressed packet header is: packet length (3 bytes), packet number (1 byte), and Uncompressed Packet Length (3 bytes). The Uncompressed Packet Length is the number of bytes in the original, uncompressed packet. If this is zero then the data in this packet has not been compressed. When the compression protocol is in use, either the client or the server may compress packets. However, compression will not occur if the compressed length is greater than the original length. Thus, some packets will contain compressed data while other packets will not. |
Use Usage Advisor | false | |
Use Performance Monitor | false |
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 |
---|---|---|
Cache Server Configuration ,
CacheServerConfiguration ,
CacheServerConfig | false | Specifies whether server variables should be updated when a pooled connection is returned. Turning this on will yield faster opens but will also not catch any server changes made by other connections. |
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 . |
This section of the manual contains a complete reference to the Connector/NET ADO.NET component, automatically generated from the embedded documentation.
Classes
Class | Description |
---|---|
MySqlCommand | |
MySqlCommandBuilder | |
MySqlConnection | |
MySqlDataAdapter | |
MySqlDataReader | Provides a means of reading a forward-only stream of rows from a MySQL database. This class cannot be inherited. |
MySqlError | Collection of error codes that can be returned by the server |
MySqlException | The exception that is thrown when MySQL returns an error. This class cannot be inherited. |
MySqlHelper | Helper class that makes it easier to work with the provider. |
MySqlInfoMessageEventArgs | Provides data for the InfoMessage event. This class cannot be inherited. |
MySqlParameter | Represents a parameter to a MySqlCommand , and optionally, its mapping to DataSetcolumns. This class cannot be inherited. |
MySqlParameterCollection | Represents a collection of parameters relevant to a MySqlCommand as well as their respective mappings to columns in a DataSet. This class cannot be inherited. |
MySqlRowUpdatedEventArgs | Provides data for the RowUpdated event. This class cannot be inherited. |
MySqlRowUpdatingEventArgs | Provides data for the RowUpdating event. This class cannot be inherited. |
MySqlTransaction |
Delegates
Delegate | Description |
---|---|
MySqlInfoMessageEventHandler | Represents the method that will handle the InfoMessage event of a MySqlConnection. |
MySqlRowUpdatedEventHandler | Represents the method that will handle the RowUpdatedevent of a MySqlDataAdapter . |
MySqlRowUpdatingEventHandler | Represents the method that will handle the RowUpdatingevent of a MySqlDataAdapter . |
Enumerations
Enumeration | Description |
---|---|
MySqlDbType | Specifies MySQL specific data type of a field, property, for use in a MySqlParameter . |
MySqlErrorCode |
For a list of all members of this type, see MySqlCommand Members .
Syntax: Visual Basic
NotInheritable Public Class MySqlCommand_ Inherits Component_ Implements IDbCommand, ICloneable
Syntax: C#
public sealed class MySqlCommand : Component, IDbCommand, ICloneable
Thread Safety
Public static (Shared in Visual Basic) members of this type are safe for multithreaded operations. Instance members are not guaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlCommand Members, MySql.Data.MySqlClient Namespace
MySqlCommand
ConstructorMySqlCommand.Cancel
MethodMySqlCommand.CreateParameter
MethodMySqlCommand.ExecuteNonQuery
MethodMySqlCommand.ExecuteScalar
MethodMySqlCommand.Prepare
MethodPublic Instance Constructors
MySqlCommand | Overloaded. Initializes a new instance of the MySqlCommand class. |
Public Instance Properties
CommandText | |
CommandTimeout | |
CommandType | |
Connection | |
Container(inherited from Component) | Gets the IContainerthat contains the Component. |
IsPrepared | |
Parameters | |
Site(inherited from Component) | Gets or sets the ISiteof the Component. |
Transaction | |
UpdatedRowSource |
Public Instance Methods
Cancel | Attempts to cancel the execution of a MySqlCommand. This operation is not supported. |
CreateObjRef(inherited from MarshalByRefObject) | Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. |
CreateParameter | Creates a new instance of a MySqlParameter object. |
Dispose(inherited from Component) | Releases all resources used by the Component. |
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
ExecuteNonQuery | |
ExecuteReader | Overloaded. |
ExecuteScalar | |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetLifetimeService(inherited from MarshalByRefObject) | Retrieves the current lifetime service object that controls the lifetime policy for this instance. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
InitializeLifetimeService(inherited from MarshalByRefObject) | Obtains a lifetime service object to control the lifetime policy for this instance. |
Prepare | |
ToString(inherited from Component) | Returns a Stringcontaining the name of the Component, if any. This method should not be overridden. |
Public Instance Events
Disposed(inherited from Component) | Adds an event handler to listen to the Disposedevent on the component. |
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlCommand class.
Overload List
Initializes a new instance of the MySqlCommand class.
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlCommand class.
Syntax: Visual Basic
Overloads Public Sub New()
Syntax: C#
public MySqlCommand();
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace, MySqlCommand Constructor Overload List
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal cmdText As String _ )
Syntax: C#
public MySqlCommand( stringcmdText );
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace, MySqlCommand Constructor Overload List
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal cmdText As String, _ ByVal connection As MySqlConnection _ )
Syntax: C#
public MySqlCommand( stringcmdText, MySqlConnectionconnection );
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace, MySqlCommand Constructor Overload List
For a list of all members of this type, see MySqlConnection Members .
Syntax: Visual Basic
NotInheritable Public Class MySqlConnection_ Inherits Component_ Implements IDbConnection, ICloneable
Syntax: C#
public sealed class MySqlConnection : Component, IDbConnection, ICloneable
Thread Safety
Public static (Shared in Visual Basic) members of this type are safe for multithreaded operations. Instance members are not guaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlConnection Members, MySql.Data.MySqlClient Namespace
Public Instance Constructors
MySqlConnection | Overloaded. Initializes a new instance of the MySqlConnection class. |
Public Instance Properties
ConnectionString | |
ConnectionTimeout | |
Container(inherited from Component) | Gets the IContainerthat contains the Component. |
Database | |
DataSource | Gets the name of the MySQL server to which to connect. |
ServerThread | Returns the id of the server thread this connection is executing on |
ServerVersion | |
Site(inherited from Component) | Gets or sets the ISiteof the Component. |
State | |
UseCompression | Indicates if this connection should use compression when communicating with the server. |
Public Instance Methods
BeginTransaction | Overloaded. |
ChangeDatabase | |
Close | |
CreateCommand | |
CreateObjRef(inherited from MarshalByRefObject) | Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. |
Dispose(inherited from Component) | Releases all resources used by the Component. |
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetLifetimeService(inherited from MarshalByRefObject) | Retrieves the current lifetime service object that controls the lifetime policy for this instance. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
InitializeLifetimeService(inherited from MarshalByRefObject) | Obtains a lifetime service object to control the lifetime policy for this instance. |
Open | |
Ping | Ping |
ToString(inherited from Component) | Returns a Stringcontaining the name of the Component, if any. This method should not be overridden. |
Public Instance Events
Disposed(inherited from Component) | Adds an event handler to listen to the Disposedevent on the component. |
InfoMessage | |
StateChange |
See Also
MySqlConnection Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlConnection class.
Overload List
Initializes a new instance of the MySqlConnection class.
See Also
MySqlConnection Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlConnection class.
Syntax: Visual Basic
Overloads Public Sub New()
Syntax: C#
public MySqlConnection();
See Also
MySqlConnection Class, MySql.Data.MySqlClient Namespace, MySqlConnection Constructor Overload List
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal connectionString As String _ )
Syntax: C#
public MySqlConnection( stringconnectionString );
See Also
MySqlConnection Class, MySql.Data.MySqlClient Namespace, MySqlConnection Constructor Overload List
Syntax: Visual Basic
NotOverridable Public Property ConnectionString As String _ _ Implements IDbConnection.ConnectionString
Syntax: C#
public string ConnectionString {get; set;}
Implements
IDbConnection.ConnectionString
See Also
Syntax: Visual Basic
NotOverridable Public ReadOnly Property ConnectionTimeout As Integer _ _ Implements IDbConnection.ConnectionTimeout
Syntax: C#
public int ConnectionTimeout {get;}
Implements
IDbConnection.ConnectionTimeout
See Also
Syntax: Visual Basic
NotOverridable Public ReadOnly Property Database As String _ _ Implements IDbConnection.Database
Syntax: C#
public string Database {get;}
Implements
IDbConnection.Database
See Also
Gets the name of the MySQL server to which to connect.
Syntax: Visual Basic
Public ReadOnly Property DataSource As String
Syntax: C#
public string DataSource {get;}
See Also
Returns the id of the server thread this connection is executing on
Syntax: Visual Basic
Public ReadOnly Property ServerThread As Integer
Syntax: C#
public int ServerThread {get;}
See Also
Syntax: Visual Basic
Public ReadOnly Property ServerVersion As String
Syntax: C#
public string ServerVersion {get;}
See Also
Syntax: Visual Basic
NotOverridable Public ReadOnly Property State As ConnectionState _ _ Implements IDbConnection.State
Syntax: C#
public System.Data.ConnectionState State {get;}
Implements
IDbConnection.State
See Also
Indicates if this connection should use compression when communicating with the server.
Syntax: Visual Basic
Public ReadOnly Property UseCompression As Boolean
Syntax: C#
public bool UseCompression {get;}
See Also
Overload List
See Also
MySqlConnection Class, MySql.Data.MySqlClient Namespace
Syntax: Visual Basic
Overloads Public Function BeginTransaction() As MySqlTransaction
Syntax: C#
public MySqlTransaction BeginTransaction();
See Also
MySqlConnection Class, MySql.Data.MySqlClient Namespace, MySqlConnection.BeginTransaction Overload List
For a list of all members of this type, see MySqlTransaction Members .
Syntax: Visual Basic
NotInheritable Public Class MySqlTransaction_ Implements IDbTransaction, IDisposable
Syntax: C#
public sealed class MySqlTransaction : IDbTransaction, IDisposable
Thread Safety
Public static (Sharedin Visual Basic) members of this type are safe for multithreaded operations. Instance members are notguaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlTransaction Members, MySql.Data.MySqlClient Namespace
Public Instance Properties
Connection | Gets the MySqlConnection object associated with the transaction, or a null reference (Nothing in Visual Basic) if the transaction is no longer valid. |
IsolationLevel | Specifies the IsolationLevelfor this transaction. |
Public Instance Methods
Commit | |
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
Rollback | |
ToString(inherited from Object) | Returns a Stringthat represents the current Object. |
See Also
MySqlTransaction Class, MySql.Data.MySqlClient Namespace
Gets the MySqlConnection object associated with the transaction, or a null reference (Nothing in Visual Basic) if the transaction is no longer valid.
Syntax: Visual Basic
Public ReadOnly Property Connection As MySqlConnection
Syntax: C#
public MySqlConnection Connection {get;}
Property Value
The MySqlConnection object associated with this transaction.
Remarks
A single application may have multiple database connections, each with zero or more transactions. This property enables you to determine the connection object associated with a particular transaction created by BeginTransaction .
See Also
Specifies the IsolationLevelfor this transaction.
Syntax: Visual Basic
NotOverridable Public ReadOnly Property IsolationLevel As IsolationLevel _ _ Implements IDbTransaction.IsolationLevel
Syntax: C#
public System.Data.IsolationLevel IsolationLevel {get;}
Property Value
The IsolationLevel for this transaction. The default is ReadCommitted.
Implements
IDbTransaction.IsolationLevel
Remarks
Parallel transactions are not supported. Therefore, the IsolationLevel applies to the entire transaction.
See Also
Syntax: Visual Basic
NotOverridable Public Sub Commit() _ _ Implements IDbTransaction.Commit
Syntax: C#
public void Commit();
Implements
IDbTransaction.Commit
See Also
Syntax: Visual Basic
NotOverridable Public Sub Rollback() _ _ Implements IDbTransaction.Rollback
Syntax: C#
public void Rollback();
Implements
IDbTransaction.Rollback
See Also
Syntax: Visual Basic
Overloads Public Function BeginTransaction( _ ByVal iso As IsolationLevel _ ) As MySqlTransaction
Syntax: C#
public MySqlTransaction BeginTransaction( IsolationLeveliso );
See Also
MySqlConnection Class, MySql.Data.MySqlClient Namespace, MySqlConnection.BeginTransaction Overload List
Syntax: Visual Basic
NotOverridable Public Sub ChangeDatabase( _ ByVal databaseName As String _ ) _ _ Implements IDbConnection.ChangeDatabase
Syntax: C#
public void ChangeDatabase( stringdatabaseName );
Implements
IDbConnection.ChangeDatabase
See Also
Syntax: Visual Basic
NotOverridable Public Sub Close() _ _ Implements IDbConnection.Close
Syntax: C#
public void Close();
Implements
IDbConnection.Close
See Also
Syntax: Visual Basic
Public Function CreateCommand() As MySqlCommand
Syntax: C#
public MySqlCommand CreateCommand();
See Also
Syntax: Visual Basic
NotOverridable Public Sub Open() _ _ Implements IDbConnection.Open
Syntax: C#
public void Open();
Implements
IDbConnection.Open
See Also
Ping
Syntax: Visual Basic
Public Function Ping() As Boolean
Syntax: C#
public bool Ping();
Return Value
See Also
Syntax: Visual Basic
Public Event InfoMessage As MySqlInfoMessageEventHandler
Syntax: C#
public event MySqlInfoMessageEventHandler InfoMessage;
See Also
MySqlConnection Class, MySql.Data.MySqlClient Namespace
Represents the method that will handle the InfoMessage event of a MySqlConnection .
Syntax: Visual Basic
Public Delegate Sub MySqlInfoMessageEventHandler( _ ByVal sender As Object, _ ByVal args As MySqlInfoMessageEventArgs _ )
Syntax: C#
public delegate void MySqlInfoMessageEventHandler( objectsender, MySqlInfoMessageEventArgsargs );
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySql.Data.MySqlClient Namespace
Provides data for the InfoMessage event. This class cannot be inherited.
For a list of all members of this type, see MySqlInfoMessageEventArgs Members .
Syntax: Visual Basic
Public Class MySqlInfoMessageEventArgs_ Inherits EventArgs
Syntax: C#
public class MySqlInfoMessageEventArgs : EventArgs
Thread Safety
Public static (Sharedin Visual Basic) members of this type are safe for multithreaded operations. Instance members are notguaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlInfoMessageEventArgs Members, MySql.Data.MySqlClient Namespace
MySqlInfoMessageEventArgs overview
Public Instance Constructors
MySqlInfoMessageEventArgs Constructor | Initializes a new instance of the MySqlInfoMessageEventArgs class. |
Public Instance Fields
Public Instance Methods
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
ToString(inherited from Object) | Returns a Stringthat represents the current Object. |
Protected Instance Methods
Finalize(inherited from Object) | Allows an Objectto attempt to free resources and perform other cleanup operations before the Objectis reclaimed by garbage collection. |
MemberwiseClone(inherited from Object) | Creates a shallow copy of the current Object. |
See Also
MySqlInfoMessageEventArgs Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlInfoMessageEventArgs class.
Syntax: Visual Basic
Public Sub New()
Syntax: C#
public MySqlInfoMessageEventArgs();
See Also
MySqlInfoMessageEventArgs Class, MySql.Data.MySqlClient Namespace
Syntax: Visual Basic
Public errors As MySqlError()
Syntax: C#
public MySqlError[] errors;
See Also
MySqlInfoMessageEventArgs Class, MySql.Data.MySqlClient Namespace
Collection of error codes that can be returned by the server
For a list of all members of this type, see MySqlError Members .
Syntax: Visual Basic
Public Class MySqlError
Syntax: C#
public class MySqlError
Thread Safety
Public static (Shared in Visual Basic) members of this type are safe for multithreaded operations. Instance members are not guaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlError Members, MySql.Data.MySqlClient Namespace
Public Instance Constructors
Public Instance Properties
Public Instance Methods
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
ToString(inherited from Object) | Returns a Stringthat represents the current Object. |
Protected Instance Methods
Finalize(inherited from Object) | Allows an Objectto attempt to free resources and perform other cleanup operations before the Objectis reclaimed by garbage collection. |
MemberwiseClone(inherited from Object) | Creates a shallow copy of the current Object. |
See Also
MySqlError Class, MySql.Data.MySqlClient Namespace
Syntax: Visual Basic
Public Sub New( _ ByVal level As String, _ ByVal code As Integer, _ ByVal message As String _ )
Syntax: C#
public MySqlError( stringlevel, intcode, stringmessage );
Parameters
level
:
code
:
message
:
See Also
Error code
Syntax: Visual Basic
Public ReadOnly Property Code As Integer
Syntax: C#
public int Code {get;}
See Also
Error level
Syntax: Visual Basic
Public ReadOnly Property Level As String
Syntax: C#
public string Level {get;}
See Also
Error message
Syntax: Visual Basic
Public ReadOnly Property Message As String
Syntax: C#
public string Message {get;}
See Also
Syntax: Visual Basic
Public Event StateChange As StateChangeEventHandler
Syntax: C#
public event StateChangeEventHandler StateChange;
See Also
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal cmdText As String, _ ByVal connection As MySqlConnection, _ ByVal transaction As MySqlTransaction _ )
Syntax: C#
public MySqlCommand( stringcmdText, MySqlConnectionconnection, MySqlTransactiontransaction );
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace, MySqlCommand Constructor Overload List
Syntax: Visual Basic
NotOverridable Public Property CommandText As String _ _ Implements IDbCommand.CommandText
Syntax: C#
public string CommandText {get; set;}
Implements
IDbCommand.CommandText
See Also
Syntax: Visual Basic
NotOverridable Public Property CommandTimeout As Integer _ _ Implements IDbCommand.CommandTimeout
Syntax: C#
public int CommandTimeout {get; set;}
Implements
IDbCommand.CommandTimeout
See Also
Syntax: Visual Basic
NotOverridable Public Property CommandType As CommandType _ _ Implements IDbCommand.CommandType
Syntax: C#
public System.Data.CommandType CommandType {get; set;}
Implements
IDbCommand.CommandType
See Also
Syntax: Visual Basic
Public Property Connection As MySqlConnection
Syntax: C#
public MySqlConnection Connection {get; set;}
See Also
Syntax: Visual Basic
Public ReadOnly Property IsPrepared As Boolean
Syntax: C#
public bool IsPrepared {get;}
See Also
Syntax: Visual Basic
Public ReadOnly Property Parameters As MySqlParameterCollection
Syntax: C#
public MySqlParameterCollection Parameters {get;}
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace
Represents a collection of parameters relevant to a MySqlCommand as well as their respective mappings to columns in a DataSet. This class cannot be inherited.
For a list of all members of this type, see MySqlParameterCollection Members .
Syntax: Visual Basic
NotInheritable Public Class MySqlParameterCollection_ Inherits MarshalByRefObject_ Implements IDataParameterCollection, IList, ICollection, IEnumerable
Syntax: C#
public sealed class MySqlParameterCollection : MarshalByRefObject, IDataParameterCollection, IList, ICollection, IEnumerable
Thread Safety
Public static (Shared in Visual Basic) members of this type are safe for multithreaded operations. Instance members are not guaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlParameterCollection Members, MySql.Data.MySqlClient Namespace
MySqlParameterCollection
ConstructorMySqlParameterCollection.Clear
MethodMySqlParameterCollection.CopyTo
MethodMySqlParameterCollection.Insert
MethodMySqlParameterCollection.Remove
MethodMySqlParameterCollection overview
Public Instance Constructors
MySqlParameterCollection Constructor | Initializes a new instance of the MySqlParameterCollection class. |
Public Instance Properties
Count | Gets the number of MySqlParameter objects in the collection. |
Item | Overloaded. Gets the MySqlParameter with a specified attribute. In C#, this property is the indexer for the MySqlParameterCollection class. |
Public Instance Methods
Add | Overloaded. Adds the specified MySqlParameter object to the MySqlParameterCollection . |
Clear | Removes all items from the collection. |
Contains | Overloaded. Gets a value indicating whether a MySqlParameter exists in the collection. |
CopyTo | Copies MySqlParameter objects from the MySqlParameterCollection to the specified array. |
CreateObjRef(inherited from MarshalByRefObject) | Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. |
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetLifetimeService(inherited from MarshalByRefObject) | Retrieves the current lifetime service object that controls the lifetime policy for this instance. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
IndexOf | Overloaded. Gets the location of a MySqlParameter in the collection. |
InitializeLifetimeService(inherited from MarshalByRefObject) | Obtains a lifetime service object to control the lifetime policy for this instance. |
Insert | Inserts a MySqlParameter into the collection at the specified index. |
Remove | Removes the specified MySqlParameter from the collection. |
RemoveAt | Overloaded. Removes the specified MySqlParameter from the collection. |
ToString(inherited from Object) | Returns a Stringthat represents the current Object. |
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlParameterCollection class.
Syntax: Visual Basic
Public Sub New()
Syntax: C#
public MySqlParameterCollection();
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Gets the number of MySqlParameter objects in the collection.
Syntax: Visual Basic
NotOverridable Public ReadOnly Property Count As Integer _ _ Implements ICollection.Count
Syntax: C#
public int Count {get;}
Implements
ICollection.Count
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Gets the MySqlParameter with a specified attribute. In C#, this property is the indexer for the MySqlParameterCollection class.
Overload List
Gets the MySqlParameter at the specified index.
Gets the MySqlParameter with the specified name.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Represents a parameter to a MySqlCommand , and optionally, its mapping to DataSetcolumns. This class cannot be inherited.
For a list of all members of this type, see MySqlParameter Members .
Syntax: Visual Basic
NotInheritable Public Class MySqlParameter_ Inherits MarshalByRefObject_ Implements IDataParameter, IDbDataParameter, ICloneable
Syntax: C#
public sealed class MySqlParameter : MarshalByRefObject, IDataParameter, IDbDataParameter, ICloneable
Thread Safety
Public static (Shared in Visual Basic) members of this type are safe for multithreaded operations. Instance members are not guaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlParameter Members, MySql.Data.MySqlClient Namespace
Public Instance Constructors
MySqlParameter | Overloaded. Initializes a new instance of the MySqlParameter class. |
Public Instance Properties
DbType | Gets or sets the DbTypeof the parameter. |
Direction | 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. |
IsNullable | Gets or sets a value indicating whether the parameter accepts null values. |
IsUnsigned | |
MySqlDbType | Gets or sets the MySqlDbType of the parameter. |
ParameterName | Gets or sets the name of the MySqlParameter. |
Precision | Gets or sets the maximum number of digits used to represent the Value property. |
Scale | Gets or sets the number of decimal places to which Value is resolved. |
Size | Gets or sets the maximum size, in bytes, of the data within the column. |
SourceColumn | Gets or sets the name of the source column that is mapped to the DataSetand used for loading or returning the Value . |
SourceVersion | Gets or sets the DataRowVersionto use when loading Value . |
Value | Gets or sets the value of the parameter. |
Public Instance Methods
CreateObjRef(inherited from MarshalByRefObject) | Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. |
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetLifetimeService(inherited from MarshalByRefObject) | Retrieves the current lifetime service object that controls the lifetime policy for this instance. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
InitializeLifetimeService(inherited from MarshalByRefObject) | Obtains a lifetime service object to control the lifetime policy for this instance. |
ToString | Overridden. Gets a string containing the ParameterName . |
See Also
MySqlParameter Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlParameter class.
Overload List
Initializes a new instance of the MySqlParameter class.
Initializes a new instance of the MySqlParameter class with the parameter name and the data type.
Initializes a new instance of the MySqlParameter class with the parameter name, the MySqlDbType , and the size.
Initializes a new instance of the MySqlParameter class with the parameter name, the type of the parameter, the size of the parameter, a ParameterDirection, the precision of the parameter, the scale of the parameter, the source column, a DataRowVersionto use, and the value of the parameter.
Initializes a new instance of the MySqlParameter class with the parameter name, the MySqlDbType , the size, and the source column name.
Initializes a new instance of the MySqlParameter class with the parameter name and a value of the new MySqlParameter.
See Also
MySqlParameter Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlParameter class.
Syntax: Visual Basic
Overloads Public Sub New()
Syntax: C#
public MySqlParameter();
See Also
MySqlParameter Class, MySql.Data.MySqlClient Namespace, MySqlParameter Constructor Overload List
Initializes a new instance of the MySqlParameter class with the parameter name and the data type.
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal parameterName As String, _ ByVal dbType As MySqlDbType _ )
Syntax: C#
public MySqlParameter( stringparameterName, MySqlDbTypedbType );
Parameters
parameterName
: The name
of the parameter to map.
dbType
: One of the
MySqlDbType
values.
See Also
MySqlParameter Class, MySql.Data.MySqlClient Namespace, MySqlParameter Constructor Overload List
Specifies MySQL specific data type of a field, property, for use in a MySqlParameter .
Syntax: Visual Basic
Public Enum MySqlDbType
Syntax: C#
public enum MySqlDbType
Members
Member Name | Description |
Newdate | Obsolete. Use Datetime or Date type. |
Timestamp | A timestamp. The range is '1970-01-01 00:00:01' to sometime in the year 2038. |
Time | The range is '-838:59:59' to '838:59:59' |
Date | Date The supported range is '1000-01-01' to '9999-12-31' |
Datetime | The supported range is '1000-01-01 00:00:00' to '9999-12-31 23:59:59' |
Year | A year in 2- or 4-digit format (default is 4-digit). The allowable values are 1901 to 2155, 0000 in the 4-digit year format, and 1970-2069 if you use the 2-digit format (70-69). |
TinyBlob | A BLOB column with a maximum length of 255 (2^8 - 1) characters |
Blob | A BLOB column with a maximum length of 65535 (2^16 - 1) characters |
MediumBlob | A BLOB column with a maximum length of 16777215 (2^24 - 1) characters |
LongBlob | A BLOB column with a maximum length of 4294967295 or 4G (2^32 - 1) characters |
Int16 | A 16-bit signed integer. The signed range is -32768 to 32767. The unsigned range is 0 to 65535 |
Int24 | Specifies a 24 (3 byte) signed or unsigned value |
Int32 | A 32-bit signed integer |
Int64 | A 64-bit signed integer |
Byte | The signed range is -128 to 127. The unsigned range is 0 to 255. |
Float | A small (single-precision) floating-point number. Allowable values are -3.402823466E+38 to -1.175494351E-38, 0, and 1.175494351E-38 to 3.402823466E+38. |
Double | A normal-size (double-precision) floating-point number. Allowable values are -1.7976931348623157E+308 to -2.2250738585072014E-308, 0, and 2.2250738585072014E-308 to 1.7976931348623157E+308. |
UByte | An 8-bit unsigned value |
UInt16 | A 16-bit unsigned value |
UInt24 | A 24-bit unsigned value |
UInt32 | A 32-bit unsigned value |
UInt64 | A 64-bit unsigned value |
Decimal | A fixed precision and scale numeric value between -1038 -1 and 10 38 -1 |
NewDecimal | New Decimal |
Set | A set. A string object that can have zero or more values, each of which must be chosen from the list of values 'value1', 'value2', ... A SET can have a maximum of 64 members. |
String | Obsolete Use VarChar type |
VarChar | A variable-length string containing 0 to 255 characters |
VarString | A variable-length string containing 0 to 65535 characters |
Enum | An enumeration. A string object that can have only one value, chosen from the list of values 'value1', 'value2', ..., NULL or the special "" error value. An ENUM can have a maximum of 65535 distinct values. |
Geometry | |
Bit | Bit-field data type |
TinyText | A nonbinary string column supporting a maximum length of 255 (2^8 - 1) characters |
Text | A nonbinary string column supporting a maximum length of 65535 (2^16 - 1) characters |
MediumText | A nonbinary string column supporting a maximum length of 16777215 (2^24 - 1) characters |
LongText | A nonbinary string column supporting a maximum length of 4294967295 (2^32 - 1) characters |
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
Initializes a new instance of the MySqlParameter class with the parameter name, the MySqlDbType , and the size.
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal parameterName As String, _ ByVal dbType As MySqlDbType, _ ByVal size As Integer _ )
Syntax: C#
public MySqlParameter( stringparameterName, MySqlDbTypedbType, intsize );
Parameters
parameterName
: The name
of the parameter to map.
dbType
: One of the
MySqlDbType
values.
size
: The length of the
parameter.
See Also
MySqlParameter Class, MySql.Data.MySqlClient Namespace, MySqlParameter Constructor Overload List
Initializes a new instance of the MySqlParameter class with the parameter name, the type of the parameter, the size of the parameter, a ParameterDirection, the precision of the parameter, the scale of the parameter, the source column, a DataRowVersionto use, and the value of the parameter.
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal parameterName As String, _ ByVal dbType As MySqlDbType, _ ByVal size As Integer, _ ByVal direction As ParameterDirection, _ ByVal isNullable As Boolean, _ ByVal precision As Byte, _ ByVal scale As Byte, _ ByVal sourceColumn As String, _ ByVal sourceVersion As DataRowVersion, _ ByVal value As Object _ )
Syntax: C#
public MySqlParameter( stringparameterName, MySqlDbTypedbType, intsize, ParameterDirectiondirection, boolisNullable, byteprecision, bytescale, stringsourceColumn, DataRowVersionsourceVersion, objectvalue );
Parameters
parameterName
: The name
of the parameter to map.
dbType
: One of the
MySqlDbType
values.
size
: The length of the
parameter.
direction
: One of the
ParameterDirectionvalues.
isNullable
: true if the
value of the field can be null, otherwise
false.
precision
: The total
number of digits to the left and right of
the decimal point to which
Value
is resolved.
scale
: The total number
of decimal places to which
Value
is resolved.
sourceColumn
: The name
of the source column.
sourceVersion
: One of
the DataRowVersionvalues.
value
: An Objectthat is
the value of the
MySqlParameter
.
Exceptions
Exception Type | Condition |
ArgumentException |
See Also
MySqlParameter Class, MySql.Data.MySqlClient Namespace, MySqlParameter Constructor Overload List
Gets or sets the value of the parameter.
Syntax: Visual Basic
NotOverridable Public Property Value As Object _ _ Implements IDataParameter.Value
Syntax: C#
public object Value {get; set;}
Implements
IDataParameter.Value
See Also
Initializes a new instance of the MySqlParameter class with the parameter name, the MySqlDbType , the size, and the source column name.
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal parameterName As String, _ ByVal dbType As MySqlDbType, _ ByVal size As Integer, _ ByVal sourceColumn As String _ )
Syntax: C#
public MySqlParameter( stringparameterName, MySqlDbTypedbType, intsize, stringsourceColumn );
Parameters
parameterName
: The name
of the parameter to map.
dbType
: One of the
MySqlDbType
values.
size
: The length of the
parameter.
sourceColumn
: The name
of the source column.
See Also
MySqlParameter Class, MySql.Data.MySqlClient Namespace, MySqlParameter Constructor Overload List
Initializes a new instance of the MySqlParameter class with the parameter name and a value of the new MySqlParameter.
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal parameterName As String, _ ByVal value As Object _ )
Syntax: C#
public MySqlParameter( stringparameterName, objectvalue );
Parameters
parameterName
: The name
of the parameter to map.
value
: An Objectthat is
the value of the
MySqlParameter
.
See Also
MySqlParameter Class, MySql.Data.MySqlClient Namespace, MySqlParameter Constructor Overload List
Gets or sets the DbTypeof the parameter.
Syntax: Visual Basic
NotOverridable Public Property DbType As DbType _ _ Implements IDataParameter.DbType
Syntax: C#
public System.Data.DbType DbType {get; set;}
Implements
IDataParameter.DbType
See Also
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.
Syntax: Visual Basic
NotOverridable Public Property Direction As ParameterDirection _ _ Implements IDataParameter.Direction
Syntax: C#
public System.Data.ParameterDirection Direction {get; set;}
Implements
IDataParameter.Direction
See Also
Gets or sets a value indicating whether the parameter accepts null values.
Syntax: Visual Basic
NotOverridable Public Property IsNullable As Boolean _ _ Implements IDataParameter.IsNullable
Syntax: C#
public bool IsNullable {get; set;}
Implements
IDataParameter.IsNullable
See Also
Syntax: Visual Basic
Public Property IsUnsigned As Boolean
Syntax: C#
public bool IsUnsigned {get; set;}
See Also
Gets or sets the MySqlDbType of the parameter.
Syntax: Visual Basic
Public Property MySqlDbType As MySqlDbType
Syntax: C#
public MySqlDbType MySqlDbType {get; set;}
See Also
Gets or sets the name of the MySqlParameter.
Syntax: Visual Basic
NotOverridable Public Property ParameterName As String _ _ Implements IDataParameter.ParameterName
Syntax: C#
public string ParameterName {get; set;}
Implements
IDataParameter.ParameterName
See Also
Gets or sets the maximum number of digits used to represent the Value property.
Syntax: Visual Basic
NotOverridable Public Property Precision As Byte _ _ Implements IDbDataParameter.Precision
Syntax: C#
public byte Precision {get; set;}
Implements
IDbDataParameter.Precision
See Also
Gets or sets the number of decimal places to which Value is resolved.
Syntax: Visual Basic
NotOverridable Public Property Scale As Byte _ _ Implements IDbDataParameter.Scale
Syntax: C#
public byte Scale {get; set;}
Implements
IDbDataParameter.Scale
See Also
Gets or sets the maximum size, in bytes, of the data within the column.
Syntax: Visual Basic
NotOverridable Public Property Size As Integer _ _ Implements IDbDataParameter.Size
Syntax: C#
public int Size {get; set;}
Implements
IDbDataParameter.Size
See Also
Gets or sets the name of the source column that is mapped to the DataSetand used for loading or returning the Value .
Syntax: Visual Basic
NotOverridable Public Property SourceColumn As String _ _ Implements IDataParameter.SourceColumn
Syntax: C#
public string SourceColumn {get; set;}
Implements
IDataParameter.SourceColumn
See Also
Gets or sets the DataRowVersionto use when loading Value .
Syntax: Visual Basic
NotOverridable Public Property SourceVersion As DataRowVersion _ _ Implements IDataParameter.SourceVersion
Syntax: C#
public System.Data.DataRowVersion SourceVersion {get; set;}
Implements
IDataParameter.SourceVersion
See Also
Overridden. Gets a string containing the ParameterName .
Syntax: Visual Basic
Overrides Public Function ToString() As String
Syntax: C#
public override string ToString();
Return Value
See Also
Gets the MySqlParameter at the specified index.
Syntax: Visual Basic
Overloads Public Default Property Item( _ ByVal index As Integer _ ) As MySqlParameter
Syntax: C#
public MySqlParameter this[ intindex ] {get; set;}
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Item Overload List
Gets the MySqlParameter with the specified name.
Syntax: Visual Basic
Overloads Public Default Property Item( _ ByVal name As String _ ) As MySqlParameter
Syntax: C#
public MySqlParameter this[ stringname ] {get; set;}
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Item Overload List
Adds the specified MySqlParameter object to the MySqlParameterCollection .
Overload List
Adds the specified MySqlParameter object to the MySqlParameterCollection .
Adds the specified MySqlParameter object to the MySqlParameterCollection .
Adds a MySqlParameter to the MySqlParameterCollection given the parameter name and the data type.
Adds a MySqlParameter to the MySqlParameterCollection with the parameter name, the data type, and the column length.
Adds a MySqlParameter to the MySqlParameterCollection with the parameter name, the data type, the column length, and the source column name.
Adds a MySqlParameter to the MySqlParameterCollection given the specified parameter name and value.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Adds the specified MySqlParameter object to the MySqlParameterCollection .
Syntax: Visual Basic
Overloads Public Function Add( _ ByVal value As MySqlParameter _ ) As MySqlParameter
Syntax: C#
public MySqlParameter Add( MySqlParametervalue );
Parameters
value
: The
MySqlParameter
to add to the collection.
Return Value
The newly added MySqlParameter object.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Add Overload List
Adds the specified MySqlParameter object to the MySqlParameterCollection .
Syntax: Visual Basic
NotOverridable Overloads Public Function Add( _ ByVal value As Object _ ) As Integer _ _ Implements IList.Add
Syntax: C#
public int Add( objectvalue );
Parameters
value
: The
MySqlParameter
to add to the collection.
Return Value
The index of the new MySqlParameter object.
Implements
IList.Add
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Add Overload List
Adds a MySqlParameter to the MySqlParameterCollection given the parameter name and the data type.
Syntax: Visual Basic
Overloads Public Function Add( _ ByVal parameterName As String, _ ByVal dbType As MySqlDbType _ ) As MySqlParameter
Syntax: C#
public MySqlParameter Add( stringparameterName, MySqlDbTypedbType );
Parameters
parameterName
: The name of
the parameter.
dbType
: One of the
MySqlDbType
values.
Return Value
The newly added MySqlParameter object.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Add Overload List
Adds a MySqlParameter to the MySqlParameterCollection with the parameter name, the data type, and the column length.
Syntax: Visual Basic
Overloads Public Function Add( _ ByVal parameterName As String, _ ByVal dbType As MySqlDbType, _ ByVal size As Integer _ ) As MySqlParameter
Syntax: C#
public MySqlParameter Add( stringparameterName, MySqlDbTypedbType, intsize );
Parameters
parameterName
: The name of
the parameter.
dbType
: One of the
MySqlDbType
values.
size
: The length of the
column.
Return Value
The newly added MySqlParameter object.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Add Overload List
Adds a MySqlParameter to the MySqlParameterCollection with the parameter name, the data type, the column length, and the source column name.
Syntax: Visual Basic
Overloads Public Function Add( _ ByVal parameterName As String, _ ByVal dbType As MySqlDbType, _ ByVal size As Integer, _ ByVal sourceColumn As String _ ) As MySqlParameter
Syntax: C#
public MySqlParameter Add( stringparameterName, MySqlDbTypedbType, intsize, stringsourceColumn );
Parameters
parameterName
: The name of
the parameter.
dbType
: One of the
MySqlDbType
values.
size
: The length of the
column.
sourceColumn
: The name of the
source column.
Return Value
The newly added MySqlParameter object.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Add Overload List
Adds a MySqlParameter to the MySqlParameterCollection given the specified parameter name and value.
Syntax: Visual Basic
Overloads Public Function Add( _ ByVal parameterName As String, _ ByVal value As Object _ ) As MySqlParameter
Syntax: C#
public MySqlParameter Add( stringparameterName, objectvalue );
Parameters
parameterName
: The name of
the parameter.
value
: The
Value
of the
MySqlParameter
to add to the collection.
Return Value
The newly added MySqlParameter object.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Add Overload List
Removes all items from the collection.
Syntax: Visual Basic
NotOverridable Public Sub Clear() _ _ Implements IList.Clear
Syntax: C#
public void Clear();
Implements
IList.Clear
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Gets a value indicating whether a MySqlParameter exists in the collection.
Overload List
Gets a value indicating whether a MySqlParameter exists in the collection.
Gets a value indicating whether a MySqlParameter with the specified parameter name exists in the collection.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Gets a value indicating whether a MySqlParameter exists in the collection.
Syntax: Visual Basic
NotOverridable Overloads Public Function Contains( _ ByVal value As Object _ ) As Boolean _ _ Implements IList.Contains
Syntax: C#
public bool Contains( objectvalue );
Parameters
value
: The value of the
MySqlParameter
object to find.
Return Value
true if the collection contains the MySqlParameter object; otherwise, false.
Implements
IList.Contains
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Contains Overload List
Gets a value indicating whether a MySqlParameter with the specified parameter name exists in the collection.
Syntax: Visual Basic
NotOverridable Overloads Public Function Contains( _ ByVal name As String _ ) As Boolean _ _ Implements IDataParameterCollection.Contains
Syntax: C#
public bool Contains( stringname );
Parameters
name
: The name of the
MySqlParameter
object to find.
Return Value
true if the collection contains the parameter; otherwise, false.
Implements
IDataParameterCollection.Contains
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.Contains Overload List
Copies MySqlParameter objects from the MySqlParameterCollection to the specified array.
Syntax: Visual Basic
NotOverridable Public Sub CopyTo( _ ByVal array As Array, _ ByVal index As Integer _ ) _ _ Implements ICollection.CopyTo
Syntax: C#
public void CopyTo( Arrayarray, intindex );
Parameters
array
:
Implements
ICollection.CopyTo
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Gets the location of a MySqlParameter in the collection.
Overload List
Gets the location of a MySqlParameter in the collection.
Gets the location of the MySqlParameter in the collection with a specific parameter name.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Gets the location of a MySqlParameter in the collection.
Syntax: Visual Basic
NotOverridable Overloads Public Function IndexOf( _ ByVal value As Object _ ) As Integer _ _ Implements IList.IndexOf
Syntax: C#
public int IndexOf( objectvalue );
Parameters
value
: The
MySqlParameter
object to locate.
Return Value
The zero-based location of the MySqlParameter in the collection.
Implements
IList.IndexOf
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.IndexOf Overload List
Gets the location of the MySqlParameter in the collection with a specific parameter name.
Syntax: Visual Basic
NotOverridable Overloads Public Function IndexOf( _ ByVal parameterName As String _ ) As Integer _ _ Implements IDataParameterCollection.IndexOf
Syntax: C#
public int IndexOf( stringparameterName );
Parameters
parameterName
: The name of
the
MySqlParameter
object to retrieve.
Return Value
The zero-based location of the MySqlParameter in the collection.
Implements
IDataParameterCollection.IndexOf
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.IndexOf Overload List
Inserts a MySqlParameter into the collection at the specified index.
Syntax: Visual Basic
NotOverridable Public Sub Insert( _ ByVal index As Integer, _ ByVal value As Object _ ) _ _ Implements IList.Insert
Syntax: C#
public void Insert( intindex, objectvalue );
Parameters
value
:
Implements
IList.Insert
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Removes the specified MySqlParameter from the collection.
Syntax: Visual Basic
NotOverridable Public Sub Remove( _ ByVal value As Object _ ) _ _ Implements IList.Remove
Syntax: C#
public void Remove( objectvalue );
Parameters
value
:
Implements
IList.Remove
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Removes the specified MySqlParameter from the collection.
Overload List
Removes the specified MySqlParameter from the collection using a specific index.
Removes the specified MySqlParameter from the collection using the parameter name.
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace
Removes the specified MySqlParameter from the collection using a specific index.
Syntax: Visual Basic
NotOverridable Overloads Public Sub RemoveAt( _ ByVal index As Integer _ ) _ _ Implements IList.RemoveAt
Syntax: C#
public void RemoveAt( intindex );
Parameters
index
: The
zero-based index of the parameter.
Implements
IList.RemoveAt
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.RemoveAt Overload List
Removes the specified MySqlParameter from the collection using the parameter name.
Syntax: Visual Basic
NotOverridable Overloads Public Sub RemoveAt( _ ByVal name As String _ ) _ _ Implements IDataParameterCollection.RemoveAt
Syntax: C#
public void RemoveAt( stringname );
Parameters
name
: The name of the
MySqlParameter
object to retrieve.
Implements
IDataParameterCollection.RemoveAt
See Also
MySqlParameterCollection Class, MySql.Data.MySqlClient Namespace, MySqlParameterCollection.RemoveAt Overload List
Syntax: Visual Basic
Public Property Transaction As MySqlTransaction
Syntax: C#
public MySqlTransaction Transaction {get; set;}
See Also
Syntax: Visual Basic
NotOverridable Public Property UpdatedRowSource As UpdateRowSource _ _ Implements IDbCommand.UpdatedRowSource
Syntax: C#
public System.Data.UpdateRowSource UpdatedRowSource {get; set;}
Implements
IDbCommand.UpdatedRowSource
See Also
Attempts to cancel the execution of a MySqlCommand. This operation is not supported.
Syntax: Visual Basic
NotOverridable Public Sub Cancel() _ _ Implements IDbCommand.Cancel
Syntax: C#
public void Cancel();
Implements
IDbCommand.Cancel
Remarks
Cancelling an executing command is currently not supported on any version of MySQL.
Exceptions
Exception Type | Condition |
NotSupportedException | This operation is not supported. |
See Also
Creates a new instance of a MySqlParameter object.
Syntax: Visual Basic
Public Function CreateParameter() As MySqlParameter
Syntax: C#
public MySqlParameter CreateParameter();
Return Value
A MySqlParameter object.
Remarks
This method is a strongly-typed version of CreateParameter.
See Also
Syntax: Visual Basic
NotOverridable Public Function ExecuteNonQuery() As Integer _ _ Implements IDbCommand.ExecuteNonQuery
Syntax: C#
public int ExecuteNonQuery();
Implements
IDbCommand.ExecuteNonQuery
See Also
Overload List
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace
Syntax: Visual Basic
Overloads Public Function ExecuteReader() As MySqlDataReader
Syntax: C#
public MySqlDataReader ExecuteReader();
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace, MySqlCommand.ExecuteReader Overload List
Provides a means of reading a forward-only stream of rows from a MySQL database. This class cannot be inherited.
For a list of all members of this type, see MySqlDataReader Members .
Syntax: Visual Basic
NotInheritable Public Class MySqlDataReader_ Inherits MarshalByRefObject_ Implements IEnumerable, IDataReader, IDisposable, IDataRecord
Syntax: C#
public sealed class MySqlDataReader : MarshalByRefObject, IEnumerable, IDataReader, IDisposable, IDataRecord
Thread Safety
Public static (Shared in Visual Basic) members of this type are safe for multithreaded operations. Instance members are not guaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlDataReader Members, MySql.Data.MySqlClient Namespace
Public Instance Properties
Depth | Gets a value indicating the depth of nesting for the current row. This method is not supported currently and always returns 0. |
FieldCount | Gets the number of columns in the current row. |
HasRows | Gets a value indicating whether the MySqlDataReader contains one or more rows. |
IsClosed | Gets a value indicating whether the data reader is closed. |
Item | Overloaded. Overloaded. Gets the value of a column in its native format. In C#, this property is the indexer for the MySqlDataReader class. |
RecordsAffected | Gets the number of rows changed, inserted, or deleted by execution of the SQL statement. |
Public Instance Methods
Close | Closes the MySqlDataReader object. |
CreateObjRef(inherited from MarshalByRefObject) | Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. |
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
GetBoolean | Gets the value of the specified column as a Boolean. |
GetByte | Gets the value of the specified column as a byte. |
GetBytes | Reads a stream of bytes from the specified column offset into the buffer an array starting at the given buffer offset. |
GetChar | Gets the value of the specified column as a single character. |
GetChars | Reads a stream of characters from the specified column offset into the buffer as an array starting at the given buffer offset. |
GetDataTypeName | Gets the name of the source data type. |
GetDateTime | |
GetDecimal | |
GetDouble | |
GetFieldType | Gets the Type that is the data type of the object. |
GetFloat | |
GetGuid | |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetInt16 | |
GetInt32 | |
GetInt64 | |
GetLifetimeService(inherited from MarshalByRefObject) | Retrieves the current lifetime service object that controls the lifetime policy for this instance. |
GetMySqlDateTime | |
GetName | Gets the name of the specified column. |
GetOrdinal | Gets the column ordinal, given the name of the column. |
GetSchemaTable | Returns a DataTable that describes the column metadata of the MySqlDataReader. |
GetString | |
GetTimeSpan | |
GetType(inherited from Object) | Gets the Typeof the current instance. |
GetUInt16 | |
GetUInt32 | |
GetUInt64 | |
GetValue | Gets the value of the specified column in its native format. |
GetValues | Gets all attribute columns in the collection for the current row. |
InitializeLifetimeService(inherited from MarshalByRefObject) | Obtains a lifetime service object to control the lifetime policy for this instance. |
IsDBNull | Gets a value indicating whether the column contains non-existent or missing values. |
NextResult | Advances the data reader to the next result, when reading the results of batch SQL statements. |
Read | Advances the MySqlDataReader to the next record. |
ToString(inherited from Object) | Returns a Stringthat represents the current Object. |
See Also
MySqlDataReader Class, MySql.Data.MySqlClient Namespace
Gets a value indicating the depth of nesting for the current row. This method is not supported currently and always returns 0.
Syntax: Visual Basic
NotOverridable Public ReadOnly Property Depth As Integer _ _ Implements IDataReader.Depth
Syntax: C#
public int Depth {get;}
Implements
IDataReader.Depth
See Also
Gets the number of columns in the current row.
Syntax: Visual Basic
NotOverridable Public ReadOnly Property FieldCount As Integer _ _ Implements IDataRecord.FieldCount
Syntax: C#
public int FieldCount {get;}
Implements
IDataRecord.FieldCount
See Also
Gets a value indicating whether the MySqlDataReader contains one or more rows.
Syntax: Visual Basic
Public ReadOnly Property HasRows As Boolean
Syntax: C#
public bool HasRows {get;}
See Also
Gets a value indicating whether the data reader is closed.
Syntax: Visual Basic
NotOverridable Public ReadOnly Property IsClosed As Boolean _ _ Implements IDataReader.IsClosed
Syntax: C#
public bool IsClosed {get;}
Implements
IDataReader.IsClosed
See Also
Overloaded. Gets the value of a column in its native format. In C#, this property is the indexer for the MySqlDataReader class.
Overload List
Overloaded. Gets the value of a column in its native format. In C#, this property is the indexer for the MySqlDataReader class.
Gets the value of a column in its native format. In C#, this property is the indexer for the MySqlDataReader class.
See Also
MySqlDataReader Class, MySql.Data.MySqlClient Namespace
Overloaded. Gets the value of a column in its native format. In C#, this property is the indexer for the MySqlDataReader class.
Syntax: Visual Basic
NotOverridable Overloads Public Default ReadOnly Property Item( _ ByVal i As Integer _ ) _ _ Implements IDataRecord.Item As Object _ _ Implements IDataRecord.Item
Syntax: C#
public object this[ inti ] {get;}
Implements
IDataRecord.Item
See Also
MySqlDataReader Class, MySql.Data.MySqlClient Namespace, MySqlDataReader.Item Overload List
Gets the value of a column in its native format. In C#, this property is the indexer for the MySqlDataReader class.
Syntax: Visual Basic
NotOverridable Overloads Public Default ReadOnly Property Item( _ ByVal name As String _ ) _ _ Implements IDataRecord.Item As Object _ _ Implements IDataRecord.Item
Syntax: C#
public object this[ stringname ] {get;}
Implements
IDataRecord.Item
See Also
MySqlDataReader Class, MySql.Data.MySqlClient Namespace, MySqlDataReader.Item Overload List
Gets the number of rows changed, inserted, or deleted by execution of the SQL statement.
Syntax: Visual Basic
NotOverridable Public ReadOnly Property RecordsAffected As Integer _ _ Implements IDataReader.RecordsAffected
Syntax: C#
public int RecordsAffected {get;}
Implements
IDataReader.RecordsAffected
See Also
Closes the MySqlDataReader object.
Syntax: Visual Basic
NotOverridable Public Sub Close() _ _ Implements IDataReader.Close
Syntax: C#
public void Close();
Implements
IDataReader.Close
See Also
Gets the value of the specified column as a Boolean.
Syntax: Visual Basic
NotOverridable Public Function GetBoolean( _ ByVal i As Integer _ ) As Boolean _ _ Implements IDataRecord.GetBoolean
Syntax: C#
public bool GetBoolean( inti );
Parameters
i
:
Return Value
Implements
IDataRecord.GetBoolean
See Also
Gets the value of the specified column as a byte.
Syntax: Visual Basic
NotOverridable Public Function GetByte( _ ByVal i As Integer _ ) As Byte _ _ Implements IDataRecord.GetByte
Syntax: C#
public byte GetByte( inti );
Parameters
i
:
Return Value
Implements
IDataRecord.GetByte
See Also
Reads a stream of bytes from the specified column offset into the buffer an array starting at the given buffer offset.
Syntax: Visual Basic
NotOverridable Public Function GetBytes( _ ByVal i As Integer, _ ByVal dataIndex As Long, _ ByVal buffer As Byte(), _ ByVal bufferIndex As Integer, _ ByVal length As Integer _ ) As Long _ _ Implements IDataRecord.GetBytes
Syntax: C#
public long GetBytes( inti, longdataIndex, byte[]buffer, intbufferIndex, intlength );
Parameters
i
: The zero-based column
ordinal.
dataIndex
: The index within
the field from which to begin the read
operation.
buffer
: The buffer into which
to read the stream of bytes.
bufferIndex
: The index for
buffer to begin the read operation.
length
: The maximum length to
copy into the buffer.
Return Value
The actual number of bytes read.
Implements
IDataRecord.GetBytes
See Also
Gets the value of the specified column as a single character.
Syntax: Visual Basic
NotOverridable Public Function GetChar( _ ByVal i As Integer _ ) As Char _ _ Implements IDataRecord.GetChar
Syntax: C#
public char GetChar( inti );
Parameters
i
:
Return Value
Implements
IDataRecord.GetChar
See Also
Reads a stream of characters from the specified column offset into the buffer as an array starting at the given buffer offset.
Syntax: Visual Basic
NotOverridable Public Function GetChars( _ ByVal i As Integer, _ ByVal fieldOffset As Long, _ ByVal buffer As Char(), _ ByVal bufferoffset As Integer, _ ByVal length As Integer _ ) As Long _ _ Implements IDataRecord.GetChars
Syntax: C#
public long GetChars( inti, longfieldOffset, char[]buffer, intbufferoffset, intlength );
Parameters
i
:
fieldOffset
:
buffer
:
bufferoffset
:
length
:
Return Value
Implements
IDataRecord.GetChars
See Also
Gets the name of the source data type.
Syntax: Visual Basic
NotOverridable Public Function GetDataTypeName( _ ByVal i As Integer _ ) As String _ _ Implements IDataRecord.GetDataTypeName
Syntax: C#
public string GetDataTypeName( inti );
Parameters
i
:
Return Value
Implements
IDataRecord.GetDataTypeName
See Also
Syntax: Visual Basic
NotOverridable Public Function GetDateTime( _ ByVal index As Integer _ ) As Date _ _ Implements IDataRecord.GetDateTime
Syntax: C#
public DateTime GetDateTime( intindex );
Implements
IDataRecord.GetDateTime
See Also
Syntax: Visual Basic
NotOverridable Public Function GetDecimal( _ ByVal index As Integer _ ) As Decimal _ _ Implements IDataRecord.GetDecimal
Syntax: C#
public decimal GetDecimal( intindex );
Implements
IDataRecord.GetDecimal
See Also
Syntax: Visual Basic
NotOverridable Public Function GetDouble( _ ByVal index As Integer _ ) As Double _ _ Implements IDataRecord.GetDouble
Syntax: C#
public double GetDouble( intindex );
Implements
IDataRecord.GetDouble
See Also
Gets the Type that is the data type of the object.
Syntax: Visual Basic
NotOverridable Public Function GetFieldType( _ ByVal i As Integer _ ) As Type _ _ Implements IDataRecord.GetFieldType
Syntax: C#
public Type GetFieldType( inti );
Parameters
i
:
Return Value
Implements
IDataRecord.GetFieldType
See Also
Syntax: Visual Basic
NotOverridable Public Function GetFloat( _ ByVal index As Integer _ ) As Single _ _ Implements IDataRecord.GetFloat
Syntax: C#
public float GetFloat( intindex );
Implements
IDataRecord.GetFloat
See Also
Syntax: Visual Basic
NotOverridable Public Function GetGuid( _ ByVal index As Integer _ ) As Guid _ _ Implements IDataRecord.GetGuid
Syntax: C#
public Guid GetGuid( intindex );
Implements
IDataRecord.GetGuid
See Also
Syntax: Visual Basic
NotOverridable Public Function GetInt16( _ ByVal index As Integer _ ) As Short _ _ Implements IDataRecord.GetInt16
Syntax: C#
public short GetInt16( intindex );
Implements
IDataRecord.GetInt16
See Also
Syntax: Visual Basic
NotOverridable Public Function GetInt32( _ ByVal index As Integer _ ) As Integer _ _ Implements IDataRecord.GetInt32
Syntax: C#
public int GetInt32( intindex );
Implements
IDataRecord.GetInt32
See Also
Syntax: Visual Basic
NotOverridable Public Function GetInt64( _ ByVal index As Integer _ ) As Long _ _ Implements IDataRecord.GetInt64
Syntax: C#
public long GetInt64( intindex );
Implements
IDataRecord.GetInt64
See Also
Syntax: Visual Basic
Public Function GetMySqlDateTime( _ ByVal index As Integer _ ) As MySqlDateTime
Syntax: C#
public MySqlDateTime GetMySqlDateTime( intindex );
See Also
Gets the name of the specified column.
Syntax: Visual Basic
NotOverridable Public Function GetName( _ ByVal i As Integer _ ) As String _ _ Implements IDataRecord.GetName
Syntax: C#
public string GetName( inti );
Parameters
i
:
Return Value
Implements
IDataRecord.GetName
See Also
Gets the column ordinal, given the name of the column.
Syntax: Visual Basic
NotOverridable Public Function GetOrdinal( _ ByVal name As String _ ) As Integer _ _ Implements IDataRecord.GetOrdinal
Syntax: C#
public int GetOrdinal( stringname );
Parameters
name
:
Return Value
Implements
IDataRecord.GetOrdinal
See Also
Returns a DataTable that describes the column metadata of the MySqlDataReader.
Syntax: Visual Basic
NotOverridable Public Function GetSchemaTable() As DataTable _ _ Implements IDataReader.GetSchemaTable
Syntax: C#
public DataTable GetSchemaTable();
Return Value
Implements
IDataReader.GetSchemaTable
See Also
Syntax: Visual Basic
NotOverridable Public Function GetString( _ ByVal index As Integer _ ) As String _ _ Implements IDataRecord.GetString
Syntax: C#
public string GetString( intindex );
Implements
IDataRecord.GetString
See Also
Syntax: Visual Basic
Public Function GetTimeSpan( _ ByVal index As Integer _ ) As TimeSpan
Syntax: C#
public TimeSpan GetTimeSpan( intindex );
See Also
Syntax: Visual Basic
Public Function GetUInt16( _ ByVal index As Integer _ ) As UInt16
Syntax: C#
public ushort GetUInt16( intindex );
See Also
Syntax: Visual Basic
Public Function GetUInt32( _ ByVal index As Integer _ ) As UInt32
Syntax: C#
public uint GetUInt32( intindex );
See Also
Syntax: Visual Basic
Public Function GetUInt64( _ ByVal index As Integer _ ) As UInt64
Syntax: C#
public ulong GetUInt64( intindex );
See Also
Gets the value of the specified column in its native format.
Syntax: Visual Basic
NotOverridable Public Function GetValue( _ ByVal i As Integer _ ) As Object _ _ Implements IDataRecord.GetValue
Syntax: C#
public object GetValue( inti );
Parameters
i
:
Return Value
Implements
IDataRecord.GetValue
See Also
Gets all attribute columns in the collection for the current row.
Syntax: Visual Basic
NotOverridable Public Function GetValues( _ ByVal values As Object() _ ) As Integer _ _ Implements IDataRecord.GetValues
Syntax: C#
public int GetValues( object[]values );
Parameters
values
:
Return Value
Implements
IDataRecord.GetValues
See Also
Gets a value indicating whether the column contains non-existent or missing values.
Syntax: Visual Basic
NotOverridable Public Function IsDBNull( _ ByVal i As Integer _ ) As Boolean _ _ Implements IDataRecord.IsDBNull
Syntax: C#
public bool IsDBNull( inti );
Parameters
i
:
Return Value
Implements
IDataRecord.IsDBNull
See Also
Advances the data reader to the next result, when reading the results of batch SQL statements.
Syntax: Visual Basic
NotOverridable Public Function NextResult() As Boolean _ _ Implements IDataReader.NextResult
Syntax: C#
public bool NextResult();
Return Value
Implements
IDataReader.NextResult
See Also
Advances the MySqlDataReader to the next record.
Syntax: Visual Basic
NotOverridable Public Function Read() As Boolean _ _ Implements IDataReader.Read
Syntax: C#
public bool Read();
Return Value
Implements
IDataReader.Read
See Also
Syntax: Visual Basic
Overloads Public Function ExecuteReader( _ ByVal behavior As CommandBehavior _ ) As MySqlDataReader
Syntax: C#
public MySqlDataReader ExecuteReader( CommandBehaviorbehavior );
See Also
MySqlCommand Class, MySql.Data.MySqlClient Namespace, MySqlCommand.ExecuteReader Overload List
Syntax: Visual Basic
NotOverridable Public Function ExecuteScalar() As Object _ _ Implements IDbCommand.ExecuteScalar
Syntax: C#
public object ExecuteScalar();
Implements
IDbCommand.ExecuteScalar
See Also
Syntax: Visual Basic
NotOverridable Public Sub Prepare() _ _ Implements IDbCommand.Prepare
Syntax: C#
public void Prepare();
Implements
IDbCommand.Prepare
See Also
For a list of all members of this type, see MySqlCommandBuilder Members .
Syntax: Visual Basic
NotInheritable Public Class MySqlCommandBuilder_ Inherits Component
Syntax: C#
public sealed class MySqlCommandBuilder : Component
Thread Safety
Public static (Sharedin Visual Basic) members of this type are safe for multithreaded operations. Instance members are notguaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlCommandBuilder Members, MySql.Data.MySqlClient Namespace
MySqlCommandBuilder
ConstructorMySqlCommandBuilder.GetDeleteCommand
MethodMySqlCommandBuilder.GetInsertCommand
MethodMySqlCommandBuilder.GetUpdateCommand
MethodMySqlCommandBuilder.RefreshSchema
MethodPublic Static (Shared) Methods
DeriveParameters | Overloaded. 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. |
Public Instance Constructors
MySqlCommandBuilder | Overloaded. Initializes a new instance of the MySqlCommandBuilder class. |
Public Instance Properties
Container(inherited from Component) | Gets the IContainerthat contains the Component. |
DataAdapter | |
QuotePrefix | |
QuoteSuffix | |
Site(inherited from Component) | Gets or sets the ISiteof the Component. |
Public Instance Methods
CreateObjRef(inherited from MarshalByRefObject) | Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. |
Dispose(inherited from Component) | Releases all resources used by the Component. |
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
GetDeleteCommand | |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetInsertCommand | |
GetLifetimeService(inherited from MarshalByRefObject) | Retrieves the current lifetime service object that controls the lifetime policy for this instance. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
GetUpdateCommand | |
InitializeLifetimeService(inherited from MarshalByRefObject) | Obtains a lifetime service object to control the lifetime policy for this instance. |
RefreshSchema | |
ToString(inherited from Component) | Returns a Stringcontaining the name of the Component, if any. This method should not be overridden. |
Public Instance Events
Disposed(inherited from Component) | Adds an event handler to listen to the Disposedevent on the component. |
See Also
MySqlCommandBuilder Class, MySql.Data.MySqlClient Namespace
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.
Overload List
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.
See Also
MySqlCommandBuilder Class, MySql.Data.MySqlClient Namespace
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.
Syntax: Visual Basic
Overloads Public Shared Sub DeriveParameters( _ ByVal command As MySqlCommand _ )
Syntax: C#
public static void DeriveParameters( MySqlCommandcommand );
Parameters
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.
Exceptions
Exception Type | Condition |
InvalidOperationException | The command text is not a valid stored procedure name. |
See Also
MySqlCommandBuilder Class, MySql.Data.MySqlClient Namespace, MySqlCommandBuilder.DeriveParameters Overload List
Syntax: Visual Basic
Overloads Public Shared Sub DeriveParameters( _ ByVal command As MySqlCommand, _ ByVal useProc As Boolean _ )
Syntax: C#
public static void DeriveParameters( MySqlCommandcommand, booluseProc );
See Also
MySqlCommandBuilder Class, MySql.Data.MySqlClient Namespace, MySqlCommandBuilder.DeriveParameters Overload List
Initializes a new instance of the MySqlCommandBuilder class.
Overload List
Initializes a new instance of the MySqlCommandBuilder class.
See Also
MySqlCommandBuilder Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlCommandBuilder class.
Syntax: Visual Basic
Overloads Public Sub New()
Syntax: C#
public MySqlCommandBuilder();
See Also
MySqlCommandBuilder Class, MySql.Data.MySqlClient Namespace, MySqlCommandBuilder Constructor Overload List
Syntax: Visual Basic
Overloads Public Sub New( _ ByVal adapter As MySqlDataAdapter _ )
Syntax: C#
public MySqlCommandBuilder( MySqlDataAdapteradapter );
See Also
MySqlCommandBuilder Class, MySql.Data.MySqlClient Namespace, MySqlCommandBuilder Constructor Overload List
For a list of all members of this type, see MySqlDataAdapter Members .
Syntax: Visual Basic
NotInheritable Public Class MySqlDataAdapter_ Inherits DbDataAdapter
Syntax: C#
public sealed class MySqlDataAdapter : DbDataAdapter
Thread Safety
Public static (Sharedin Visual Basic) members of this type are safe for multithreaded operations. Instance members are notguaranteed to be thread-safe.
Requirements
Namespace: MySql.Data.MySqlClient
Assembly: MySql.Data (in MySql.Data.dll)
See Also
MySqlDataAdapter Members, MySql.Data.MySqlClient Namespace
Public Instance Constructors
MySqlDataAdapter | Overloaded. Initializes a new instance of the MySqlDataAdapter class. |
Public Instance Properties
AcceptChangesDuringFill(inherited from DataAdapter) | Gets or sets a value indicating whether AcceptChangesis called on a DataRowafter it is added to the DataTableduring any of the Fill operations. |
AcceptChangesDuringUpdate(inherited from DataAdapter) | Gets or sets whether AcceptChangesis called during a Update. |
Container(inherited from Component) | Gets the IContainerthat contains the Component. |
ContinueUpdateOnError(inherited from DataAdapter) | Gets or sets a value that specifies whether to generate an exception when an error is encountered during a row update. |
DeleteCommand | Overloaded. |
FillLoadOption(inherited from DataAdapter) | Gets or sets the LoadOptionthat determines how the adapter fills the DataTablefrom the DbDataReader. |
InsertCommand | Overloaded. |
MissingMappingAction(inherited from DataAdapter) | Determines the action to take when incoming data does not have a matching table or column. |
MissingSchemaAction(inherited from DataAdapter) | Determines the action to take when existing DataSetschema does not match incoming data. |
ReturnProviderSpecificTypes(inherited from DataAdapter) | Gets or sets whether the Fillmethod should return provider-specific values or common CLS-compliant values. |
SelectCommand | Overloaded. |
Site(inherited from Component) | Gets or sets the ISiteof the Component. |
TableMappings(inherited from DataAdapter) | Gets a collection that provides the master mapping between a source table and a DataTable. |
UpdateBatchSize(inherited from DbDataAdapter) | Gets or sets a value that enables or disables batch processing support, and specifies the number of commands that can be executed in a batch. |
UpdateCommand | Overloaded. |
Public Instance Methods
CreateObjRef(inherited from MarshalByRefObject) | Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. |
Dispose(inherited from Component) | Releases all resources used by the Component. |
Equals(inherited from Object) | Determines whether the specified Objectis equal to the current Object. |
Fill(inherited from DbDataAdapter) | Overloaded. Adds or refreshes rows in the DataSetto match those in the data source using the DataSetname, and creates a DataTablenamed "Table." |
FillSchema(inherited from DbDataAdapter) | Overloaded. Configures the schema of the specified DataTablebased on the specified SchemaType. |
GetFillParameters(inherited from DbDataAdapter) | Gets the parameters set by the user when executing an SQL
SELECT
statement. |
GetHashCode(inherited from Object) | Serves as a hash function for a particular type. GetHashCodeis suitable for use in hashing algorithms and data structures like a hash table. |
GetLifetimeService(inherited from MarshalByRefObject) | Retrieves the current lifetime service object that controls the lifetime policy for this instance. |
GetType(inherited from Object) | Gets the Typeof the current instance. |
InitializeLifetimeService(inherited from MarshalByRefObject) | Obtains a lifetime service object to control the lifetime policy for this instance. |
ResetFillLoadOption(inherited from DataAdapter) | Resets FillLoadOptionto its default state and causes Fillto honor AcceptChangesDuringFill. |
ShouldSerializeAcceptChangesDuringFill(inherited from DataAdapter) | Determines whether the AcceptChangesDuringFillproperty should be persisted. |
ShouldSerializeFillLoadOption(inherited from DataAdapter) | Determines whether the FillLoadOptionproperty should be persisted. |
ToString(inherited from Component) | Returns a Stringcontaining the name of the Component, if any. This method should not be overridden. |
Update(inherited from DbDataAdapter) | Overloaded. Calls the respective INSERT, UPDATE, or DELETE statements for each inserted, updated, or deleted row in the specified DataSet. |
Public Instance Events
Disposed(inherited from Component) | Adds an event handler to listen to the Disposedevent on the component. |
FillError(inherited from DataAdapter) | Returned when an error occurs during a fill operation. |
RowUpdated | Occurs during Update after a command is executed against the data source. The attempt to update is made, so the event fires. |
RowUpdating | Occurs during Update before a command is executed against the data source. The attempt to update is made, so the event fires. |
Protected Internal Instance Properties
FillCommandBehavior(inherited from DbDataAdapter) | Gets or sets the behavior of the command used to fill the data adapter. |
See Also
MySqlDataAdapter Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlDataAdapter class.
Overload List
Initializes a new instance of the MySqlDataAdapter class.
See Also
MySqlDataAdapter Class, MySql.Data.MySqlClient Namespace
Initializes a new instance of the MySqlDataAdapter class.
Syntax: Visual Basic
Overloads Public Sub New()
Syntax: C#
public MySqlDataAdapter();
See Also