C# 操作PostgreSQL 数据库


一、第三方类库

Npgsql提供 .NET 操作postgreSQL数据库的相关类。支持postgreSQL7.x 及以上版本。

二、自定义接口及操作类

2.1接口类

  1. public interface IDBHelper  
  2.     {  
  3.         /// <summary>   
  4.         /// 执行 Transact-SQL 语句并返回受影响的行数。   
  5.         /// </summary>   
  6.         int ExecuteNonQuery(string connectionString, System.Data.CommandType cmdType, string cmdText, params System.Data.Common.DbParameter[] cmdParms);  
  7.   
  8.         /// <summary>   
  9.         /// 在事务中执行 Transact-SQL 语句并返回受影响的行数。   
  10.         /// </summary>   
  11.         int ExecuteNonQuery(System.Data.Common.DbTransaction trans, System.Data.CommandType cmdType, string cmdText, params System.Data.Common.DbParameter[] cmdParms);  
  12.   
  13.         /// <summary>   
  14.         /// 在事务中执行查询，返回DataSet   
  15.         /// </summary>   
  16.         DataSet ExecuteQuery(System.Data.Common.DbTransaction trans, System.Data.CommandType cmdType, string cmdText, params System.Data.Common.DbParameter[] cmdParms);  
  17.   
  18.         /// <summary>   
  19.         /// 执行查询，返回DataSet   
  20.         /// </summary>   
  21.         DataSet ExecuteQuery(string connectionString, System.Data.CommandType cmdType, string cmdText, params System.Data.Common.DbParameter[] cmdParms);  
  22.   
  23.         /// <summary>   
  24.         /// 在事务中执行查询，返回DataReader   
  25.         /// </summary>   
  26.         DbDataReader ExecuteReader(System.Data.Common.DbTransaction trans, System.Data.CommandType cmdType, string cmdText, params System.Data.Common.DbParameter[] cmdParms);  
  27.   
  28.         /// <summary>   
  29.         /// 执行查询，返回DataReader   
  30.         /// </summary>   
  31.         DbDataReader ExecuteReader(string connectionString, System.Data.CommandType cmdType, string cmdText, params System.Data.Common.DbParameter[] cmdParms);  
  32.   
  33.         /// <summary>   
  34.         /// 在事务中执行查询，并返回查询所返回的结果集中第一行的第一列。忽略其他列或行。   
  35.         /// </summary>   
  36.         object ExecuteScalar(System.Data.Common.DbTransaction trans, System.Data.CommandType cmdType, string cmdText, params System.Data.Common.DbParameter[] cmdParms);  
  37.   
  38.         /// <summary>   
  39.         /// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略其他列或行。   
  40.         /// </summary>   
  41.         object ExecuteScalar(string connectionString, System.Data.CommandType cmdType, string cmdText, params System.Data.Common.DbParameter[] cmdParms);  
  42.   
  43.         /// <summary>   
  44.         /// 得到数据条数   
  45.         /// </summary>   
  46.         /// <param name="tblName">表名</param>   
  47.         /// <param name="condition">条件(不需要where)</param>   
  48.         /// <returns>数据条数</returns>   
  49.         int GetCount(string connectionString, string tblName, string condition);  
  50.     }  

