Chapitre 25. Pilotes MySQL
Précédent |  | Suivant

## Chapitre 25. Pilotes MySQL

Ce chapitre décrit les différents pilotes MySQL qui fournissent l'interface entre le serveur MysQL et les clients.

## 25.1. Support ODBC de MySQL

MySQL supporte ODBC grâce au MySQL Connector/ODBC, une famille de pilote MyODBC. C'est la référence pour les produits Connector/ODBC, qui fournissent un accès compatible ODBC 3.5x à MySQL. Cette section vous montre comment installer MyODBC et l'utiliser. Vous obtiendrez aussi des informations sur les programmes les plus courants qui sont reconnus pour fonctionner avec MyODBC et les réponses aux questions les plus courantes à propos de MyODBC.

Cette section de s'applique à MyODBC 3.51. Vous pouvez trouver le manuel pour les anciennes versions de MyODBC dans la distribution source ou binaire de cette version.

C'est la section de référence pour les pilotes MySQL ODBC, et non pas un guide général pour ODBC. Pour plus d'informations sur ODBC, reportez-vous à http://www.microsoft.com/data/.

La partie sur le développement d'applciation de ce manuel de référence suppose une bonne connaissance du développement C, des concepts de bases de données relationnelles et MySQL. Pour plus d'informations sur MySQL et ses fonctionnalités, voyez http://dev.mysql.com/doc/.

Si vous avez des questions qui ne sont pas dans ce document, envoyez-les à `<myodbc@lists.mysql.com>`.

### 25.1.1. Introduction to MyODBC

#### 25.1.1.1. Qu'est-ce que ODBC?

ODBC (`Open Database Connectivity`) fournit un moyen aux clients pour accéder à une vaste gamme d'applications et de sources de données. ODBC est une interface standardisée, qui permet la connexion aux serveurs de bases de données. Elle a été développée en fonction des spécifications du `SQL Access Group` et définit un ensemble de fonction, code d'erreurs et types de donnés qui peuvent être utilisés pour développer des applications indépendantes des bases de données. ODBC est généralement utilisé lorsque l'indépendance à la base de données ou les accès simultanés de différents clients est nécessaire.

Pour plus d'informations sur ODBC, voyez http://www.microsoft.com/data/.

#### 25.1.1.2. Qu'est ce que Connector/ODBC?

Connector/ODBC est le nom désignant la famille des pilotes MySQL ODBC. Ils sont reconnus sous le nom de pilotes MyODBC.

#### 25.1.1.3. Qu'est-ce que MyODBC 2.50?

MyODBC 2.50 est un pilote 32 bits ODBC de MySQL AB, basé sur les spécifications ODBC 2.50 de niveau 0 (avec les fonctionnalités de niveau 1 et 2). C'est l'un des pilotes ODBC les plus populaires du marché Open Source, utilisés par de nombreux programmeurs pour accéder aux fonctionnalités de MySQL.

#### 25.1.1.4. Qu'est-ce que MyODBC 3.51?

MyODBC 3.51 est un pilote 32 bits ODBC, aussi connu sous le nom de MySQL ODBC 3.51. Cette version est une amélioration de la version MyODBC 2.50. Elle supporte les spécifications ODBC 3.5x de niveau 1 (API complète plus fonctionnalités de niveau 2), afin de fournir un accès à toutes les fonctionnalités ODBC lors de l'accès à MySQL.

#### 25.1.1.5. Où obtenir MyODBC

MySQL AB distribue tous ses produits sous licence General Public License (GPL). Vous pouvez obtenir une copie de la dernière version des binaires MyODBC et des sources sur le site Web de MySQL AB : http://dev.mysql.com/downloads/.

Pour plus d'informations sur MyODBC, visitez http://www.mysql.com/products/myodbc/.

#### 25.1.1.6. Supported Platforms

MyODBC can be used on all major platforms supported by MySQL, such as:

- Windows 95, 98, Me, NT, 2000, and XP

- All Unix Operating Systems

  - AIX

  - Amiga

  - BSDI

  - DEC

  - FreeBSD

  - HP-UX 10, 11

  - Linux

  - Mac OS X Server

  - Mac OS X

  - NetBSD

  - OpenBSD

  - OS/2

  - SGI Irix

  - Solaris

  - SunOS

  - SCO OpenServer

  - SCO UnixWare

  - Tru64 Unix

If a binary distribution is not available for downloading for a particular platform, you can build the driver yourself by downloading the driver sources. You can contribute the binaries to MySQL by sending a mail message to `<myodbc@lists.mysql.com>`, so that it becomes available for other users.

#### 25.1.1.7. MyODBC Mailing List

MySQL AB provides assistance to the user community by means of its mailing lists. For MyODBC-related issues, you can get help from experienced users by using the `<myodbc@lists.mysql.com>` mailing list.

For information about subscribing to MySQL mailing lists or to browse list archives, visit http://lists.mysql.com/.

#### 25.1.1.8. Forum `MyODBC`

Le support communautaire de la part d'utilisateurs expérimentés est disponible via les forums de MySQL, situé sur http://forums.mysql.com.

#### 25.1.1.9. Rapporter des problèmes avec `MYODBC`

Si vous rencontrez des difficultés avec `MyODBC`, commencez par faire un fichier de log avec le gestionnaire ODBC (le fichier de log que vous obtenez en demande les logs de ODBCADMIN) et un log `MyODBC`.

Pour obtenir un fichier de log `MyODBC`, vous devez faire ceci :

1. Assurez vous que vous utilisez `myodbcd.dll` et non pas `myodbc.dll`. Le moyen le plus facile pour le faire est d'obtenir `myodbcd.dll` dans la distribution `MYODBC` et de le copier à la place de `myodbc.dll`, qui est probablement dans le dossier `C:\windows\system32` ou `C:\winnt\system32`.

   Notez que vous voudrez probablement récupérer votre vieux fichier `myodbc.dll` lorsque vous aurez fini de tester, car il est bien plus rapide que `myodbcd.dll`.

2. Activez l'option ``Trace MyODBC`' dans l'écran de configuration de `MyODBC`. Le fichier de log sera écrit dans le fichier `C:\myodbc.log`.

   Si l'option de trace n'est pas recommandée lorsque vous retournez dans l'écran précédent, cela signifie que vous n'utilisez pas `myodbcd.dll` (voir ci-dessus).

3. Démarrez votre application, et faîtes la planter.

Vérifiez le fichier de `trace MyODBC`, pour essayer de comprendre ce qui ne va pas. Vous devriez être capable de trouver les requêtes émises en recherchant la chaîne `>mysql_real_query` dans le fichier `myodbc.log`.

Vous devriez aussi essayer de dupliquer la requête dans le client `mysql` ou `admndemo` pour voir si le problème vient de `MYODBC` ou MySQL.

Si vous trouvez quelques chose d'incorrect, n'envoyez que les lignes pertinentes (maximum, 40 lignes) à `<myodbc@lists.mysql.com>`. N'envoyez jamais le fichier de log `MYODBC` ou ODBC complet!

Si vous êtes incapables de trouver une erreur, la dernière option est de faire une archive (`tar` ou `zip`) qui contienne le fichier de trace `MYODBC`, le fichier de log ODBC, et un fichier `README` qui contienne une description du problème. Vous pouvez envoyer le tout à ftp://support.mysql.com/pub/mysql/secret/. Seuls nous, à MYSQL AB, pourront accéder à ces fichiers, et nous seront très respectueux de vos données.

Si vous pouvez créer un problème qui reproduit le problème, essayez de l'uploader aussi!

Si le programme fonctionne avec d'autres serveurs SQL, vous devriez faire un log ODBC où vous faîtes exactement la même chose sur les autres serveurs SQL.

N'oubliez jamais que plus vous nous fournissez d'explication, plus nous pourront vous aider!

#### 25.1.1.10. Comment soumettre un correctif `MyODBC`

Vous pouvez envoyer un correctif ou suggérer une meilleure solution à un problème en envoyant un message à `<myodbc@lists.mysql.com>`.

### 25.1.2. General Information About ODBC and MyODBC

#### 25.1.2.1. Introduction à ODBC

Open Database Connectivity (ODBC) est une interface d'application populaire pour accéder aux bases de donnése. Elle est basée sur l'interface CLI `Call-Level Interface` de X/Open et ISO/IEC pour les bases de données, et utilise le SQL (`Structured Query Language`) comme langage d'accès.

La liste des fonctions ODBC supportées par MyODBC est donné dans la section Section 25.1.16, « Table de référence MyODBC ». Pour les informations générales sur ODBC, voyez http://www.microsoft.com/data/.

#### 25.1.2.2. MyODBC Architecture

The MyODBC architecture is based on five components, as shown in the following diagram:

- Application:

  An application is a program that calls the ODBC API to access the data from the MySQL server. 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)

  - Driver loading and unloading

  - Processes ODBC function calls or passes them to the driver

- MyODBC Driver:

  The MyODBC driver is a library that implements the functions in 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 the MySQL.

- ODBC.INI:

  `ODBC.INI` is the ODBC configuration file that 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 using the Data Source Name. The driver uses this to read connection parameters based on the DSN specified. For more information, Section 25.1.9, « MyODBC Configuration ».

- MySQL Server:

  The MySQL server is the source of data. MySQL is:

  - A database management system (DBMS)

  - A relational database management system (RDBMS)

  - Open Source Software

#### 25.1.2.3. Gestionnaire de pilotes ODBC

Un gestionnaire de pilotes ODBC est une bibliothèque qui gère les communications entre une application compatible ODBC et les pilotes. Ses fonctionnalités principales sont :

- Résolution des noms de sources (DSN)

- Chargement et déchargement des pilotes

- Traitement des appels de fonctions ODBC et relais vers le pilote

Les gestionnaires suivants sont les plus utilisés :

- Microsoft Windows ODBC Driver Manager (`odbc32.dll`), http://www.microsoft.com/data/

- unixODBC Driver Manager for Unix (`libodbc.so`), http://www.unixodbc.org.

- iODBC ODBC Driver Manager for Unix (`libiodbc.so`), http://www.iodbc.org

MyODBC 3.51 est aussi livré avec UnixODBC depuis la version 2.1.2.

#### 25.1.2.4. Types de pilotes MySQL ODBC

MySQL AB supporte deux pilotes ODBC Open Source pour accéder à MySQL via l'API ODBC : MyODBC (MyODBC 2.50) et MySQL ODBC 3.51 Driver (MyODBC 3.51).

Note : dans cette section, nous nous référerons aux deux pilotes sous le nom de MyODBC. Lorsque la différence sera nécessaire, nous utiliseront les noms originaux.

### 25.1.3. Comment installer MyODBC

`MyODBC` 2.50 est un pilote 32-bit ODBC 2.50 avec un niveau de spécification 0 (avec le niveau 1 et 2 de proposés) pour connecter une application compatible ODBC à MySQL. `MyODBC` fonctionne sur Windows 9x/Me/NT/2000/XP et la plupart des plate-formes Unix. `MyODBC` 3.51 est une version améliorée avec les spécifications de niveau 1 de ODBC 3.5x (API noyau complète + fonctionnalités du niveau 2).

`MyODBC` est `Open Source`, et vous pouvez trouver la version la plus récente sur http://www.mysql.com/downloads/api-myodbc.html. Notez que les version 2.50.x sont licencées `LGPL` tandis que les versions 3.51.x sont licencées `GPL`.

Si vous avez des problèmes avec `MyODBC` et que votre programme fonctionne aussi avec OLEDB, essayez le pilote OLEDB.

Normalement, vous n'avez besoin d'installer `MyODBC` que sur les machines Windows. Vous avez besoin d'installer `MyODBC` sous Unix si vous avez un programme tel que ColdFusion qui fonctionne sur les machines Unix et utilise ODBC pour se connecter aux bases de données.

Si vous voulez installer `MyODBC` sur un ordinateur Unix, vous aurez aussi besoin d'un gestionnaire `ODBC`. `MyODBC` est connu pour fonctionner avec la plupart des gestionnaires ODBC d'Unix.

Pour installer `MyODBC` sur Windows, vous devez télécharger le fichier `.zip` de `MyODBC` approprié, le décompresser avec `WinZIP` ou un programme similaire et exécuter le fichier `SETUP.EXE`.

Sur Windows/NT/XP vous pouvez obtenir l'erreur suivante durant l'installation de `MyODBC` :

    An error occurred while copying C:\WINDOWS\SYSTEM\MFC30.DLL. Restart
    Windows and try installing again (before running any applications which
    use ODBC)

Le problème dans ce cas est qu'un autre programme utilise ODBC et du fait de l'architecture Windows, vous ne pouvez pas installer de nouveau pilote ODBC avec le programme d'installation de Microsoft ODBC. Dans la plupart des cas, vous pouvez continuer en cliquant juste sur `Ignore` pour copier le reste des fichiers MyODBC et l'installation finale devrait fonctionner. Si ce n'est pas le cas, la solution est de redémarrer votre machine en mode ``safe mode`` (faites le en appuyant sur F8 juste avant que votre machine ne démarre Windows), installez `MyODBC`, et redémarrez en mode normal.

