Die MyODBC-Architektur basiert auf den im folgenden Diagramm gezeigten fünf Komponenten:

Ein ODBC-Treiber-Manager ist eine Bibliothek zur Verwaltung der Kommunikation zwischen einer ODBC-fähigen Anwendung und Treibern. Seine Hauptfunktionen sind:

Bei Windows und Mac OS X sind ODBC-Treiber-Manager im Betriebssystem enthalten. Die meisten Implementierungen von ODBC-Treiber-Managern umfassen auch eine Administrationsanwendung, um die Konfiguration von DSN und Treibern zu vereinfachen. Beispiele und Informationen zu diesen Managern, einschließlich der ODBC-Treiber-Manager von Unix, sind im Folgenden aufgelistet:

Bevor Sie die MyODBC-Treiber auf Windows installieren, sollten Sie sicherstellen, dass Ihre Microsoft Data Access Components (MDAC) auf dem neuesten Stand sind. Die aktuellste Version erhalten Sie auf der Website Microsoft Data Access and Storage.

Für die Windows-Installation stehen drei Distributionstypen zur Verfügung. Der Inhalt ist immer derselbe; nur die Installationsmethode ist unterschiedlich.

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

Es gibt zwei Methoden, um MyODBC auf Unix von einer Binärdistribution zu installieren. Für die meisten Unix-Umgebungen wird die Tarball-Distribution benötigt. Für Linux-Systeme steht außerdem eine RPM-Distribution zur Verfügung.

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

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

shell> su root
 shell> rpm -ivh MyODBC-3.51.12.i386.rpm

shell> su root
shell> rpm -Uvh MyODBC-3.51.12.i386.rpm

shell> su root
shell> rpm -e MyODBC

Mac OS X basiert auf dem Betriebssystem FreeBSD. Normalerweise können Sie den MySQL-Netzwerkanschluss benutzen, um sich mit MySQL Servern auf anderen Hosts zu verbinden. Die Installation des MyODBC-Treibers versetzt Sie in die Lage, sich mit MySQL-Datenbanken auf jeder beliebigen Plattform über die ODBC-Schnittstelle zu verbinden. Den MyODBC-Treiber müssen Sie nur dann installieren, wenn Ihre Anwendung eine ODBC-Schnittstelle benötigt. Zu den Anwendungen, die ODBC (und somit auch den MyODBC-Treiber) erfordern oder nutzen können, gehören ColdFusion, Filemaker Pro, 4th Dimension und viele andere mehr.

Mac OS X enthält einen eigenen ODBC-Manager, der auf dem iODBC-Manager basiert. Mac OS X hat ein Administrationstool, das die Administration von ODBC-Treibern und die Konfiguration erleichtert, wobei die zugrunde liegenden iODBC-Konfigurationsdateien aktualisiert werden.

Auf Windows müsste eine Quellinstallation von MyODBC nur dann nötig sein, wenn Sie die Quelle oder die Installation ändern möchten. Wenn Sie unsicher sind, ob Sie von Quelldateien installieren sollten, verwenden Sie besser die Binärinstallation, die in Abschnitt 25.1.2.3.1, „Installation von MyODBC aus einer Binärdistribution unter Windows“, beschrieben ist.

Für eine Quellinstallation von MyODBC auf Windows sind verschiedene Tools und Pakete erforderlich:

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

Folgende Tools werden benötigt, um MySQL auf Unix aus der Quelldistribution zu erstellen:

Wenn Sie alle erforderlichen Dateien beisammen haben, extrahieren Sie die Quelldateien in ein getrenntes Verzeichnis. Danach führen Sie configure aus und erstellen mit make die Bibliothek.

shell> ./configure --help

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

shell> make

--without-server --enable-shared

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

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

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

shell> make install

shell> make test

shell> ./configure --prefix=/usr/local
          --with-unixODBC=/usr/local
          --with-mysql-path=/usr/local/mysql
          --disable-shared
          --enable-gui=no
          --host=powerpc-apple

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

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

shell> otool -LD .libs/libmyodbc3-3.51.01.so

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

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

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

Achtung: Bitte lesen Sie den folgenden Abschnitt nur dann, wenn Sie daran interessiert sind, uns zu helfen oder Code zu testen. Wenn Sie MySQL Connector/ODBC lediglich auf Ihrem System ans Laufen bringen möchten, benutzen Sie bitte eine Standard-Release-Distribution.

Um auf den Quellbaum von MyODBC zugreifen zu können, müssen Sie Subversion installiert haben. Subversion ist kostenlos unter http://subversion.tigris.org/ erhältlich.

Folgende Tools sind erforderlich, um MyODBC von den Quellbäumen erstellen zu können:

Den aktuellsten Quellbaum in der Entwicklung finden Sie unter unseren öffentlichen Subversion-Bäumen unter http://dev.mysql.com/tech-resources/sources.html.

Um die Connector/ODBC-Quelldateien auszuchecken, gehen Sie in das Verzeichnis, in welches Sie den zu speichernden MyODBC-Baum kopieren möchten, und geben folgenden Befehl ein:

shell> svn co http://svn.mysql.com/svnpublic/connector-odbc3

Danach dürfte eine Kopie des gesamten MyODBC-Quellbaums im Verzeichnis connector-odbc3 vorliegen. Auf Unix oder Linux erstellen Sie den Build aus diesen Quelldateien wie folgt:

shell> cd connector-odbc3
shell> aclocal
shell> autoheader
shell> autoconf
shell> automake;
shell> ./configure  # Hier geben Sie Ihre Optionen an
shell> make

Weitere Informationen über den Build finden Sie in der Datei INSTALL, die in demselben Verzeichnis liegt. Über configure-Optionen können Sie unter Abschnitt 25.1.2.4.2.1, „Typische configure-Optionen“, Genaueres erfahren.

Nach dem Build führen Sie make install aus, um den MyODBC 3.51-Treiber auf Ihrem System zu installieren.

Wenn Sie bis make vorgedrungen sind, aber die Distribution sich nicht kompilieren lässt, schicken Sie bitte einen Bericht an <myodbc@lists.mysql.com>.

Auf Windows können Sie zur Erstellung des Treibers die Windows-Makefiles WIN-Makefile und WIN-Makefile_debug benutzen. Weiteres erfahren Sie unter Abschnitt 25.1.2.4.1, „Installation von MyODBC aus einer Quelldistribution unter Windows“.

Nach dem ersten Auschecken, mit dem Sie den Quellbaum heruntergeladen haben, sollten Sie regelmäßig svn update laufen lassen, um Ihre Quelldateien mit den neuesten Versionen zu aktualisieren.

Zum Hinzufügen und Konfigurieren einer neuen MyODBC-Datenquelle auf Windows benutzen Sie den ODBC-Datenquellen-Administrator:

Eine vollständige DSN-Konfiguration kann folgendermaßen aussehen:

Um die Verbindung mit den von Ihnen eingegebenen Parametern zu überprüfen, klicken Sie auf Test. Lässt sich die Verbindung problemlos einrichten, erscheint ein Dialog mit der Meldung Success; connection was made! (abhängig von den Spracheinstellungen auch auf Deutsch).

Wenn die Verbindung nicht zustande kam, können Sie Informationen über den Test und die Gründe seines Scheiterns mit einem Klick auf Diagnostics einholen. Es werden dann zusätzliche Fehlermeldungen angezeigt.

Sie können eine Reihe von Optionen für einen konkreten DSN einstellen, indem Sie im DSN-Konfigurationsdialog entweder eine der Registerkarten Connect Options oder Advanced anklicken.

Den Dialog Connect Options sehen Sie unten.

Folgende drei Optionen können konfiguriert werden:

Auf der Registerkarte Advanced können Sie MyODBC-Verbindungsparameter einstellen. Informationen über die Bedeutung dieser Optionen finden Sie unter Abschnitt 25.1.3.5, „MyODBC: Verbindungsparameter“.

Dieser Abschnitt beantwortet Fragen im Zusammenhang mit MyODBC-Verbindungen.

Trace-Option auf Windows aktivieren:

Um die Trace-Option unter Mac OS X 10.3 oder höher zu aktivieren, nutzen Sie die Registerkarte Tracing im ODBC Administrator .

Um die Trace-Option unter Mac OS X 10.2 (oder früher) oder unter Unix einzuschalten, müssen Sie die trace-Option zur ODBC-Konfiguration hinzufügen:

Ein MyODBC-Log wird folgendermaßen erstellt:

Wenn Sie Hilfe benötigen, um herauszufinden, wo das Problem liegt, schauen Sie in Abschnitt 25.1.7.1, „MyODBC: Community-Support“.

