artifact_id;status_id;status_name;priority;submitter_id;submitter_name;assigned_to_id;assigned_to_name;open_date;close_date;last_modified_date;summary;details;"Category";"Group";"Resolution"
1000445;1;"Open";3;100510;"Gevik Babakhani";100;"Nobody";"2005-11-23 19:05";"";"2012-09-24 02:14";"Single npgsql.dll";"I was wondering if it is possible to joing the mono dll and the npgsql dll into one?";"None";"None";"None"
1000449;1;"Open";3;100;"Nobody";100;"Nobody";"2005-11-24 20:31";"";"2012-09-24 02:14";"real parameter support";"Today, npgsql is binding .NET parameter into the query...
I've read that, with the new Pg 8.0 protocol, there is a way to send parameters appart from the query (like in oracle). It could be useful to avoid sql injection problem, and it could improve performance when inserting large binary values.
";"None";"None";"None"
1000461;1;"Open";3;100;"Nobody";100;"Nobody";"2005-12-01 16:05";"";"2012-09-24 02:14";"Rename the assemblies...";"1- i agree with merging Npgsql and the MonoSecurity assembly into one single assembly can be fine

2- some names can be renamed as follows 
Npgsql.dll         -> PostgreSQL.dll
using Npgsql;      -> using PostgreSQL;
NpgsqlDbType.XXX   -> PgDbType.XXX 
NpgsqlConnection   -> PgConnection
...

3- support for dotnet 2.0

4- PostgreSQL known with better documentation i think Npgsql can have better documentation.

5- i think a gui can be writen with dotnet and Npgsql (like PgAdmin)

6- can Npgsql have multiple solution files for Visual Studio , SharpDevelop , Nant, Nmake...

7- NpgsqlDbType namespace can be merge with Npgsql namespace

8- a server explorer addin for designing within visual studio

9- and can BSD license

Thanks...";"None";"None";"None"
1000486;1;"Open";3;101716;"Ottó Havasvölgyi";100;"Nobody";"2005-12-14 19:19";"";"2012-09-24 02:14";"Support for custom types";"Developers could be able to develop their own typeconverters for their custom Pg types, and register them in Npgsql.";"Interface Improvements (example)";"None";"None"
1000487;1;"Open";3;100;"Nobody";100;"Nobody";"2005-12-15 14:54";"";"2012-09-24 02:14";"handling copy to stdout in npgsql";"I need support to copy to/from stdout in npgsql for custom data replication solution.";"Interface Improvements (example)";"Next Release (example)";"None"
1000539;1;"Open";3;101941;"Nicola Milani";100;"Nobody";"2006-01-29 11:10";"";"2012-09-24 02:14";"Npgsql on compact framework";"I need to create a software for a wireless terminal with Windows CE 4.2.
In particular, the software need read and write to a postgreSQL 8.1 installed on Windows XP. The connection to database is wireless.
I don't see a version of npgsql for compact framework 1.0 so, is it possible to have a npgsql compact version?
Thank you.";"None";"None";"None"
1000552;1;"Open";3;100;"Nobody";100;"Nobody";"2006-02-08 11:08";"";"2012-09-24 02:14";"NpgSQL for .NET CE";"I tested NpgSQL in Windows CE.Net and the solution make an exception. You can make a build for .Net CE?";"None";"None";"None"
1000562;1;"Open";3;100;"Nobody";100;"Nobody";"2006-02-21 23:28";"";"2012-09-24 02:14";"Respect ""DateTime.Kind"" in .Net 2.0 Build";"The current code does not appear to pay any attention to the new ""Kind"" member of DateTime.  This can lead to timezone confusion if, for example, ""Kind"" happens to be Utc in an INSERT or if someone calls ""ToUniversalTime()"" on a value from a SELECT.";"None";"None";"None"
1000594;1;"Open";3;100;"Nobody";100;"Nobody";"2006-03-20 11:20";"";"2012-09-24 02:14";"Accept SecureString as connection string input";"Standard .net strings are very insecure - they appear several times in memory, are in plain text and cannot be overwitten as they are immutable.

Using the SecureString class would help alleviate these problems.

";"None";"None";"None"
1000654;1;"Open";3;100;"Nobody";100;"Nobody";"2006-05-29 21:22";"";"2012-09-24 02:14";"Add Support for SqlDatasource in ASP.NET 2.0";"I would like to see support for working with ASP.NET 2.0's SqlDataSource, possibly it is already there but I saw no instructions on how to install it.  I have already wrote the necessary support code around MySQL's connector (but the internals caused to many problems, probably why they are basically rewriting it), I would be glad to try, but if someone has already done the work, I would appreciate a copy :-)";"None";"None";"None"
1000711;1;"Open";3;102760;"David Boone";100;"Nobody";"2006-08-16 04:56";"";"2012-09-24 02:14";"Add PID property to NpgsqlConnection";"Currently there is no easy way to get the PID of the connection.  This becomes necessary when dealing with notifications, when we want to filter out notifications sent by ourselves.