2.2 操作类

  1. /// <summary>   
  2.     /// 数据库操作基类(for PostgreSQL)   
  3.     /// </summary>   
  4.     public class PostgreHelper : PageHelper, IDBHelper  
  5.     {  
  6.         /// <summary>   
  7.         /// 分页获取数据   
  8.         /// </summary>   
  9.         /// <param name="connectionString">连接字符串</param>   
  10.         /// <param name="tblName">表名</param>   
  11.         /// <param name="fldName">字段名</param>   
  12.         /// <param name="pageSize">页大小</param>   
  13.         /// <param name="pageIndex">第几页</param>   
  14.         /// <param name="fldSort">排序字段</param>   
  15.         /// <param name="sort">升序{False}/降序(True)</param>   
  16.         /// <param name="condition">条件(不需要where)</param>   
  17.         public DbDataReader GetPageList(string connectionString, string tblName, int pageSize,  
  18.             int pageIndex, string fldSort, bool sort, string condition)  
  19.         {  
  20.             string sql = GetPagerSQL(condition, pageSize, pageIndex, fldSort, tblName, sort);  
  21.             return ExecuteReader(connectionString, CommandType.Text, sql, null);  
  22.         }  
  23.   
  24.         /// <summary>   
  25.         /// 得到数据条数   
  26.         /// </summary>   
  27.         public int GetCount(string connectionString, string tblName, string condition)  
  28.         {  
  29.             StringBuilder sql = new StringBuilder("select count(*) from " + tblName);  
  30.             if (!string.IsNullOrEmpty(condition))  
  31.                 sql.Append(" where " + condition);  
  32.   
  33.             object count = ExecuteScalar(connectionString, CommandType.Text, sql.ToString(), null);  
  34.             return int.Parse(count.ToString());  
  35.         }  
  36.   
  37.         /// <summary>   
  38.         /// 执行查询，返回DataSet   
  39.         /// </summary>   
  40.         public DataSet ExecuteQuery(string connectionString, CommandType cmdType, string cmdText,  
  41.             params DbParameter[] cmdParms)  
  42.         {  
  43.             using (NpgsqlConnection conn = new NpgsqlConnection(connectionString))  
  44.             {  
  45.                 using (NpgsqlCommand cmd = new NpgsqlCommand())  
  46.                 {  
  47.                     PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);  
  48.                     using (NpgsqlDataAdapter da = new NpgsqlDataAdapter(cmd))  
  49.                     {  
  50.                         DataSet ds = new DataSet();  
  51.                         da.Fill(ds, "ds");  
  52.                         cmd.Parameters.Clear();  
  53.                         return ds;  
  54.                     }  
  55.                 }  
  56.             }  
  57.         }  
  58.   
  59.         /// <summary>   
  60.         /// 在事务中执行查询，返回DataSet   
  61.         /// </summary>   
  62.         public DataSet ExecuteQuery(DbTransaction trans, CommandType cmdType, string cmdText,  
  63.             params DbParameter[] cmdParms)  
  64.         {  
  65.             NpgsqlCommand cmd = new NpgsqlCommand();  
  66.             PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParms);  
  67.             NpgsqlDataAdapter da = new NpgsqlDataAdapter(cmd);  
  68.             DataSet ds = new DataSet();  
  69.             da.Fill(ds, "ds");  
  70.             cmd.Parameters.Clear();  
  71.             return ds;  
  72.         }  
  73.   
  74.         /// <summary>   
  75.         /// 执行 Transact-SQL 语句并返回受影响的行数。   
  76.         /// </summary>   
  77.         public int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText,  
  78.             params DbParameter[] cmdParms)  
  79.         {  
  80.             NpgsqlCommand cmd = new NpgsqlCommand();  
  81.   
  82.             using (NpgsqlConnection conn = new NpgsqlConnection(connectionString))  
  83.             {  
  84.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);  
  85.                 int val = cmd.ExecuteNonQuery();  
  86.                 cmd.Parameters.Clear();  
  87.                 return val;  
  88.             }  
  89.         }  
  90.   
  91.         /// <summary>   
  92.         /// 在事务中执行 Transact-SQL 语句并返回受影响的行数。   
  93.         /// </summary>   
  94.         public int ExecuteNonQuery(DbTransaction trans, CommandType cmdType, string cmdText,  
  95.             params DbParameter[] cmdParms)  
  96.         {  
  97.             NpgsqlCommand cmd = new NpgsqlCommand();  
  98.             PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParms);  
  99.             int val = cmd.ExecuteNonQuery();  
  100.             cmd.Parameters.Clear();  
  101.             return val;  
  102.         }  
  103.   
  104.         /// <summary>   
  105.         /// 执行查询，返回DataReader   
  106.         /// </summary>   
  107.         public DbDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText,  
  108.             params DbParameter[] cmdParms)  
  109.         {  
  110.             NpgsqlCommand cmd = new NpgsqlCommand();  
  111.             NpgsqlConnection conn = new NpgsqlConnection(connectionString);  
  112.   
  113.             try  
  114.             {  
  115.                 PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);  
  116.                 NpgsqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
  117.                 cmd.Parameters.Clear();  
  118.                 return rdr;  
  119.             }  
  120.             catch  
  121.             {  
  122.                 conn.Close();  
  123.                 throw;  
  124.             }  
  125.         }  
  126.   
  127.         /// <summary>   
  128.         /// 在事务中执行查询，返回DataReader   
  129.         /// </summary>   
  130.         public DbDataReader ExecuteReader(DbTransaction trans, CommandType cmdType, string cmdText,  
  131.             params DbParameter[] cmdParms)  
  132.         {  
  133.             NpgsqlCommand cmd = new NpgsqlCommand();  
  134.             PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParms);  
  135.             NpgsqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
  136.             cmd.Parameters.Clear();  
  137.             return rdr;  
  138.         }  
  139.   
  140.         /// <summary>   
  141.         /// 执行查询，并返回查询所返回的结果集中第一行的第一列。忽略其他列或行。   
  142.         /// </summary>   
  143.         public object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText,  
  144.             params DbParameter[] cmdParms)  
  145.         {  
  146.             NpgsqlCommand cmd = new NpgsqlCommand();  
  147.   
  148.             using (NpgsqlConnection connection = new NpgsqlConnection(connectionString))  
  149.             {  
  150.                 PrepareCommand(cmd, connection, null, cmdType, cmdText, cmdParms);  
  151.                 object val = cmd.ExecuteScalar();  
  152.                 cmd.Parameters.Clear();  
  153.                 return val;  
  154.             }  
  155.         }  
  156.   
  157.         /// <summary>   
  158.         /// 在事务中执行查询，并返回查询所返回的结果集中第一行的第一列。忽略其他列或行。   
  159.         /// </summary>   
  160.         public object ExecuteScalar(DbTransaction trans, CommandType cmdType, string cmdText,  
  161.             params DbParameter[] cmdParms)  
  162.         {  
  163.             NpgsqlCommand cmd = new NpgsqlCommand();  
  164.             PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParms);  
  165.             object val = cmd.ExecuteScalar();  
  166.             cmd.Parameters.Clear();  
  167.             return val;  
  168.         }  
  169.   
  170.         /// <summary>   
  171.         /// 生成要执行的命令   
  172.         /// </summary>   
  173.         /// <remarks>参数的格式：冒号+参数名</remarks>   
  174.         private static void PrepareCommand(DbCommand cmd, DbConnection conn, DbTransaction trans, CommandType cmdType,  
  175.             string cmdText, DbParameter[] cmdParms)  
  176.         {  
  177.             if (conn.State != ConnectionState.Open)  
  178.                 conn.Open();  
  179.   
  180.             cmd.Connection = conn;  
  181.             cmd.CommandText = cmdText.Replace("@", ":").Replace("?", ":").Replace("[", "\"").Replace("]", "\"");  
  182.   
  183.             if (trans != null)  
  184.                 cmd.Transaction = trans;  
  185.   
  186.             cmd.CommandType = cmdType;  
  187.   
  188.             if (cmdParms != null)  
  189.             {  
  190.                 foreach (NpgsqlParameter parm in cmdParms)  
  191.                 {  
  192.                     parm.ParameterName = parm.ParameterName.Replace("@", ":").Replace("?",":");  
  193.   
  194.                     cmd.Parameters.Add(parm);  
  195.                 }  
  196.             }  
  197.         }  
  198.     }  