- Pour créer une connexion à un ordinateur Unix depuis un ordinateur Windows, avec une application ODBC (une qui ne supporte pas MySQL nativement), vous devez installer `MyODBC` sur l'ordinateur Windows.

- L'utilisateur et la machine Windows doivent avoir les droits d'accès au serveur MySQL situé sur la machine Unix. vous pouvez configurer cela avec la commande `GRANT`. See Section 13.5.1.3, « Syntaxe de `GRANT` et `REVOKE` ».

- Vous devez créer une entrée DNS ODBC comme suit :

  - Ouvrez le panneau de configuration de Windows.

  - Double-cliquez sur l'icône Sources de données ODBC (32 bits).

  - Cliquez sur le volet User DSN.

  - Cliquez sur le bouton Add.

  - Sélectionnez MySQL dans l'écran Create New Data Source et cliquez sur le bouton Terminer.

  - L'écran de configuration par défaut du pilote MySQL est affiché. See Section 25.1.9.2, « Configuration du DSN MyODBC sur Windows ».

- Démarrez maintenant votre application et sélectionnez le pilote ODBC avec les DSN que vous avez spécifié dans l'administrateur ODBC.

Notez que d'autres options de configuration sont présentes dans l'écran de MySQL (tra¸age, se connecter automatiquement, etc.), vous pouvez les essayer en cas de problèmes.

### 25.1.4. Installer MyODBC depuis une distribution binaire sur Windows

Pour installer MyODBC sur Windows, il est recommandé de téléchager la distribution appropriée sur http://dev.mysql.com/downloads/connector/odbc/, la décompresser, et exécuter la commande MyODBC-`VERSION`.exe.

Sous Windows, vous pourriez rencontrer l'erreur suivante lors de l'installation d'un ancien pilote MyODBC 2.50 :

    An error occurred while copying C:\WINDOWS\SYSTEM\MFC30.DLL. Restart
    Windows and try installing again (before running any applications
    which use ODBC)

Le problème est qu'un autre programme utilise ODBC. A cause de l'architecture de Windows, vous pourriez ne pas pouvoir installer de nouveau pilote ODBC avec le programme d'installation de Microsoft. Dans la plupart des cas, vous pouvez continuer avec le bouton `Ignore` pour copier le restant des fichiers MyODBC et l'installation finale peut fonctionner malgré tout. Si ce n'est pas le cas, la solution est de relancer votre ordinateur en ``mode sans échec''. Choisissez ce mode en pressant F8 durant le redémarrage de Windows : installez MyODBC et relancez en mode normal.

### 25.1.5. Installing MyODBC from a Binary Distribution on Unix

#### 25.1.5.1. Installing MyODBC from an RPM Distribution

To install or upgrade MyODBC from an RPM distribution on Linux, simply download the RPM distribution of the latest version of MyODBC 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 MyODBC-3.51.01.i386-1.rpm

If the driver already exists, upgrade like this:

    shell> su root
    shell> rpm -Uvh MyODBC-3.51.01.i386-1.rpm

If there is any dependancy 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. Now proceed onto Section 25.1.9.3, « Configuration d'un DSN MyODBC sous Unix ».

To uninstall the driver, become `root` and execute an rpm command:

    shell> su root
    shell> rpm -e MyODBC

#### 25.1.5.2. Installing MyODBC from a Binary Tarball Distribution

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:

    shell> su root
    shell> gunzip MyODBC-3.51.01-i686-pc-linux.tar.gz
    shell> tar xvf MyODBC-3.51.01-i686-pc-linux.tar
    shell> cd MyODBC-3.51.01-i686-pc-linux

Read the installation instructions in the `INSTALL-BINARY` file and execute these commands.

    shell> cp libmyodbc* /usr/local/lib
    shell> cp odbc.ini /usr/local/etc
    shell> export ODBCINI=/usr/local/etc/odbc.ini

Then proceed on to how to configure the DSN on unix to configure the DSN for MyODBC. For more information, refer to the `INSTALL-BINARY` file that comes with your distribution.

### 25.1.6. Installer MyODBC depuis la version source sur Windows

#### 25.1.6.1. Pré-requis

- MDAC, Microsoft Data Access SDK téléchargé sur http://www.microsoft.com/data/.

- Bibliothèques client MySQL et fichiers d'inclusions de MySQL 4.0.0 ou plus récent. (De préférence, MySQL version 4.0.16 ou plus récent). Ceci est nécessaire car MyODBC utilise les nouvelles interfaces et structures qui ne sont disponibles que depuis cette version. Pour télécharger les bibliothèques clientes et les fichiers d'inclusion, voyez http://dev.mysql.com/downloads/.

#### 25.1.6.2. Compiler MyODBC 3.51

Les distribution source de MyODBC 3.51 incluent les fichiers `Makefiles` et utilisent nmake. Dans la distribution, vous pouvez trouver le `Makefile` pour différentes versions et le `Makefile_debug` pour compiler les versions de déboguage du pilote et des DLL.

Pour compiler le pilote, suivez la procédure suivante :

1. Téléchargez et décompressez les sources dans un dossier, puis placez vous dans ce dossier. Les commandes suivantes supposeront que ce dossier s'appelle `myodbc3-src` :

       C:\> cd myodbc3-src

2. Editez le fichier `Makefile` pour spécifier le chemin correct vers les bibliothèques client MySQL et les fichiers d'inclusions. Puis, utilisez les commandes suivantes pour compiler et installer votre version :

       C:\> nmake -f Makefile
       C:\> nmake -f Makefile install

   nmake -f Makefile compile la version de production du pilote, et place les exécutables dans le dossier `Release`.

   nmake -f Makefile install installe (copie) le pilote DLL et les bibliothèques (`myodbc3.dll`, `myodbc3.lib`) dans votre dossier système.

3. Pour compiler la version de déboguage, utilisez `Makefile_Debug` plutôt que `Makefile`, comme ceci :

       C:\> nmake -f Makefile_debug
       C:\> nmake -f Makefile_debug install

4. Vous pouvez nettoyer et recompiler le pilote avec les commandes suivantes :

       C:\> nmake -f Makefile clean
       C:\> nmake -f Makefile install

Note :

- Assurez-vous de spécifier le chemin correct jusqu'au bibliothèques client MySQL et aux fichiers d'entêtes dans le fichier Makefile (modifiez les variables `MYSQL_LIB_PATH` et `MYSQL_INCLUDE_PATH`). Le chemin d'entête par défaut est `C:\mysql\include`. Le chemin par défaut pour la bibliothèque est `C:\mysql\lib\opt` pour les versions de publication, et `C:\mysql\lib\debug` pour les versions de déboguage.

- Pour une documentation complète de nmake, visitez http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wcepb40/htm/_wcepb_nmake_tool.asp.

- Si vous utilisez les sources sous BitKeeper pour la compilation, tous les fichiers `Makefiles` spécifiques à Windows sont nommés `Win_Makefile*`.

#### 25.1.6.3. Tests de MyODBC

Apres la compilation et l'installation des bibliothèques du pilote dans le système vous pouvez tester votre installation avec les commandes suivantes, fournies dans le sous-dossier `samples` :

    C:\> cd samples
    C:\> nmake -f Makefile all

#### 25.1.6.4. Compiler MyODBC 2.50

La distribution source MyODBC 2.50 inclut un projet VC. Vous pouvez compiler le pilote à partir de ces fichiers `.dsp` et `.dsw`, en les chargeant directement dans Microsoft Visual Studio 6.0 ou plus récent.

### 25.1.7. Installing MyODBC from a Source Distribution on Unix

#### 25.1.7.1. Requirements

- MySQL client libraries and include files from MySQL 4.0.0 or higher. (Preferably MySQL 4.0.16 or higher). This is required because MyODBC 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/.

- The MySQL library must be configured with the `--enable-thread-safe-client` option. libmysqlclient installed as a shared library.

