.NET Programming with Open Source Databases
Creating .NET applications using MySQL and PostgreSQL
By: Richard K. Blum
Jan. 8, 2007 01:45 PM
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.
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:
This \s met-command shows that the MySQL server is running, the version that is running, and a few other server statistics.
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:
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 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;
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";
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:
The individual data records are extracted from the result set, and the individual data elements within the records are extracted and displayed.
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
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;
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);
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);
Again, this is similar to the structure used for the MySQL Connector/NET library.
Reader Feedback: Page 1 of 1
Tweets by @BigDataExpo
Digital Transformation Blogs