三、数据库操作实例

写入实例：

  1. IDBHelper dbHelper = new PostgreHelper();  
  2. string connectionString = "User ID=postgres;Password=admin;Server=192.168.0.226;Port=5432;Database=MonitorDB;";  
  3. string sql = "insert into [RawLog]([ProjectID],[File],[Note]) values('项目编号',@file,'备注')";  
  4.   
  5. string file = this.textBox1.Text;  
  6. if (!File.Exists(file)) return;  
  7.   
  8. //获取文件二进制流   
  9. System.IO.FileStream fs = new System.IO.FileStream(file, System.IO.FileMode.Open);  
  10. BinaryReader br = new BinaryReader(fs);  
  11. byte[] b = br.ReadBytes((int)fs.Length);  
  12. fs.Close();  
  13.   
  14. int r = dbHelper.ExecuteNonQuery(connectionString, CommandType.Text,sql,new Npgsql.NpgsqlParameter("@file",raw_log.File));  

注意：

1.查询语句中表名、字段名需用中括号[ ] 封起来，在操作类中会统一替换为双引号。

2.命令语句中的参数名格式为：@或？+ 参数名，在操作类中为统一替换为冒号。

3.对于二进制流、日期等特殊类型需采用2中的参数形式。

4.经多次测试postgreSQL数据库只直接支持（冒号+参数名）的参数方式。

相关内容