For example if we have a notification sent out by a trigger indicating that a table has changed, we probably want to filter out those caused by our own updates to the database.

Currently the only way to figure out this value (that I can see) is to LISTEN to and send out your own notification and grab the PID from that event.

Example:

new NpgsqlCommand(""LISTEN randomstring"", pg_connection).ExecuteNonQuery();
new NpgsqlCommand(""NOTIFY randomstring"", pg_connection).ExecuteNonQuery();

Then in your Notification event:

if (e.Condition == ""randomstring"")
   int ourOwnPID = e.PID;

";"Interface Improvements (example)";"Next Release (example)";"None"
1000769;1;"Open";3;103395;"Brad King";100;"Nobody";"2006-11-01 17:52";"";"2012-09-24 02:14";"Kerberos support";"We need a better authentication mechanism. Clear text passwords in connection strings doesn't cut it. Kerberos is supported by Postgres 8.1. Would be nice to integrate this seamlessly with Active Directory on Windows domains, similar to how SSPI works for SQL Server.";"None";"None";"None"
1001470;1;"Open";3;102450;"Ciril Santos";100;"Nobody";"2007-01-16 18:00";"";"2012-09-24 02:14";"StateChanged event";"you can create a event StateChanged to dectect change in state of the connection?  It will be very usefull";"None";"None";"None"
1005312;1;"Open";3;105843;"Joannes Vermorel";100;"Nobody";"2007-05-24 04:35";"";"2012-09-24 02:14";"Remove dependency toward Mono.Security.dll";"It would be more practical for Microsoft .Net based applications if Npgsql was not link Mono.Security.dll.

According to this entry
http://pgfoundry.org/forum/message.php?msg_id=1002382
such dependency is no longer needed with .Net 2.0.

Best regards,
Joannes
http://www.lokad.com";"None";"None";"None"
1007005;1;"Open";3;101741;"Andrus Moor";100;"Nobody";"2007-06-25 13:34";"";"2012-09-24 02:14";"Implement profiling";"npgsqlconnection() should have option to log all commands sent to server and their durations to text file.

NpgsqlEventLog.Level = LogLevel.Debug works but slows down program too much.
Also this result file has too many unnessecary information. 

MS SQL net data provider has profiling capabilities.

npgsql should also have profiling capabilites in client side.";"None";"None";"None"
1008864;1;"Open";3;107132;"Andreas Tille";100;"Nobody";"2007-09-10 14:40";"";"2012-09-24 02:14";"Please support ident authentication";"Hello,

a very convinient method to connect to PostgreSQL server is the ident method. In fact it seems to be the default method for the Debian packaged version of PostgreSQL and the most interesting feature is that you don't have to provide a password if you are connecting to a database at localhost.

It would be really great if Npgsql would support this feature.

Kind regards and thanks for working on Npgsql

         Andreas.";"None";"None";"None"
1008893;1;"Open";3;100;"Nobody";100;"Nobody";"2007-09-13 09:07";"";"2012-09-24 02:14";"is it possible to bundle npgsql in a visual studio 2005 plug_in like the one provided by mysql";"mysql has provided a single bundle plug in for visual studio 2005 which made it very easy to connect to mysql and use the development environmemt as easy as using it with ms_sql200,2005 and oracle! 

i love postgresql and find it much better than any other RDBMS in performance and would like to see a similar plug in for vs2005

thank you
ziad dodin";"Interface Improvements (example)";"Next Release (example)";"None"
1008894;1;"Open";3;107177;"ziad dodin";100;"Nobody";"2007-09-13 09:22";"";"2012-09-24 02:14";"visual studio 2005 plug_in for postgresql";"mysql has provided a single bundle plug in for visual studio
2005 which made it very easy to connect to mysql and use
the development environmemt as easy as using it with ms_sql200,2005
and oracle!

i beleive this requires a final release of pgoledb or other connector

i love postgresql and find it much better than any other RDBMS
in performance and would like to see a similar plug in
for vs2005
";"Interface Improvements (example)";"Next Release (example)";"None"
1010318;1;"Open";3;108484;"harry do";100;"Nobody";"2008-03-15 15:32";"";"2012-09-24 02:14";"DataReader.GetSchemaTable() returns incorrect ColumnSize";"DataReader.GetSchemaTable() returns incorrect ColumnSize for column of type ENUM. For example, 

The sample pagila database defines

CREATE TYPE mpaa_rating AS ENUM (
    'G',
    'PG',
    'PG-13',
    'R',
    'NC-17'
);