- One of the following Unix ODBC driver managers must be installed:

  - `iodbc` 3.0 or later (http://www.iodbc.org)

  - `unixodbc` Alpha 3 or later (http://www.unixodbc.org)

- If using a character set that isn't compiled into the MySQL client library (the defaults are: latin1 big5 czech euc_kr gb2312 gbk sjis tis620 ujis) 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 already be into place if you have installed the MySQL server on the same machine.

Once you have all the required files, unpack the source files to a separate directory and follow the instructions as given below:

#### 25.1.7.2. Typical configure Options

The configure script gives you a great deal of control over how you configure your MyODBC 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:

1. To compile MyODBC, you need to supply the MySQL client include and library files path using the `--with-mysql-path=`DIR`` option, where `DIR` is the directory where the MySQL is installed.

   MySQL compile options can be determined by running ``DIR`/bin/mysql_config`.

2. Supply the standard header and library files path for your ODBC Driver Manager(`iodbc` or `unixobc`).

   - If you are using `iodbc` and `iodbc` is not installed in its default location (`/usr/local`), you might have to use the `--with-iodbc=`DIR`` option, where `DIR` is the directory where iodbc is installed.

     If the iodbc headers do not reside in ``DIR`/include`, you can use the `--with-iodbc-includes=`INCDIR`` option to specify their location.

     The applies to libraries. If they are not in ``DIR`/lib`, you can use the `--with-iodbc-libs=`LIBDIR`` option.

   - If you are using `unixODBC`, use the `--with-unixODBC=`DIR`` option (case sensitive) to make configure look for `unixODBC` instead of `iodbc` by default, `DIR` is the directory where unixODBC is installed.

     If the unixODBC headers and libraries aren't located in ``DIR`/include` and ``DIR`/lib`, use the `--with-unixODBC-includes=`INCDIR`` and `--with-unixODBC-libs=`LIBDIR`` options.

3. You might want to specify an installation prefix other than `/usr/local`. For example, to install the MyODBC drivers in `/usr/local/odbc/lib`, use the `--prefix=/usr/local/odbc` option.

The final configuration command will look something like this:

    shell> ./configure --prefix=/usr/local \
               --with-iodbc=/usr/local \
               --with-mysql-path=/usr/local/mysql

#### 25.1.7.3. Thread-Safe Client

In order 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 driver thread-safe library `libmyodbc3_r.so` from by linking with mysql thread-safe client library `libmysqlclient_r.so` (The extensions are OS dependent).

In case while configuring with thread-safe option, and gotten into a configure error; then look at the `config.log` and see if it is due to the lack of thread-libraries in the system; and supply one with LIBS options i.e.

    LIBS="-lpthread" ./configure ..

#### 25.1.7.4. Shared or Static Options

You can enable or disable the shared and static versions using these options:

    --enable-shared[=yes/no]
    --disable-shared
    --enable-static[=yes/no]
    --disable-static

#### 25.1.7.5. Enabling Debugging Information

By default, all the binary distributions are built as non-debugging versions (configured with `--without-debug`).

To enable debugging information, build the driver from source distribution and use the `--with-debug`) when you run configure.

#### 25.1.7.6. Enabling the Documentation

This option is available only for `BK` clone trees; not for normal source distributions.

By default, the driver is built with (`--without-docs`); And in case if you want the documentation to be taken care in the normal build, then configure with:

     --with-docs

#### 25.1.7.7. Building and Compilation

To build the driver libraries, you have to just execute make, which takes care of everything.

    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.

#### 25.1.7.8. Building Shared Libraries

On most platforms, MySQL doesn't build or support `.so` (shared) client libraries by default, because building with shared libraries has caused us problems in the past.

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 MyODBC-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 MyODBC library 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

#### 25.1.7.9. Installing Driver Libraries

To install the driver libraries, execute the following command:

    shell> make install

That command installs one of the following sets of libraries:

For MyODBC 3.51:

- `libmyodbc3.so`

- `libmyodbc3-3.51.01.so`, where 3.51.01 is the version of the driver

- `libmyodbc3.a`

For thread-safe MyODBC 3.51:

- `libmyodbc3_r.so`

- `libmyodbc3-3_r.51.01.so`

- `libmyodbc3_r.a`

For MyODBC 2.5.0:

- `libmyodbc.so`

- `libmyodbc-2.50.39.so`, where 2.50.39 is the version of the driver

- `libmyodbc.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.

#### 25.1.7.10. Testing MyODBC on Unix

To run the basic samples provided in the distribution with the libraries that you built, just execute:

    shell> make test

Make sure the DSN 'myodbc3' is configured first in `odbc.ini` and environment variable `ODBCINI` is pointing to the right `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.

#### 25.1.7.11. Mac OS X Notes

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.

Now 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

#### 25.1.7.12. HP-UX Notes

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 see whether or not you need to have the MySQL client libraries path using the `SHLIB_PATH` environment variable. For static versions, ignore all shared-library options and run configure with the `--disable-shared` option.

#### 25.1.7.13. Notes pour AIX :

Pour compiler le pilote sur AIX, utilisez la commande configure suivante :

    shell> ./configure --prefix=/usr/local
    			       --with-unixodbc=/usr/local
    			       --with-mysql-path=/usr/local/mysql
    			       --disable-shared
    			       --enable-thread-safe

NOTE : pour plus d'informations sur la compilation et la configuration de bibliothèques statiques ou partagées sur différentes plates-formes, voyez 'Using static and shared libraries across platforms'.

### 25.1.8. Installer MyODBC depuis le serveur de versions BitKeeper

Note : il est recommandé de lire cette section si vous souhaitez nous aider à tester les nouveaux codes.

Pour obtenir la version la plus récente depuis les serveurs de versions, utilisez ces instructions :

1. Téléchargez BitKeeper depuis http://www.bitmover.com/cgi-bin/download.cgi. Vous aurez besoin de `BitKeeper 3.0` ou plus récent pour vous connecter au serveur de versions.

2. Suivez les instructions fournies pour l'installer.

3. Une fois que `BitKeeper` est installé, placez-vous dans le dossier où vous voulez travailler, puis utilisez la commande suivante pour cloner la branche MyODBC 3.51 :

       shell> bk clone bk://mysql.bkbits.net/myodbc3 myodbc-3.51

   Dans l'exemple précédent, les sources seront installé dans le dossier `myodbc-3.51/` ou par défaut dans le sous-dossier `myodbc3/` de votre dossier courrant. Si vous êtes derrière un pare-feu, et que nous devez initier les connexions HTTP, vous devrez utiliser BitKeeper via HTTP. Si vous devez utiliser un serveur proxy, il suffit de configurer la variable d'environnement `http_proxy` pour qu'elle pointe sur votre proxy :

       shell> export http_proxy="http://your.proxy.server:8080/"

   Maintenant, remplacez simplement `bk://` par `http://` lors du clonage. Par exemple :

       shell> bk clone http://mysql.bkbits.net/myodbc3 myodbc-3.51

   Le téléchargement initial de l'arbre peut prendre un certain temps, en fonction de votre connexion : soyez patients.

4. Vous aurez besoin de GNU `autoconf 2.52` (ou plus récent), `automake 1.4`, `libtool 1.4` et `m4` pour lancer les commandes suivantes.

       shell> cd myodbc-3.51
       shell> bk -r edit
       shell> aclocal; autoheader; autoconf;  automake;
       shell> ./configure  # Add your favorite options here
       shell> make

   Pour plus d'informations sur la compilation, lisez le fichier `INSTALL` dans le même dossier. Sous Windows, utilisez les fichiers Windows Makefiles `WIN-Makefile` et `WIN-Makefile_debug` pour compiler le pilote. Pour plus d'informations, voyez Section 25.1.6, « Installer MyODBC depuis la version source sur Windows ».

5. Lorsque la compilation est faite, lancez make install pour installer le pilote MyODBC 3.51 sur votre système.

6. Si vous avez atteind l'instruction make et que la distribution ne compile pas, envoyez un message à `<myodbc@lists.mysql.com>`.

7. Après la commande bk clone initiale, vous devez utiliser la commande bk pull régulièrement, pour obtenir les dernières modifications.

8. Vous pouvez éxaminer l'historique de changements du fichier avec toutes les modifications grâce à la commande bk sccstool. Si vous rencontrez des patchs étranges sur lesquels vous avez des questions, envoyez un mail à `<myodbc@lists.mysql.com>`.

   De même, si vous pensez avoir une meilleure idée pour un traitement, envoyez un courriel avec votre patch. bk diffs va générer un patch pour vous, à partir de vos modifications. Si vous n'avez pas le temps de programmer votre idée, envoyez simplement une description.

9. BitKeeper dispose d'une aide en ligne précieuse, que vous pouvez obtenir avec bk helptool.

Vous pouvez aussi lire les listes de modifications, les commentaires et les sources en ligne : http://mysql.bkbits.net:8080/myodbc3.

### 25.1.9. MyODBC Configuration

This section describes how to configure MyODBC, including DSN creation and the different arguments that the driver takes as an input arguments in the connection string. It also describes how to create an ODBC trace file.

#### 25.1.9.1. Qu'est-ce qu'un `Data Source Name`, ou Nom de Source de Données?

Une "source de données" est un système qui émet des données. Les sources de données doivent avoir un identifiant persistant, qppelé `Data Source Name`, ou Nom de Source de Données. En utilisant un Nom de Source de Données, MySQL peut accéder aux informations d'initialisation. Avec les informations d'initialisation, MySQL sait où accéder à la base, et quels options de configuration utiliser lors de la connexion.

En effet, la source de données est un chemin vers les données. Dans un contexte différent, cela signifie autre choses, mais typiquement,, cela identifie un serveur MySQL : par exemple, une adresse réseau, ou un nom de service; plus un nom de base de données par défaut et les informations obligatoires comme le port, par exemple. Les pilotes MySQL, le système Windows et le gestionnaire ODBC utiliseront la source de données pour se connecter. Un utilitaire d'administration, appelé `Microsoft ODBC Data Source Administrator` peut être utile dans cette situation.

Il y a deux endroits pour stocker les informations d'initialisation : dans la base de registres de Windows, ou via un DSN sur n'importe quel système.

Si les informations sont dans la base de registres de Windows, elles sont dites sources de données Machine (`"Machine data source"`). Cela peut être une source de données utilisateur (`"User data source"`), auquel cas, seul un utilisateur pour la voir. Ou, cela peut être une source de données système (`"System data source"`), auquel cas, elle sera accessible à tous les utilisateurs du système, ou même, tous les utilisateurs connectés au serveur. Lorsque vous exéctuez le programme d'administration ODBC vous aurez le choix entre `"User"` et `"System"` : ce sont deux onglets séparés.

Si les informations sont dans un fichier DSN, elles portent le nom de source de données fichiers (`"File data source"`). C'est un fichier texte. Les avantages sont que (a) c'est une option pour n'importe quel ordinateur et non pas seulement sur Windows; (b) son contenu peut être transmis ou copié facilement.

#### 25.1.9.2. Configuration du DSN MyODBC sur Windows

Pour ajouter et configurer une nouvelle source de données MyODBC sur Windows, utilisez le `ODBC Data Source Administrator`. Le `ODBC Administrator` modifie les informations de connexion à la source de données. En ajoutant de nouvelles sources, le `ODBC Administrator` met à jour la base des registres pour vous.

To open the `ODBC Administrator` from the Control Panel:

1. Click `Start`, point to `Settings`, and then click `Control Panel`.

2. On computers running Microsoft Windows 2000 or newer, double-click `Administrative Tools`, and then double-click `Data Sources (ODBC)`. On computers running older versions of Windows, double-click `32-bit ODBC` or `ODBC`.

   The `ODBC Data Source Administrator` dialog box appears, as shown here:

   Click `Help` for detailed information about each tab of the `ODBC Data Source Administrator` dialog box.

To add a data source on Windows:

1. Open the `ODBC Data Source Administrator`.

2. In the `ODBC Data Source Administrator` dialog box, click `Add`. The `Create New Data Source` dialog box appears.

3. Select `MySQL ODBC 3.51 Driver`, and then click `Finish`. The `MySQL ODBC 3.51 Driver - DSN Configuration` dialog box appears, as shown here:

4. 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.

5. In the `Description` box, enter the description needed for the DSN.

6. For `Host or Server Name (or IP)` box, enter the name of the MySQL server host that you want to access. By default, it is `localhost`.

7. In the `Database Name` box, enter the name of the MySQL database that you want to use as the default database.

8. In the `User` box, enter your MySQL username (your database user ID).

9. In the `Password` box, enter your password.

10. In the `Port` box, enter the port number if it is not the default (3306).

11. In the `SQL Command` box, you can enter an optional SQL statement that you want to issue automatically after the connection has been established.

    The final dialog looks like this:

    Click `OK` to add this data source.

Note: Upon clicking `OK`, the `Data Sources` dialog box appears, and the `ODBC Administrator` updates the registry information. The username and connect string that you entered become the default connection values for this data source when you connect to it.

You can also test whether your settings are suitable for connecting to the server using the button `Test Data Source`. This feature is available only for the MyODBC 3.51 driver. A successful test results in the following window:

A failed test results in an error:

The DSN configuration dialog also has an `Options` button. If you select it, the following options dialog appears displaying that control driver behavior. Refer to Section 25.1.9.4, « Paramètres de connexion » for information about the meaning of these options.

Note: The options listed under `Driver Trace Options` are disabled (grayed out) unless you are using the debugging version of the driver DLL.

To modify a data source on Windows:

1. Open the `ODBC Data Source Administrator`. Click the appropriate DSN tab.

2. Select the MySQL data source that you want to modify and then click `Configure`. The `MySQL ODBC 3.51 Driver - DSN Configuration` dialog box appears.

3. Modify the applicable data source fields, and then click `OK`.

When you have finished modifying the information in this dialog box, the `ODBC Administrator` updates the registry information.

#### 25.1.9.3. Configuration d'un DSN MyODBC sous Unix

Sous `Unix`, vous configurez les DSN directement dans le fichier `odbc.ini`. Voici un exemple typique de fichier `odbc.ini` qui configure `myodbc` et `myodbc3` comme noms DSN pour MyODBC 2.50 et MyODBC 3.51, respectivement :

    ;
    ;  odbc.ini configuration for MyODBC and MyODBC 3.51 drivers
    ;

    [ODBC Data Sources]
    myodbc      = MyODBC 2.50 Driver DSN
    myodbc3     = MyODBC 3.51 Driver DSN

    [myodbc]
    Driver       = /usr/local/lib/libmyodbc.so
    Description  = MyODBC 2.50 Driver DSN
    SERVER       = localhost
    PORT         =
    USER         = root
    Password     =
    Database     = test
    OPTION       = 3
    SOCKET       =

    [myodbc3]
    Driver       = /usr/local/lib/libmyodbc3.so
    Description  = MyODBC 3.51 Driver DSN
    SERVER       = localhost
    PORT         =
    USER         = root
    Password     =
    Database     = test
    OPTION       = 3
    SOCKET       =

    [Default]
    Driver       = /usr/local/lib/libmyodbc3.so
    Description  = MyODBC 3.51 Driver DSN
    SERVER       = localhost
    PORT         =
    USER         = root
    Password     =
    Database     = test
    OPTION       = 3
    SOCKET       =

Reportez vous aux Section 25.1.9.4, « Paramètres de connexion », pour la liste de paramètres de connexion qui sont disponibles.

Note : si vous utilisez unixODBC, vous pouvez utiliser les outils suivants pour configurer les DSN :

- ODBCConfig GUI(HOWTO: ODBCConfig)

- odbcinst

Dans certains cas lorsque vous utilisez unixODBC, vous pouvez obtenir cette erreur :

    Data source name not found and no default driver specified

Lorsque cela survient, assurez vous que les variables d'environnement `ODBCINI` et `ODBCSYSINI` pointent sur le bon fichier `odbc.ini`. Par exemple, si votre fichier `odbc.ini` est situé dans `/usr/local/etc`, donnez les valeurs suivantes aux variables d'environnement :

    export ODBCINI=/usr/local/etc/odbc.ini
    export ODBCSYSINI=/usr/local/etc

#### 25.1.9.4. Paramètres de connexion

Vous pouvez spécifier les paramètres suivants de MyODBC dans la section `[Data Source Name]` du fichier `ODBC.INI` ou via l'argumet `InConnectionString` dans l'appel à `SQLDriverConnect()`.

Paramètre | Valeur par défaut | Commentaire
`user` | ODBC (sur Windows) | Le nom de l'utilisateur pour se connecter à MySQL.
`server` | `localhost` | Le nom de l'hôte MySQL.
`database` |  | La base de données par défaut.
`option` | 0 | Options qui spécifient comment MyODBC fonctionne. Voir ci-dessous.
`port` | 3306 | Le port TCP/IP à utiliser si le `server` n'est pas `localhost`.
`stmt` |  | Une commmande à exécuter lors de la connexion à MySQL.
`password` |  | Le mot de passe pour le compte `user` sur le serveur `server`.
`socket` |  | Le fichier de socket Unix ou le pipe nommé Windows utilisé pour se connecter à `server` s'il est sur `localhost`.

L'argument `option` sert à indiquer à MyODBC que le client n'est pas compatible à 100% ODBC. Sur Windows, vous pouvez sélectionner des options avec les boîtes à cocher dans l'écran de configuration, mais vous pouvez aussi les configurer avec l'argument `option`. Les options suivantes sont listées dans l'ordre d'apparition à l'écran de connexion MyODBC :

Valeur | Description
1 | Le client ne peut pas gérer la taille réelle des colonnes retournées par MyODBC.
2 | Le client ne peut pas gérer la vraie valeur des lignes modifiées. Si cette option est active, MySQL retourne ```found rows`'' à la place. Vous devez avoir MySQL 3.21.14 ou plus récent pour faire fonctionner cette option.
4 | Crée un log de déboguage dans `c:\myodbc.log`. Cela revient à ajouter la ligne `MYSQL_DEBUG=d:t:O,c::\myodbc.log` dans le fichier `AUTOEXEC.BAT`. (Sous Unix, ce fichier est `/tmp/myodbc.log`.)
8 | Ne pas envoyer de limites de paquets pour les résultats et paramètres.
16 | Ne pose aucune question, même si le pilote souhaite poser des questions.
32 | Active ou désactive le support des curseurs dynamiques. (Interdit en MyODBC 2.50.)
64 | Ignore l'utilisation du nom de la base de données dans la syntaxe `db_name.tbl_name.col_name`.
128 | Force l'utilisation du gestionnaire de curseur ODBC (expérimental).
256 | Désactive l'utilisation de la lecture étendue (`extended fetch`, expérimental).
512 | Complète les colonnes `CHAR` jusqu'à leur taille maximale.
1024 | `SQLDescribeCol()` retourne des noms de colonnes complets.
2048 | Utilise le protocole client - serveur compressé.
4096 | Indique au serveur qu'il peut ignorer l'espace après les noms de fonctions, avant la parenthèse ouvrante ‘`(`’ (exigé par PowerBuilder). Cela transforme tous les noms de fonctions en mots clés.
8192 | Connexion au serveur mysqld avec les pipes nommés sous NT.
16384 | Change les colonnes `LONGLONG` en `INT` (certaines applications ne peuvent pas gérer les `LONGLONG`).
32768 | Retourne 'user' comme `Table_qualifier` et `Table_owner` de `SQLTables` (expérimental).
65536 | Lit les paramètres du client depuis les groupes `[client]` et `[odbc]` dans `my.cnf`.
131072 | Ajoute certains vérifications de sécurité (normalement inutile, mais sais-t-on jamais...)
262144 | Désactive les transactions.
524288 | Active le log de requêtes dans le fichier `c:\myodbc.sql`(`/tmp/myodbc.sql`). (Activé uniquement en mode déboguage).
1048576 | Ne met pas les résultats en cache localement dans le pilote, mais lit toujours auprès du serveur (`mysql_use_result()`). Cela ne fonctionne que pour les curseurs directs. Cette option est très importante pour traiter les très grandes tables, lorsque vous ne voulez pas que le pilote ne mette en cache toute la table.
2097152 | Impose l'utilisation du curseur `Forward-only`. Dans le cas d'applications qui configurent le type par défaut des curseurs, et que vous souhaitez malgré tout ne pas mettre en cache les résultats, cette option imposera un comportement de curseur direct.

Pour sélectionner plusieurs options en même temps, additionnez leur valeurs. Par exemple, l'option 12 (4+8) vous donne le débogugage sans limite de paquets.

`myodbc3.dll` par défaut est compilé pour les meilleures performances. Si vous voulez déboguer MyODBC 3.51 (par exemple, pour activer les traces), vous devriez utiliser `myodbc3d.dll`. Pour installer ce fichier, copiez le fichier `myodbc3d.dll` à la place de `myodbc3.dll`. Assurez vous de bien remettre la bonne biliothèque une fois que vous avez fini, car la version de déboguage peut vous ralentir considérablement.

Pour MyODBC 2.50, `myodbc.dll` et `myodbcd.dll` doivent être utilisés.

La table suivante affiche différentes valeurs recommandées pour `option` :

Configuration | Valeur
Microsoft Access | 3
Microsoft Visual Basic | 3
Grandes tables avec trop de lignes | 2049
Génération de trace de déboguage | 4
Génération de log de requêtes | 524288
Génération de logs de requêtes et de traces | 524292
De grandes tables sans cache | 3145731

#### 25.1.9.5. Se connecter sans définir de DSN

C'est possible. Vous pouvez vous connecter à un serveur MySQL en utilisant SQLDriverConnect, et en spécifiant le champ `DRIVER`. Voici les chaînes de connexion à utiliser avec MyODBC pour une connexion sans DSN :

For MyODBC 2.50:

    ConnectionString = "DRIVER={MySQL};\
                        SERVER=localhost;\
                        DATABASE=test;\
                        USER=venu;\
                        PASSWORD=venu;\
                        OPTION=3;"

For MyODBC 3.51:

    ConnectionString = "DRIVER={MySQL ODBC 3.51 Driver};\
                        SERVER=localhost;\
                        DATABASE=test;\
                        USER=venu;\
                        PASSWORD=venu;\
                        OPTION=3;"

Si votre langage de programmation convertit les anti-slash suivis d'espaces en espace, il est préférable de spécifier la chaîne de connexion sous la forme d'une longue chaîne, ou d'utiliser la concaténation de plusieurs chaînes, sans ajouter d'espace entre :

    ConnectionString = "DRIVER={MySQL ODBC 3.51 Driver};"
                        "SERVER=localhost;"
                        "DATABASE=test;"
                        "USER=venu;"
                        "PASSWORD=venu;"
                        "OPTION=3;"

Reportez-vous à la section Section 25.1.9.4, « Paramètres de connexion », pour la liste complète est paramètres de connexion à fournir.

#### 25.1.9.6. Etablir une connexion distante d'un système A à un système B

Si vous voulez connecter à un système A un système B, avec le nom d'utilisateur et le mot de passe `myuser` et `mypassword`, voici une procédure simple :

Sur le système A, suivez les étapes suivantes :

1. Lancez le serveur MySQL.

2. Utilisez la commande `GRANT` pour configurer un compte avec le nom d'utilisateur de `myuser` qui peut se connecter depuis le système B, avec le mot de passe de `myuser` :

       GRANT ALL ON *.* to 'myuser'@'B' IDENTIFIED BY 'mypassword';

3. La commande `GRANT` donne tous les droits à l'utilisateur `myuser` pour se connecter depuis le système B, en utilisant le mot de passe `mypassword`. Pour exécuter cette commande, il faut faut les droits de `root` sur le système A, ou un utilisateur équivalent. Pour plus d'informations sur le système de droits de MySLQ, voyez la section Section 5.6, « Gestion des comptes utilisateurs de MySQL ».

Sur le système B, suivez ces instructions :

1. Configurez un DSN MyODBC en utilisant les informations de connexion suivantes :

       DSN            = remote_test
       SERVER or HOST = A (ou l'adresse IP du système A)
       DATABASE       = test (La base de données par défaut)
       USER           = myuser
       PASSWORD       = mypassword

   Pour configurer une connexion sans DSN, voyez Section 25.1.9.5, « Se connecter sans définir de DSN ».

2. Vérifiez si vous êtes capables d'accéder au système A depuis le système B avev un ping ou un autre moyen. Si vous n'êtes pas capables d'atteindre B, vérifiez votre réseau, les connexions internet ou alors contactez votre administrateur réseau.

3. Maintenant, essayez de vous connecter en utilisant `DSN=remote_test`. Si vous échouéez, lisez le log MyODBC, et suivez les instructions indiquées dans le message d'erreur du log. Si vous avez besoin d'autre support, envoyez un mail à to `<myodbc@lists.mysql.com>`.

Vous pouvez aussi lire un HOWTO sur http://www.phphelp.com/tutorial/using-myodbc-to-connect-to-a-remote-database.html.

#### 25.1.9.7. Obtenir un fichier de trace ODBC

Si vous rencontrez des difficultés ou des problèmes avec MyODBC, vous devriez lancer le programme en créant un fichier de log à partir du `ODBC Manager` (le log que vous obteniez de `ODBC ADMIN`) et MyODBC.

Pour obtenir une trace ODBC via le gestionnaire de pilotes, faites ceci :

- Ouvrez l'administrateur de sources ODBC :

  1. Cliquez sur `Start`, pointez sur `Settings`, et ensuite cliquez sur `Control Panel`.

  2. Sur les machines Microsoft Windows 2000 ou XP, double-cliquez sur `Administrative Tools`, puis sur `Data Sources (ODBC)`, comme montré ci-dessous.

     Sur les machines avec des versions de Microsoft plus anciennes, double-cliquez sur `32-bit ODBC` ou `ODBC` dans le panneau de contrôle.

  3. Le dialogue `ODBC Data Source Administrator` apparait :

  4. Cliquez sur Help pour des informations détaillées sur chaque onglet de la boîte de dialogue.

- Activez l'option de trace. Cette procédure est différente sur Windows et sur Unix.

  Pour activer l'option de trace sur Windows :

  1. L'onglet `Tracing` de la boîte de dialogue de `ODBC Data Source Administrator` vous permet de configurer la trace des fonctions ODBC.

  2. Lorsque vous activez la trace depuis l'onglet `Tracing`, le `Driver Manager` va enregistrer toutes les fonctions ODBC de toutes les futures applications.

  3. Les fonctions ODBC des applications en fonctionnement ne sont pas enregistrées. Les fonctions ODBC sont enregistrées dans le fichier de log que vous spécifiez.

  4. La trace cesse après que vous ayez cliqué sur `Stop Tracing Now`. N'oubliez pas que tant que la trace est active, le fichier de log continue de croitre en taille, et que la trace ralentit toutes vos applications ODBC.

  Pour activer la trace sous Unix :

  1. Sous Unix, vous devez explicitement configurer l'option `Trace` dans le fichier `ODBC.INI`.

     Spécifiez la valeur de `ON` ou `OFF` aux options `TraceFile` et `Trace` dans le fichier `odbc.ini` :

         TraceFile  = /tmp/odbc.trace
         Trace      = 1

     `TraceFile` spécifie le nom et le chemin complet des fichiers de trace, et `Trace` vaut `ON` ou `OFF`. Vous pouvez aussi utiliser `1` ou `YES` pour `ON` et `0` ou `NO` pour `OFF`. Si vous utilisez ODBCConfig avec `unixODBC`, alors suivez les instructions de trace d'`unixODBC` sur HOWTO-ODBCConfig.

  Pour générer un log MyODBC, faites ceci :

  1. Assurez-vous que vous utilisez la bibliothèque de déboguage DLL, c'est à dire `myodbc3d.dll` et non pas `myodbc3.dll` de MyODBC 3.51, et `myodbcd.dll` pour MyODBC 2.50.

     La méthode la plus facile est de prendre `myodbc3d.dll` ou `myodbcd.dll` dans la distribution de MyODBC 3.51 et de la copier le fichier `myodbc3.dll` ou `myodbc.dll`, qui est probablement dans votre dossier `C:\windows\system32` ou `C:\winnt\system32`. Notez que vous souhaiterez surement remettre l'ancien fichier `myodbc.dll` lorsque vous aurez fini, car il est bien plus rapide que `myodbc3d.dll` et `myodbcd.dll` : alors gardez une copie de vos fichiers originaux.

  2. Activez l'option `Trace MyODBC` dans l'écran de connexion MyODBC. Le log sera écrit dans le fichier `C:\myodbc.log`. Si l'option de trace n'est pas conservée lorsque vous retournez dans l'écran ci-dessus, cela signifie que vous n'utilisez pas le pilote `myodbcd.dll`. Sur Linux ou si vous avec une connexion sans DSN, il faut fournir l'option `OPTION=4` dans la chaîne de connexion.

  3. Lancez votre application, et essayez de reproduire votre problème. Puis, vérifiez le fichier de trace ODBC.

     Si vous trouvez un problème, envoyez un message à `<myodbc@lists.mysql.com>` ou à `<support@mysql.com>` si vous avez un contrat de support, avec une brève description de votre problème, et les informations suivantes :

     - version de MyODBC

     - type de pilote ODBC et sa version

     - serveur MySQL et sa version

     - la trace ODBC du gestionnaire de pilote

     - le fichier de log MyODBC du pilote MyODBC

     - un exemple reproductible aussi simple que possible

  Pensez que plus vous nous fournissez d'explication, plus nous pourrons résoudre votre problème rapidement.

  De plus, après avoir envoyé le rapport de bogue, vérifiez les listes de discussion MyODBC sur http://lists.mysql.com/.

#### 25.1.9.8. Applications Tested with MyODBC

MyODBC has been tested with the following applications:

- MS Access 95, 97, 2000, and 2002

- C++-Builder, Borland Builder 4

- Centura Team Developer (formerly Gupta SQL/Windows)

- ColdFusion (on Solaris and NT with service pack 5), How-to: MySQL and Coldfusion. Troubleshooting Data Sources and Database Connectivity for UnixPlatforms.

- Crystal Reports

- DataJunction

- Delphi

- ERwin

- MS Excel

- iHTML

- FileMaker Pro

- FoxPro

- Notes 4.5/4.6

- MS Visio Enterprise 2000

- Vision

- Visual Objects

- Visual Interdev

- SBSS

- Perl DBD-ODBC

- Paradox

- Powerbuilder

- Powerdesigner 32-bit

- MS Visual C++

- Visual Basic

- ODBC.NET through CSharp(C#), VB and C++

- Data Architect(http://thekompany.com/products/dataarchitect/)

- SQLExpress for Xbase++(http://www.SQLExpress.net)

- Open Office (http://www.openoffice.org) How-to: MySQL + OpenOffice. How-to: OpenOffice + MyODBC + unixODBC.

- Star Office (http://wwws.sun.com/software/star/staroffice/6.0/index.html)

- G2-ODBC bridge (http://www.gensym.com)

- Sambar Server (http://www.sambarserver.info) How-to: MyODBC + SambarServer + MySQL.

If you know of any other applications that work with MyODBC, please send mail to `<myodbc@lists.mysql.com>` about them.

#### 25.1.9.9. Programs Known to Work With MyODBC

La majorité des programmes doivent pouvoir fonctionner avec MyODBC, mais ceux qui sont listés ici ont été testé par nous-même, ou bien été testé par des utilisateurs de confiance. Les descriptions fournissent des palliatifs aux problèmes rencontrés.

- Programme

  Commentaire

- Access

  Pour faire fonctionner Access :

  - Si vous utilisez Access 2000, il est recommandé d'installer la dernière version 2.6 ou plus récente, de Microsoft MDAC (`Microsoft Data Access Components`) depuis http://www.microsoft.com/data/. Cela va corriger un problème dans Access lors de l'exportation de données vers MySQL, lorsque le nom de la table et de ses colonnes ne sont pas spécfiés. Une autre solution à ce problème est de passer en MyODBC 2.50.33 et MySQL 3.23.x, qui, ensemble, fournissent un palliatif à ce problème.

    Nous vous recommandons aussi d'appliquer le Microsoft Jet 4.0 Service Pack 5 (SP5) qui est téléchargeable sur http://support.microsoft.com/default.aspx?scid=kb;EN-US;q239114. Cela corrigera des situations où les colonnes sont marquées comme `#DELETED#` dans Access.

    Note : si vous utilisez MySQL 3.22, vous devez appliquer le patch MDAC et utiliser MyODBC 2.50.32 ou 2.50.34 et plus récent pour corriger le problème.

  - Pour toutes les versions d'Access, vous devez activer l'option MyODBC `Return matching rows`. Pour Access 2.0, il faut aussi activer l'option `Simulate ODBC 1.0`.

  - Il faut avoir une colonne timestamp dans toutes les tables qui seront modifiées. Pour une portabilité maximale, n'utilisez pas de spécification de taille dans la déclaration de la colonne. C'est à dire, utilisez `TIMESTAMP`, et non `TIMESTAMP(`n`)`, `n` < 14.

  - Vous devez avoir une clé primaire dans la table. Si non, les nouvelles lignes ou les lignes modifiées risquent d'apparaitre comme `#DELETED#`.

  - Utilisez uniquement des champs décimaux `DOUBLE`. Access ne sait pas comparer des décimaux simple. Le symptôme est généralement que les nouvelles lignes ou les lignes modifiées apparaissent comme `#DELETED#` ou que vous ne pouvez pas trouver ou modifier ces lignes.

  - Si vous utilisez MyODBC pour relier une table qui a une colonne `BIGINT`, le résultat risque d'apparaître comme `#DELETED`. La solution est la suivante :

    - Ajoutez une ou plusieurs colonnes `TIMESTAMP`.

    - Sélectionnez l'option `Change BIGINT columns to INT` dans le dialogue de connexion ODBC DSN Administrator.

    - Effacez le lien de la table depuis Access et recréez le.

    Les anciennes lignes seront toujours affichées comme `#DELETED#`, mais les nouvellse lignes seront affichées correctement.

  - Si vous avez toujours des erreurs de type `Another user has changed your data` après avoir ajouté une colonne de type `TIMESTAMP`, le truc suivant pourra vous aider :

    N'utilisez pas les données de la table `table` en mode tableau. Au lieu de cela, créez un formulaire avec les champs que vous vouleez, et utilisez le mode tableu de ce `form`. Activez l'option `DefaultValue` de la colonne `TIMESTAMP`, avec la valeur `NOW()`. C'est une bonne idée que de masquer la colonne `TIMESTAMP` pour que les utilisateurs ne soient pas perturbés.

  - Dans certains cas, Access génère des commandes SQL incorrecte que MySQL ne peut pas comprendre. Vous pouvez corriger cela en sélectionnant l'option `"Query|SQLSpecific|Pass-Through"` dans le menu d'Access.

  - Sous NT, Access indique que les colonnes `BLOB` sont des `OLE OBJECTS`. Si vous voulez avoir des colonnes `MEMO` à la place, changez les colonnes `BLOB` en `TEXT` avec `ALTER TABLE`.

  - Access ne peut pas toujours gérer les colonnes `DATE` correctement. Si vous avez des problèmes avec avec elles, utilisez `DATETIME`.

  - Si vous avez une colonne d'Access définie commme `BYTE`, Access va l'exporter comme `TINYINT` au lieu de `TINYINT UNSIGNED`. Cela vous posera des problèmes si vous avez des valeurs supérieures à 127.

- ADO

  Lorsque vous codez avec l'API ADO et MyODBC, vous devez faire attention aux propriétés par défaut qui ne sont pas supportées par MySQL. Par exemple, en utilisant `CursorLocation Property`, `adUseServer` va retourner un résultat de −1 pour `RecordCount Property`. Pour avoir la bonne valeur, vous devez donner la valeur de `adUseClient` à cette propriété, tel que présenté ci-dessous :

      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

  Un autre palliatif est d'utiliser `SELECT COUNT(*)` pour connaître le nombre de lignes.

- Active server pages (ASP)

  Il est recommandé de sélectionner l'option `Return matching rows`.

- applications BDE

  Pour faire fonctionner ces applications, vous devez sélectionner les options `Don't optimize column widths` et `Return matching rows`.

- Borland Builder 4

  Lorsque vous lancez une requête, vous pouvez utiliser la propriété `Active` ou la méthode `Open`. Notez que `Active` commencera par émettre automatiquement une requête `SELECT * FROM ...`. Cela n'est pas forcément pratique si vos tables sont grandes.

- ColdFusion (On Unix)

  Les informations suivantes sont tirées de la documentation ColdFusion :

  Utilisez les informations suivantes pour configurer le serveur ColdFusion pour Linux avec le pilote unixODBC et MyODBC pour MySQL. Allaire a vérifié que MyODBC 2.50.26 fonctionne avec MySQL 3.22.27 et ColdFusion pour Linux. Toutes les versions plus récentes devraient aussi fonctionner. Vous pouvez télécharger MyODBC sur http://dev.mysql.com/downloads/connector/odbc/.

  ColdFusion Version 4.5.1 vous permet d'utiliser l'administrateur ColdFusion pour ajouter des sources de données MySQL. Cependant, le pilote n'est pas inclus avec ColdFusion Version 4.5.1. Avant que le pilote MySQL n'apparaisse dans les listes de sources ODBC, vous devez compiler et copier le pilote MyODBC dans `/opt/coldfusion/lib/libmyodbc.so`.

  Le dossier Contrib contient le programme `mydsn-`xxx`.zip` qui vous permet de compiler et supprimer le fichier DSN pour les applications Coldfusion qui utilisent le pilote MyODBC.

- DataJunction

  Vous devez changer pour exporter des `VARCHAR` au lieu des types `ENUM`, car l'export de ce dernier pose des problèmes à MySQL.

- Excel

  Fonctionne. Quelques conseils :

  - Si vous avez des problèmes avec les dates, essayez de les transformer en chaîne, avec la fonction `CONCAT()` function. Par exemple :

        SELECT CONCAT(rise_time), CONCAT(set_time)
            FROM sunrise_sunset;

    Les valeurs lues comme des chaînes seront reconnues correctement par Excel97.

    Le but de `CONCAT()` dans cette exemple est de faire croire à ODBC que la colonne est de type ``chaîne''. Sans `CONCAT()`, ODBC sait que la colonne est de type TIME, et Excel ne le comprendra pas.

    Notez que c'est un bogue dans Excel, car il convertit automatiquement une chaîne en heure. Cela serait bien si la source était un fichier de texte, mais malheureusement ici, la connexion ODBC indique le bon type pour chaque colonne.

- Word

  Pour lire des données depuis MySQL vers des documents Word/Excel, vous devez utiliser le pilote MyODBC et le Add-in Microsoft Query.

  Par exemple, pour créer une base de données avec une table avec 2 colonnes de texte :

  - Inserez deux lignes avec le client mysql.

  - Créez un fichier DSN file en utilisant le gestionnaire ODBC, par exemple, `my`, pour la base de données créée.

  - Lancez Word.

  - Créez un document vide.

  - Dans la barre d'outil `Database`, cliquez sur le bouton `Insert Database`.

  - Cliquez sur le bouton `Get Data`.

  - Dans la gauche de l'écran `Get Data`, cliquez sur `Ms Query`.

  - Dans `Ms Query`, créez une nouvelle source de données en utilisant le DSN `my`.

  - Sélectionnez la nouvelle requête.

  - Sélectionnez les colonnes que vous voulez.

  - Ajoutez le filtre que vous voulez.

  - Ajoutez le tri que vous souhaitez.

  - Sélectionnez `Return Data to Microsoft Word`.

  - Cliquez sur `Finish`.

  - Cliquez sur `Insert Data` et sélectionnez les lignes.

  - Cliquez sur `OK` et voyez les lignes dans votre document Word.

- odbcadmin

  Program de test pour ODBC.

- Delphi

  Vous devez utiliser BDE Version 3.2 ou plus récent. Sélectionnez l'option `Don't optimize column width` lors de la connexion à MySQL.

  De plus, il y a des codes pratiques Delphi qui configurer une entrée ODBC et une source BDE pour MyODBC. La source BDE requiert BDE Alias Editor qui est gratuit sur Delphi Super Page. (Merci à Bryan Brunton `<bryan@flesherfab.com>` pour cela):

      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);

- C++ Builder

  Testé avec BDE Version 3.0. Le seul problème est que lorsque le schéma de tables change, les champs de requêtes ne sont pas mis à jour. BDE, de son coté, ne semble pas reconnaître les clés primaires, et seulement l'index appelé `PRIMARY`, mais ce n'est jamais un problème.

- Vision

  Vous devez sélectionner l'option `Return matching rows`.

- Visual Basic

  Pour être capable de modifier une table, vous devez définir une clé primaire dans la table.

  Visual Basic avec ADO ne peut pas gérer les grands entiers. Cela signifie que certaines requêtes comme `SHOW PROCESSLIST` ne fonctionneront pas comme attendu. Pour pallier ce problème, il faut utiliser l'option `OPTION=16384` dans la chaîne de connexion ODBC ou sélectionez l'option `Change BIGINT columns to INT` dans l'écran MyODBC. Vous pouvez aussi sélectionner l'option `Return matching rows`.

- VisualInterDev

  SI vous avez un `BIGINT` dans votre résultat, vous pouvez aussi avoir l'erreur `[Microsoft][ODBC Driver Manager] Driver does not support this parameter` Essayez de sélectionner `Change BIGINT columns to INT` dans la configuration MyODBC.

- Visual Objects

  Vous devriez sélectionner l'option `Don't optimize column widths`.

- MS Visio Enterprise 2000

  Nous avons créé un diagramme de base de données en connectant depuis MS Vision Enterprise 2000 vers MySQL via MyODBC (2.50.37 ou plus récent) et en utilisant les fonctions de retro-ingénierie de Visio pour lire les informations sur la base (Visio montre toutes les définitions de colonnes, les clés primaires, les index, etc.). De plus, nous avons aussi testé la conception de nouvelles tables avec Visio, et avons réussi à les exporter de MySQL via MyODBC.

### 25.1.10. Problèmes avec les connexions MyODBC

This section answers MyODBC connection-related questions.

#### 25.1.10.1. Durant la configuration d'un DSN MyODBC, une erreur `Could Not Load Translator or Setup Library` survient

Pour plus d'informations, reportez-vous à MS KnowledgeBase Article(Q260558). De plus, assurez-vous que vous avez la dernière version `ctl3d32.dll` dans votre système.

#### 25.1.10.2. Lors de la connexion, une erreur `Access denied` survient

Reportez-vous à Section 5.5.8, « Causes des erreurs `Access denied` ».

#### 25.1.10.3. Information : a propos des pools de connexions ODBC

Lisez ce document sur les pools de connexions : http://support.microsoft.com/default.aspx?scid=kb;EN-US;q169470.

### 25.1.11. MyODBC et Microsoft Access

Cette section répond aux questions reliées à MyODBC et Microsoft Access.

#### 25.1.11.1. Comment configurer Microsoft Access pour travailler avec MySQL via MyODBC?

Les instructions suivantes doivent être faites sur votre PC, pour que Microsoft Access fonctionne avec MyODBC.

1. Si vous utilisez Access 2000, vous devez installer la dernière version (2.6 ou plus récent) de Microsoft MDAC (`Microsoft Data Access Components`) depuis http://www.microsoft.com/data/. Cela va corriger un bug d'Access qui survient lors de l'export vers MySQL, si les noms de table et de colonne ne sont pas spécifiés. Un autre moyen de contourner ce bug est de passer en MyODBC 2.50.33 et MySQL 3.23.x, qui pallie ce problème.

   Il est aussi recommandé d'obtenir et appliquer le Microsoft Jet 4.0 Service Pack 5 (SP5), qui est disponible sur http://support.microsoft.com/default.aspx?scid=kb;EN-US;q239114. Cela va corriger certains cas où les colonnes sont marquées comme `#DELETED#` par Access.

   Note : si vous utilisez MySQL 3.22, vous devez appliquer le patch MDAC et utiliser MyODBC 2.50.32 ou 2.50.34 et plus récent pour corriger ce problème.

2. Installez la dernière version de MySQL depuis http://dev.mysql.com/downloads/.

3. Installez la dernière version de MyODBC 3.51 ou 2.50 depuis http://dev.mysql.com/downloads/connector/odbc/.

4. Pour toutes les versions d'Access, il faut activer les options `Return matching rows`.

5. Utilisez Access comme Access interface pour MySQL via MyODBC.

#### 25.1.11.2. Comment exporter une table ou une requête depuis Access vers MySQL?

Vous ne pouvez pas exporter de table ou requête vers MySQL sans avoir installé MyODBC.

Pour exporter une table depuis Access vers MySQL, suivez ces instructions :

1. Lorsque vous ouvrez une base de données Access ou un projet Access, une fenêtre de base de données apparait. Elle affiche les raccourcis pour créer une nouvelle base de donnée, ou ouvrir une base existante.

2. Cliquez sur le nom de la `table` ou de la requête `query` que vous souhaitez exporter, puis dans le menu `File`, sélecitonnez `Export`.

3. Dans la boite de dialogue `Export Object Type `Object name` To`, dans le champ `Save As Type`, sélectionnez `ODBC Databases ()` comme ci-dessous :

4. Dans la boîte de dialogue `Export`, entrez le nom d'un fichier ou bien utilisez le nom suggéré, et sélectionnez `OK`.

5. Le dialogue de sélection de source de données est alors affiché : il affiche les sources de données ODBC disponibles sur votre machine. Cliquez sur l'onglet `File Data Source` ou sur `Machine Data Source`, puis double-cliquez sur la source MyODBC ou MyODBC 3.51 que vous souhaitez exporter. Pour définir une nouvelle source MyODBC, voyez Section 25.1.9.2, « Configuration du DSN MyODBC sur Windows ».

Microsoft Access se connecte alors au serveur via ODBC et exporte les données.

#### 25.1.11.3. Comment importer ou relier des bases de données MySQL avec Access?

Vous ne pouvez pas exporter une table ou une requête vers un serveur MySQL sans avoir installé le pilote MyODBC.

Pour importer ou relier des tables depuis MySQL vers Access, suivez les instructions suivantes :

1. Ouvrez la base de données, ou passez à la fenêtre de bases de données de la base courante.

2. Pour importer des tables, dans le menu `File`, pointer sur `Get External Data`, et cliquez sur `Import`. Pour lier des tables, dans le menu `File`, pointez sur `Get External Data`, et cliquez sur `Link Tables`.

3. Dans le dialogue `Import` (ou `Link`), dans le champ `Files Of Type`, sélectionnez `ODBC Databases ()`. Le dialogue `Select Data Source` liste les différentes sources de données : toutes les sources de tous les pilotes de votre machine sont listées ici. Cliquez sur l'onglet `File Data Source` ou `Machine Data Source`, puis double-cliquez sur une source MyODBC ou MyODBC 3.51, que vous voulez exporter. Pour définir une nouvelle source pour MyODBC ou MyODBC 3.51, voyez Section 25.1.9.2, « Configuration du DSN MyODBC sur Windows ».

4. Si la source ODBC que vous avez sélectionné requiert une identification, saisissez votre nom d'utilisateur et votre mot de passe (ainsi que les informations complémentaires éventuelles), puis cliquez sur `OK`.

5. Microsoft Access se connecte au serveur MySQL via `ODBC` et affiche la liste des tables que vous pouvez `importer` ou `lier`.

6. Cliquez sur chaque table que voulez `importer` ou `lier`, puis cliquez sur `OK`. Si vous liez une table et qu'elle n'a pas d'index unique, alors Microsoft Access affiche une liste de champs dans de la table. Cliquez sur un champ ou une combinaison de champs qui identifieront sans ambiguité une ligne, puis `OK`.

#### 25.1.11.4. La structure ou la localisation d'une table liée a changé. Est-ce que je peux voir ces changements localement?

Oui. Utilisez la procédure suivante pour voir ou rafraîchir les liens lorsque la structure ou la localisation d'une table liée a changé. Le `Linked Table Manager` liste les chemins de toutes les tables liées courantes.

Pour voir ou rafraîchir des liens :

1. Ouvrez la base de données qui contient les tables liées.

2. Dans le menu `Tools`, pointez sur `Add-ins`, et cliquez sur `Linked Table Manager`.

3. Sélectionnez la boîte à cocher des tables que vous voulez rafraîchir.

4. Cliquez sur le bouton `OK`.

Microsoft Access confirme les rafraîchissement réussit, ou, si une table n'a pu être trouvée, affiche le dialogue `Select New Location of` <table name>, dans lequel vous pouvez indiquer les nouvelles informations de la table. Si plusieurs tables ont été déplacées, le `Linked Table Manager` va rechercher dans ce dossier toutes les autres tables sélectionnées : il va mettre à jour plusieurs liens d'un coup.

Pour changer le chemin vers un jeu de tables liées :

1. Ouvrez la base de données qui contient les tables liées.

2. Dans le menu `Tools`, pointer sur `Add-ins`, et cliquez dans `Linked Table Manager`.

3. Sélectionnez la boîte `Always Prompt For A New Location`.

4. Sélectionnez la boîte des tables dont vous voulez modifier les liens, et cliquez dans `OK`.

5. Dans le dialogue `Select New Location of` <table name>, spécifiez la nouvelle localisation, cliquez dans `Open`, puis cliquez dans `OK`.

#### 25.1.11.5. Lorsque j'insère ou modifie une ligne dans des tables liées, j'obtiens `#DELETED#`

Si la ligne insérée ou modifiée est présentée comme `#DELETED#`, alors :

- Si vous utilisez Access 2000, il est recommandé d'installer la dernière version (version 2.6 ou plus récent) Microsoft MDAC (`Microsoft Data Access Components`) depuis http://www.microsoft.com/data/. Cela va corriger un bogue d'Access qui ne spécifie pas les noms des colonnes et des tables lors de leur exportation vers MySQL. Un autre palliatif est de passer en MyODBC 2.50.33 et MySQL 3.23.x, qui compense ce problème.

  Il est aussi recommandé d'appliquer le paquet de service Microsoft Jet 4.0 Service Pack 5 (SP5) qui est disponible sur http://support.microsoft.com/default.aspx?scid=kb;EN-US;q239114. Cela corrigera certains cas où les colonnes sont marquées comme `#DELETED#` dans Access.

  Note : si vous utilisez MySQL 3.22, vous devez appliquer le patch MDAC et utiliser MyODBC 2.50.32 ou 2.50.34 puis corriger ce problème.

- Pour toutes les versions d'Access, il est recommandé d'activer l'option MyODBC `Return matching rows`. Pour Access 2.0, il est recommandé d'ajouter l'option `Simulate ODBC 1.0`.

- Il est recommandé d'avoir un timestamp dans toutes les tables que vous voulez pouvoir modifier. Pour une portabilité maximale, n'utilisez pas de taille de colonne dans la déclaration. C'est à dire, utilisez `TIMESTAMP` et non pas `TIMESTAMP(`n`)`, `n` < 14.

- Il est recommandé d'avoir toujours une clé primaire dans une table. Si non, les nouvelles lignes ou les lignes modifiées peuvent être indiquées comme `#DELETED#`.

- Utilisez uniquement des champs décimaux `DOUBLE`. Access échoue à comparer des décimaux simples. Le symptôme est alors que les nouvelles lignes sont indiquées comme `#DELETED#` ou que vous ne pouvez pas les trouver.

- Si vous utilisez MyODBC pour relier une table qui as une colonne `BIGINT`, le résultat risque d'être affiché comme `#DELETED`. Le palliatif est :

  - Ajoutez une colonne avec le type `TIMESTAMP`.

  - Sélectionnez l'option `Change BIGINT columns to INT` dans le dialogue de connexion du gestionnaire ODBC.

  - Effacez le lien de table depuis Access, puis recréez-le.

  Les anciennes lignes seront affichées comme `#DELETED#`, mais les nouvelles lignes seront affichées correctement.

#### 25.1.11.6. Comment puis-je éviter les conflits d'écriture ou de localisation?

Si vous rencontrez les erreurs suivantes, sélectionnez l'option `Return Matching Rows` dans la configuration du DSN, ou spécifiez `OPTION=2`, comme paramètre de connexion :

    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.

#### 25.1.11.7. Lorsque j'exporte une table depuis Access 97, une erreur de syntaxe etrange survient

C'est une erreur étrange avec Access 97, qui n'apparait plus avec Access 2000 ou 2002. Vous pouvez contourner ce problème en mettant à jour le pilote MyODBC en version MyODBC 3.51.02 ou plus récente.

#### 25.1.11.8. Access retourne l'erreur `Another user has modified the record that you have modified` durant l'édition de lignes

Avec certains programmes, cette erreur survient : `Another user has modified the record that you have modified`. Dans la majorité des cas, ce problème peut être résolu avec l'une des techniques suivantes :

- Ajouter une clé primaire dans la table, s'il n'y en pas.

- Ajouter une colonne timestamp dans la table, s'il n'y en pas.

- Utiliser uniquement des nombre décimaux doubles. Certains programmes échouent lors de la comparaison avec des décimaux simples.

Si ces stratégies ne vous dépannent pas, essayez de faire un log deuis le gestionnaire ODBC (c'est le log que vous obtenez lorsque vous demandez des logs depuis ODBCADMIN), et un log MyODBC vous aideront à comprendre ce qui se passe. Pour des instructions, voyez Section 25.1.9.7, « Obtenir un fichier de trace ODBC ».

#### 25.1.11.9. Comment intercepter les messages d'erreur d'identification ODBC?

Lisez, en anglais, ```How to Trap ODBC Login Error Messages in Access`'' sur http://support.microsoft.com/support/kb/articles/Q124/9/01.asp?LN=EN-US&SD=gn&FR=0%3CP%3E.

#### 25.1.11.10. Comment optimiser les performances d'accès avec MyODBC?

- Optimizing for Client/Server Performance

- Tips for Converting Applications to Using ODBCDirect

- Tips for Optimizing Queries on Attached SQL Tables

#### 25.1.11.11. J'ai de très grandes tables. Quelle est la meilleure configuration pour que MyODBC accède à ces tables?

Si vous avez de très grandes (longues) tables dans Access, elles peuvent prendre beaucoup de temps à s'ouvrir. Ou alors, vous allez consommer beaucoup de mémoire, et finir avec une erreur bloquante de type `ODBC Query Failed`. Pour régler ce problème, sélectionnez une des options suivantes :

- `Return Matching Rows` (2)

- `Allow BIG Results` (8).

La somme de ces deux options fait alors 10 (`OPTION=10`).

#### 25.1.11.12. Comment spécifier la valeur de QueryTimeout pour les connexion ODBC?

Lisez, en anglais, ```Set the QueryTimeout Value for ODBC Connections`'' sur http://support.microsoft.com/default.aspx?scid=kb%3Ben-us%3B153756.

#### 25.1.11.13. INFO : outils pour exporter/importer des données entre Access et MySQL

Voyez la section converters pour une liste d'outils disponibles.

### 25.1.12. MyODBC et Microsoft VBA et ASP

Cette section répond aux questions reliées à MyODBC utilisé avec Microsoft Visual Basic(ADO, DAO & RDO) et ASP.

#### 25.1.12.1. Pourquoi est-ce que `SELECT COUNT(*) FROM `tbl_name`` retourne une erreur?

L'expression `COUNT(*)` retourne un entier de type `BIGINT`, et ADO ne comprend pas les nombres aussi gros. Sélectionnez l'option `Change BIGINT columns to INT` (Valeur 16384).

#### 25.1.12.2. Quand j'utilise les méthodes ADO `AppendChunk()` ou `GetChunk()`, j'ai une erreur `Multiple-step operation generated errors. Check each status value`?

Les méthodes `GetChunk()` et `AppendChunk()` d'ADO ne fonctionnent pas comment on l'attend lorsque la position du curseur est spécifiée avec adUseServer. D'un autre coté, vous pouvez pallier cette erreur avec adUseClient.

Un exemple simple est disponible sur http://www.dwam.net/iishelp/ado/docs/adomth02_4.htm.

#### 25.1.12.3. Comment connaître le nombre total de lignes affectées par une requêtet SQL, avec ADO?

Vous pouvez utiliser la propriété `RecordsAffected` de la méthode ADO execute. Pour plus d'informations sur l'utilisation de cette méthode, voyez http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ado270/htm/mdmthcnnexecute.asp.

#### 25.1.12.4. Comment puis-je gérer des données BLOB avec Visual Basic?

Voici un excellent article de Mike Hillyer (`<m.hillyer@telusplanet.net>`); qui explique comment insérer et/ou lire des données dans des colonnes de type BOLD via MyODBC depuis ADO: MySQL BLOB columns and Visual Basic 6.

#### 25.1.12.5. Comment associer les types de données de Visual Basic avec ceux de MySQL?

Voici un autre article brillant de Mike Hillyer (`<m.hillyer@telusplanet.net>`) : How to map Visual basic data type to MySQL types.

#### 25.1.12.6. Exemple VB avec ADO, DAO et RDO

Des exemples simples pour utiliser ADO, DAO et RDO avec VB sont disponibles sur ces sites :

- Exemple avec ADO : Section 25.1.19, « MyODBC avec VB : ADO, DAO and RDO »

- Exemple avec DAO : Section 25.1.19, « MyODBC avec VB : ADO, DAO and RDO »

- Exemple avec RDO : Section 25.1.19, « MyODBC avec VB : ADO, DAO and RDO »

Si vous trouvez d'autres bons exemples ou des tutoriels ADO/DAO/RDO, alors laissez nous un message sur `<myodbc@lists.mysql.com>`

#### 25.1.12.7. ASP et MySQL avec MyODBC

Pour plus d'informations sur comment accéder à MySQL via ASP avec MyODBC, reportez-vous aux articles suivants :

- Using MyODBC To Access Your MySQL Database Via ASP

- ASP and MySQL at DWAM.NT

Une liste de questions fréquentes pour ASP est disponible sur http://support.microsoft.com/default.aspx?scid=/Support/ActiveServer/faq/data/adofaq.asp.

#### 25.1.12.8. INFO: Question fréquemment posée sur les objets ActiveX Data Objects (ADO)

Pour plus d'informations, voyez ActiveX Data Objects(ADO) Freqently Asked Questions.

### 25.1.13. MyODBC et les outils tierce partie

Cette section répond aux questions relative à MyODBC en conjonction avec des outils ODBC, tels que Microsoft Word et Excel, ainsi que ColdFusion.

#### 25.1.13.1. Comment lire les données MySQL dans un document Word ou Excel?

Pour lire les données de MySQL vers Word/Excel, vous devez installer le pilote MyODBC et le compagnon Microsoft Query (Add-in Office).

Par exemple, créez une base de données avec une table, contenant les deux colonnes suivantes :

- Insérez des lignes avec le client mysql.

- Créez un fichier DSN avec le gestionnaire ODBC, par exemple `my`, pour la base de données quie vous avez créé.

- Lancez Word.

- Créez un nouveau document vide.

- Dans la barre d'outil `Database`, pressez le bouton `Insert Database`.

- Pressez le bouton `Get Data`.

- Sur la gauche de l'écran de `Get Data`, pressez le bouton `Ms Query`.

- Dans `Ms Query`, créez une nouvelle source de données, en utilisant le fichier `my`.

- Selectionnez une requête.

- Sélectionnez les colonnes que vous désirez.

- Ajoutez un filtre si vous voulez.

- Ajoutez un tri si vous voulez.

- Sélectionnez `Return Data to Microsoft Word`.

- Cliquez sur le bouton `Finish`.

- Cliquez sur le bouton `Insert Data` et sélectionnez les lignes.

- Cliquez sur le bouton `OK` et vous pouvez voir les lignes dans votre document Word.

#### 25.1.13.2. L'export des tables depuis MS DTS vers MySQL avec MyODBC conduit à une erreur de syntaxe

Ce problème est similaire à celui de Access 97 lorsque votre table est constituée de données de type `TEXT` ou `VARCHAR`. Vous pouvez corriger ce problème en mettant à jour votre pilote MyODBC en version 3.51.02 ou plus récent.

#### 25.1.13.3. HOWTO : configuration de MySQL, MyODBC, unixODBC et ColdFusion sur Solaris

Reportez-vous à MySQL ColdFusion unixODBC MyODBC and Solaris - how to succeed

### 25.1.14. Fonctionnalités générales de MyODBC

Cette section répond aux questions reliées à MyODBC.

#### 25.1.14.1. Comment obtenir la valeur d'une colonne `AUTO_INCREMENT` avec ODBC

Un problème récurrent est d'obtenir la dernière valeur générée automatiquement par une commande `INSERT`. Avec ODBC, vous pouvez procéder de cette fa¸on (en supposons que `auto` est un champ `AUTO_INCREMENT`):

    INSERT INTO foo (auto,text) VALUES(NULL,'text');
    SELECT LAST_INSERT_ID();

Ou, si vous voulez juste insérer cette valeur dans une autre table :

    INSERT INTO foo (auto,text) VALUES(NULL,'text');
    INSERT INTO foo2 (id,text) VALUES(LAST_INSERT_ID(),'text');

See Section 24.2.13.3, « Comment lire l'identifiant unique de la dernière ligne insérée ».

Pour quelques applications utilisant ODBC (du moins Delphi et Access), la requête suivante peut être utilisée pour trouver une ligne insérée dernièrement :

    SELECT * FROM nom_de_table WHERE auto IS NULL;

#### 25.1.14.2. Est-ce que MyODBC accepte les curseurs dynamiques?

Oui. MyODBC 3.51 supporte les `curseurs dynamiques` avec les modes `Forward-only` et `static`.

A cause des problèmes de performances, le pilote ne supporte pas cette fonctionnalité par défaut. Vous pouvez l'activer en spécifiant l'option de connexion `OPTION=32` ou en cliquant dans l'option `Enable Dynamic Cursor` dans le panneau de configuration DSN.

#### 25.1.14.3. Quelle est la cause de l'erreur `Transactions are not enabled`?

Le pilote retourne cette erreur lorsque l'application émet un appel transactionnel, mais que le serveur MySQL sous-jacent ne supporte pas les transactions.

Pour éviter ce problème, vous devez utiliser un serveur qui dispose des moteurs `InnoDB` ou `BDB` et utilise les tables de ce type. Les serveurs MySQL depuis la version 4.0 supporte `InnoDB` par défaut. Les serveurs MySQL-Max supportent aussi `BDB` sur les plates-formes où `BDB` est disponible.

De plus, si votre serveur supporte les tables transactionnelles `InnoDB` ou `BDB`, assurez-vous que l'option `disable transactions` n'est pas active dans la configuration du DSN.

#### 25.1.14.4. Quelle est la cause de l'erreur `Cursor not found`?

C'est à cause d'applications qui utilisent d'anciennes versions MyODBC 2.50, et qui ne donne pas de nom explicite aux curseurs, via SQLSetCursorName. La solution est de passer à version MyODBC 3.51.

#### 25.1.14.5. Puis-je utiliser des applications MyODBC 2.50 avec MyODBC 3.51?

Oui. Si vous trouvez une erreur avec MyODBC 3.51 qui n'apparait pas avec MyODBC 2.50, envoyez un message mail à `<myodbc@lists.mysql.com>`

#### 25.1.14.6. Puis-je accéder à MySQL depuis .NET avec MyODBC?

Oui. Vous pouvez utiliser odbc.net pour vous connecter à MySQL via MyODBC. Voici quelques exemples simples pour vous connecter à MySQL depuis VC.NET et VB.NET.

- Voyez Section 25.1.20.1, « ODBC.NET : CSHARP(C#) »

- Voyez Section 25.1.20.2, « ODBC.NET: VB »

Voici un autre excellent article : "Exploring MySQL on .NET environment" by Venu (MyODBC developer) qui couvre toutes les interfaces MySQL .NET.

Attention : en utilisant ODBC.NET avec MyODBC, lorsque vous lisez des lignes vides (taille nulle), vous obtiendrez une exception SQL_NO_DATA. Vous pouvez obtenir un partch pour cela sur http://support.microsoft.com/default.aspx?scid=kb;EN-US;q319243.

#### 25.1.14.7. Pourquoi est-ce que MyODBC s'exécute lentement et fait beaucoup d'accès disques pour de petites requêtes?

MyODBC est bien plus rapide que n'importe quel autre pilote ODBC. Des lenteurs peuvent être causées par la mauvaise utilisation des options suivantes.

- L'option ODBC Tracing est active. Vous pouvez vérifier si sette option est active en suivant les instructions suivantes : here.

  Comme vous pouvez le voir dans l'image ci-dessus, l'option 'When to trace' du gestionnaire de sources de données ODBC, onglet 'Tracing', doit toujours pointer sur 'Start Tracing Now', au lieu de 'Stop Tracing Now'.

- La version Debug version du pilote est utilisée. Si vous utilisez la version de déboguage de la bibliothèque DLL, vous sera ralentit par les traitements supplémentaires. Vous pouvez vérifier que vous utilisez la version de déboguage ou non en lisant la section commentaire 'Comments' des propriétés de la bibliothèque DLL (dans le dossier système, faites un clic droit sur le pilote DLL et choisissez les propriétés), tel que présenté ci-dessous :

- L'option Driver trace and query logs est activée. Même si vous envisagez d'utiliser la version de déboguage du pilote (il est recommandé de toujours utiliser la version de production), assurez vous que les traces du pilote et que les logs de requêtes (options OPTION=4,524288 respectivement) ne sont pas activées :

### 25.1.15. Instructions de base pour utiliser MyODBC

Travailler avec un serveur MySQL depuis une application MyODBC se fait en plusieurs étapes :

- Configuration du DSN MyODBC

- Connexion au serveur MySQL

- Initialisation des opérations

- Exécution des requêtes SQL

- Lecture des résultats

- Calcul des transactions

- Déconnexion

La plupart des applications utilisent certaines variations de ces étapes. Les étapes de bases sont présentées dans ce diagramme :

### 25.1.16. Table de référence MyODBC

Cette section rassemble toutes les routines ODBC, classées par catégories.

Pour la référence complète, voyez celle du programmeur ODBC sur http://msdn.microsoft.com/library/en-us/odbc/htm/odbcabout_this_manual.asp.

Une application peut appeler la fonction `SQLGetInfo` pour obtenir les informations de conformité MyODBC. Pour savoir si une fonction spécifique est supportée, vous pouvez appeler `SQLGetFunctions`.

Note : pour assurer la compatibilité ascendante, le pilote MyODBC 3.51 supporte toutes les fonctions obsolètes.

Les tables suivantes listes toutes les fonctions MyODBC, rassemblées par tâche :

Connexion à une source de données :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLAllocHandle` | Non | Oui | ISO 92 | Obtenir un pointeur d'environnement, de connexion, de commande ou de curseur.
`SQLConnect` | Oui | Oui | ISO 92 | Se connecter à une source de données spécifique, avec un pilote donné, avec le nom de source, le mot de passe et le nom d'utilisateur.
`SQLDriverConnect` | Oui | Oui | ODBC | Se connecter à une source de données avec un pilote spécifique et une chaîne de connexion ou une requête du gestionnaire de pilote pour afficher un dialogue.
`SQLAllocEnv` | Oui | Oui | Obsolète | Obtenir un pointeur d'environnement pour un pilote.
`SQLAllocConnect` | Oui | Oui | Obsolète | Obtenir un pointeur de connexion.

Obtenir des informations sur les pilotes et les sources de données :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLDataSources` | Non | Non | ISO 92 | Retourne la liste des sources de données disponibles, gérées par le gestionnaire de pilotes.
`SQLDrivers` | Non | Non | ODBC | Retourne la liste des pilotes installés, leurs attributs et les pointeurs
`SQLGetInfo` | Oui | Oui | ISO 92 | Retourne les informations sur un pilote spécifique et ses sources de données.
`SQLGetFunctions` | Oui | Oui | ISO 92 | Retourne les fonctions supportées par le pilote.
`SQLGetTypeInfo` | Oui | Oui | ISO 92 | Retourne les informations sur les types de données supportées.

Configurer et lire des valeurs d'attributs :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLSetConnectAttr` | Non | Oui | ISO 92 | Configure un attribut de connexion.
`SQLGetConnectAttr` | Non | Oui | ISO 92 | Retourne un attribut de connexion.
`SQLSetConnectOption` | Oui | Oui | Obsolète | Configure une option de connexion.
`SQLGetConnectOption` | Oui | Oui | Obsolète | Retourne une option de connexion.
`SQLSetEnvAttr` | Non | Oui | ISO 92 | Configure un attribut d'environnement.
`SQLGetEnvAttr` | Non | Oui | ISO 92 | Retourne un attribut d'environnement.
`SQLSetStmtAttr` | Non | Oui | ISO 92 | Configure un attribut de commande.
`SQLGetStmtAttr` | Non | Oui | ISO 92 | Retourne un attribut de commande.
`SQLSetStmtOption` | Oui | Oui | Obsolète | Configure une option de commande.
`SQLGetStmtOption` | Oui | Oui | Obsolète | Retourne une option de commande.

Préparation des commandes SQL :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLAllocStmt` | Oui | Oui | Obsolète | Alloue un pointeur de connexion.
`SQLPrepare` | Oui | Oui | ISO 92 | Prépare une commande SQL pour exécution ultérieure.
`SQLBindParameter` | Oui | Oui | ODBC | Assigne un paramètre de commande SQL.
`SQLGetCursorName` | Oui | Oui | ISO 92 | Retourne le nom du curseur associé à une commande.
`SQLSetCursorName` | Oui | Oui | ISO 92 | Spécifie un nom de curseur.
`SQLSetScrollOptions` | Oui | Oui | ODBC | Configure les options qui contrôle un curseur.

Envoi de requête :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLExecute` | Oui | Oui | ISO 92 | Exécute une commande préparée.
`SQLExecDirect` | Oui | Oui | ISO 92 | Exécute une commande.
`SQLNativeSql` | Oui | Oui | ODBC | Retourne le texte d'une commande, tel que traduit par le pilote.
`SQLDescribeParam` | Oui | Oui | ODBC | Retourne la description d'un paramètre spécifique d'une commande.
`SQLNumParams` | Oui | Oui | ISO 92 | Retourne le nombre de paramètre dans une commande.
`SQLParamData` | Oui | Oui | ISO 92 | Utilisé en conjonction avec `SQLPutData` pour fournir des données supplémentaires au moment de l'exécution : pratique pour les données de grande taille.
`SQLPutData` | Oui | Oui | ISO 92 | Envoie une partie ou toute une valeur de paramètre : pratique pour les données de grande taille.

Lecture de résultats et d'informations sur les résultats :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLRowCount` | Oui | Oui | ISO 92 | Retourne le nombre de lignes affectées par une insertion, une modification ou un effacement.
`SQLNumResultCols` | Oui | Oui | ISO 92 | Retourne le nombre de colonnes dans un résultat.
`SQLDescribeCol` | Oui | Oui | ISO 92 | Décrit une colonne dans un résultat.
`SQLColAttribute` | Non | Oui | ISO 92 | Décrit un attribut d'une colonne de résultat.
`SQLColAttributes` | Oui | Oui | Obsolète | Décrit les attributs d'une colonne dans un résultat.
`SQLFetch` | Oui | Oui | ISO 92 | Retourne les lignes d'un résultat multiple.
`SQLFetchScroll` | Non | Oui | ISO 92 | Retourne un résultat scrollable.
`SQLExtendedFetch` | Oui | Oui | Obsolète | Retourne un résultat scrollable
`SQLSetPos` | Oui | Oui | ODBC | Place un curseur dans un bloc lu, et laisse l'application rafraichir les données dans le résultat, pour modifier ou effacer des lignes dans le résultat.
`SQLBulkOperations` | Non | Oui | ODBC | Effectue des insertions de masse et des opérations de masse, y compris les modification, effacement et lecture par signet.

Lecture des erreurs et diagnostics :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLError` | Oui | Oui | Obsolète | Retourne des informations supplémentaires sur une erreur ou un statut.
`SQLGetDiagField` | Oui | Oui | ISO 92 | Retourne des informations supplémentaires sur un diagnostic (un seul champ de la structure de diagnostic).
`SQLGetDiagRec` | Oui | Oui | ISO 92 | Retourne des informations supplémentaires sur un diagnostic (champ multiple de la structure de diagnostic).

Obtention des informations sur la source de données (catalogue de fonctions) :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLColumnPrivileges` | Oui | Oui | ODBC | Retourne la liste des colonnes et les droits associés pour une ou plusieurs tables.
`SQLColumns` | Oui | Oui | X/Open | Retourne la liste des noms de colonnes pour les tables spécifiées.
`SQLForeignKeys` | Oui | Oui | ODBC | Retourne la liste des noms de colonnes dans une clé étrangère, s'il en existe pour les tables mentionnées.
`SQLPrimaryKeys` | Oui | Oui | ODBC | Retourne la liste des noms de colonnes de la clé primaire pour la table.
`SQLSpecialColumns` | Oui | Oui | X/Open | Retourne des informations sur le jeu de colonnes optimal qui identifie de manière unique une ligne, ou les colonnes qui sont automatiquement modifiée si une ligne est modifiée par une transaction.
`SQLStatistics` | Oui | Oui | ISO 92 | Retourne des statistiques sur une table, et la liste des index associés.
`SQLTablePrivileges` | Oui | Oui | ODBC | Rertourne la liste des tables et les droits associés de chaque table.
`SQLTables` | Oui | Oui | X/Open | Retourne la liste des noms de tables stockés dans une source de données spécifique.

Exécution des transactions :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLTransact` | Oui | Oui | Obsolète | Archive ou annule une transaction
`SQLEndTran` | Non | Oui | ISO 92 | Archive ou annule une transaction.

Terminaison d'une commande :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLFreeStmt` | Oui | Oui | ISO 92 | Termine le traitement d'une commande, détruit les résultats et libère toute les ressources.
`SQLCloseCursor` | Oui | Oui | ISO 92 | Détruit un curseur ouvert par une commande.
`SQLCancel` | Oui | Oui | ISO 92 | Annule une commande SQL.

Fin d'une connexion :

Nom de la fonction | MyODBC | MyODBC | Conformité | Utilisation
| 2.50 | 3.51 |  |
`SQLDisconnect` | Oui | Oui | ISO 92 | Ferme la connexion.
`SQLFreeHandle` | Non | Oui | ISO 92 | Libère les ressources occupées par un environnement, une connexion, une commande ou un descripteur.
`SQLFreeConnect` | Oui | Oui | Obsolète | Libère les ressources d'une commande.
`SQLFreeEnv` | Oui | Oui | Obsolète | Libère les ressources d'un environnement.

### 25.1.17. MyODBC Data Types

The following table illustrates how driver maps the server data types to default SQL and C data types:

Native Value | SQL Type | C Type
`bit` | `SQL_BIT` | `SQL_C_BIT`
`tinyint` | `SQL_TINYINT` | `SQL_C_STINYINT`
`tinyint unsigned` | `SQL_TINYINT` | `SQL_C_UTINYINT`
`bigint` | `SQL_BIGINT` | `SQL_C_SBIGINT`
`bigint unsigned` | `SQL_BIGINT` | `SQL_C_UBIGINT`
`long varbinary` | `SQL_LONGVARBINARY` | `SQL_C_BINARY`
`blob` | `SQL_VARBINARY` | `SQL_C_BINARY`
`longblob` | `SQL_VARBINARY` | `SQL_C_BINARY`
`tinyblob` | `SQL_BINARY` | `SQL_C_BINARY`
`mediumblob` | `SQL_LONGVARBINARY` | `SQL_C_BINARY`
`long varchar` | `SQL_LONGVARCHAR` | `SQL_C_CHAR`
`text` | `SQL_LONGVARCHAR` | `SQL_C_CHAR`
`mediumtext` | `SQL_LONGVARCHAR` | `SQL_C_CHAR`
`char` | `SQL_CHAR` | `SQL_C_CHAR`
`numeric` | `SQL_NUMERIC` | `SQL_C_CHAR`
`decimal` | `SQL_DECIMAL` | `SQL_C_CHAR`
`integer` | `SQL_INTEGER` | `SQL_C_SLONG`
`integer unsigned` | `SQL_INTEGER` | `SQL_C_ULONG`
`int` | `SQL_INTEGER` | `SQL_C_SLONG`
`int unsigned` | `SQL_INTEGER` | `SQL_C_ULONG`
`mediumint` | `SQL_INTEGER` | `SQL_C_SLONG`
`mediumint unsigned` | `SQL_INTEGER` | `SQL_C_ULONG`
`smallint` | `SQL_SMALLINT` | `SQL_C_SSHORT`
`smallint unsigned` | `SQL_SMALLINT` | `SQL_C_USHORT`
`real` | `SQL_FLOAT` | `SQL_C_DOUBLE`
`double` | `SQL_FLOAT` | `SQL_C_DOUBLE`
`float` | `SQL_REAL` | `SQL_C_FLOAT`
`double precision` | `SQL_DOUBLE` | `SQL_C_DOUBLE`
`date` | `SQL_DATE` | `SQL_C_DATE`
`time` | `SQL_TIME` | `SQL_C_TIME`
`year` | `SQL_SMALLINT` | `SQL_C_SHORT`
`datetime` | `SQL_TIMESTAMP` | `SQL_C_TIMESTAMP`
`timestamp` | `SQL_TIMESTAMP` | `SQL_C_TIMESTAMP`
`text` | `SQL_VARCHAR` | `SQL_C_CHAR`
`varchar` | `SQL_VARCHAR` | `SQL_C_CHAR`
`enum` | `SQL_VARCHAR` | `SQL_C_CHAR`
`set` | `SQL_VARCHAR` | `SQL_C_CHAR`
`bit` | `SQL_CHAR` | `SQL_C_CHAR`
`bool` | `SQL_CHAR` | `SQL_C_CHAR`

### 25.1.18. Codes d'erreurs MyODBC

La table suivante liste les codes d'erreurs retournés par le pilote, en plus des erreurs fournies par le serveur.

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

### 25.1.19. MyODBC avec VB : ADO, DAO and RDO

Cette section contient des exemples simples qui illustrent l'utilisation de MySQL ODBC 3.51 avec ADO, DAO et RDO.

#### 25.1.19.1. ADO: `rs.addNew`, `rs.delete` et `rs.update`

L'exemple ADO (`ActiveX Data Objects`) suivant crée une table `my_ado` et montre comment utiliser `rs.addNew`, `rs.delete`, et `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

#### 25.1.19.2. DAO : `rs.addNew`, `rs.update` et scrolls

L'exemple DAO (Data Access Objects) suivant crée la table `my_dao` et montre l'utilisation de `rs.addNew`, `rs.update` et le scroll dans les résultats.

    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

#### 25.1.19.3. RDO : `rs.addNew` et `rs.update`

L'exemple RDO (`Remote Data Objects`) crée une table `my_rdo` et illustre l'utilisation de `rs.addNew` et `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

### 25.1.20. MyODBC avec Microsoft .NET

Cette section contient des exemples simples qui illustrent l'utilisation de MyODBC avec ODBC.NET.

#### 25.1.20.1. ODBC.NET : CSHARP(C#)

L'exemple suivant crée une table `my_odbc_net` et illustre l'utilisation de C#.

     /**
     * @sample    : mycon.cs
     * @purpose   : Demo sample for ODBC.NET using MyODBC
     * @author    : Venu, <venu@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 MyODBC 2.50
            /*string MyConString = "DRIVER={MySQL};" +
                                 "SERVER=localhost;" +
                                 "DATABASE=test;" +
                                 "UID=venu;" +
                                 "PASSWORD=venu;" +
                                 "OPTION=3";
            */
            //Connection string for MyODBC 3.51
            string MyConString = "DRIVER={MySQL ODBC 3.51 Driver};" +
                                 "SERVER=localhost;" +
                                 "DATABASE=test;" +
                                 "UID=venu;" +
                                 "PASSWORD=venu;" +
                                 "OPTION=3";

            //Connect to MySQL using MyODBC
            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) {
               Console.WriteLine("Data:" + MyDataReader.GetInt32(0) + " " +
                                           MyDataReader.GetString(1) + " " +
                                           MyDataReader.GetInt64(2)); //Supported only by MyODBC 3.51
             }
             else {
               Console.WriteLine("Data:" + MyDataReader.GetInt32(0) + " " +
                                           MyDataReader.GetString(1) + " " +
                                           MyDataReader.GetInt32(2)); //BIGINTs not supported by MyODBC
             }
            }

            //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");
            }
          }
        }
      }
     }

#### 25.1.20.2. ODBC.NET: VB

L'exemple suivante créée une table `my_vb_net` et illustre l'utilisation de VB.

    ' @sample    : myvb.vb
    ' @purpose   : Demo sample for ODBC.NET using MyODBC
    ' @author    : Venu, <venu@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

                'MyODBC 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
    End Module

### 25.1.21. Crédits

Voici la liste des développeurs qui ont travaillé sur les pilotes MyODBC et MyODBC 3.51 de MySQL AB.

- Micheal (Monty) Widenius

- Venu Anuganti

- Peter Harvey

## 25.2. MySQL et Java (JDBC)

Il y a 2 pilotes JDBC supportés pour MySQL :

- `MySQL Connector/J` de MySQL AB, implémenté 100% Java natif. Ce produit était connu sous le nom de pilote `mm.mysql`. Vous pouvez télécharger `MySQL Connector/J` depuis l'URL http://www.mysql.com/products/connector-j/.

- Le pilote Resin JDBC, qui est disponible sur l'URL http://www.caucho.com/projects/jdbc-mysql/index.xtp.

Pour de la documentation, consultez celle de JDBC et des pilotes pour les fonctionnalités relatives à MySQL.

La documentation de `MySQL Connector/J` est disponible en ligne, sur le site de MySQL AB à http://dev.mysql.com/doc/.

This is a translation of the MySQL Reference Manual that can be found at dev.mysql.com. The original Reference Manual is in English, and this translation is not necessarily as up to date as the English version.

Précédent |  | Suivant
Chapitre 24. API MySQL | Sommaire | Chapitre 26. Gestion des erreurs avec MySQL