In the past, using open source databases meant running UNIX (or Linux) servers and open source development environments. Today however, the two most popular open source database packages - MySQL and PostgreSQL - have full featured Windows installations, and can be run on most Windows platforms. This allows Windows developers to easily utilize open source databases in their applications.

To make life even easier, both MySQL and PostgreSQL provide .NET Data Provider classes that can be used in your .NET programs to easily access the database servers, send queries, and retrieve query results. This article walks you through creating .NET applications using both the MySQL and PostgreSQL open source databases.

MySQL
The MySQL open source database software is quite possibly the most popular open source database system available. While relatively new to the Windows world, it is a popular back end database used in Web-based applications running on UNIX and Linux systems.

The MySQL Windows installation package can be downloaded for free from the MySQL Web site (www.mysql.org). Make sure to download the Windows binary installation package, and not one of the ones for the various UNIX and Linux flavors. At the time of this writing, the most current MySQL Windows installation package was mysql-essential-5.0.24a-win32.msi. This file contains the complete MySQL server, as well as a few extra client programs. Download the file to a temporary directory on your Windows system.

After downloading the installation package, you can start the installation process. A standard installation wizard guides you through the simple installation process. The typical package installs both the MySQL server software and a couple of MySQL client applications that come in handy for administering and using the MySQL server - the command line interface and the server configuration utility. At the end of the installation, you have the option to immediately configure the MySQL server using the server configuration utility.

The MySQL server configuration utility involves setting up the MySQL server instance to handle the anticipated database applications that will run on the server. You can choose from a detailed configuration process or a simplified configuration process. The simplified configuration process sets the server configuration parameters - such as memory usage and allowed concurrent connections - using standard default values. If you want to fine-tune the server performance, you can choose the detailed configuration option and manually set the performance values. You can also use the server configuration utility after the initial server installation to change parameters on the server configuration. The server configuration utility is shown in Figure 1.

During the configuration process you can opt to automatically start the MySQL server as a Windows service. This allows the MySQL server to run as a background process on the Windows system without any user intervention.

Once the MySQL server service is running, you can test the installation by connecting with the command line client. Start the MySQL command line client application by clicking Start, All Programs, MySQL, MySQL Server 5.0, MySQL Command Line Client. A command prompt window appears, and asks for the MySQL root user password (this was set during the configuration process). After entering the root password, a command prompt appears.

At the command prompt, you can enter simple SQL commands to interact with the database. There are also several special meta-commands that are used for displaying server and database information. Use the \s command to retrieve the status of the running server:

mysql> \s
--------------
C:\Program Files\MySQL\MySQL Server 5.0\bin\mysql.exe Ver 14.12 Distrib
5.0.24a, for Win32 (ia32)

Connection id:      3
Current database:
Current user:        root@localhost
SSL:                    Not in use
Using delimiter:      ;
Server version:      5.0.24a-community-nt
Protocol version:   10
Connection:           localhost via TCP/IP
Server characterset:     latin1
Db characterset:          latin1
Client characterset:      latin1
Conn. characterset:     latin1
TCP port:      3306
Uptime:      9 min 29 sec

Threads: 1 Questions: 15 Slow queries: 0 Opens: 12 Flush tables: 1
Open tables: 6 Queries per second avg: 0.026

--------------

mysql>

This \s met-command shows that the MySQL server is running, the version that is running, and a few other server statistics.

MySQL Connector/NET
Now that you have a running MySQL database server, you can start developing .NET programs that interact with it. This is done using the MySQL Connector/NET software.

This package provides the .NET classes required to connect to a MySQL database server, log in using a user account, and access tables and other database objects. You can download the MySQL Connector/NET package from the site:

dev.mysql.com/downloads/connector/net/1.0.html

The package is downloaded as a ZIP file that contains the Windows .msi installation program. You must extract the installation package from the ZIP file to run it. After starting the Connector/NET installation, you can select between several options for installing just the core library files, the documentation, sample programs, and the complete library source code. The installation options window is shown in Figure 2.

You at least need to install the Core Components to run MySQL .NET applications. If you want to have the Connector/NET class documentation handy, it is also a good idea to install the documentation option as well.

At the end of the installation, you have the option to load the Connector/NET classes into the .NET Global Assembly Cache. This allows any .NET application on the system to access the Connector/NET classes. By default, the installation creates three folders: one for the .NET 1.0 connector library file, one for the .NET 1.1 connector library file, and one for the .NET 2.0 connector library file. Each of the files is called by the same file name (MySql.Data.dll), so you can only install the one that is associated with your .NET installation version.

Using the MySQL Connector/NET classes
The Connector/NET library contains several classes used to interact with the MySQL server. These are shown in Table 1.

The server connection is started using a MySqlConnection object. The constructor includes a connection string, which defines the server, database, and user account information:

MySqlConnection conn = new MySqlConnection("Source=localhost;Database=test;

           User Id=root;Password=testing");

The resulting connection object can then be used in a MySqlCommand object to reference the connection. The MySqlCommand class contains the text SQL command that is sent to the server. The class contains three methods used for executing the SQL command, shown in Table 2.

The ExecuteScalar() and ExecuteNonQuery() methods return a single value from the server. The ExecuteReader() method returns a complete result set, which can be placed into a MySqlDataReader object to extract the individual result set data:

String query = "Select * from employee";
MySqlCommand comm. = new mySqlCommand(query, conn);
conn.Open();
MySqlDataReader data = comm..ExecuteReader();
while (data.Read())
{
     int empid = data.GetInt32(0);
     String lastname = data.GetString(1);
     String firstname = data.GetString(2);
     float salary = data.GetFloat(9);
     Console.WriteLine("{0} - {1},{2} ${3}", empid, lastname, firstname, salary);
}

The SQL command is sent to the MySQL server using the ExecuteReader() method. The return value is a MySqlDataReader object, which contains the result set returned from the server. The Read() method is used to read forward through the result set, one record at a time. The GetString(), GetFloat(), GetDate(), and GetInt32() methods are used to extract the individual column data elements from the retrieved record. Columns are referenced in the order they appear in the table, starting with 0.

Listing 1 shows the getdata.cs program. This program demonstrates the steps required to extract data from a MySQL database table using Connector/NET. Remember you must reference the MySql.Data.dll file when compiling the application:

csc /r:MySql.Data.dll getdata.cs

After compiling the program, you can run it against a test database:

C:\> getdata
100 - Blum, Rich     $20000
101 - Blum, Barbara     $45000

The individual data records are extracted from the result set, and the individual data elements within the records are extracted and displayed.

Using PostgreSQL
The PostgreSQL open source database is known for having the most features of all the open source databases. PostgreSQL can compare head-to-head with most commercial database packages. It can be downloaded for free from the PostgreSQL Web site (www.postgresql.org). Again, make sure to download the Windows binary version.

The PostgreSQL installation wizard guides you through the steps of installing and configuring a basic PostgreSQL server all in one process. The Installation Options window shown in Figure 3 provides an opportunity for you to select the PostgreSQL options to install.

For .NET development, make sure you install the Npgsql option. This is the PostgreSQL .NET connector library that allows you to create .NET applications for PostgreSQL databases.

Using the Npgsql classes
The Npgsql library contains all the classes required to connect to a PostgreSQL server, send an SQL command, and retrieve the result set data. The Npgsql classes are shown in Table 3.

You might see a trend here. Most of the basic Npgsql library classes are similar to the MySQL Connector/NET classes, and they behave in similar ways. This makes it relatively easy for .NET developers to switch code from one open source database server to another.

In Npgsql, the connection is started using the NpgsqlConnection class. The class constructor uses a connection string to define the server and database to connect to:

NpgsqlConnection conn = new NpgsqlConnection("Server=localhost;Database=test;
User Id=postgres;Password=testing");

The resulting NpgsqlConnection object is then used in NpgsqlCommand objects to send SQL commands to the database server. As expected, the NpgsqlCommand class contains the SQL command to send to the server. It also contains three separate methods for sending SQL commands to the server, as shown in Table 4.

If the SQL command sent to the server returns a result set, use the NpgsqlDataReader class to extract the individual data elements from the result set:

NpgsqlCommand comm. = new NpgsqlCommand(query, conn);
NpgsqlDataReader data = comm.ExecuteReader();
while(data.Read())
{
     int empid = data.GetInt32(0);
     String lastname = data.GetString(1);
     String firstname = data.GetString(2);
     Float salary = data.GetFloat(9);
     Console.WriteLine("{0} - {1},{2} ${3}", empid, lastname, firstname, salary);
}

Look familiar? This is the same code format as used for the MySQL Connector/.NET library. For SQL commands that only return a single value (such as functions), you can use the ExecuteScalar() method:

NpgsqlCommand comm. = new NpgsqlCommand("Select pi()", conn);
Double result = (Double)comm.ExecuteScalar();

Again, this is similar to the structure used for the MySQL Connector/NET library.

Summary
The MySQL and PostgreSQL open source databases are excellent resources for .NET developers. Having a database back end available that can be scaled from a simple Windows workstation to a large UNIX server platform can be invaluable for growing applications. Both MySQL and PostgreSQL supply .NET Data Providers that can be used to write .NET code that directly accesses open source databases. Both of the Data Provider packages contain similar classes that are used for connecting to the server, sending queries, and retrieving result sets. With these tools in hand, it is easy to start using open source database servers with your .NET applications.