MyODBC wurde mit folgenden Anwendungen getestet:

Wenn Sie von anderen Anwendungen wissen, dass sie mit MyODBC funktionieren, melden Sie sie bitte per E-Mail an <myodbc@lists.mysql.com>.

Sie können Microsoft Word und Microsoft Excel nutzen, um auf Daten einer MySQL-Datenbank mithilfe von MyODBC zuzugreifen. In Microsoft Word ist diese Fähigkeit besonders nützlich, wenn Daten für einen Serienbrief importiert oder Tabellen und Daten in Reports eingebunden werden sollen. In Microsoft Excel können Sie Anfragen auf Ihrem MySQL Server verarbeiten und die Daten direkt in ein Excel-Arbeitsblatt importieren, wo sie dann in Form von Zeilen und Spalten dargestellt werden.

In beiden Anwendungen werden die Daten mit Microsoft Query abgefragt und importiert. Diese Anwendung kann eine Anfrage über eine ODBC-Quelle ausführen. Sie erstellen mit Microsoft Query die SQL-Anweisung, die ausgeführt werden soll, und wählen dabei die Tabellen, Felder, Auswahlkriterien und Sortierreihenfolge. Um beispielsweise Tabellendaten aus einer Tabelle der Testdatenbank World in ein Excel-Arbeitsblatt einzufügen und dazu die DSN-Beispiele aus Abschnitt 25.1.3, „MyODBC: Konfiguration“, zu verwenden, gehen Sie folgendermaßen vor:

Mit demselben Verfahren können Sie Daten auch in ein Word-Dokument importieren, wo sie in Form einer Tabelle eingefügt werden. Dies kann für Serienbriefe genutzt werden (wo die Felddaten aus einer Word-Tabelle gelesen werden) oder auch zum Einbinden von Daten und Berichten in einen anderen Bericht oder ein Dokument.

Unter Verwendung von MyODBC können Sie MySQL-Datenbanken auch mit Microsoft Access benutzen. Die MySQL-Datenbank kann als Importquelle, als Exportquelle oder als verknüpfte Tabelle verwendet werden, die direkt in einer Access-Anwendung eingesetzt wird. So wird Access zu einem Frontend einer MySQL-Datenbank.

Dieser Abschnitt zeigt einfache Beispiele für die Verwendung des MySQL ODBC 3.51-Treibers mit ADO, DAO und RDO.

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

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

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

Dieser Abschnitt zeigt einfache Beispiele für die Verwendung von MyODBC-Treibern mit ODBC.NET.

/**
 * @sample    : mycon.cs
 * @purpose   : Demo sample for ODBC.NET using MyODBC
 * @author    : Venu, <myodbc@lists.mysql.com>
 *
 * (C) Copyright MySQL AB, 1995-2006
 *
 **/
          
/* Build-Befehl
 *
 *  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
        {
          //Verbindungs-String für MyODBC 2.50
          /*string MyConString = "DRIVER={MySQL};" +
            "SERVER=localhost;" +
            "DATABASE=test;" +
            "UID=venu;" +
            "PASSWORD=venu;" +
            "OPTION=3";
          */
          //Verbindungs-String für MyODBC 3.51
          string MyConString = "DRIVER={MySQL ODBC 3.51 Driver};" +
            "SERVER=localhost;" +
            "DATABASE=test;" +
            "UID=venu;" +
            "PASSWORD=venu;" +
            "OPTION=3";
          
          //Verbindung zu MySQL mittels MyODBC
          OdbcConnection MyConnection = new OdbcConnection(MyConString);
          MyConnection.Open();
          
          Console.WriteLine("\n !!! success, connected successfully !!!\n");
          
          //Verbindungs-Informationen anzeigen
          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);
          
          //Beispieltabelle anlegen
          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) {
                //Nur von MyODBC 3.51 unterstützt
                Console.WriteLine("Data:" + MyDataReader.GetInt32(0) + " " +
                                  MyDataReader.GetString(1) + " " +
                                  MyDataReader.GetInt64(2)); 
              }
              else {
                //BIGINTs werden von MyODBC nicht unterstützt
                Console.WriteLine("Data:" + MyDataReader.GetInt32(0) + " " +
                                  MyDataReader.GetString(1) + " " +
                                  MyDataReader.GetInt32(2)); 
              }
            }
          
          //Alle Ressourcen schließen
          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");
            }
        }
    }
  }
}

' @sample    : myvb.vb
' @purpose   : Demo sample for ODBC.NET using MyODBC
' @author    : Venu, <myodbc@lists.mysql.com>
'
' (C) Copyright MySQL AB, 1995-2006
'
'

'
' build command
'
' vbc /target:exe
'     /out:myvb.exe
'     /r:Microsoft.Data.Odbc.dll
'     /r:System.dll
'     /r:System.Data.dll
'

Imports Microsoft.Data.Odbc
Imports System

Module myvb
  Sub Main()
    Try

      '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

Den Wert einer Spalte, die nach einer INSERT-Anweisung AUTO_INCREMENT verwendet, kann man auf mehrere Weisen beschaffen. Um ihn unmittelbar nach dem INSERT abzurufen, verwendet man eine SELECT-Anfrage mit der LAST_INSERT_ID()-Funktion.

Mit MyODBC würden Sie hier zwei Anweisungen absetzen: die INSERT-Anweisung und die SELECT-Anfrage, die Ihnen den Auto-Increment-Wert liefert.

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

Wenn Sie den Wert nicht für Ihre Anwendung, aber für ein anderes INSERT benötigen, können Sie das Ganze auch mit folgenden beiden Anweisungen erledigen:

INSERT INTO tbl (auto,text) VALUES(NULL,'text');
INSERT INTO tbl2 (id,text) VALUES(LAST_INSERT_ID(),'text');

Manche ODBC-Anwendungen (darunter Delphi und Access) haben Schwierigkeiten, mit den oben gezeigten Methoden den Auto-Increment-Wert abzurufen. Hier bietet sich als Alternative folgende Anweisung an:

SELECT * FROM tbl WHERE auto IS NULL;

Siehe Abschnitt 24.2.13.3, „Wie erhalte ich die eindeutige Kennung für die letzte eingefügte Zeile?“.

MyODBC 3.51 bietet zwar dynamic cursor-Unterstützung, aber nach Voreinstellung sind dynamische Cursors nicht aktiviert. In Windows schalten Sie diese Funktion ein, indem Sie das Kontrollkästchen Dynamische Cursor aktivieren im ODBC-Datenquellen-Administrator markieren.

Auf anderen Plattformen schalten Sie dynamische Cursors ein, indem Sie zu dem Wert von OPTION den Wert 32 addieren, wenn Sie den DSN anlegen.

Der MyODBC-Treiber wurde auf eine sehr schnelle Leistung hin optimiert. Wenn Sie Probleme mit der Leistung von MyODBC haben oder viele Plattenzugriffe für einfache Anfragen auftreten, sollten Sie mehrere Dinge überprüfen:

Wie Sie in Microsoft Windows ein Anfragen-Timeout einstellen, wenn Anfragen über eine ODBC-Verbindung ausgeführt werden, erfahren Sie in folgendem Artikel der Microsoft Knowledge Base: http://support.microsoft.com/default.aspx?scid=kb%3Ben-us%3B153756.

Die meisten Microsoft-Anwendungen wurden mit MyODBC getestet, einschließlich Microsoft Office, Microsoft Access und den verschiedenen von ASP und Microsoft Visual Studio unterstützten Programmiersprachen.

Wenn Sie mit MyODBC Probleme haben, aber Ihr Programm auch mit OLEDB funktioniert, sollten Sie den OLEDB-Treiber ausprobieren.

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

Für alle Borland-Anwendungen, in denen die Borland Database Engine (BDE) benutzt wird, gelten folgende Hinweise zur Verbesserung der Kompatibilität:

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

Die folgenden Informationen wurden der ColdFusion-Dokumentation entnommen:

Anhand der folgenden Informationen konfigurieren Sie den ColdFusion Server für Linux für die Benutzung des unixODBC-Treibers mit MyODBC für MySQL-Datenquellen. Allaire hat sichergestellt, dass MyODBC 2.50.26 mit MySQL 3.22.27 und ColdFusion für Linux funktioniert. (Auch alle neueren Versionen müssten funktionieren.) Sie können MyODBC unter folgender Adresse herunterladen: http://dev.mysql.com/downloads/connector/odbc/.