CREATE TABLE film (
    film_id integer DEFAULT nextval('film_film_id_seq'::regclass) NOT NULL,
    title character varying(255) NOT NULL,
    description text,
    release_year year,
    language_id smallint NOT NULL,
    original_language_id smallint,
    rental_duration smallint DEFAULT 3 NOT NULL,
    rental_rate numeric(4,2) DEFAULT 4.99 NOT NULL,
    length smallint,
    replacement_cost numeric(5,2) DEFAULT 19.99 NOT NULL,
    rating mpaa_rating DEFAULT 'G'::mpaa_rating,
    last_update timestamp without time zone DEFAULT now() NOT NULL,
    special_features text[],
    fulltext tsvector NOT NULL
);


.Net codes

DataTable schema = myDataReader.GetSchemaTable();
schema.Rows[i][""ColumnSize""] will return 4, it should be 5
";"None";"None";"None"
1010369;1;"Open";3;108677;"Manuel de la Pena";100;"Nobody";"2008-04-03 08:50";"";"2012-09-24 02:14";"Adding '?' as acceptable leading char in parameter names";"People that are used to code using the Oracle client have the habit of using '?' as the leading char for parameter names instead of '@' of ':'. 

It would be a really nice feature to accept'?' as the leading character since it will ease the migration from Oracle to PostgreSQL. ";"None";"None";"None"
1010417;1;"Open";3;109517;"Jacek Rużyczka";100;"Nobody";"2008-06-23 10:28";"";"2012-09-24 02:14";"Support for <table>%ROWTYPE as Return Type of Stored Procedures";"In order to use a <table>%ROWTYPE returned by a stored procedure, you need to state the structure (columns) of the %ROWTYPE in the select statement calling the  procedure. However, when using the CommandType = StoredProcedure and CommandText = <procedure> properties, there's currently no way to give the column structure to the NpgsqlCommand object.
";"Interface Improvements (example)";"Next Release (example)";"None"
1010449;1;"Open";3;102254;"Christian Graefe";100;"Nobody";"2008-08-07 14:32";"";"2012-09-24 02:14";"Please provide setup ";"Hi,

Your work is great, but please implement an installer for Npgsql.
This would ease the installation of Npgsql on development/production servers.

regards
Christian
";"None";"None";"None"
1010477;1;"Open";3;103944;"Federico Di Gregorio";100;"Nobody";"2008-09-19 18:44";"";"2012-09-24 02:14";"Support for ""IN (...)"" in SQL queries";"Right now using the ""IN (item1, item2, ..., itemN)"" construct in SQL queries requires  client-side (C#) formatting of IN arguments. If one has, for example, a list of strings, he should format them into an appropriate list and then:

1) Pass them as a single string parameter;
2) Change the query to use casting to produce an array of items with the right tye;
3) Use the ANY operator and the string_to_array function to do the work usually done by IN.

Some example code is available in the mailing list discussion:

http://pgfoundry.org/pipermail/npgsql-devel/2008-September/000784.html
http://pgfoundry.org/pipermail/npgsql-devel/2008-September/000786.html

This is clumsy, requires the programmer to know the details of C#<->PostgreSQL type conversions (including quoting) and prone to error.

It would be much better to have a wrapper type that initialized with an array can be directly bound to an NpgsqlParameter leaving all the real work to Npgsql itself. Writing a query involving the IN operator would then be as simle as:

string[] ids = new string[3] {""one"",""two"",""three""};
NpgsqlCommand cmd = new NpgsqlCommand(""SELECT * FROM xxx WHERE id IN (:ids)"", conn);
IDbDataParameter param = cmd.CreateParameter();
param.ParameterName = ""ids"";
param.Value = new NpgsqlSqlIn<string>(ids);
cmd.Parameters.Add(param);
cmd.ExecuteReader();


";"None";"None";"None"
1010650;1;"Open";3;115473;"Dario Quintana";100;"Nobody";"2009-06-10 20:59";"";"2012-09-24 02:14";"DbConnection.GetSchema: Metadata for Indexes";"Useful for frameworks that use this information in Schema Update, like NHibernate.";"None";"None";"None"
1010651;1;"Open";3;115473;"Dario Quintana";100;"Nobody";"2009-06-10 21:02";"";"2012-09-24 02:14";"DbConnection.GetSchema: Reserved words";"Useful for frameworks that use this information in Schema Update, like NHibernate.";"None";"None";"None"
1010682;1;"Open";3;116156;"Adam Ruth";100;"Nobody";"2009-08-03 22:47";"";"2012-09-24 02:14";"Allow for user mapping when using Integrated Security";"When using Integrated Security with version 8.4 it is possible to log in as a database user other than the currently logged on OS user (assuming that the proper pg_ident.conf entries.) 

All that is required is to pass in a User ID during authentication other than the OS user name. I made a one line patch to the sources for 2.0.6 to do this for my environment. I'm not sure how this would work with earlier versions, it may need some version checking added.

I don't know the proper syntax for patches (I'm a patch virgin :-), but since it's just one line, I'll put it here.

File: NpgsqlConnectionStringBuilder.cs line 393 in UserName:get

