* ADO.NET

	The coordinator for the ADO.NET implementation is <a
	href="mailto:rodrigo@ximian.com">Rodrigo Moya</a>, with
	the collaboration of <a href="mailto:danmorg@sc.rr.com">Daniel
	Morgan</a>.

* Action plan

	The current plan to implement ADO.NET is as follows:

	<b>Step 1:</b> SqlClient:

	<ul>
		* Implementation of System.Data.SqlClient based on
		  the <a href="http://www.postgresql.org/idocs/">PostgreSQL C API</a>

		* Once the <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfsystemdatasqlclient.asp?frame=true">System.Data.SqlClient</a>
		  code is functional and is usable by other people, we willl move it to
		  System.Data.PostgreSQL, and will convert the existing
		  System.Data.SqlClient to be just a wrapper around
		  System.Data.PostgreSQL.  

	</ul>

	<b>Step 2:</b> <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfSystemDataOleDb.asp?frame=true">System.Data.OleDb</a> Provider:
		
	<ul>
		* On Unix systems: System.Data.OleDb will use the
		<a href="http://www.gnome-db.org/">LibGDA</a>
		 engine. 

		  LibGDA is a data access engine like ADO/OLE-DB, but for Unix.  It is
		  used by Gnome-Db and libgnomedb.  There is work under way to get libgda
		  working under Windows by the Gnome-Db developers.

		* On Windows systems: System.Data.OleDb will use OLE-DB as
		  its engine.  It may have the option of using libgda too.
	</ul>

	<b>Step 3:</b> <a href="http://msdn.microsoft.com/library/en-us/cpref/html/frlrfsystemdatasqlclient.asp?frame=true">System.Data.SqlClient</a> Provider:

	<ul>
		* <p>System.Data.SqlClient will then become a managed
		  provider for Microsoft SQL Server, both on Windows and
		  Linux, to be compatible with applications written
		  for the Microsoft .NET Development Framework.
		  
		  <p>Once Step 1 has been completed and the PostgreSQL
		  provider support has been moved to its own place at 
		  System.Data.PostgreSQL, we will use 
		  <a href="http://www.freetds.org/">FreeTDS</a> as the basis
		  for providing access to Microsoft SQL Server databases.
		  
		  FreeTDS is a C API for Unix and Windows that implements 
		  the TDS (Tabular Data Stream) protocol used in accessing 
		  Microsoft SQL Server and Sybase databases.
	</ul>

	<b>Step 4:</b> <a href="http://msdn.microsoft.com/downloads/sample.asp?url=/MSDN-FILES/027/001/668/msdncompositedoc.xml&frame=true">System.Data.Odbc</a> Provider:
	
	<ul>
		* We will create a .NET Managaed Provider for ODBC
		  in System.Data.Odbc for those using ODBC.
		  On Unix and Windows, <a href="http://www.unixodbc.org/">unixODBC</a> will be used.
		  
		  unixODBC works on Unix and Windows.  Providers exist for
		  Oracle, Microsoft SQL Server and Sybase via FreeTDS, 
		  MySQL, PostgreSQL, IBM DB2, Interbase, and others.
		  
	</ul>

	<b>Step 5:</b> Other System.Data providers:

	<ul>
		* The idea in Microsoft .NET System.Data seems to be to have
		  a managed provider for each supported DBMS. So, apart
		  from System.Data.OleDb (generic) and System.Data.SqlClient,
		  we'll need to have System.Data.MySQL,
		  System.Data.Oracle, and System.Data.PostgreSQL. Others,
		  of course, are welcomed.
	</ul>
	