Die ColdFusion-Version 4.5.1 ermöglicht es, die MySQL-Datenquelle mit ColdFusion Administrator zu laden. Allerdings wird der Treiber mit der ColdFusion-Version 4.5.1 nicht mitgeliefert. Bevor der MySQL-Treiber in der Dropdown-Liste der ODBC-Datenquellen auftaucht, müssen Sie den MyODBC-Treiber bauen und in /opt/coldfusion/lib/libmyodbc.so kopieren.

Das Contrib-Verzeichnis enthält das Programm mydsn-xxx.zip, mit dem Sie die DSN-Registrierungsdatei für den MyODBC-Treiber in ColdFusion-Anwendungen erstellen und entfernen können.

Weitere Informationen und Hinweise für die Benutzung von ColdFusion und MyODBC finden Sie auf folgenden externen Sites:

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

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

Sie müssen dafür sorgen, dass VARCHAR statt ENUM ausgegeben wird, da ENUM in einer Weise exportiert wird, die MySQL Schwierigkeiten verursacht.

Aktivieren Sie bitte die Option Return matching rows.

Mit dem Installer gelingt die Installation von Connector/NET auf Windows am einfachsten. Er installiert den Quellcode, den Testcode und die vollständige Referenzdokumentation.

Connector/NET wird auf allen Windows-Betriebssystemen mit einem Windows-Installer (.msi-Installations-Package) installiert. Das MSI-Package liegt in einem ZIP-Archiv namens mysql-connector-net-version.zip, wobei version die Connector/NET-Version ist.

Connector/NET installieren Sie wie folgt:

Wenn Sie nichts anderes eingestellt haben, wird Connector/NET C:\Program Files\MySQL\MySQL Connector Net X.X.X installiert, wobei X.X.X die installierte Version von Connector/NET ist. Neue Installationen werden die vorhandenen Versionen von Connector/NET nicht überschreiben.

Je nach Installationstyp werden einige oder alle der folgenden Komponenten installiert:

Wenn Sie Schwierigkeiten mit dem Installer haben, können Sie auch eine .zip-Datei ohne Installer herunterladen. Diese Datei heißt mysql-connector-net-version-noinstall.zip. Die darin enthaltenen Dateien extrahieren Sie in ein Verzeichnis Ihrer Wahl.

Die .zip-Datei enthält folgende Verzeichnisse:

Es gibt keinen Installer für Connector/NET auf Unix, aber die Installation ist dennoch ganz einfach. Vorher müssen Sie gewährleisten, dass Sie über eine funktionierende Mono-Installation verfügen.

Installieren Sie Connector/NET bitte nur auf Unix, wenn Sie sich mit einem MySQL Server über Mono verbinden wollen. Möchten Sie Connector/NET in einer anderen Umgebung, wie beispielsweise Java oder Perl, installieren oder damit arbeiten, wählen Sie bitte eine passendere Komponente für die Verbindungen aus. Weitere Informationen finden Sie unter Kapitel 25, Connectors, oder Kapitel 24, APIs und Bibliotheken.

Um Connector/NET auf Unix/Mono zu installieren, gehen Sie folgendermaßen vor:

Nach der Installation sind an Anwendungen, die mit der Connector/NET-Komponente installiert wurden, keine weiteren Änderungen mehr erforderlich. Sie müssen allerdings darauf achten, die Connector/NET-Komponente mit der Kommandozeilenoption -r:MySqlData.dll beim Kompilieren Ihrer Anwendungen einzubinden.

Jegliche Interaktion zwischen einer .NET-Anwendung und einem MySQL Server vollzieht sich durch ein MySqlConnection-Objekt. Also muss, ehe Sie mit dem Server kommunizieren können, zunächst ein MySqlConnection-Objekt erzeugt, konfiguriert und geöffnet werden.

Auch wenn die Klasse MySqlHelper benutzt wird, wird ein MySqlConnection-Objekt von dieser Hilfsklasse angelegt.

In diesem Abschnitt wird beschrieben, wie man über das MySqlConnection-Objekt mit MySQL Verbindung aufnimmt.

Das MySqlConnection-Objekt ist für einen Verbindungs-String konfiguriert. Dieser String enthält mehrere, durch Semikola getrennte Schlüssel/Wert-Paare, die jeweils durch ein Gleichheitszeichen verbunden sind.

Sehen Sie hier ein Beispiel für einen Verbindungs-String:

    Server=127.0.0.1;Uid=root;Pwd=12345;Database=test;
    

In diesem Beispiel ist das MySqlConnection-Objekt so konfiguriert, dass es sich mit einem MySQL Server auf 127.0.0.1 verbindet und dazu den Benutzernamen root und das Passwort 12345 verwendet. Als Standarddatenbank für alle Anweisungen benutzen wir test.

Die folgenden Optionen werden typischerweise gesetzt (eine vollständige Liste der Optionen finden Sie in der nachfolgenden Tabelle):

Die folgende Tabelle führt die Namen für alle zulässigen Schlüsselwortwerte des ConnectionStrings auf.

Sobald Sie den Verbindungs-String angelegt haben, können Sie ihn nutzen, um eine Verbindung zu einem MySQL Server damit aufzubauen.

Der folgende Code erzeugt ein MySqlConnection-Objekt, weist den Verbindungs-String zu und öffnet die Verbindung.

Visual Basic-Beispiel

Dim conn As New MySql.Data.MySqlClient.MySqlConnection
Dim myConnectionString as String

myConnectionString = "server=127.0.0.1;" _
            & "uid=root;" _
            & "pwd=12345;" _
            & "database=test;"

Try
  conn.ConnectionString = myConnectionString
  conn.Open()

Catch ex As MySql.Data.MySqlClient.MySqlException
  MessageBox.Show(ex.Message)
End Try
  

C#-Beispiel

MySql.Data.MySqlClient.MySqlConnection conn;
string myConnectionString;
    
myConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";
  
try
{
    conn = new MySql.Data.MySqlClient.MySqlConnection();
    conn.ConnectionString = myConnectionString;
    conn.Open();
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show(ex.Message);
}

Sie können den Verbindungs-String auch an den Klassenkonstruktor von MySqlConnection übergeben:

Visual Basic-Beispiel

Dim myConnectionString as String

myConnectionString = "server=127.0.0.1;" _
              & "uid=root;" _
              & "pwd=12345;" _
              & "database=test;" 

Try
    Dim conn As New MySql.Data.MySqlClient.MySqlConnection(myConnectionString)
    conn.Open()
Catch ex As MySql.Data.MySqlClient.MySqlException
   MessageBox.Show(ex.Message)
End Try
  

C#-Beispiel

MySql.Data.MySqlClient.MySqlConnection conn;
string myConnectionString;

myConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";

try
{
    conn = new MySql.Data.MySqlClient.MySqlConnection(myConnectionString);
    conn.Open();
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show(ex.Message);
}

Sobald die Verbindung geöffnet ist, können auch andere Connector/NET-Klassen sie zur Kommunikation mit dem MySQL Server nutzen.

Da eine Verbindung mit einem externen Server immer Unwägbarkeiten in sich birgt, muss Ihre .NET-Anwendung auch mit Fehlern umgehen können. Tritt bei der Verbindung ein Fehler auf, gibt die Klasse MySqlConnection ein MySqlException-Objekt zurück. Dieses Objekt hat zwei Eigenschaften, die für die Fehlerbehandlung interessant sind:

Sie können die Reaktion Ihrer Anwendung auf Fehler auf der Basis der Fehlernummer gestalten. Die beiden Fehler, die bei Verbindungsproblemen am häufigsten auftreten, sind:

Der folgende Code zeigt, wie die Anwendung auf die jeweilige Fehlernummer reagieren kann:

Visual Basic-Beispiel

Dim myConnectionString as String

myConnectionString = "server=127.0.0.1;" _
          & "uid=root;" _
          & "pwd=12345;" _
          & "database=test;" 

Try
    Dim conn As New MySql.Data.MySqlClient.MySqlConnection(myConnectionString)
    conn.Open()
Catch ex As MySql.Data.MySqlClient.MySqlException
    Select Case ex.Number
        Case 0
            MessageBox.Show("Cannot connect to server. Contact administrator")
        Case 1045
            MessageBox.Show("Invalid username/password, please try again")
    End Select
End Try
  

C#-Beispiel

MySql.Data.MySqlClient.MySqlConnection conn;
string myConnectionString;

myConnectionString = "server=127.0.0.1;uid=root;" +  
    "pwd=12345;database=test;";