if (_integrated_security && _username == string.Empty) // added the test for user name empty

If the User ID is set in the connection string, then the user name isn't taken from WindowsIdentity.




";"None";"None";"None"
1010700;1;"Open";3;116683;"Brian Schloz";100;"Nobody";"2009-09-09 17:56";"";"2012-09-24 02:14";"Capture parameter names with NpgsqlCommandBuilder.DeriveParameters";"Currently, NpgsqlCommandBuilder.DeriveParameters method only retrieves the type and then adds generically the parameter names (e.g. parameter1, parameter2, ...). It would be useful to also capture the parameter names. I have a specific need for this but it would also be consistent with other data providers.

I've reviewed the source code and believe this would be an easy fix. I would be happy to provide a patch if this seems reasonable.

Brian";"Interface Improvements (example)";"Next Release (example)";"None"
1010755;1;"Open";3;102449;"Alaric Dailey";100;"Nobody";"2010-01-19 17:46";"";"2012-09-24 02:14";"Installer that puts the required information in Machine.Config";"Here is a sample program that will do just that, however it would need to recompiled for each CLR supported, such as 1.0, 1.1, 2.0, 4.0, and Mono.  Since 3.0 and 3.5 use the same CLR it will work as is.  

I don't have a good way of testing this for 1.1 and 1.0, so I have no idea if it can even be made to work, for those platforms.

There is an assumption that the .NET framework SDK is installed, however that could be worked around by including the proper GACUTIL with the application.";"None";"None";"None"
1010760;1;"Open";3;102449;"Alaric Dailey";100;"Nobody";"2010-02-03 15:14";"";"2012-09-24 02:14";"DataTypes MetaData isn't supported ";"I was trying to write a piece of code to map the providers specific DbType to the base DbType for a response to one of my articles and found that npgsql doesn't support the metadata I was using. 

here is the code

//get our provider factory and connection
    DbProviderFactory factory = DbProviderFactories.GetFactory(""System.Data.SqlClient"");
    DbConnection connection = factory.CreateConnection();
    connection.ConnectionString = ""Data Source=(local);Integrated Security=SSPI;Initial Catalog=cars;"";
//connect
    connection.Open();
//create a parameter to let it do the mapping for us
    DbParameter providerParameter = factory.CreateParameter();

//get the type for reflecting
    Type parameterType = providerParameter.GetType();