* Current Status

	<p>We are still working on Step 1, but we are planning the other steps.
	If you have any ideas, let us know.
	
	<p>We are able to do simple CREATE TABLE, DROP TABLE, UPDATE, INSERT, and
	DELETE SQL commands using the ExecuteNonQuery method in SqlCommand.  
	
	<p>We are also able to do simple aggregate functions, 
	ie, count(), sum(), min(), and max() 
	in a simple SELECT SQL query using the ExecuteScalar() now.  
	
	<p>We are also able to retrieve data with a simple SELECT SQL query 
	using ExecuteReader() which returns a SqlDataReader.  We are able to
	use GetSchemaTable() to get the meta data about the table columns.  
	We are able	to Read() to get each row from the result set.  We are able to get 
	String data (char, bpchar (character), text, varchar), Int16 (int2 or smallint),
	Int32 (int4 or integer), Int64 (int8 or bigint), DateTime (time, date, timestamp),
	Boolean (boolean), Single (float), and Double (double).
	Other More data types will follow later on.
		
	<p>Parameters and stored procedures have not been tested and most likely
	do not work.
	
	<p>A lot of functionality in System.Data is missing, but the 
	infrastructure is starting to come together.
	
	<p>Need help on the DataSet/DataAdaptor/DataTable/DataRelation/XML 
	functionality so we	can integrate with 
	the ASP.NET controls and Windows.Forms.  
	
	<P>Need to add XML support in System.Data.
	
	<p>The System.Data.dll gets built with the rest of the class library.
	To compile the System.Data.dll assembly separately, you need:

	<b>On GNU/Linux and Unix</b>

	<ul>
		* update your mono sources. Be sure you have latest mcs.exe
		  and .dll's, since there have been many fixes needed for
		  compilation on Linux.

		* compile System.Data.dll:

			cd mcs/class/System.Data
			mcs --target library -o System.Data.dll @list
	</ul>

	<b>On Windows</b>

	<ul>
		* update your mono sources. Be sure you have latest mcs.exe
		  and .dll's.  You can use the same method as Linux, or you can use NAnt.

		* To use NAnt:

			cd mcs/class/System.Data
			../../nant/NAnt.exe
			
			This will automatically copy the System.Data.dll to Test.
			If you need to do a clean for the System.Data.dll assembly,
			cd mcs/class/System.Data and run ../../nant/NAnt.exe clean
	</ul>

* Testing

	<p>In order to test System.Data.SqlClient, you will need to have
	access to a remote PostgreSQL DBMS, or you will have to install 
	one locally.  PostgreSQL is the DBMS used for the initial 
	implementation of System.Data.SqlClient.
		
	<p>Why?  Because it is open source, has a client 
	library that is easy to use, PostgreSQL on Windows is easy to install on
	Unix and Windows (using the Cygwin install program), not difficult to setup after
	installation, and it runs under: Linux, 
	Windows (via cygwin and ipc-daemon), Unix, and
	others.  This allowed us to create the
	System.Data functionality in Mono much quicker.
		
	<p>If you plan on using a remote PostgreSQL DBMS Server,
	than you will need to have the PostgreSQL client software on your
	local computer that includes libpq.so (pq.dll on Windows).
	
	<p>The System.Data tests use this connection string to connect
	to the PostgreSQL database named "test" at host "localhost" as
	user "postgres".

<pre>
"host=localhost;dbname=test;user=postgres"
</pre>
		
	<p>Installation instructions for PostgreSQL DBMS:

	<b>On GNU/Linux and Unix</b>

	<ul>
		* Read the PostgreSQL Installation Instructions 
		at \usr\doc\postgresql-x.x.x\html\installation.html
		
		* Depending on your GNU/Linux distribution or Unix, 
		PostgreSQL maybe already installed, a database user 'postgres' created, 
		a linux user 'postgres' created and initdb ran.  Or maybe not.

<pre>
 su
 adduser postgres
 mkdir /usr/local/pgsql/data
 chown postgres /usr/local/pgsql/data
 su - postgres
 initdb -D /usr/local/pgsql/data
 postmaster -i -D /usr/local/pgsql/data >logfile 2>&1 &
 createdb test
 psql test
</pre>
	
		* Make sure you have a database user named postgres.  It is best to install
		the PostgreSQL DBMS under linux user postgres.  When you run the postmaster,
		run it under the user postgres as well.  If this was not done, then you
		will need to create a user named postgres for the System.Data tests.

		* If you already installed PostgeSQL and you do not have a database
		user named postgres, then you can create user postgres using psql:
		
<pre>		
psql test
create user postgres with password 'fun2db';
</pre>
				
		* The postmaster must be run with -i option.
		
		* In the /usr/local/pgsql/data/pg_hba.conf file, you need
		to have the AUTH_TYPE set to md5.  You can read more on this at
		/usr/doc/postgresql-7.2.1/html/client-authentication.html or wherever your
		PostgreSQL html docs are located.  See the 2nd line below,
		host 127.0.0.1 has an AUTH_TYPE md5 in pg_hba.conf.
		