try
{
    conn = new MySql.Data.MySqlClient.MySqlConnection(myConnectionString);
    conn.Open();
}
    catch (MySql.Data.MySqlClient.MySqlException ex)
{
    switch (ex.Number)
    {
        case 0:
            MessageBox.Show("Cannot connect to server.  Contact administrator");
        case 1045:
            MessageBox.Show("Invalid username/password, please try again");
    }
}
  

Wichtig: Wenn Sie Datenbanken mit mehreren Sprachen verwenden, müssen Sie den jeweiligen Zeichensatz im Verbindungs-String angeben, sonst wird latin1 als Standardzeichensatz zugrunde gelegt. Ein Beispiel für die Angabe eines Zeichensatzes im Verbindungs-String folgt:

MySqlConnection myConnection = new MySqlConnection("server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;Charset=latin1;");

Seit MySQL 4.1 ist es möglich, vorbereitete Anweisungen mit Connector/NET zu verwenden. Diese können bei Anfragen, die immer wieder ausgeführt werden müssen, die Leistung massiv steigern.

Die vorbereitete Ausführung von Anweisungen ist viel schneller als die direkte Ausführung, da die Anfrage nur ein einziges Mal geparst werden muss. Bei einer Direktausführung müsste sie jedes Mal von neuem geparst werden. Außerdem kann die vorbereitete Ausführung die Netzwerklast reduzieren, da bei der Ausführung einer vorbereiteten Anweisung nur die Parameterdaten übermittelt werden müssen.

Ein weiterer Vorteil vorbereiteter Anweisungen ist die Verwendung eines Binärprotokolls, das die Datenübertragung zwischen Client und Server beschleunigt.

Um eine Anweisung vorzubereiten, erzeugen Sie ein Befehlsobjekt und stellen die Eigenschaft .CommandText auf Ihre Anfrage ein.

Nach dem Eintritt in die Anweisung rufen Sie die .Prepare-Methode des MySqlCommand-Objekts auf. Ist die Anweisung vorbereitet, fügen Sie die Parameter für die dynamischen Elemente der Anfrage hinzu.

Danach führen Sie die Anweisung mit .ExecuteNonQuery()-, .ExecuteScalar()- oder .ExecuteReader-Methoden aus.

Für jede weitere Ausführung müssen Sie nur noch die Parameterwerte einstellen und dann die Ausführungsmethode erneut aufrufen. Es ist nicht mehr erforderlich, die .CommandText-Eigenschaft zu setzen oder die Parameter umzudefinieren.

Visual Basic-Beispiel

Dim conn As New MySqlConnection
Dim cmd As New MySqlCommand
  
conn.ConnectionString = strConnection

Try
   conn.Open()
   cmd.Connection = conn
 
   cmd.CommandText = "INSERT INTO myTable VALUES(NULL, ?number, ?text)"
   cmd.Prepare()

   cmd.Parameters.Add("?number", 1)
   cmd.Parameters.Add("?text", "One")

   For i = 1 To 1000
       cmd.Parameters["?number"].Value = i
       cmd.Parameters["?text"].Value = "A string value"

       cmd.ExecuteNonQuery()
     Next 
