codesmith连接postgresql修复bug

转：CodeSmith7代码生成器针对PostgreSQL数据库无法使用的Bug修复全过程

我自己又修改过，完整的PostgreSQLSchemaProvider.cs文件如下

 using Npgsql;
 using NpgsqlTypes;
 using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Text.RegularExpressions;

 namespace SchemaExplorer
 {
     public class PostgreSQLSchemaProvider : IDbSchemaProvider, IDbConnectionStringEditor
     {
         public string Name
         {
             get
             {
                 return "PostgreSQLSchemaProvider";
             }
         }

         public string Description
         {
             get
             {
                 return "PostgreSQL Schema Provider";
             }
         }

         public string ConnectionString
         {
             get
             {
                 return string.Empty;
             }
         }

         public bool EditorAvailable
         {
             get
             {
                 return false;
             }
         }

         public bool ShowEditor(string currentConnectionString)
         {
             return false;
         }

         public TableSchema[] GetTables(string connectionString, DatabaseSchema database)
         {
             List<TableSchema> list = new List<TableSchema>();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand("select tablename, tableowner,obj_description(relfilenode,'pg_class') as pg_description from pg_catalog.pg_tables as t left join pg_catalog.pg_class as c on t.tablename = c.relname where t.schemaname = 'public' order by t.tablename", npgsqlConnection))
                 {
                     using (NpgsqlDataReader npgsqlDataReader = npgsqlCommand.ExecuteReader(CommandBehavior.CloseConnection))
                     {
                         while (npgsqlDataReader.Read())
                         {
                             if (!npgsqlDataReader.IsDBNull() && npgsqlDataReader.GetString().ToUpper() != "CODESMITH_EXTENDED_PROPERTIES")
                             {
                                 list.Add(new TableSchema(database, npgsqlDataReader.GetString(), npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString(), DateTime.MinValue, new ExtendedProperty[] { new ExtendedProperty("CS_Description", npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString(), DbType.String, PropertyStateEnum.ReadOnly) }));
                             }
                         }
                     }
                 }
             }
             return list.ToArray();
         }

         public IndexSchema[] GetTableIndexes(string connectionString, TableSchema table)
         {
             List<IndexSchema> list = new List<IndexSchema>();
             if (table.Columns == null)
                 table.Columns.AddRange(GetTableColumns(connectionString, table));
             DataSet ds = new DataSet();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("select schemaname, tablename, indexname, tablespace from pg_catalog.pg_indexes where schemaname='public' and tablename = '{0}'", table.Name);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     using (NpgsqlDataAdapter nda = new NpgsqlDataAdapter(npgsqlCommand))
                     {
                         nda.Fill(ds, "pg_indexes");
                     }

                     foreach (DataRow item in ds.Tables["pg_indexes"].Rows)
                     {
                         string @string = string.Empty;
                         @string = item.Field<string>("indexname");
                         if (!string.IsNullOrEmpty(@string))
                         {
                             string text2 = string.Format("SELECT n.nspname AS schemaname, c.relname AS tablename, i.relname AS indexname, t.spcname AS \"tablespace\", a.attname as \"colname\", x.indisunique as \"unique\", x.indisprimary as \"primary\", x.indisclustered as \"clustered\" FROM pg_catalog.pg_index x JOIN pg_catalog.pg_class c ON c.oid = x.indrelid JOIN pg_catalog.pg_class i ON i.oid = x.indexrelid JOIN pg_catalog.pg_attribute a ON a.attrelid = i.relfilenode LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace LEFT JOIN pg_catalog.pg_tablespace t ON t.oid = i.reltablespace WHERE c.relkind = 'r'::\"char\" AND i.relkind = 'i'::\"char\" AND n.nspname='public' AND c.relname='{0}' AND i.relname ='{1}'", table.Name, @string);

                             using (NpgsqlCommand npgsqlCommand2 = new NpgsqlCommand(text2, npgsqlConnection))
                             {
                                 using (NpgsqlDataAdapter nda2 = new NpgsqlDataAdapter(npgsqlCommand2))
                                 {
                                     nda2.Fill(ds, "pg_catalog");
                                 }
                             }
                             List<string> list2 = new List<string>();
                             bool? isPrimaryKey = false;
                             bool? isUnique = false;
                             bool? isClustered = false;
                             foreach (DataRow item2 in ds.Tables["pg_catalog"].Rows)
                             {
                                 isPrimaryKey = item2.Field<bool?>("primary");// (!npgsqlDataReader2.IsDBNull(6) && npgsqlDataReader2.GetBoolean(6));
                                 isUnique = item2.Field<bool?>("unique"); //(!npgsqlDataReader2.IsDBNull(5) && npgsqlDataReader2.GetBoolean(5));
                                 isClustered = item2.Field<bool?>("clustered"); //(!npgsqlDataReader2.IsDBNull(7) && npgsqlDataReader2.GetBoolean(7));
                                 list2.Add(item2.Field<string>("colname"));
                             }
                             list.Add(new IndexSchema(table, @string, isPrimaryKey ?? false, isUnique ?? false, isClustered ?? false, list2.ToArray()));
                             list2.Clear();
                             ds.Tables["pg_catalog"].Clear();
                         }
                     }
                 }
             }
             return list.ToArray();
         }

         public ColumnSchema[] GetTableColumns(string connectionString, TableSchema table)
         {
             List<ColumnSchema> list = new List<ColumnSchema>();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("select column_name, is_nullable, character_maximum_length, numeric_precision, numeric_scale, data_type, udt_name,col_description(b.attrelid,b.attnum) as pg_description from information_schema.columns as a join pg_attribute as b on a.column_name=b.attname join pg_class as c on a.table_name=c.relname and b.attrelid = c.oid where b.attnum>0 and a.table_schema = 'public' and a.table_name='{0}'", table.Name);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     using (NpgsqlDataReader npgsqlDataReader = npgsqlCommand.ExecuteReader(CommandBehavior.CloseConnection))
                     {
                         while (npgsqlDataReader.Read())
                         {
                             bool allowDBNull = npgsqlDataReader.IsDBNull() || npgsqlDataReader.GetString() == "YES";
                             byte precision = (byte)(npgsqlDataReader.IsDBNull() ?  : npgsqlDataReader.GetInt32());
                             int size = npgsqlDataReader.IsDBNull() ?  : npgsqlDataReader.GetInt32();
                             int scale = npgsqlDataReader.IsDBNull() ?  : npgsqlDataReader.GetInt32();
                             string name = npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString();
                             string text2 = npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString();
                             string type = npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString();
                             list.Add(new ColumnSchema(table, name, PostgreSQLSchemaProvider.GetDbType(type), text2, size, precision, scale, allowDBNull, new ExtendedProperty[]
                     {
                         new ExtendedProperty("NpgsqlDbType", PostgreSQLSchemaProvider.GetNativeDbType(text2), DbType.String),
                         new ExtendedProperty("CS_Description",npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString(), DbType.String)
                     }));
                         }
                         if (!npgsqlDataReader.IsClosed)
                         {
                             npgsqlDataReader.Close();
                         }
                     }
                 }
             }
             return list.ToArray();
         }

         public TableKeySchema[] GetTableKeys(string connectionString, TableSchema table)
         {
             List<TableKeySchema> list = new List<TableKeySchema>();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("SELECT constraint_name as constrname FROM information_schema.table_constraints WHERE table_name = '{0}' AND constraint_type = 'FOREIGN KEY' AND constraint_schema='public'", table.Name);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     string text2 = string.Format("SELECT px.conname as constrname, att.attname as colname, fore.relname as reftabname, fatt.attname as refcolname, CASE px.confupdtype WHEN 'a' THEN 'NO ACTION' WHEN 'r' THEN 'RESTRICT' WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT' END AS on_update, CASE px.confdeltype WHEN 'a' THEN 'NO ACTION' WHEN 'r' THEN 'RESTRICT' WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT' END AS on_delete, CASE px.contype WHEN 'p' THEN true WHEN 'f' THEN false END as IsPrimaryKey from pg_constraint px left join pg_class home on (home.oid = px.conrelid) left join pg_class fore on (fore.oid = px.confrelid) left join pg_attribute att on (att.attrelid = px.conrelid AND att.attnum = ANY(px.conkey)) left join pg_attribute fatt on (fatt.attrelid = px.confrelid AND fatt.attnum = ANY(px.confkey)) where (home.relname = '{0}') and px.contype = 'f' order by constrname", table.Name);
                     using (NpgsqlCommand npgsqlCommand2 = new NpgsqlCommand(text2, npgsqlConnection))
                     {
                         NpgsqlDataAdapter npgsqlDataAdapter = new NpgsqlDataAdapter(npgsqlCommand);
                         DataSet dataSet = new DataSet();
                         npgsqlDataAdapter.Fill(dataSet, "constraint");
                         npgsqlDataAdapter.SelectCommand = npgsqlCommand2;
                         npgsqlDataAdapter.Fill(dataSet, "keys");
                         if (dataSet.Tables[].Rows.Count > )
                         {
                             dataSet.Relations.Add("Contraint_to_Keys", dataSet.Tables[].Columns["constrname"], dataSet.Tables[].Columns["constrname"]);
                             foreach (DataRow dataRow in dataSet.Tables[].Rows)
                             {
                                 string name = dataRow["constrname"].ToString();
                                 DataRow[] childRows = dataRow.GetChildRows("Contraint_to_Keys");
                                 string[] array = new string[childRows.Length];
                                 string[] array2 = new string[childRows.Length];
                                 string name2 = table.Name;
                                 string primaryKeyTable = childRows[]["reftabname"].ToString();
                                 for (int i = ; i < childRows.Length; i++)
                                 {
                                     array2[i] = childRows[i]["colname"].ToString();
                                     array[i] = childRows[i]["refcolname"].ToString();
                                 }
                                 list.Add(new TableKeySchema(table.Database, name, array2, name2, array, primaryKeyTable));
                             }
                         }
                     }
                 }
                 string text3 = string.Format("SELECT px.conname as constrname FROM pg_constraint px left join pg_class fore on fore.oid = px.confrelid where fore.relname = '{0}'", table.Name);
                 using (NpgsqlCommand npgsqlCommand3 = new NpgsqlCommand(text3, npgsqlConnection))
                 {
                     string text4 = string.Format("SELECT px.conname as constrname, fatt.attname as colname, home.relname as reftabname, att.attname as refcolname, CASE px.confupdtype WHEN 'a' THEN 'NO ACTION' WHEN 'r' THEN 'RESTRICT' WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT' END AS on_update, CASE px.confdeltype WHEN 'a' THEN 'NO ACTION' WHEN 'r' THEN 'RESTRICT' WHEN 'c' THEN 'CASCADE' WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT' END AS on_delete, CASE px.contype WHEN 'p' THEN true WHEN 'f' THEN false END as IsPrimaryKey from pg_constraint px left join pg_class home on (home.oid = px.conrelid) left join pg_class fore on (fore.oid = px.confrelid) left join pg_attribute att on (att.attrelid = px.conrelid AND att.attnum = ANY(px.conkey)) left join pg_attribute fatt on (fatt.attrelid = px.confrelid AND fatt.attnum = ANY(px.confkey)) where (fore.relname = '{0}') order by constrname", table.Name);
                     using (NpgsqlCommand npgsqlCommand4 = new NpgsqlCommand(text4, npgsqlConnection))
                     {
                         NpgsqlDataAdapter npgsqlDataAdapter2 = new NpgsqlDataAdapter();
                         DataSet dataSet2 = new DataSet();
                         npgsqlDataAdapter2.SelectCommand = npgsqlCommand3;
                         npgsqlDataAdapter2.Fill(dataSet2, "constraint");
                         npgsqlDataAdapter2.SelectCommand = npgsqlCommand4;
                         npgsqlDataAdapter2.Fill(dataSet2, "keys");
                         if (dataSet2.Tables[].Rows.Count > )
                         {
                             dataSet2.Relations.Add("Contraint_to_Keys", dataSet2.Tables[].Columns["constrname"], dataSet2.Tables[].Columns["constrname"]);
                             foreach (DataRow dataRow2 in dataSet2.Tables[].Rows)
                             {
                                 string name3 = dataRow2["constrname"].ToString();
                                 DataRow[] childRows2 = dataRow2.GetChildRows("Contraint_to_Keys");
                                 string[] array3 = new string[childRows2.Length];
                                 string[] array4 = new string[childRows2.Length];
                                 string foreignKeyTable = childRows2[]["reftabname"].ToString();
                                 string name4 = table.Name;
                                 for (int j = ; j < childRows2.Length; j++)
                                 {
                                     array4[j] = childRows2[j]["refcolname"].ToString();
                                     array3[j] = childRows2[j]["colname"].ToString();
                                 }
                                 list.Add(new TableKeySchema(table.Database, name3, array4, foreignKeyTable, array3, name4));
                             }
                         }
                     }
                 }
             }
             return list.ToArray();
         }

         public PrimaryKeySchema GetTablePrimaryKey(string connectionString, TableSchema table)
         {
             PrimaryKeySchema result = null;
             DataSet ds = new DataSet();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("select constraint_name from information_schema.table_constraints where constraint_schema='public' and table_name='{0}' and constraint_type='PRIMARY KEY'", table.Name);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     using (NpgsqlDataAdapter nda = new NpgsqlDataAdapter(npgsqlCommand))
                     {
                         nda.Fill(ds, "table_constraints");
                     }
                 }

                 string text2 = string.Format("select px.conname as ConstraintName, att.attname as ColumnName from pg_constraint px inner join pg_class home on (home.oid = px.conrelid) left join pg_attribute att on (att.attrelid = px.conrelid AND att.attnum = ANY(px.conkey)) where (home.relname = '{0}') and px.contype = 'p'", table.Name);

                 using (NpgsqlCommand npgsqlCommand2 = new NpgsqlCommand(text2, npgsqlConnection))
                 {
                     using (NpgsqlDataAdapter nda = new NpgsqlDataAdapter(npgsqlCommand2))
                     {
                         nda.Fill(ds, "pg_constraint");
                     }
                 }

                 foreach (DataRow item in ds.Tables["table_constraints"].Rows)
                 {
                     List<string> list = new List<string>();
                     foreach (DataRow item2 in ds.Tables["pg_constraint"].Rows)
                     {
                         list.Add(item2.Field<string>("ColumnName"));
                     }
                     result = new PrimaryKeySchema(table, item.Field<string>("constraint_name"), list.ToArray());
                 }

             }
             return result;
         }

         public DataTable GetTableData(string connectionString, TableSchema table)
         {
             DataTable dataTable;
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 dataTable = new DataTable(table.Name);
                 string text = string.Format("SELECT * FROM {0}", table.Name);
                 using (NpgsqlDataAdapter npgsqlDataAdapter = new NpgsqlDataAdapter(text, npgsqlConnection))
                 {
                     npgsqlDataAdapter.Fill(dataTable);
                 }
                 if (npgsqlConnection.State != ConnectionState.Closed)
                 {
                     npgsqlConnection.Close();
                 }
             }
             return dataTable;
         }

         public ExtendedProperty[] GetExtendedProperties(string connectionString, SchemaObjectBase schemaObject)
         {
             List<ExtendedProperty> list = new List<ExtendedProperty>();
             if (schemaObject is ColumnSchema)
             {
                 ColumnSchema columnSchema = schemaObject as ColumnSchema;
                 string text = string.Format("select pg_get_serial_sequence(c.table_name, c.column_name) as EXTRA, COLUMN_DEFAULT, data_type \r\n                          from pg_tables t\r\n                          INNER JOIN information_schema.columns c on t.tablename = c.table_name\r\n                          WHERE schemaname = '{0}' \r\n                          AND table_name = '{1}'\r\n                          AND COLUMN_NAME = '{2}'\r\n                          order by ordinal_position", columnSchema.Table.Database.Name, columnSchema.Table.Name, columnSchema.Name);
                 using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
                 {
                     npgsqlConnection.Open();
                     using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                     {
                         using (IDataReader dataReader = npgsqlCommand.ExecuteReader(CommandBehavior.CloseConnection))
                         {
                             while (dataReader.Read())
                             {
                                 string text2 = dataReader.IsDBNull() ? string.Empty : dataReader.GetString().ToLower();
                                 string value = dataReader.IsDBNull() ? null : dataReader.GetString().ToUpper();
                                 string value2 = dataReader.GetString().ToUpper();
                                 bool flag = !string.IsNullOrEmpty(text2);
                                 list.Add(new ExtendedProperty("CS_IsIdentity", flag, columnSchema.DataType));
                                 if (flag)
                                 {
                                     list.Add(new ExtendedProperty("CS_IdentitySeed", , columnSchema.DataType));
                                     list.Add(new ExtendedProperty("CS_IdentityIncrement", , columnSchema.DataType));
                                 }
                                 list.Add(new ExtendedProperty("CS_Default", value, DbType.String));
                                 list.Add(new ExtendedProperty("CS_SystemType", value2, DbType.String));
                                 list.Add(new ExtendedProperty("CS_Sequence", text2.ToUpper(), DbType.String));
                             }
                             if (!dataReader.IsClosed)
                             {
                                 dataReader.Close();
                             }
                         }
                     }
                     if (npgsqlConnection.State != ConnectionState.Closed)
                     {
                         npgsqlConnection.Close();
                     }
                 }
             }
             return list.ToArray();
         }

         public void SetExtendedProperties(string connectionString, SchemaObjectBase schemaObject)
         {
             throw new NotImplementedException();
         }

         public ViewColumnSchema[] GetViewColumns(string connectionString, ViewSchema view)
         {
             List<ViewColumnSchema> list = new List<ViewColumnSchema>();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("select column_name, is_nullable, character_maximum_length, numeric_precision, numeric_scale, data_type, udt_name,col_description(b.attrelid,b.attnum) as pg_description from information_schema.columns as a join pg_attribute as b on a.column_name=b.attname join pg_class as c on a.table_name=c.relname and b.attrelid = c.oid where b.attnum>0 and a.table_schema = 'public' and a.table_name='{0}' ORDER BY ordinal_position", view.Name);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     using (NpgsqlDataReader npgsqlDataReader = npgsqlCommand.ExecuteReader(CommandBehavior.CloseConnection))
                     {
                         while (npgsqlDataReader.Read())
                         {
                             bool allowDBNull = npgsqlDataReader.IsDBNull() || npgsqlDataReader.GetString() == "YES";
                             int size = npgsqlDataReader.IsDBNull() ?  : npgsqlDataReader.GetInt32();
                             byte precision = (byte)(npgsqlDataReader.IsDBNull() ?  : npgsqlDataReader.GetInt32());
                             int scale = npgsqlDataReader.IsDBNull() ?  : npgsqlDataReader.GetInt32();
                             string text2 = npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString();
                             string type = npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString();
                             list.Add(new ViewColumnSchema(view, npgsqlDataReader.GetString(), PostgreSQLSchemaProvider.GetDbType(type), text2, size, precision, scale, allowDBNull, new ExtendedProperty[]
                             {
                                 new ExtendedProperty("NpgsqlDbType", PostgreSQLSchemaProvider.GetNativeDbType(text2), DbType.String)
                             }));
                         }
                     }
                 }
             }
             return list.ToArray();
         }

         public DataTable GetViewData(string connectionString, ViewSchema view)
         {
             DataTable dataTable;
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 dataTable = new DataTable(view.Name);
                 string text = string.Format("SELECT * FROM {0}", view.Name);
                 using (NpgsqlDataAdapter npgsqlDataAdapter = new NpgsqlDataAdapter(text, npgsqlConnection))
                 {
                     npgsqlDataAdapter.Fill(dataTable);
                 }
             }
             return dataTable;
         }

         public ViewSchema[] GetViews(string connectionString, DatabaseSchema database)
         {
             List<ViewSchema> list = new List<ViewSchema>();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand("select viewname, viewowner from pg_catalog.pg_views where schemaname = 'public' order by viewname;", npgsqlConnection))
                 {
                     DataTable dt = new DataTable();

                     using (NpgsqlDataAdapter nda = new NpgsqlDataAdapter(npgsqlCommand))
                     {
                         nda.Fill(dt);
                         nda.Dispose();
                     }
                     foreach (DataRow item in dt.Rows)
                     {
                         list.Add(new ViewSchema(database, item.Field<string>("viewname"), item.Field<string>("viewowner"), DateTime.MinValue));
                     }

                 }
             }
             return list.ToArray();
         }

         public string GetViewText(string connectionString, ViewSchema view)
         {
             string result;
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("select view_definition from information_schema.views where table_schema='public' and table_name = '{0}'", view.Name);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     result = (string)npgsqlCommand.ExecuteScalar();
                 }
             }
             return result;
         }

         public CommandSchema[] GetCommands(string connectionString, DatabaseSchema database)
         {
             List<CommandSchema> list = new List<CommandSchema>();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand("SELECT routine_name, rolname, specific_name, data_type from information_schema.routines LEFT JOIN pg_catalog.pg_proc p ON p.proname = routine_name INNER JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace INNER JOIN pg_catalog.pg_authid a on a.oid = proowner WHERE routine_schema='public' ORDER BY routine_name ", npgsqlConnection))
                 {
                     using (NpgsqlDataReader npgsqlDataReader = npgsqlCommand.ExecuteReader(CommandBehavior.CloseConnection))
                     {
                         while (npgsqlDataReader.Read())
                         {
                             bool flag = !npgsqlDataReader.IsDBNull() && npgsqlDataReader.GetString().Trim().Equals("VOID", StringComparison.InvariantCultureIgnoreCase);
                             if (!flag || database.IncludeFunctions)
                             {
                                 List<ExtendedProperty> list2 = new List<ExtendedProperty>
                                 {
                                     new ExtendedProperty("CS_Name", npgsqlDataReader.GetString(), DbType.String, PropertyStateEnum.ReadOnly),
                                     new ExtendedProperty("CS_IsScalarFunction", flag, DbType.Boolean, PropertyStateEnum.ReadOnly),
                                     new ExtendedProperty("CS_IsProcedure", flag, DbType.Boolean, PropertyStateEnum.ReadOnly),
                                     new ExtendedProperty("CS_IsTrigger", npgsqlDataReader.GetString().Equals("TRIGGER", StringComparison.InvariantCultureIgnoreCase), DbType.Boolean, PropertyStateEnum.ReadOnly)
                                 };
                                 list.Add(new CommandSchema(database, npgsqlDataReader.GetString(), npgsqlDataReader.GetString(), DateTime.MinValue, list2.ToArray()));
                             }
                         }
                         if (!npgsqlDataReader.IsClosed)
                         {
                             npgsqlDataReader.Close();
                         }
                     }
                 }
                 if (npgsqlConnection.State != ConnectionState.Closed)
                 {
                     npgsqlConnection.Close();
                 }
             }
             return list.ToArray();
         }

         public ParameterSchema[] GetCommandParameters(string connectionString, CommandSchema commandSchema)
         {
             string arg = commandSchema.ExtendedProperties["CS_Name"].Value as string;
             List<ParameterSchema> list = new List<ParameterSchema>();
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("select * from information_schema.parameters where specific_schema='public' and specific_name = '{0}' order by ordinal_position", arg);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     using (NpgsqlDataReader npgsqlDataReader = npgsqlCommand.ExecuteReader(CommandBehavior.CloseConnection))
                     {
                         while (npgsqlDataReader.Read())
                         {
                             string name = npgsqlDataReader.IsDBNull() ? string.Empty : npgsqlDataReader.GetString();
                             int size = npgsqlDataReader.IsDBNull() ?  : npgsqlDataReader.GetInt32();
                             int scale = npgsqlDataReader.IsDBNull() ?  : npgsqlDataReader.GetInt32();
                             byte precision = npgsqlDataReader.IsDBNull() ? (byte) : npgsqlDataReader.GetByte();
                             string @string = npgsqlDataReader.GetString();
                             list.Add(new ParameterSchema(commandSchema, name, PostgreSQLSchemaProvider.GetParameterDirection(npgsqlDataReader.GetString()), PostgreSQLSchemaProvider.GetDbType(@string), @string, size, precision, scale, false, new ExtendedProperty[]
                             {
                                 new ExtendedProperty("NpgsqlDbType", PostgreSQLSchemaProvider.GetNativeDbType(@string), DbType.String)
                             }));
                         }
                         if (!npgsqlDataReader.IsClosed)
                         {
                             npgsqlDataReader.Close();
                         }
                     }
                 }
                 if (npgsqlConnection.State != ConnectionState.Closed)
                 {
                     npgsqlConnection.Close();
                 }
             }
             return list.ToArray();
         }

         public CommandResultSchema[] GetCommandResultSchemas(string connectionString, CommandSchema command)
         {
             CommandResultSchema[] array = null;
             string arg = command.ExtendedProperties["CS_Name"].Value as string;
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("select data_type from information_schema.routines where specific_schema='public' and specific_name = '{0}'", arg);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     using (NpgsqlDataReader npgsqlDataReader = npgsqlCommand.ExecuteReader(CommandBehavior.CloseConnection))
                     {
                         while (npgsqlDataReader.Read())
                         {
                             string @string = npgsqlDataReader.GetString();
                             if (@string == "void")
                             {
                                 array = new CommandResultSchema[];
                             }
                             else if (@string == "USER-DEFINED")
                             {
                                 NpgsqlCommand npgsqlCommand2 = new NpgsqlCommand(string.Format("SELECT t.typname, attname, a.typname from pg_type t JOIN pg_class on (reltype = t.oid) JOIN pg_attribute on (attrelid = pg_class.oid) JOIN pg_type a on (atttypid = a.oid) WHERE t.typname = (SELECT t.typname FROM pg_catalog.pg_proc p LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace INNER JOIN pg_type t ON p.prorettype = t.oid WHERE n.nspname = 'public' and proname = '{0}' ORDER BY proname);", command.Name), npgsqlConnection);
                                 using (NpgsqlDataReader npgsqlDataReader2 = npgsqlCommand2.ExecuteReader(CommandBehavior.CloseConnection))
                                 {
                                     string text2 = null;
                                     List<CommandResultColumnSchema> list = new List<CommandResultColumnSchema>();
                                     while (npgsqlDataReader2.Read())
                                     {
                                         if (string.IsNullOrEmpty(text2))
                                         {
                                             text2 = npgsqlDataReader2.GetString();
                                         }
                                         string string2 = npgsqlDataReader2.GetString();
                                         list.Add(new CommandResultColumnSchema(command, npgsqlDataReader2.GetString(), PostgreSQLSchemaProvider.GetDbType(string2), string2, , , , true, new ExtendedProperty[]
                                         {
                                             new ExtendedProperty("NpgsqlDbType", PostgreSQLSchemaProvider.GetNativeDbType(string2), DbType.String)
                                         }));
                                     }
                                     array = new CommandResultSchema[]
                                     {
                                         new CommandResultSchema(command, text2, list.ToArray())
                                     };
                                 }
                             }
                         }
                     }
                 }
             }
             return array ?? new CommandResultSchema[];
         }

         public string GetCommandText(string connectionString, CommandSchema commandSchema)
         {
             object result = string.Empty;
             string arg = commandSchema.ExtendedProperties["CS_Name"].Value as string;
             using (NpgsqlConnection npgsqlConnection = new NpgsqlConnection(connectionString))
             {
                 npgsqlConnection.Open();
                 string text = string.Format("select routine_definition from information_schema.routines where specific_schema='public' and specific_name = '{0}'", arg);
                 using (NpgsqlCommand npgsqlCommand = new NpgsqlCommand(text, npgsqlConnection))
                 {
                     result = npgsqlCommand.ExecuteScalar();
                 }
             }
             if (result != null)
                 return string.Empty;
             return result.ToString();
         }

         public string GetDatabaseName(string connectionString)
         {
             Regex regex = new Regex("Database\\W*=\\W*(?<database>[^;]*)", RegexOptions.IgnoreCase);
             string result;
             if (regex.IsMatch(connectionString))
             {
                 result = regex.Match(connectionString).Groups["database"].ToString();
             }
             else
             {
                 result = connectionString;
             }
             return result;
         }

         private static DbType GetDbType(string type)
         {
             DbType result;
             switch (type)
             {
                 case "bit":
                 case "bool":
                 case "boolean":
                     result = DbType.Boolean;
                     return result;
                 case "bytea":
                     result = DbType.Binary;
                     return result;
                 case "bpchar":
                 case "char":
                 case "character":
                 case "text":
                 case "varchar":
                 case "character varying":
                     result = DbType.String;
                     return result;
                 case "date":
                     result = DbType.Date;
                     return result;
                 case "float4":
                 case "single precision":
                 case "real":
                     result = DbType.Single;
                     return result;
                 case "float8":
                 case "double precision":
                     result = DbType.Double;
                     return result;
                 case "int2":
                 case "smallint":
                     result = DbType.Int16;
                     return result;
                 case "int4":
                 case "integer":
                     result = DbType.Int32;
                     return result;
                 case "int8":
                 case "bigint":
                     result = DbType.Int64;
                     return result;
                 case "money":
                 case "numeric":
                     result = DbType.Decimal;
                     return result;
                 case "time":
                 case "timetz":
                 case "time without time zone":
                 case "time without timezone":
                 case "time with time zone":
                 case "time with timezone":
                     result = DbType.Time;
                     return result;
                 case "interval":
                 case "timestamp":
                 case "timestamptz":
                 case "timestamp without time zone":
                 case "timestamp without timezone":
                 case "timestamp with time zone":
                 case "timestamp with timezone":
                     result = DbType.DateTime;
                     return result;
                 case "uuid":
                     result = DbType.Guid;
                     return result;
                 case "box":
                 case "circle":
                 case "inet":
                 case "line":
                 case "lseg":
                 case "path":
                 case "point":
                 case "polygon":
                 case "refcursor":
                     result = DbType.Object;
                     return result;
             }
             result = DbType.Object;
             return result;
         }

         private static NpgsqlDbType GetNativeDbType(string type)
         {
             string key;
             switch (key = type.ToLower())
             {
                 case "array":
                     return (NpgsqlDbType)(-);
                 case "bit":
                     return (NpgsqlDbType);
                 case "box":
                     return (NpgsqlDbType);
                 case "bool":
                 case "boolean":
                     return (NpgsqlDbType);
                 case "bytea":
                     return (NpgsqlDbType);
                 case "char":
                     return (NpgsqlDbType);
                 case "bpchar":
                 case "character":
                 case "varchar":
                 case "character varying":
                     return (NpgsqlDbType);
                 case "date":
                     return (NpgsqlDbType);
                 case "float4":
                 case "single precision":
                 case "real":
                     return (NpgsqlDbType);
                 case "float8":
                 case "double precision":
                 case "double":
                     return (NpgsqlDbType);
                 case "int2":
                 case "smallint":
                     return (NpgsqlDbType);
                 case "int4":
                 case "integer":
                     return (NpgsqlDbType);
                 case "int8":
                 case "bigint":
                     return (NpgsqlDbType);
                 case "money":
                     return (NpgsqlDbType);
                 case "name":
                     return (NpgsqlDbType);
                 case "numeric":
                     return (NpgsqlDbType);
                 case "text":
                 case "user-defined":
                     return (NpgsqlDbType);
                 case "oidvector":
                     return (NpgsqlDbType);
                 case "abstime":
                     return (NpgsqlDbType);
                 case "time":
                 case "time without time zone":
                 case "time without timezone":
                     return (NpgsqlDbType);
                 case "timetz":
                 case "time with time zone":
                 case "time with timezone":
                     return (NpgsqlDbType);
                 case "interval":
                     return (NpgsqlDbType);
                 case "timestamp":
                 case "timestamptz":
                 case "timestamp without time zone":
                 case "timestamp without timezone":
                     return (NpgsqlDbType);
                 case "timestamp with time zone":
                 case "timestamp with timezone":
                     return (NpgsqlDbType);
                 case "uuid":
                     return (NpgsqlDbType);
                 case "circle":
                     return (NpgsqlDbType);
                 case "inet":
                     return (NpgsqlDbType);
                 case "line":
                     return (NpgsqlDbType);
                 case "lseg":
                     return (NpgsqlDbType);
                 case "path":
                     return (NpgsqlDbType);
                 case "point":
                     return (NpgsqlDbType);
                 case "polygon":
                     return (NpgsqlDbType);
                 case "refcursor":
                     return (NpgsqlDbType);
                 case "xml":
                     return (NpgsqlDbType);
             }
             throw new ArgumentOutOfRangeException();
         }

         private static ParameterDirection GetParameterDirection(string direction)
         {
             ParameterDirection result;
             if (direction != null)
             {
                 if (direction == "IN")
                 {
                     result = ParameterDirection.Input;
                     return result;
                 }
                 if (direction == "OUT")
                 {
                     result = ParameterDirection.Output;
                     return result;
                 }
             }
             result = ParameterDirection.InputOutput;
             return result;
         }
     }
 }

PostgreSQLSchemaProvider.cs