<pre>
 # TYPE     DATABASE    IP_ADDRESS    MASK               AUTH_TYPE  AUTH_ARGUMENT

 local      all                                          trust
 host       all         127.0.0.1     255.255.255.255    md5
</pre>

	* If you can not find your PostgreSQL documentation locally or you 
	did not install it, then you 
	can get it <a href="http://www.postgresql.org/idocs/">here</a>.

	</ul>

	<b>On Windows</b>

	<ul>
		* Use the <a href="http://www.cygwin.com/">Cygwin</a> installer to install the PostgreSQL DBMS.  It is
		  found in the database category.
		  
		* <p>Read the file postgres-x.x.README at /usr/doc/Cygwin and read 
		  the requirements to install PostgreSQL.  Those requirements
		  are included with cygwin except cygipc.  A default installtion
		  of cygwin does not install everything you will need, so on the 
		  safe side, just include everything when installing cygwin.
		
		* <p>The -x.x in postgres-x.x is the version of your PostgreSQL DBMS.
		
		* <p>Once Cygwin has installed the PostgreSQL DBMS on your computer,
		  read the file FAQ_MSWIN which is available 
		  in /usr/doc/postgres-x.x 
				  
		* <p>Important notes from this file are:
		  
		  <ul>
				<p><b>2.</b> - Install the latest <a href="http://www.neuro.gatech.edu/users/cwilson/cygutils/OBSOLETE/V1.1/cygipc/index.html">CygIPC</a> package.
			  			  
				<p>The cygipc package contains the ipc-daemon you will need 
				to run before you can
				run the PostgreSQL DBMS Server daemon (postmaster) or run
				initdb which initializes the PostgreSQL database.
			  
				<p><b>3.</b>  The Cygwin bin directory has to be placed in 
				the path before the Windows program directories, 
				for example, C:\cygwin\bin 
			  
				<p><b>My own note.</b>  In the Windows control panel, I set
				the environment variables PATH to my cygwin /usr/local/bin,
				/usr/bin, and /bin.  I also set my LD_LIBRARY_PATH to 
				/usr/local/lib and /usr/lib.  For example:
			  
				<p>
<pre>
PATH=c:\cygwin\usr\local\bin;c:\cygwin\usr\bin;c:\cygwin\bin;
LD_LIBRARY_PATH=c:\cygwin\usr\local\lib;c:\cygwin\usr\lib;
</pre>
							  
				<p><b>4.</b> Start the ipc-daemon that came with the cygipc package.  There
				are two ways to do this: run it from the command line as:
			  
				<p>
<pre>
ipc-daemon &
</pre> 			  
				<p>or you can set it up as a Windows service.  See the 
				file cygrunsrv.README at /usr/doc/Cygwin on how to do this
				for ipc-daemon and postmaster.  Note the
				troubleshooting section at the end of 
				the cygrunsrv.README file.
			  
				<p>To install ipc-daemon as a service, 
				you just have to run
			  
				<p>
<pre>
ipc-daemon --install-as-service' (--remove-as-service) 
</pre>
			  
				<p>and then run
			  
<pre>
net start ipc-daemon
</pre>
			</ul>
			  
			<p>Read the installation.html file 
			at /usr/doc/postgresql-x.x/html/installation.html
		
			<p>You will see in this file that you will need to 
			run the following commands:
		  
			<p>
<pre>
mkdir /usr/local/pgsql/data
initdb -D /usr/local/pgsql/data
postmaster -D /usr/local/pgsql/data >logfile 2>&1 &
createdb test
psql test  		
</pre>
		  
			<p>When you need to connect to the database, 
			you will need ipc-daemon and postmaster running.  Start ipc-daemon
			before any of the command above.  
		  
			<p>psql is a command-line PostgreSQL client tool to 
			enter and run SQL commands and queries.
		  
			<p>If there is no database user named postgres, create a user named
			postgres with the following SQL command in the client tool psql:
		  
			<p>
<pre>
psql test
create user postgres with password 'fun2db';
</pre>
			<p>The only reason I say this is so you can easily use the System.Data tests
			without having to change the database, userid, etc.
	</ul>
	
	<p>In the path mcs/class/System.Data/Test
	there is a PostgreSQL test program named
	PostgreTest.cs.  Thanks goes to Gonzalo for creating the original
	PostgreSQL test.
	
	<p>To use it to test System.Data, you
	modify the file to your PostgreSQL database
	connection requirements:

	<p>
	<ul>
		<li><b>dbname</b> database, ie., test</li>
		<li><b>host</b> hostname of the PostgreSQL DBMS Server to connect to, ie., localhost</li>
		<li><b>user</b> username, ie., someuser</li>
		<li><b>password</b> password, ie., mypass1234</li>
	</ul>
	
	<p>The connection string is in OLE-DB connection string format.  Internally,
	SqlConnection converts this to the PostgreSQL connection string format.
	
	<p>