Catch ex As MySqlException
    MessageBox.Show("Error " & ex.Number & " has occurred: " & ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
  

C#-Beispiel

MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;
  
conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();

conn.ConnectionString = strConnection;

try
{
    conn.Open();
    cmd.Connection = conn;

    cmd.CommandText = "INSERT INTO myTable VALUES(NULL, ?number, ?text)";
    cmd.Prepare();

    cmd.Parameters.Add("?number", 1);
    cmd.Parameters.Add("?text", "One");

    for (int i=1; i <= 1000; i++)
    {
        cmd.Parameters["?number"].Value = i;
        cmd.Parameters["?text"].Value = "A string value";

        cmd.ExecuteNonQuery();
    }
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show("Error " + ex.Number + " has occurred: " + ex.Message,
        "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}

Seit der MySQL-Version 5 kennt der MySQL Server nun auch gespeicherte Prozeduren mit der Syntax von SQL 2003.

Eine gespeicherte Prozedur besteht in einer Reihe von SQL-Anweisungen, die im Server gespeichert werden können. fortan müssen die Clients keine individuellen Anweisungen mehr geben, sondern können stattdessen auf die gespeicherte Prozedur verweisen.

Gespeicherte Prozeduren können vor allem in folgenden Situationen nützlich sein:

Connector/NET unterstützt den Aufruf von gespeicherten Prozeduren mit dem MySqlCommand-Objekt. Zur Übergabe von Daten in die und aus der gespeicherten Prozedur von MySQL dient die MySqlCommand.Parameters-Collection.

Hinweis:  Wenn Sie eine gespeicherte Prozedur aufrufen, setzt das Befehlsobjekt einen zusätzlichen SELECT-Aufruf ab, um die Parameter der gespeicherten Prozedur zu ermitteln. Sie müssen sicherstellen, dass der Benutzer, der die Prozedur aufruft, die SELECT-Berechtigung für die mysql.proc-Tabelle besitzt, um die Parameter überprüfen zu können. Sonst wird beim Aufruf der Prozedur ein Fehler ausgelöst.

Eine tiefer gehende Erörterung zu gespeicherten Prozeduren finden Sie in http://dev.mysql.com/doc/mysql/en/stored-procedures.html, aber nicht im vorliegenden Abschnitt.

Eine Beispielanwendung zur Verwendung von gespeicherten Prozeduren mit Connector/NET finden Sie im Samples-Verzeichnis Ihrer Connector/NET-Installation.

In MySQL gibt es mehrere Möglichkeiten, gespeicherte Prozeduren anzulegen. Erstens können gespeicherte Prozeduren mit dem Kommandozeilen-Client mysql erzeugt werden, zweitens mit dem GUI-Client MySQL Query Browser und drittens mit der .ExecuteNonQuery-Methode des MySqlCommand-Objekts:

Visual Basic-Beispiel

Dim conn As New MySqlConnection
Dim cmd As New MySqlCommand

conn.ConnectionString = "server=127.0.0.1;" _
    & "uid=root;" _
    & "pwd=12345;" _
    & "database=test"

Try
    conn.Open()
    cmd.Connection = conn

    cmd.CommandText = "CREATE PROCEDURE add_emp(" _
        & "IN fname VARCHAR(20), IN lname VARCHAR(20), IN bday DATETIME, OUT empno INT) " _
        & "BEGIN INSERT INTO emp(first_name, last_name, birthdate) " _
        & "VALUES(fname, lname, DATE(bday)); SET empno = LAST_INSERT_ID(); END"
 
    cmd.ExecuteNonQuery()
Catch ex As MySqlException
    MessageBox.Show("Error " & ex.Number & " has occurred: " & ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try

C#-Beispiel

MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;

conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();

conn.ConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";

try
{
    conn.Open();
    cmd.Connection = conn;

    cmd.CommandText = "CREATE PROCEDURE add_emp(" +
        "IN fname VARCHAR(20), IN lname VARCHAR(20), IN bday DATETIME, OUT empno INT) " +
        "BEGIN INSERT INTO emp(first_name, last_name, birthdate) " +
        "VALUES(fname, lname, DATE(bday)); SET empno = LAST_INSERT_ID(); END";

    cmd.ExecuteNonQuery();
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
MessageBox.Show("Error " + ex.Number + " has occurred: " + ex.Message,
    "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}

Wenn Sie gespeicherte Prozeduren in Connector/NET anlegen, sind Sie, anders als beim Kommandozeilen- oder GUI-Client, nicht auf ein bestimmtes Trennzeichen festgelegt.

Um eine gespeicherte Prozedur mit Connector/NET aufzurufen, erzeugen Sie ein MySqlCommand-Objekt und übergeben den Namen der Prozedur als .CommandText-Eigenschaft. Setzen Sie die .CommandType-Eigenschaft auf CommandType.StoredProcedure.

Auf die Angabe der gespeicherten Prozedur folgt für jeden ihrer Parameter ein MySqlCommand-Parameter. IN-Parameter werden mit ihrem Namen und dem Objekt, das ihren Wert enthält, definiert, und OUT-Parameter mit ihrem Namen und dem erwarteten Rückgabe-Datentyp. Alle Parameter müssen mit Richtung definiert werden.

Sind die Parameter angelegt, so kann die gespeicherte Prozedur mit der Methode MySqlCommand.ExecuteNonQuery() aufgerufen werden:

Visual Basic-Beispiel

Dim conn As New MySqlConnection
Dim cmd As New MySqlCommand

conn.ConnectionString = "server=127.0.0.1;" _
    & "uid=root;" _
    & "pwd=12345;" _
    & "database=test"

Try
    conn.Open()
    cmd.Connection = conn

    cmd.CommandText = "add_emp"
    cmd.CommandType = CommandType.StoredProcedure

    cmd.Parameters.Add("?lname", 'Jones')
    cmd.Parameters["?lname"].Direction = ParameterDirection.Input

    cmd.Parameters.Add("?fname", 'Tom')
    cmd.Parameters["?fname"].Direction = ParameterDirection.Input

    cmd.Parameters.Add("?bday", #12/13/1977 2:17:36 PM#)
    cmd.Parameters["?bday"].Direction = ParameterDirection.Input

    cmd.Parameters.Add("?empno", MySqlDbType.Int32)
    cmd.Parameters["?empno"].Direction = ParameterDirection.Output

    cmd.ExecuteNonQuery()

    MessageBox.Show(cmd.Parameters["?empno"].Value)
Catch ex As MySqlException
    MessageBox.Show("Error " & ex.Number & " has occurred: " & ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try

C#-Beispiel

MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;

conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();

conn.ConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";

try
{
    conn.Open();
    cmd.Connection = conn;

    cmd.CommandText = "add_emp";
    cmd.CommandType = CommandType.StoredProcedure;

    cmd.Parameters.Add("?lname", "Jones");
    cmd.Parameters["?lname"].Direction = ParameterDirection.Input;

    cmd.Parameters.Add("?fname", "Tom");
    cmd.Parameters["?fname"].Direction = ParameterDirection.Input;

    cmd.Parameters.Add("?bday", DateTime.Parse("12/13/1977 2:17:36 PM"));
    cmd.Parameters["?bday"].Direction = ParameterDirection.Input;

    cmd.Parameters.Add("?empno", MySqlDbType.Int32);
    cmd.Parameters["?empno"].Direction = ParameterDirection.Output;

    cmd.ExecuteNonQuery();

    MessageBox.Show(cmd.Parameters["?empno"].Value);
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show("Error " + ex.Number + " has occurred: " + ex.Message,
      "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}

Sobald die gespeicherte Prozedur aufgerufen wird, können die Werte ihrer Ausgabeparameter mit der .Value-Eigenschaft der MySqlConnector.Parameters-Collection abgerufen werden.

Häufig werden mit MySQL Binärdaten in BLOB-Spalten gespeichert. MySQL unterstützt vier verschiedene BLOB-Datentypen: TINYBLOB, BLOB, MEDIUMBLOB und LONGBLOB.

Die Daten einer BLOB-Spalte können mit Connector/NET angesprochen und mit clientseitigem Code manipuliert werden. Es gibt keine Sonderbedingungen für den Einsatz von Connector/NET mit BLOB-Daten.

In diesem Abschnitt werden wir einfache Codebeispiele vorstellen. Eine vollständige Musteranwendung finden Sie im Samples-Verzeichnis der Connector/NET-Installation.

Um MySQL für BLOB-Daten einsetzen zu können, müssen Sie als Erstes den Server konfigurieren. Zunächst werden wir eine Tabelle anlegen. Meine Dateitabellen haben normalerweise vier Spalten: Eine AUTO_INCREMENT-Spalte passender Größe (UNSIGNED SMALLINT) dient als Primärschlüssel, um die Datei zu identifizieren, eine VARCHAR-Spalte speichert den Dateinamen, eine UNSIGNED MEDIUMINT-Spalte hält die Größe der Datei fest und eine MEDIUMBLOB-Spalte enthält die Datei selbst. Für dieses Beispiel werde ich folgende Tabellendefinition einsetzen:

CREATE TABLE file(
file_id SMALLINT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
file_name VARCHAR(64) NOT NULL,
file_size MEDIUMINT UNSIGNED NOT NULL,
file MEDIUMBLOB NOT NULL);

Nach der Erstellung einer Tabelle muss eventuell die Systemvariable max_allowed_packet modifiziert werden, die festlegt, welche maximale Paketgröße (d. h. eine einzelne Zeile) an den MySQL Server geschickt werden kann. Nach Voreinstellung akzeptiert der Server nur 1 Mbyte als maximale Paketgröße von der Clientanwendung. Wenn Sie diesen Wert nicht überschreiten wollen, ist er in Ordnung, aber wenn doch, müssen Sie ihn heraufsetzen.

Die Option max_allowed_packet kann in den MySQL Administrator's Startup Variables eingestellt werden. Setzen Sie hierzu die Option Maximum allowed im Memory-Teil der Registerkarte Networking auf einen geeigneten Wert. Dann klicken Sie auf Apply Changes und starten den Server über den Service Control-Bildschirm des MySQL Administrators neu. Sie können diesen Wert allerdings auch direkt in der my.cnf-Datei einstellen (und die Zeile max_allowed_packet=xxM hinzufügen) oder die Syntax SET max_allowed_packet=xxM; in MySQL nutzen.

Bitte stellen Sie max_allowed_packet nicht zu hoch ein, da eine Übertragung von BLOB-Daten viel Zeit in Anspruch nehmen kann. Versuchen Sie, einen für Ihre Situation angemessenen Wert zu finden, und setzen Sie ihn notfalls später herauf.

Um eine Datei in eine Datenbank zu schreiben, konvertieren wir die Datei zuerst in ein Byte-Array und übergeben dieses dann als Parameter an die INSERT-Anfrage.

Der folgende Code öffnet eine Datei mithilfe eines FileStream-Objekts, liest sie in ein Byte-Array ein und fügt sie in die Tabelle file ein:

Visual Basic-Beispiel

Dim conn As New MySqlConnection
Dim cmd As New MySqlCommand

Dim SQL As String

Dim FileSize As UInt32
Dim rawData() As Byte
Dim fs As FileStream

conn.ConnectionString = "server=127.0.0.1;" _
    & "uid=root;" _
    & "pwd=12345;" _
    & "database=test"

Try
    fs = New FileStream("c:\image.png", FileMode.Open, FileAccess.Read)
    FileSize = fs.Length
    
    rawData = New Byte(FileSize) {}
    fs.Read(rawData, 0, FileSize)
    fs.Close()
    
    conn.Open()
    
    SQL = "INSERT INTO file VALUES(NULL, ?FileName, ?FileSize, ?File)"
    
    cmd.Connection = conn
    cmd.CommandText = SQL
    cmd.Parameters.Add("?FileName", strFileName)
    cmd.Parameters.Add("?FileSize", FileSize)
    cmd.Parameters.Add("?File", rawData)
    
    cmd.ExecuteNonQuery()
    
    MessageBox.Show("File Inserted into database successfully!", _
    "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk)
    
    conn.Close()
Catch ex As Exception
    MessageBox.Show("There was an error: " & ex.Message, "Error", _
        MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
  

C#-Beispiel

MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;

conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();

string SQL;
UInt32 FileSize;
byte[] rawData;
FileStream fs;

conn.ConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";

try
{
    fs = new FileStream(@"c:\image.png", FileMode.Open, FileAccess.Read);
    FileSize = fs.Length;

    rawData = new byte[FileSize];
    fs.Read(rawData, 0, FileSize);
    fs.Close();

    conn.Open();

    SQL = "INSERT INTO file VALUES(NULL, ?FileName, ?FileSize, ?File)";

    cmd.Connection = conn;
    cmd.CommandText = SQL;
    cmd.Parameters.Add("?FileName", strFileName);
    cmd.Parameters.Add("?FileSize", FileSize);
    cmd.Parameters.Add("?File", rawData);

    cmd.ExecuteNonQuery();

    MessageBox.Show("File Inserted into database successfully!",
        "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);

    conn.Close();
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show("Error " + ex.Number + " has occurred: " + ex.Message,
        "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
 

Die Methode Read des FileStream-Objekts lädt die Datei in ein Byte-Array, über dessen Größe die Length-Eigenschaft des FileStream-Objekts entscheidet.

Nachdem das Byte-Array als Parameter des MySqlCommand-Objekts zugewiesen wurde, wird die ExecuteNonQuery-Methode aufgerufen und der BLOB in die file-Tabelle eingefügt.

Sobald wir eine Datei in der file-Tabelle gespeichert haben, können wir sie mit der Klasse MySqlDataReader abrufen.

Der folgende Code ruft eine Zeile aus der Tabelle file ab und lädt die Daten dann in ein FileStream-Objekt, das auf die Festplatte geschrieben wird:

Visual Basic-Beispiel

Dim conn As New MySqlConnection
Dim cmd As New MySqlCommand
Dim myData As MySqlDataReader
Dim SQL As String
Dim rawData() As Byte
Dim FileSize As UInt32
Dim fs As FileStream

conn.ConnectionString = "server=127.0.0.1;" _
    & "uid=root;" _
    & "pwd=12345;" _
    & "database=test"

SQL = "SELECT file_name, file_size, file FROM file"

Try
    conn.Open()
    
    cmd.Connection = conn
    cmd.CommandText = SQL
    
    myData = cmd.ExecuteReader
    
    If Not myData.HasRows Then Throw New Exception("There are no BLOBs to save")
    
    myData.Read()
    
    FileSize = myData.GetUInt32(myData.GetOrdinal("file_size"))
    rawData = New Byte(FileSize) {}
    
    myData.GetBytes(myData.GetOrdinal("file"), 0, rawData, 0, FileSize)
    
    fs = New FileStream("C:\newfile.png", FileMode.OpenOrCreate, FileAccess.Write)
    fs.Write(rawData, 0, FileSize)
    fs.Close()
    
    MessageBox.Show("File successfully written to disk!", "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk)
    
    myData.Close()
    conn.Close()
Catch ex As Exception
    MessageBox.Show("There was an error: " & ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
  

C#-Beispiel

MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;
MySql.Data.MySqlClient.MySqlDataReader myData;

conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();

string SQL;
UInt32 FileSize;
byte[] rawData;
FileStream fs;

conn.ConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";

SQL = "SELECT file_name, file_size, file FROM file";

try
{
    conn.Open();

    cmd.Connection = conn;
    cmd.CommandText = SQL;

    myData = cmd.ExecuteReader();

    if (! myData.HasRows)
        throw new Exception("There are no BLOBs to save");

    myData.Read();

    FileSize = myData.GetUInt32(myData.GetOrdinal("file_size"));
    rawData = new byte[FileSize];

    myData.GetBytes(myData.GetOrdinal("file"), 0, rawData, 0, FileSize);

    fs = new FileStream(@"C:\newfile.png", FileMode.OpenOrCreate, FileAccess.Write);
    fs.Write(rawData, 0, FileSize);
    fs.Close();

    MessageBox.Show("File successfully written to disk!",
        "Success!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);

    myData.Close();
    conn.Close();
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show("Error " + ex.Number + " has occurred: " + ex.Message,
        "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
 

Nach dem Aufbau der Verbindung werden die Daten der file-Tabelle in ein MySqlDataReader-Objekt geladen. Die Methode GetBytes des MySqlDataReaders lädt den BLOB in ein Byte-Array, das dann mit einem FileStream-Objekt auf die Festplatte geschrieben wird.

Die Methode GetOrdinal des MySqlDataReaders kann den ganzzahligen Index einer benannten Spalte ermitteln. Wenn Sie GetOrdinal verwenden, vermeiden Sie Fehler, die bei einer Änderung der Spaltenreihenfolge in der SELECT-Anfrage entstehen könnten.

Crystal Reports ist ein Tool, das Windows-Anwendungsentwickler gerne für das Reporting und zur Dokumenterstellung einsetzen. In diesem Abschnitt erfahren Sie, wie man Crystal Reports XI mit MySQL und Connector/NET einsetzt.

Wenn Sie in Crystal Reports einen Bericht anlegen, können Sie in zwei Weisen auf MySQL-Daten für den Bericht zugreifen.

Die erste Möglichkeit: Sie verwenden Connector/ODBC als ADO-Datenquelle, wenn Sie Ihren Bericht entwerfen. Sie können dann in der Datenbank stöbern und Tabellen und Felder mit Drag & Drop in den Bericht einbinden. Der Nachteil dieser Methode: Es ist zusätzliche Arbeit an Ihrer Anwendung erforderlich, um ein zu Ihrem Bericht passendes Dataset zu erzeugen.

Die zweite Möglichkeit: Sie erstellen ein Dataset in VB.NET und speichern Sie im XML-Format. Diese XML-Datei kann dann zur Berichterstellung eingesetzt werden. Das funktioniert zwar recht gut, wenn Sie den Bericht in Ihrer Anwendung anzeigen, ist aber zur Entwurfszeit unpraktisch, da Sie alle relevanten Spalten auswählen müssen, wenn Sie das Dataset anlegen. Vergessen Sie eine Spalte, so müssen Sie das gesamte Dataset neu anlegen, um die Spalte dem Bericht hinzuzufügen.

Mit dem folgenden Code erzeugen Sie aus einer Anfrage ein Dataset und schreiben es auf die Festplatte:

Visual Basic-Beispiel

Dim myData As New DataSet
Dim conn As New MySqlConnection
Dim cmd As New MySqlCommand
Dim myAdapter As New MySqlDataAdapter

conn.ConnectionString = "server=127.0.0.1;" _
    & "uid=root;" _
    & "pwd=12345;" _
    & "database=world"

Try
    conn.Open()
    cmd.CommandText = "SELECT city.name AS cityName, city.population AS CityPopulation, " _ 
        & "country.name, country.population, country.continent " _
        & "FROM country, city ORDER BY country.continent, country.name"
    cmd.Connection = conn
    
    myAdapter.SelectCommand = cmd
    myAdapter.Fill(myData)
    
    myData.WriteXml("C:\dataset.xml", XmlWriteMode.WriteSchema)
Catch ex As Exception
    MessageBox.Show(ex.Message, "Report could not be created", MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
 

C#-Beispiel

DataSet myData = new DataSet();
MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;
MySql.Data.MySqlClient.MySqlDataAdapter myAdapter;

conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();
myAdapter = new MySql.Data.MySqlClient.MySqlDataAdapter();

conn.ConnectionString = "server=127.0.0.1;uid=root;" +
  "pwd=12345;database=test;";
  
try
{
  cmd.CommandText = "SELECT city.name AS cityName, city.population AS CityPopulation, " +
  "country.name, country.population, country.continent " +
  "FROM country, city ORDER BY country.continent, country.name";
  cmd.Connection = conn;
  
  myAdapter.SelectCommand = cmd;
  myAdapter.Fill(myData);
  
  myData.WriteXml(@"C:\dataset.xml", XmlWriteMode.WriteSchema);
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
  MessageBox.Show(ex.Message, "Report could not be created",
  MessageBoxButtons.OK, MessageBoxIcon.Error);
}

Die resultierende XML-Datei kann bei der Berichterstellung als ADO.NET XML-Datenquelle verwendet werden.

Wenn Sie Ihre Berichte mit Connector/ODBC erstellen möchten, können Sie diese Komponente von dev.mysql.com herunterladen.

Für die meisten Zwecke müsste der Standard Report-Assistent für die ersten Schritte der Berichterstellung ausreichen. Um den Assistenten zu starten, öffnen Sie Crystal Reports und wählen aus dem Dateimenü die Option Neu > Standard Report.

Der Assistent fragt Sie dann nach einer Datenquelle. Wenn Sie Connector/ODBC verwenden, wählen Sie die Option OLEDB provider for ODBC aus dem OLE DB (ADO)-Baum statt aus dem ODBC (RDO)-Baum, wenn Sie die Datenquelle einstellen. Wenn Sie ein gespeichertes Dataset verwenden, wählen Sie die Option ADO.NET (XML) und gehen zu diesem Dataset.

Der Rest des Berichterstellungsprozesses läuft im Assistenten automatisch ab.

Nachdem der Bericht angelegt wurde, wählen Sie den Eintrag Report Options... aus dem Dateimenü. Deaktivieren Sie die Option Save Data With Report, damit keine gespeicherten Daten das Laden der Daten in Ihrer Anwendung behindern.

Um einen Bericht anzuzeigen, laden wir zuerst das Dataset hinein, in dem die benötigten Daten gespeichert sind, laden dann den Bericht und binden ihn an das Dataset. Zum Schluss übergeben wir den Bericht an den crViewer, damit er dem Benutzer angezeigt wird.

Folgendes müssen Sie in einem Projekt, das einen Bericht anzeigt, referenzieren:

Der folgende Code geht davon aus, dass Sie Ihren Bericht mit einem Dataset angelegt haben, das wie in Abschnitt 25.2.3.5.2, „Datenquelle anlegen“, gezeigt gespeichert wurde, und dass Sie einen crViewer namens myViewer auf Ihrem Formular haben.

Visual Basic-Beispiel

Imports CrystalDecisions.CrystalReports.Engine
Imports System.Data
Imports MySql.Data.MySqlClient

Dim myReport As New ReportDocument
Dim myData As New DataSet
Dim conn As New MySqlConnection
Dim cmd As New MySqlCommand
Dim myAdapter As New MySqlDataAdapter

conn.ConnectionString = _
    "server=127.0.0.1;" _
    & "uid=root;" _
    & "pwd=12345;" _
    & "database=test"

Try
    conn.Open()
    
    cmd.CommandText = "SELECT city.name AS cityName, city.population AS CityPopulation, " _ 
        & "country.name, country.population, country.continent " _
        & "FROM country, city ORDER BY country.continent, country.name"
    cmd.Connection = conn
    
    myAdapter.SelectCommand = cmd
    myAdapter.Fill(myData)
    
    myReport.Load(".\world_report.rpt")
    myReport.SetDataSource(myData)
    myViewer.ReportSource = myReport
Catch ex As Exception
    MessageBox.Show(ex.Message, "Report could not be created", MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try

C#-Beispiel

using CrystalDecisions.CrystalReports.Engine;
using System.Data;
using MySql.Data.MySqlClient;

ReportDocument myReport = new ReportDocument();
DataSet myData = new DataSet();
MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;
MySql.Data.MySqlClient.MySqlDataAdapter myAdapter;

conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();
myAdapter = new MySql.Data.MySqlClient.MySqlDataAdapter();

conn.ConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";

try
{
    cmd.CommandText = "SELECT city.name AS cityName, city.population AS CityPopulation, " +
        "country.name, country.population, country.continent " +
        "FROM country, city ORDER BY country.continent, country.name";
    cmd.Connection = conn;

    myAdapter.SelectCommand = cmd;
    myAdapter.Fill(myData);

    myReport.Load(@".\world_report.rpt");
    myReport.SetDataSource(myData);
    myViewer.ReportSource = myReport;
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show(ex.Message, "Report could not be created",
        MessageBoxButtons.OK, MessageBoxIcon.Error);
}

Ein neues Dataset wird mit derselben Anfrage wie das zuvor gespeicherte angelegt. Sobald es mit Daten gefüllt ist, wird die Berichtsdatei mithilfe eines ReportDocuments geladen und an das Dataset gebunden. Das ReportDocument wird als ReportSource des crViewers übergeben.

Denselben Ansatz verfolgen wir, wenn ein Bericht mit Connector/ODBC aus einer einzelnen Tabelle erstellt wird. Das Dataset ersetzt die im Bericht verwendete Tabelle und der Bericht wird korrekt angezeigt.

Wird ein Bericht mit Connector/ODBC aus mehreren Tabellen erstellt, müssen wir in unserer Anwendung ein Dataset aus mehreren Tabellen anlegen. So kann jede Tabelle aus der Berichtsdatenquelle im Dataset durch einen Bericht ersetzt werden.

Um mehrere Tabellen in ein Dataset zu laden, sind mehrere SELECT-Anweisungen in unserem MySqlCommand-Objekt erforderlich. Diese SELECT-Anweisungen beruhen auf der SQL-Anfrage, die in Crystal Reports in der Option Show SQL Query des Datenbankmenüs angezeigt wird. Legen wir einmal folgende Anfrage zugrunde:

SELECT `country`.`Name`, `country`.`Continent`, `country`.`Population`, `city`.`Name`, `city`.`Population`
FROM `world`.`country` `country` LEFT OUTER JOIN `world`.`city` `city` ON `country`.`Code`=`city`.`CountryCode`
ORDER BY `country`.`Continent`, `country`.`Name`, `city`.`Name`

Diese Anfrage wird in zwei SELECT-Anfragen aufgespalten und mit folgendem Code angezeigt:

Visual Basic-Beispiel

Imports CrystalDecisions.CrystalReports.Engine
Imports System.Data
Imports MySql.Data.MySqlClient

Dim myReport As New ReportDocument
Dim myData As New DataSet
Dim conn As New MySqlConnection
Dim cmd As New MySqlCommand
Dim myAdapter As New MySqlDataAdapter

conn.ConnectionString = "server=127.0.0.1;" _
    & "uid=root;" _
    & "pwd=12345;" _
    & "database=world"

Try
    conn.Open()
    cmd.CommandText = "SELECT name, population, countrycode FROM city ORDER BY countrycode, name; " _
        & "SELECT name, population, code, continent FROM country ORDER BY continent, name"
    cmd.Connection = conn
    
    myAdapter.SelectCommand = cmd
    myAdapter.Fill(myData)
    
    myReport.Load(".\world_report.rpt")
    myReport.Database.Tables(0).SetDataSource(myData.Tables(0))
    myReport.Database.Tables(1).SetDataSource(myData.Tables(1))
    myViewer.ReportSource = myReport
Catch ex As Exception
    MessageBox.Show(ex.Message, "Report could not be created", MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try

C#-Beispiel

using CrystalDecisions.CrystalReports.Engine;
using System.Data;
using MySql.Data.MySqlClient;

ReportDocument myReport = new ReportDocument();
DataSet myData = new DataSet();
MySql.Data.MySqlClient.MySqlConnection conn;
MySql.Data.MySqlClient.MySqlCommand cmd;
MySql.Data.MySqlClient.MySqlDataAdapter myAdapter;

conn = new MySql.Data.MySqlClient.MySqlConnection();
cmd = new MySql.Data.MySqlClient.MySqlCommand();
myAdapter = new MySql.Data.MySqlClient.MySqlDataAdapter();

conn.ConnectionString = "server=127.0.0.1;uid=root;" +
    "pwd=12345;database=test;";

try
{
    cmd.CommandText = "SELECT name, population, countrycode FROM city ORDER " +
        "BY countrycode, name; SELECT name, population, code, continent FROM " +
        "country ORDER BY continent, name";
    cmd.Connection = conn;

    myAdapter.SelectCommand = cmd;
    myAdapter.Fill(myData);

    myReport.Load(@".\world_report.rpt");
    myReport.Database.Tables(0).SetDataSource(myData.Tables(0));
    myReport.Database.Tables(1).SetDataSource(myData.Tables(1));
    myViewer.ReportSource = myReport;
}
catch (MySql.Data.MySqlClient.MySqlException ex)
{
    MessageBox.Show(ex.Message, "Report could not be created",
        MessageBoxButtons.OK, MessageBoxIcon.Error);
}  
 

Die SELECT-Anfragen müssen unbedingt in alphabetischer Reihenfolge stehen, da der Bericht erwartet, dass seine Quelltabellen diese Reihenfolge haben. Für jede Tabelle im Bericht ist eine SetDataSource-Anweisung erforderlich.

Dieser Ansatz kann Performanceprobleme mit sich bringen, da Crystal Reports die Tabellen auf der Clientseite aneinander binden muss. Das braucht mehr Zeit als ein vordefiniertes, gespeichertes Dataset.

MySQL und die .NET-Sprachen gehen unterschiedlich mit Datums- und Uhrzeitinformationen um: MySQL erlaubt Datumswerte, die von keinem .NET-Datentyp dargestellt werden können, wie etwa '0000-00-00 00:00:00'. Diese Unterschiede können Probleme verursachen, wenn man nicht richtig damit umgeht.

In diesem Abschnitt werden wir zeigen, wie Datums- und Uhrzeitinformationen mit Connector/NET korrekt behandelt werden.

Die Unterschiede in der Datumsbehandlung können Probleme bereiten, wenn Entwickler ungültige Datumswerte verwenden. Ungültige MySQL-Datumswerte, einschließlich NULL-Datumswerten, lassen sich nicht in native DateTime-Objekte von .NET laden.

Daher können DataSet-Objekte von .NET nicht mit der Fill-Methode der Klasse MySqlDataAdapter gefüllt werden, da ungültige Datumswerte eine System.ArgumentOutOfRangeException verursachen würden.

Datumsprobleme lassen sich am besten dadurch in den Griff bekommen, dass die Benutzer gar keine Möglichkeit erhalten, ungültige Datumswerte einzugeben. Dies lässt sich auf der Client- oder der Serverseite bewerkstelligen.

Um ungültige Datumswerte auf der Clientseite zu unterbinden, müssen Sie die Datumswerte nur immer mit der .NET-Klasse DateTime behandeln. Diese erlaubt nämlich nur gültige Datumswerte und stellt dadurch sicher, dass auch in Ihre Datenbank nur gültige Werte gelangen. Leider kann man sie jedoch nicht in einer gemischten Umgebung einsetzen, in der die Datenbank sowohl mit .NET- als auch mit Nicht-.NET-Code bearbeitet wird, da jede Anwendung ihre eigene Datumsvalidierung vornehmen muss.

Auf MySQL 5.0.2 und höher können Sie den neuen SQL-Modus traditional einstellen, um ungültige Datumswerte zu unterbinden. Informationen über diesen SQL-Modus erhalten Sie unter traditional, Abschnitt 5.2.5, „Der SQL-Modus des Servers“.

Zwar raten wir von ungültigen Datumswerten in .NET-Anwendungen ausdrücklich ab, aber es ist immerhin möglich, ungültige Datumswerte über den Datentyp MySqlDateTime zu behandeln.

Der Datentyp MySqlDateTime unterstützt dieselben Datumswerte wie der MySQL Server. Standardmäßig gibt Connector/NET für gültige Datumswerte ein DateTime-Objekt von .NET und für ungültige Datumswerte einen Fehler zurück. Diese Voreinstellung können Sie jedoch so abändern, dass Connector/NET MySqlDateTime-Objekte für ungültige Datumswerte zurückliefert.

Damit Connector/NET für ungültige Datumswerte ein MySqlDateTime-Objekt zurückgibt, fügen Sie Ihrem Verbindungs-String folgende Zeile hinzu:

  Allow Zero Datetime=True
  

Bitte beachten Sie, dass die Verwendung der Klasse MySqlDateTime immer problematisch sein kann. Folgende Probleme sind bereits aufgetreten:

Wegen dieser bekannten Probleme lautet der beste Rat: Verwenden Sie bitte nur gültige Datumswerte Ihrer Anwendung.

Der .NET-Datentyp DateTime kann mit NULL-Werten nicht umgehen. Daher müssen Sie, wenn Sie Werte aus einer Anfrage an eine DateTime-Variable zuweisen, immer zuerst prüfen, ob nicht ein NULL-Wert vorliegt.

Wenn Sie einen MySqlDataReader verwenden, sollten Sie mit der Methode .IsDBNull überprüfen, ob ein NULL-Wert vorliegt, bevor Sie die Zuweisung vornehmen:

Visual Basic-Beispiel

If Not myReader.IsDBNull(myReader.GetOrdinal("mytime")) Then
    myTime = myReader.GetDateTime(myReader.GetOrdinal("mytime"))
Else
    myTime = DateTime.MinValue
End If
  

C#-Beispiel

if (! myReader.IsDBNull(myReader.GetOrdinal("mytime")))
    myTime = myReader.GetDateTime(myReader.GetOrdinal("mytime"));
else
    myTime = DateTime.MinValue;
  

NULL-Werte funktionieren nicht in einem Dataset und können ohne Sonderbehandlung an Formularelemente gebunden werden.

Connector/J 3.1 ist auf größtmögliche Abwärtskompatibilität mit Connector/J 3.0 ausgelegt. Größere Änderungen beschränken sich auf die neuen Funktionen von MySQL 4.1 und höher, darunter Unicode-Zeichensätze, vorbereitete Anweisungen auf der Serverseite, SQLState-Codes die in Fehlermeldungen vom Server zurückgegeben werden, und verschiedene Leistungsverbesserungen, die mit Konfigurationseigenschaften ein- und ausgeschaltet werden können.

Wenn Sie JDBC außerhalb eines Anwendungsservers benutzen, wird die Einrichtung von Verbindungen über die Klasse DriverManager verwaltet.

Sie müssen dem DriverManager mitteilen, mit welchen JDBC-Treibern er sich verbinden soll. Die einfachste Möglichkeit besteht darin, die Methode Class.forName() auf der Klasse aufzurufen, welche die java.sql.Driver-Schnittstelle implementiert. Bei MySQL Connector/J heißt diese Klasse com.mysql.jdbc.Driver. Mit dieser Methode können Sie eine externe Konfigurationsdatei verwenden, um den Namen der Treiberklasse und die Treiberparameter zu übergeben, wenn eine Datenbankverbindung aufgebaut wird.

Der folgende Java-Code zeigt, wie Sie MySQL Connector/J in der main()-Methode Ihrer Anwendung registrieren könnten:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

// Achtung, nicht com.mysql.jdbc.* importieren,
// sonst bekommen Sie Probleme!

public class LoadDriver {
    public static void main(String[] args) {
        try {
            // Der Aufruf von newInstance() ist ein Workaround
            // für einige misslungene Java-Implementierungen

            Class.forName("com.mysql.jdbc.Driver").newInstance();
        } catch (Exception ex) {
            // Fehler behandeln
        }
}

Nachdem der Treiber beim DriverManager registriert wurde, können Sie eine Connection-Instanz zur Verbindung mit einer bestimmten Datenbank erzeugen, indem Sie DriverManager.getConnection() aufrufen:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

    ... try {
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/test?user=monty&password=greatsqldb");

            // Verbindung benutzen

           ....
        } catch (SQLException ex) {
            // Fehler behandeln
            System.out.println("SQLException: " + ex.getMessage());
            System.out.println("SQLState: " + ex.getSQLState());
            System.out.println("VendorError: " + ex.getErrorCode());
        }

Mit Statement-Objekten können Sie grundlegende SQL-Anfragen ausführen und die Ergebnisse mithilfe der weiter unten beschriebenen Klasse ResultSet abrufen.

Um ein Statement-Objekt zu erzeugen, rufen Sie die Methode createStatement() auf dem Connection-Objekt auf, das Sie mit einer der zuvor beschriebenen Methoden DriverManager.getConnection() oder DataSource.getConnection() erzeugt haben.

Wenn Sie ein Statement-Objekt angelegt haben, können Sie eine SELECT-Anfrage ausführen, indem Sie executeQuery(String) mit der gewünschten SQL-Anweisung aufrufen.

Um Daten in der Datenbank zu aktualisieren, verwenden Sie die Methode executeUpdate(String SQL). Diese liefert die Anzahl der von dem Update betroffenen Zeilen zurück.

Wenn Sie im Voraus noch nicht wissen, ob Ihre SQL-Anweisung ein SELECT oder ein UPDATE/INSERT wird, können Sie die Methode execute(String SQL) verwenden. Sie gibt true zurück, wenn die SQL-Anfrage ein SELECT ist, oder false, wenn sie ein UPDATE, INSERT oder DELETE ist. Handelt es sich um ein SELECT, so können Sie die Ergebnisse mit der Methode getResultSet() abrufen. Für UPDATE-, INSERT- oder DELETE-Anweisungen können Sie die Anzahl der betroffenen Zeilen in Erfahrung bringen, indem Sie getUpdateCount() auf dem Statement-Objekt aufrufen.

// conn sei eine bereits vorhandene JDBC-Verbindung
Statement stmt = null;
ResultSet rs = null;

try {
    stmt = conn.createStatement();
    rs = stmt.executeQuery("SELECT foo FROM bar");

    // oder, wenn Sie im Voraus nicht wissen, ob die
    // Anfrage ein SELECT ist...

    if (stmt.execute("SELECT foo FROM bar")) {
        rs = stmt.getResultSet();
    }

    // Tue etwas mit dem ResultSet ....
} finally {
    // Ressourcen sollten immer in einem
    // finally{}-Block
    // in der umgekehrten Reihenfolge ihrer Zuweisung
    // freigegeben werden

    if (rs != null) {
        try {
            rs.close();
        } catch (SQLException sqlEx) { // ignore }

        rs = null;
    }

    if (stmt != null) {
        try {
            stmt.close();
        } catch (SQLException sqlEx) { // ignore }

        stmt = null;
    }
}

Seit der MySQL-Server-Version 5.0 in Verbindung mit Connector/J 3.1.1 oder höher ist die Schnittstelle java.sql.CallableStatement mit Ausnahme der Methode getParameterMetaData() vollständig implementiert.

Mehr über gespeicherte Prozeduren in MySQL erfahren Sie in Kapitel 19, Gespeicherte Prozeduren und Funktionen.

Connector/J stellt Funktionalität für gespeicherte Prozeduren über die JDBC-Schnittstelle CallableStatement zur Verfügung.

Hinweis.  Aktuelle Versionen von MySQL-Server geben nicht genug Informationen zurück, damit der JDBC-Treiber Ergebnismengen-Metadaten für Callable Statements liefern kann. Folglich wird ResultSetMetaData für CallableStatement unter Umständen den Wert NULL zurückgeben.

Das folgende Beispiel zeigt eine gespeicherte Prozedur, die den Wert von inOutParam um 1 inkrementiert und den im inputParam übergebenen String als ResultSet zurückgibt:

CREATE PROCEDURE demoSp(IN inputParam VARCHAR(255), INOUT inOutParam INT)
BEGIN
    DECLARE z INT;
    SET z = inOutParam + 1;
    SET inOutParam = z;

    SELECT inputParam;

    SELECT CONCAT('zyxw', inputParam);
END