//find the provider specific DbType property
    PropertyInfo[] pis =
        parameterType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
    PropertyInfo providerDbTypeProperty = null;
    foreach (PropertyInfo pi in pis)
    {
//ignore the ""DbType"" property, instead, get the other one
        if (pi.Name.IndexOf(""DbType"") > 0)
        {
            providerDbTypeProperty = pi;
            break;
        }
    }
    if (providerDbTypeProperty == null)
    {
        throw new Exception(""couldn't find providers native DbType"");
    }

//get our metadata collection
    using (DataTable dt = connection.GetSchema(DbMetaDataCollectionNames.DataTypes))
    {
        DbParameter parameter = providerParameter;
//use the column that provides the number for the value
        DataColumn column = dt.Columns[DbMetaDataColumnNames.ProviderDbType];

//create mapping dictionary
        Dictionary<string, DbType> dictionary = new Dictionary<string, DbType>();
        foreach (DataRow row in dt.Rows)
        {
//set a default
            parameter.DbType = DbType.Object;
//get value
            object value = row[column];
//set the property via reflection
            providerDbTypeProperty.SetValue(providerParameter, value, null);
//get the NAME that the provider specifies
            string name = Enum.GetName(providerDbTypeProperty.PropertyType, value);
            try
            {
//add that Name, and mapping over to my dictionary
                dictionary.Add(name, parameter.DbType);
            }
            catch
            {
                //eat the errors of the duplicates;
            }
        }
//put a breakpoint here to inspect the dictionary
        Debug.WriteLine(""stop"");
//return it if we want
        return dictionary;
    }

////////--------------------------------------------------------------

and here is the serialized XML output from the datatable returned from SqlServer (though I know oracle would be better, I don't have an oracle instance)

the columns are Fairly self explanatory when you look at the data, except the ProviderDbType. That value of the enum from the Native type, in the case of SQL Server that is System.Data.SqlClient.SqlDbType for Npgsql it would be NpgsqlDbType;

<?xml version=""1.0"" standalone=""yes""?>
<DocumentElement>
  <DataTypes>
    <TypeName>smallint</TypeName>
    <ProviderDbType>16</ProviderDbType>
    <ColumnSize>5</ColumnSize>
    <CreateFormat>smallint</CreateFormat>
    <DataType>System.Int16</DataType>
    <IsAutoIncrementable>true</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>true</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>int</TypeName>
    <ProviderDbType>8</ProviderDbType>
    <ColumnSize>10</ColumnSize>
    <CreateFormat>int</CreateFormat>
    <DataType>System.Int32</DataType>
    <IsAutoIncrementable>true</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>true</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>real</TypeName>
    <ProviderDbType>13</ProviderDbType>
    <ColumnSize>7</ColumnSize>
    <CreateFormat>real</CreateFormat>
    <DataType>System.Single</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>float</TypeName>
    <ProviderDbType>6</ProviderDbType>
    <ColumnSize>53</ColumnSize>
    <CreateFormat>float({0})</CreateFormat>
    <CreateParameters>number of bits used to store the mantissa</CreateParameters>
    <DataType>System.Double</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>money</TypeName>
    <ProviderDbType>9</ProviderDbType>
    <ColumnSize>19</ColumnSize>
    <CreateFormat>money</CreateFormat>
    <DataType>System.Decimal</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>false</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>true</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>smallmoney</TypeName>
    <ProviderDbType>17</ProviderDbType>
    <ColumnSize>10</ColumnSize>
    <CreateFormat>smallmoney</CreateFormat>
    <DataType>System.Decimal</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>false</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>true</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>bit</TypeName>
    <ProviderDbType>2</ProviderDbType>
    <ColumnSize>1</ColumnSize>
    <CreateFormat>bit</CreateFormat>
    <DataType>System.Boolean</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>false</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>tinyint</TypeName>
    <ProviderDbType>20</ProviderDbType>
    <ColumnSize>3</ColumnSize>
    <CreateFormat>tinyint</CreateFormat>
    <DataType>System.SByte</DataType>
    <IsAutoIncrementable>true</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>true</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>true</IsUnsigned>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>bigint</TypeName>
    <ProviderDbType>0</ProviderDbType>
    <ColumnSize>19</ColumnSize>
    <CreateFormat>bigint</CreateFormat>
    <DataType>System.Int64</DataType>
    <IsAutoIncrementable>true</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>true</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>timestamp</TypeName>
    <ProviderDbType>19</ProviderDbType>
    <ColumnSize>8</ColumnSize>
    <CreateFormat>timestamp</CreateFormat>
    <DataType>System.Byte[]</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>false</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>false</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsConcurrencyType>true</IsConcurrencyType>
    <LiteralPrefix>0x</LiteralPrefix>
  </DataTypes>
  <DataTypes>
    <TypeName>binary</TypeName>
    <ProviderDbType>1</ProviderDbType>
    <ColumnSize>8000</ColumnSize>
    <CreateFormat>binary({0})</CreateFormat>
    <CreateParameters>length</CreateParameters>
    <DataType>System.Byte[]</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>0x</LiteralPrefix>
  </DataTypes>
  <DataTypes>
    <TypeName>image</TypeName>
    <ProviderDbType>7</ProviderDbType>
    <ColumnSize>2147483647</ColumnSize>
    <CreateFormat>image</CreateFormat>
    <DataType>System.Byte[]</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>true</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>false</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>0x</LiteralPrefix>
  </DataTypes>
  <DataTypes>
    <TypeName>text</TypeName>
    <ProviderDbType>18</ProviderDbType>
    <ColumnSize>2147483647</ColumnSize>
    <CreateFormat>text</CreateFormat>
    <DataType>System.String</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>true</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>false</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>'</LiteralPrefix>
    <LiteralSuffix>'</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>ntext</TypeName>
    <ProviderDbType>11</ProviderDbType>
    <ColumnSize>1073741823</ColumnSize>
    <CreateFormat>ntext</CreateFormat>
    <DataType>System.String</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>true</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>false</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>N'</LiteralPrefix>
    <LiteralSuffix>'</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>decimal</TypeName>
    <ProviderDbType>5</ProviderDbType>
    <ColumnSize>38</ColumnSize>
    <CreateFormat>decimal({0}, {1})</CreateFormat>
    <CreateParameters>precision,scale</CreateParameters>
    <DataType>System.Decimal</DataType>
    <IsAutoIncrementable>true</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <MaximumScale>38</MaximumScale>
    <MinimumScale>0</MinimumScale>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>numeric</TypeName>
    <ProviderDbType>5</ProviderDbType>
    <ColumnSize>38</ColumnSize>
    <CreateFormat>numeric({0}, {1})</CreateFormat>
    <CreateParameters>precision,scale</CreateParameters>
    <DataType>System.Decimal</DataType>
    <IsAutoIncrementable>true</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsUnsigned>false</IsUnsigned>
    <MaximumScale>38</MaximumScale>
    <MinimumScale>0</MinimumScale>
    <IsConcurrencyType>false</IsConcurrencyType>
  </DataTypes>
  <DataTypes>
    <TypeName>datetime</TypeName>
    <ProviderDbType>4</ProviderDbType>
    <ColumnSize>23</ColumnSize>
    <CreateFormat>datetime</CreateFormat>
    <DataType>System.DateTime</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>{ts '</LiteralPrefix>
    <LiteralSuffix>'}</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>smalldatetime</TypeName>
    <ProviderDbType>15</ProviderDbType>
    <ColumnSize>16</ColumnSize>
    <CreateFormat>smalldatetime</CreateFormat>
    <DataType>System.DateTime</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>{ts '</LiteralPrefix>
    <LiteralSuffix>'}</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>sql_variant</TypeName>
    <ProviderDbType>23</ProviderDbType>
    <CreateFormat>sql_variant</CreateFormat>
    <DataType>System.Object</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <IsLiteralSupported>false</IsLiteralSupported>
  </DataTypes>
  <DataTypes>
    <TypeName>xml</TypeName>
    <ProviderDbType>25</ProviderDbType>
    <ColumnSize>2147483647</ColumnSize>
    <CreateFormat>xml</CreateFormat>
    <DataType>System.String</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>false</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>true</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>false</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <IsLiteralSupported>false</IsLiteralSupported>
  </DataTypes>
  <DataTypes>
    <TypeName>varchar</TypeName>
    <ProviderDbType>22</ProviderDbType>
    <ColumnSize>2147483647</ColumnSize>
    <CreateFormat>varchar({0})</CreateFormat>
    <CreateParameters>max length</CreateParameters>
    <DataType>System.String</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>'</LiteralPrefix>
    <LiteralSuffix>'</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>char</TypeName>
    <ProviderDbType>3</ProviderDbType>
    <ColumnSize>2147483647</ColumnSize>
    <CreateFormat>char({0})</CreateFormat>
    <CreateParameters>length</CreateParameters>
    <DataType>System.String</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>'</LiteralPrefix>
    <LiteralSuffix>'</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>nchar</TypeName>
    <ProviderDbType>10</ProviderDbType>
    <ColumnSize>1073741823</ColumnSize>
    <CreateFormat>nchar({0})</CreateFormat>
    <CreateParameters>length</CreateParameters>
    <DataType>System.String</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>N'</LiteralPrefix>
    <LiteralSuffix>'</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>nvarchar</TypeName>
    <ProviderDbType>12</ProviderDbType>
    <ColumnSize>1073741823</ColumnSize>
    <CreateFormat>nvarchar({0})</CreateFormat>
    <CreateParameters>max length</CreateParameters>
    <DataType>System.String</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>N'</LiteralPrefix>
    <LiteralSuffix>'</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>varbinary</TypeName>
    <ProviderDbType>21</ProviderDbType>
    <ColumnSize>1073741823</ColumnSize>
    <CreateFormat>varbinary({0})</CreateFormat>
    <CreateParameters>max length</CreateParameters>
    <DataType>System.Byte[]</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>0x</LiteralPrefix>
  </DataTypes>
  <DataTypes>
    <TypeName>uniqueidentifier</TypeName>
    <ProviderDbType>14</ProviderDbType>
    <ColumnSize>16</ColumnSize>
    <CreateFormat>uniqueidentifier</CreateFormat>
    <DataType>System.Guid</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>false</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>'</LiteralPrefix>
    <LiteralSuffix>'</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>date</TypeName>
    <ProviderDbType>31</ProviderDbType>
    <ColumnSize>3</ColumnSize>
    <CreateFormat>date</CreateFormat>
    <DataType>System.DateTime</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>false</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>true</IsFixedLength>
    <IsFixedPrecisionScale>true</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>{ts '</LiteralPrefix>
    <LiteralSuffix>'}</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>time</TypeName>
    <ProviderDbType>32</ProviderDbType>
    <ColumnSize>5</ColumnSize>
    <CreateFormat>time({0})</CreateFormat>
    <CreateParameters>scale</CreateParameters>
    <DataType>System.TimeSpan</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>false</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <MaximumScale>7</MaximumScale>
    <MinimumScale>0</MinimumScale>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>{ts '</LiteralPrefix>
    <LiteralSuffix>'}</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>datetime2</TypeName>
    <ProviderDbType>33</ProviderDbType>
    <ColumnSize>8</ColumnSize>
    <CreateFormat>datetime2({0})</CreateFormat>
    <CreateParameters>scale</CreateParameters>
    <DataType>System.DateTime</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <MaximumScale>7</MaximumScale>
    <MinimumScale>0</MinimumScale>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>{ts '</LiteralPrefix>
    <LiteralSuffix>'}</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>datetimeoffset</TypeName>
    <ProviderDbType>34</ProviderDbType>
    <ColumnSize>10</ColumnSize>
    <CreateFormat>datetimeoffset({0})</CreateFormat>
    <CreateParameters>scale</CreateParameters>
    <DataType>System.DateTimeOffset</DataType>
    <IsAutoIncrementable>false</IsAutoIncrementable>
    <IsBestMatch>true</IsBestMatch>
    <IsCaseSensitive>false</IsCaseSensitive>
    <IsFixedLength>false</IsFixedLength>
    <IsFixedPrecisionScale>false</IsFixedPrecisionScale>
    <IsLong>false</IsLong>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsSearchableWithLike>true</IsSearchableWithLike>
    <MaximumScale>7</MaximumScale>
    <MinimumScale>0</MinimumScale>
    <IsConcurrencyType>false</IsConcurrencyType>
    <LiteralPrefix>{ts '</LiteralPrefix>
    <LiteralSuffix>'}</LiteralSuffix>
  </DataTypes>
  <DataTypes>
    <TypeName>Microsoft.SqlServer.Types.SqlHierarchyId, Microsoft.SqlServer.Types, Version=10.0.0.0, PublicKeyToken=89845dcd8080cc91</TypeName>
    <ProviderDbType>29</ProviderDbType>
    <ColumnSize>892</ColumnSize>
    <IsFixedLength>false</IsFixedLength>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsLiteralSupported>false</IsLiteralSupported>
  </DataTypes>
  <DataTypes>
    <TypeName>Microsoft.SqlServer.Types.SqlGeometry, Microsoft.SqlServer.Types, Version=10.0.0.0, PublicKeyToken=89845dcd8080cc91</TypeName>
    <ProviderDbType>29</ProviderDbType>
    <ColumnSize>-1</ColumnSize>
    <IsFixedLength>false</IsFixedLength>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsLiteralSupported>false</IsLiteralSupported>
  </DataTypes>
  <DataTypes>
    <TypeName>Microsoft.SqlServer.Types.SqlGeography, Microsoft.SqlServer.Types, Version=10.0.0.0, PublicKeyToken=89845dcd8080cc91</TypeName>
    <ProviderDbType>29</ProviderDbType>
    <ColumnSize>-1</ColumnSize>
    <IsFixedLength>false</IsFixedLength>
    <IsNullable>true</IsNullable>
    <IsSearchable>true</IsSearchable>
    <IsLiteralSupported>false</IsLiteralSupported>
  </DataTypes>
</DocumentElement>
";"None";"None";"None"
1010948;1;"Open";3;194907;"asdf asdf";100;"Nobody";"2010-11-29 17:27";"";"2012-09-24 02:14";"DbConnection.GetSchema: DataTypes";"Would be handy to implement the DataTypes for use with orm mappers including NHibernate.";"None";"None";"None"
1010951;1;"Open";3;111951;"Claudia Murialdo";100;"Nobody";"2010-12-02 17:46";"";"2012-09-24 02:14";"AllowPartiallyTrustedCallers for npgsql assemblies";"There are some hosts like http://ajuda.uolhost.com.br/index.php?ind=&p=resposta&res=550 which run applications in a partially trusted environment (Medium Trust level) and requires that all the assemblies have that attribute. 
Npgsql assemblies don't have it, I need AllowPartiallyTrustedCallers attribute to be added to the npqsql assemblies so my application can be hosted in such environments.";"None";"None";"None"
1010994;1;"Open";3;230018;"Yaroslav Potapov";100;"Nobody";"2011-02-20 12:28";"";"2012-09-24 02:14";"Add composite type support";"I propose to add composite type support like this (need to complete):
---------------------------------------------------------------------------
    public class NpgsqlCProperty
    {
        public NpgsqlCProperty(string name, NpgsqlDbType type)
        {
            if (name == null) throw new ArgumentNullException(""name"");
            if (type == null) throw new ArgumentNullException(""type"");
            //TODO: other verifies
            PName = name;
            PType = type;
            
        }
        public string PName { get; private set; }
        public NpgsqlDbType PType { get; private set; }
    }


    public class NpgsqlComposite
    {
        public NpgsqlComposite(string name, params NpgsqlCProperty[] properties)
        {
            if (name == null) throw new ArgumentNullException(""name"");
            if (properties == null) throw new ArgumentNullException(""properties"");
            Name = name;
            _properties = new Dictionary<string, int>(properties.Length);
            _values = new object[properties.Length];
            _types = new NpgsqlDbType[properties.Length];
            for (int i = 0 ; i < properties.Length ; i++)
            {
                if (properties[i] == null) throw new ArgumentNullException(""properties["" + i.ToString() + ""]"" );
                _properties[properties[i].PName] = i;
                _types[i] = properties[i].PType;
            }
        }
        
        public string Name {get; private set;}

        public int Count { get { return _values.Length; } }

        private Dictionary<string, int> _properties;
        private object[] _values;
        private NpgsqlDbType[] _types;

        public object this[int index]
        {
            get {
                if (index < 0 || index > (_values.Length - 1)) throw new IndexOutOfRangeException(index.ToString());

                return _values[index];
            }
            set {
                if (index < 0 || index > (_values.Length - 1)) throw new IndexOutOfRangeException(index.ToString());
                /*
                 TODO: need verify type of 'value' by '_types[index]' and switch statement.
                 */
                _values[index] = value;
            }
        }

        public object this[string index]
        {
            get {
                if (index == null) throw new ArgumentNullException();
                if (!_properties.ContainsKey(index)) throw new ArgumentOutOfRangeException(index);
                return this[_properties[index]];
            }
            set {
                if (index == null) throw new ArgumentNullException();
                if (!_properties.ContainsKey(index)) throw new ArgumentOutOfRangeException(index);
                this[_properties[index]] = value; 
            }
        }
    }
----------------------------------------------------------


For getting from DB need method:
    reader.GetComposite(ref NpgsqlComposite cType)

Thank you.";"None";"None";"None"
1011021;1;"Open";3;109423;"Patrick Earl";100;"Nobody";"2011-04-25 05:28";"";"2012-09-24 02:14";"Support DbMetaDataCollectionNames.ReservedWords";"NHibernate uses the following code to get a list of reserved words from ADO.NET providers.  Unfortunately Npgsql does not support this.

public virtual ISet<string> GetReservedWords()
{
    var result = new HashedSet<string>();
    DataTable dtReservedWords =
        connection.GetSchema(DbMetaDataCollectionNames.ReservedWords);
    foreach (DataRow row in dtReservedWords.Rows)
    {
        result.Add(row[""ReservedWord""].ToString());
    }
    return result;
}

The lack of this feature is currently causing many tests to fail.

Thankfully, using the following chart the feature should be easy to implement.

http://www.postgresql.org/docs/9.0/interactive/sql-keywords-appendix.html

I'd be happy to test it and report back if it could be implemented.";"None";"None";"None"
1011143;1;"Open";3;167109;"Pablo Ruiz";100;"Nobody";"2011-12-30 17:50";"";"2012-09-24 02:14";"Split System.Data.Entity dependant code to an independent assembly (¿Npgsql.Entity.dll?)";"This would allow a single assembly (Npgsql.dll) compatible with both mono/ms.net and would reduce the API surface for thoose not using Entity Framework, as well as allowing providing independent Npgsql.Entity.dll for each Entity Framework version.

I could provide a pull request over github in case the idea gets accepted.

Regards";"None";"None";"None"
1011216;1;"Open";3;111335;"Mike Christensen";100;"Nobody";"2012-08-03 20:23";"";"2012-09-24 02:14";"Nplsql should natively handle new Postgres 9.2 RANGE types";"Right now, Npgsql will handle a RANGE type as a string, which is not ideal.

However, I'm not sure the best way to implement this as there's not really a native concept of a range type in .NET.  It would probably be hacky to implement this as a two-element array.

Perhaps Npgsql can implement its own Range<T> class which would contain an upper and lower value.  This class would also need to support inclusive and exclusive bounds, as well as unbounded ranges.

A bonus feature would be to implement an implicit conversion between Range<T> and String so that code can work with ranges exactly as you could in Postgres, for example:

Range<Int32> foo = ""[5,10]"";

As well as operators to compare ranges with other instances.

Reference: http://www.postgresql.org/docs/devel/static/rangetypes.html";"Interface Improvements (example)";"Next Release (example)";"None"
1011245;1;"Open";3;475664;"chen huajun";100;"Nobody";"2012-10-10 04:16";"";"2012-10-10 04:16";"Fill SQLSTATE in all NpgsqlExceptions";"Right now,Only NpgsqlExceptions related to talking to the server have SQLSTATE(NpgsqlException.Code) been filled.
Maybe it's better to fill SQLSTATE to all NpgsqlExceptions.

For example:
1)NpgsqlException with SQLSTATE filled
throw new NpgsqlException(errors);

2)NpgsqlException without SQLSTATE filled
NpgsqlCommand.cs(1506): return new NpgsqlException(resman.GetString(""Exception_ConnectionBroken""), e);

reference:
http://pgfoundry.org/forum/forum.php?thread_id=15317&forum_id=518

";"None";"None";"None"
1011295;1;"Open";3;3055;"Francisco Figueiredo jr. ";100;"Nobody";"2013-01-15 12:15";"";"2013-01-15 12:15";"Improve castexception error log.";"A lot of times, users are faced with cast exception inside Npgsql but the exception message gives no clue about what is happening. The idea would be to improve this message. 

Check this message: http://stackoverflow.com/questions/14322516/specified-cast-is-not-valid-whith-datetime-field-mapping-npgsql-2-0-12-nhiber

There are many others like that where you can't easily find why the cast failed.
";"None";"None";"None"
1011313;1;"Open";3;491885;"Brice Lambson";100;"Nobody";"2013-03-04 21:45";"";"2013-03-04 21:45";"Better support for Entity Framework Code First";"Entity Framework Code First adds support for generating a database at runtime. In order to fully support this, the DbCreateDatabase, DbCreateDatabaseScript, DbDatabaseExists, and DbDeleteDatabase method of DbProviderServices should be implemented.";"None";"None";"None"