<pre>
    OLE-DB: "host=localhost;dbname=test;user=joe;password=smoe"
PostgreSQL: "host=localhost dbname=test user=joe password=smoe"
</pre>

	<p>
	Note that OLE-DB includes the semicolons while PostgreSQL's connection
	string does not.

	<p>
    To compile the PostgresTest.cs program, do:
    
    <p>
<pre>
mcs PostgresTest.cs -r System.Data.dll
</pre>
    
    <p>
    To run using mint, do:
    
    <p>
<pre>
mint PostgresTest.exe
</pre>
    
    <p>
    To run using mono, do:
<pre>
mono PostgresTest.exe
</pre>
    
    <p>You should get something like:

<p>
<pre>   
 danmorg@DANPC ~/mono/mcs/class/System.Data/Test
 $ mcs PostgresTest.cs -r System.Data.dll

 danmorg@DANPC ~/mono/mcs/class/System.Data/Test
 $ mono PostgresTest.exe
         Postgres provider specific tests...

                 Drop table:
 Error (don't worry about this one)SqlError:PGRES_FATAL_ERROR ERROR:  table "mono
 _postgres_test" does not exist
  <Stack Trace>

                 Create table with all supported types:
 OK
                 Insert values for all known types:
 OK
                 Update values:
 OK
                 Insert values for all known types:
 OK
 Aggregate: count(*)
 Agg Result: 2
 Aggregate: min(text_value)
 Agg Result: This is a text
 Aggregate: max(int4_value)
 Agg Result: 1048000
 Aggregate: sum(int4_value)
 Agg Result: 1048003
                 Select values from the database:
                 Get Schema.
 dt.Columns.Count: 12
 * Column Name: boolean_value
          MaxLength: 1
          Type: System.Boolean
 * Column Name: int2_value
          MaxLength: 2
          Type: System.Int16
 * Column Name: int4_value
          MaxLength: 4
          Type: System.Int32
 * Column Name: bigint_value
          MaxLength: 8
          Type: System.Int64
 * Column Name: float_value
          MaxLength: 4
          Type: System.Single
 * Column Name: double_value
          MaxLength: 8
          Type: System.Double
 * Column Name: char_value
          MaxLength: -1
          Type: System.String
 * Column Name: varchar_value
          MaxLength: -1
          Type: System.String
 * Column Name: text_value
          MaxLength: -1
          Type: System.String
 * Column Name: time_value
          MaxLength: 8
          Type: System.DateTime
 * Column Name: date_value
          MaxLength: 4
          Type: System.DateTime
 * Column Name: timestamp_value
          MaxLength: 8
          Type: System.DateTime
 Row 0:
     Col 0: boolean_value: False
     Col 1: int2_value: 5
     Col 2: int4_value: 3
     Col 3: bigint_value: 9
     Col 4: float_value: 3.141590
     Col 5: double_value: 3.141593
     Col 6: char_value: Mono.Data!
     Col 7: varchar_value: It was not me!
     Col 8: text_value: We got data!
     Col 9: time_value: Monday, 01 January 1 21:13:14
     Col 10: date_value: Tuesday, 29 February 2000 00:00:00
     Col 11: timestamp_value: Sunday, 29 February 2004 14:00:11
 Row 1:
     Col 0: boolean_value: True
     Col 1: int2_value: -22
     Col 2: int4_value: 1048000
     Col 3: bigint_value: 123456789012345
     Col 4: float_value: 3.141590
     Col 5: double_value: 3.141593
     Col 6: char_value: This is a char
     Col 7: varchar_value: This is a varchar
     Col 8: text_value: This is a text
     Col 9: time_value: Monday, 01 January 1 21:13:14
     Col 10: date_value: Tuesday, 29 February 2000 00:00:00
     Col 11: timestamp_value: Sunday, 29 February 2004 14:00:11
 Rows: 2
 Clean up...
                 Drop table...
 OK
 RESULT: 0

</pre>