dataset访问Oraclel数据库
using System;
using System.Configuration;
using System.Data;
using System.Data.OracleClient;
using System.Collections.Generic;
using System.Text;
namespace Best.Biz.Repository.Base
{
/// <summary>
/// 数据库访问类
/// </summary>
public static class OracleDbHelper
{
/// <summary>
/// 默认数据库连接字符串，在程序配置文件中的ConnectionStrings段定义，名称是OracleDbConnectionString
/// </summary>
private static readonly string dbConnectionString = ConfigurationManager.ConnectionStrings["OracleDbConnectionString"].ToString();
/// <summary>
/// 用指定的连接字符串执行SQL，返回DataSet
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="connectionString">连接字符串</param>
/// <returns>DataSet</returns>
public static DataSet ExecuteDataSet(string sql, string connectionString)
{
using (OracleConnection oraConn = new OracleConnection(connectionString))
{
using (OracleDataAdapter oda = new OracleDataAdapter(sql, oraConn))
{
DataSet ds = new DataSet();
oda.Fill(ds);
return ds;
}
}
}
/// <summary>
/// 用默认连接字符串执行SQL，返回DataSet
/// </summary>
/// <param name="sql">SQL语句</param>
/// <returns>DataSet</returns>
public static DataSet ExecuteDataSet(string sql)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleDataAdapter oda = new OracleDataAdapter(sql, oraConn))
{
DataSet ds = new DataSet();
oda.Fill(ds);
return ds;
}
}
}
/// <summary>
/// 用默认连接字符串执行查询语句，返回DataSet
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="parameters">参数</param>
/// <returns>DataSet</returns>
public static DataSet ExecuteDataSet(string sql, params OracleParameter[] parameters)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleCommand oraCmd = new OracleCommand())
{
PrepareCommand(oraCmd, oraConn, null, sql, parameters);
using (OracleDataAdapter oda = new OracleDataAdapter(oraCmd))
{
DataSet ds = new DataSet();
oda.Fill(ds, "ds");
oraCmd.Parameters.Clear();
return ds;
}
}
}
}
/// <summary>
/// 用默认连接字符串执行查询语句，返回DataSet
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="parametersCollection">参数集合</param>
/// <returns></returns>
public static DataSet ExecuteDataSet(string sql, OracleParameterCollection parametersCollection)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleCommand oraCmd = new OracleCommand())
{
PrepareCommand(oraCmd, oraConn, null, sql, parametersCollection);
using (OracleDataAdapter oda = new OracleDataAdapter(oraCmd))
{
DataSet ds = new DataSet();
oda.Fill(ds, "ds");
oraCmd.Parameters.Clear();
return ds;
}
}
}
}
public static int ExecuteSqlCount(string sql, OracleParameterCollection parametersCollection)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleCommand oraCmd = new OracleCommand(sql, oraConn))
{
PrepareCommand(oraCmd, oraConn, null, sql, parametersCollection);
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
return oraCmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// 用默认连接字符串执行SQL语句
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="parameters">参数</param>
public static void ExecuteSql(string sql, params OracleParameter[] parameters)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleCommand oraCmd = new OracleCommand(sql, oraConn))
{
PrepareCommand(oraCmd, oraConn, null, sql, parameters);
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
oraCmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// 用默认连接字符串执行SQL
/// </summary>
/// <param name="sql">SQL语句</param>
public static void ExecuteSql(string sql)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleCommand oraCmd = new OracleCommand(sql, oraConn))
{
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
oraCmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// 用指定连接字符串执行SQL
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="connectionString">连接字符串</param>
public static void ExecuteSql(string sql, string connectionString)
{
using (OracleConnection oraConn = new OracleConnection(connectionString))
{
using (OracleCommand oraCmd = new OracleCommand(sql, oraConn))
{
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
oraCmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// 用指定连接字符串执行SQL
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="connectionString">连接字符串</param>
/// <param name="parameters">参数</param>
public static void ExecuteSql(string sql, string connectionString, params OracleParameter[] parameters)
{
using (OracleConnection oraConn = new OracleConnection(connectionString))
{
using (OracleCommand oraCmd = new OracleCommand(sql, oraConn))
{
PrepareCommand(oraCmd, oraConn, null, sql, parameters);
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
oraCmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// 用指定连接字符串执行SQL，返回受影响的行数
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="connectionString">连接字符串</param>
/// <returns>受影响的行数</returns>
public static int ExecuteSqlCount(string sql, string connectionString)
{
using (OracleConnection oraConn = new OracleConnection(connectionString))
{
using (OracleCommand oraCmd = new OracleCommand(sql, oraConn))
{
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
return oraCmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// 用默认连接字符串执行SQL，返回受影响的行数
/// </summary>
/// <param name="sql">SQL语句</param>
/// <returns>受影响的行数</returns>
public static int ExecuteSqlCount(string sql)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleCommand oraCmd = new OracleCommand(sql, oraConn))
{
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
return oraCmd.ExecuteNonQuery();
}
}
}
/// <summary>
/// 用默认连接字符串执行SQL语句，返回影响的记录数
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="params">参数列表</param>
/// <returns>影响的记录数</returns>
public static int ExecuteSqlCount(string sql, params OracleParameter[] @params)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleCommand oraCmd = new OracleCommand())
{
PrepareCommand(oraCmd, oraConn, null, sql, @params);
int affectedRows = oraCmd.ExecuteNonQuery();
oraCmd.Parameters.Clear();
return affectedRows;
}
}
}
/// <summary>
/// 为准备执行的命令绑定参数
/// </summary>
/// <param name="cmd">OracleCommand</param>
/// <param name="conn">OracleConnection</param>
/// <param name="trx">OracleTransaction</param>
/// <param name="cmdText">要执行的命令</param>
/// <param name="parameters">参数数组</param>
private static void PrepareCommand(OracleCommand cmd, OracleConnection conn, OracleTransaction trx, string cmdText, OracleParameter[] parameters)
{
if (conn.State != ConnectionState.Open)
conn.Open();
cmd.Connection = conn;
cmd.CommandText = cmdText;
if (trx != null)
cmd.Transaction = trx;
cmd.CommandType = CommandType.Text;
if (parameters != null)
{
foreach (OracleParameter param in parameters)
{
if (param.Value == null)
{
param.Value = DBNull.Value;
}
cmd.Parameters.Add(param);
}
}
}
/// <summary>
/// 为准备执行的命令绑定参数
/// </summary>
/// <param name="cmd">OracleCommand</param>
/// <param name="conn">OracleConnection</param>
/// <param name="trx">OracleTransaction</param>
/// <param name="cmdText">要执行的命令</param>
/// <param name="parametersCollection">参数集合</param>
private static void PrepareCommand(OracleCommand cmd, OracleConnection conn, OracleTransaction trx, string cmdText, OracleParameterCollection parametersCollection)
{
if (conn.State != ConnectionState.Open)
conn.Open();
cmd.Connection = conn;
cmd.CommandText = cmdText;
if (trx != null)
cmd.Transaction = trx;
cmd.CommandType = CommandType.Text;//cmdType;
if (parametersCollection != null)
{
foreach (OracleParameter param in parametersCollection)
{
if (param.Value == null)
{
param.Value = DBNull.Value;
}
//赋值，避免"The OracleParameter is already contained by another OracleParameterCollection. "错误
if (param.Direction != ParameterDirection.Output)
cmd.Parameters.Add(param.ParameterName, param.OracleType, param.Size).Value = param.Value;
else
cmd.Parameters.Add(param.ParameterName, param.OracleType, param.Size).Direction = param.Direction;
}
}
}
/// <summary>
/// 使用Oracle的特性进行分页，使用默认连接字符串
/// </summary>
/// <param name="tableName">查询的表名</param>
/// <param name="condition">查询条件</param>
/// <param name="selectColumns">查询的列</param>
/// <param name="size">分页大小</param>
/// <param name="offset">开始位置</param>
/// <param name="sortDirection">排序方式</param>
/// <param name="sortColumn">排序列</param>
/// <returns>DataSet</returns>
public static DataSet ExecutePagedResult(string tableName, string condition, string selectColumns, int size, int offset, string sortDirection, string sortColumn)
{
offset = offset / size;
offset += 1;
StringBuilder sql = new StringBuilder();
sql.Append("select ");
sql.Append(selectColumns);
sql.Append(" from ");
sql.Append(tableName);
sql.Append(" where rowid in (select rid from (select rownum rn,rid from(select rowid rid,");
sql.Append(sortColumn);
sql.Append(" from ");
sql.Append(tableName);
sql.Append(" where 1=1 ");
sql.Append(condition);
sql.Append(" order by ");
sql.Append(sortColumn);
sql.Append(" ");
sql.Append(sortDirection);
sql.Append(") where rownum<=");
sql.Append(offset * size);
sql.Append(") where rn>=");
sql.Append(((offset - 1) * size + 1));
sql.Append(") order by ");
sql.Append(sortColumn);
sql.Append(" ");
sql.Append(sortDirection);
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleDataAdapter oda = new OracleDataAdapter(sql.ToString(), oraConn))
{
DataSet ds = new DataSet();
oda.Fill(ds);
return ds;
}
}
}
/// <summary>
/// 普通分页方法，使用默认连接字符串
/// </summary>
/// <param name="sql"></param>
/// <param name="size"></param>
/// <param name="pageIndex"></param>
/// <returns></returns>
public static DataSet ExecutePagedResult(string sql, int size, int pageIndex)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
using (OracleDataAdapter oda = new OracleDataAdapter(sql, oraConn))
{
DataSet ds = new DataSet();
oda.Fill(ds, size * pageIndex, size, "PagedTable");
return ds;
}
}
}
/// <summary>
/// 使用默认连接字符串执行SQL，返回指定字段的值
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="dataField">要返回的字段名</param>
/// <returns>指定字段的值</returns>
public static string ExecuteDataField(string sql, string dataField)
{
DataSet ds = new DataSet();
using (OracleConnection oConn = new OracleConnection(dbConnectionString))
{
using (OracleDataAdapter da = new OracleDataAdapter(sql, oConn))
{
da.Fill(ds);
}
}
if (ds.Tables[0].Rows.Count > 0)
{
if (ds.Tables[0].Rows[0][dataField] != DBNull.Value)
{
return ds.Tables[0].Rows[0][dataField].ToString();
}
return null;
}
return null;
}
/// <summary>
/// 使用默认连接字符串执行SQL，返回指定字段的值
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="dataField">要返回的字段名</param>
/// <param name="parametersCollection">参数集合</param>
/// <returns>指定字段的值</returns>
public static string ExecuteDataField(string sql, string dataField, OracleParameterCollection parametersCollection)
{
DataSet ds = new DataSet();
using (OracleConnection oConn = new OracleConnection(dbConnectionString))
{
using (OracleCommand oraCmd = new OracleCommand())
{
PrepareCommand(oraCmd, oConn, null, sql, parametersCollection);
using (OracleDataAdapter oda = new OracleDataAdapter(oraCmd))
{
oda.Fill(ds, "ds");
oraCmd.Parameters.Clear();
}
}
}
if (ds.Tables[0].Rows.Count > 0)
{
if (ds.Tables[0].Rows[0][dataField] != DBNull.Value)
{
return ds.Tables[0].Rows[0][dataField].ToString();
}
return null;
}
return null;
}
/// <summary>
/// 使用指定连接字符串执行SQL，返回指定字段的值
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="dataField">要返回的字段名</param>
/// <param name="connectionString">连接字符串</param>
/// <returns>指定字段的值</returns>
public static string ExecuteDataField(string sql, string dataField, string connectionString)
{
DataSet ds = new DataSet();
using (OracleDataAdapter da = new OracleDataAdapter(sql, connectionString))
{
da.Fill(ds);
}
if (ds.Tables[0].Rows.Count > 0)
{
if (ds.Tables[0].Rows[0][dataField] != DBNull.Value)
{
return ds.Tables[0].Rows[0][dataField].ToString();
}
return null;
}
return null;
}
/// <summary>
/// 使用指定的连接字符串，返回符合查询条件的记录数
/// </summary>
/// <param name="tableName">要查询的表名</param>
/// <param name="condition">查询条件</param>
/// <param name="connectionString">连接字符串</param>
/// <returns>记录数</returns>
public static int ExecuteCount(string tableName, string condition, string connectionString)
{
if (string.IsNullOrEmpty(tableName))
{
throw new ArgumentOutOfRangeException("tableName", "TableName Can not be null or empty");
}
return int.Parse(ExecuteDataField("SELECT COUNT(*) COUNTER FROM " + tableName + " WHERE 1=1 " + condition, "COUNTER", connectionString));
}
/// <summary>
/// 使用默认的连接字符串，返回符合查询条件的记录数
/// </summary>
/// <param name="tableName">要查询的表名</param>
/// <param name="condition">查询条件</param>
/// <returns>记录数</returns>
public static int ExecuteCount(string tableName, string condition)
{
if (string.IsNullOrEmpty(tableName))
{
throw new ArgumentOutOfRangeException("tableName", "TableName Can not be null or empty");
}
return int.Parse(ExecuteDataField("SELECT COUNT(*) COUNTER FROM " + tableName + " WHERE 1=1 " + condition, "COUNTER"));
}
/// <summary>
/// 使用默认的连接字符串，返回Count Sql的查询结果。查询语句中COUNT(*)的别名必须是COUNTER。
/// </summary>
/// <param name="sql">SQL语句</param>
/// <returns>查询结果</returns>
public static int ExecuteCount(string sql)
{
if (string.IsNullOrEmpty(sql))
{
throw new ArgumentOutOfRangeException("sql", "Sql Can not be null or empty");
}
if (!sql.Contains("COUNTER"))
{
throw new ArgumentOutOfRangeException("sql", "Sql must contains COUNTER");
}
return int.Parse(ExecuteDataField(sql, "COUNTER"));
}
/// <summary>
/// 使用默认的连接字符串执行SQL，返回DataReader，注意用完之后必须关闭DataReader。
/// </summary>
/// <param name="sql">SQL语句</param>
/// <returns>DataReader</returns>
public static OracleDataReader ExecuteDataReader(string sql)
{
OracleConnection oraConn = new OracleConnection(dbConnectionString);
using (OracleCommand oraCmd = new OracleCommand(sql, oraConn))
{
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
OracleDataReader dr = oraCmd.ExecuteReader(CommandBehavior.CloseConnection);
return dr;
}
}
/// <summary>
/// 使用默认连接字符串执行多条SQL语句，实现数据库事务。
/// </summary>
/// <param name="sqlList">Sql List</param>
/// <returns>返回0成功，否则失败</returns>
public static int ExecuteSqlTransaction(List<String> sqlList)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
OracleCommand cmd = new OracleCommand { Connection = oraConn };
OracleTransaction tx = oraConn.BeginTransaction();
cmd.Transaction = tx;
try
{
foreach (string sql in sqlList)
{
if (!String.IsNullOrEmpty(sql))
{
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
}
}
tx.Commit();
return 0;
}
catch
{
tx.Rollback();
throw;
}
}
}
/// <summary>
/// 使用默认连接字符串执行存储过程，返回DataReader ( 注意：调用该方法后，一定要对DataReader进行Close )
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>DataReader</returns>
public static OracleDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
{
OracleConnection oraConn = new OracleConnection(dbConnectionString);
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
OracleCommand command = BuildQueryCommand(oraConn, storedProcName, parameters);
command.CommandType = CommandType.StoredProcedure;
OracleDataReader returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);
return returnReader;
}
/// <summary>
/// 使用默认连接字符串执行存储过程，返回DataSet
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <param name="tableName">DataSet结果中的表名</param>
/// <returns>DataSet</returns>
public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
DataSet dataSet = new DataSet();
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
OracleDataAdapter oda = new OracleDataAdapter
{
SelectCommand = BuildQueryCommand(oraConn, storedProcName, parameters)
};
oda.Fill(dataSet, tableName);
return dataSet;
}
}
/// <summary>
/// 使用默认连接字符串执行存储过程，指定超时时间，返回DataSet
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <param name="tableName">DataSet结果中的表名</param>
/// <param name="timeOut">超时时间</param>
/// <returns>DataSet</returns>
public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int timeOut)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
DataSet dataSet = new DataSet();
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
OracleDataAdapter oda = new OracleDataAdapter
{
SelectCommand = BuildQueryCommand(oraConn, storedProcName, parameters)
};
oda.SelectCommand.CommandTimeout = timeOut;
oda.Fill(dataSet, tableName);
return dataSet;
}
}
/// <summary>
/// 构建 OracleCommand 对象(用来返回一个结果集，而不是一个整数值)
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>OracleCommand</returns>
private static OracleCommand BuildQueryCommand(OracleConnection connection, string storedProcName, IDataParameter[] parameters)
{
OracleCommand oraCmd = new OracleCommand(storedProcName, connection)
{
CommandType = CommandType.StoredProcedure
};
foreach (OracleParameter parameter in parameters)
{
if (parameter != null)
{
// 检查未分配值的输出参数,将其分配以DBNull.Value.
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
(parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
oraCmd.Parameters.Add(parameter);
}
}
return oraCmd;
}
/// <summary>
/// 使用默认连接字符串执行存储过程，返回影响的行数。
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <param name="rowsAffected">影响的行数</param>
/// <returns></returns>
public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
OracleCommand command = BuildIntCommand(oraConn, storedProcName, parameters);
rowsAffected = command.ExecuteNonQuery();
int result = (int)command.Parameters["ReturnValue"].Value;
return result;
}
}
/// <summary>
/// 使用默认连接字符串执行存储过程，返回结果。
/// </summary>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>存储过程执行的结果</returns>
public static string RunSimpleProcedure(string storedProcName, IDataParameter[] parameters)
{
using (OracleConnection oraConn = new OracleConnection(dbConnectionString))
{
if (oraConn.State != ConnectionState.Open)
oraConn.Open();
OracleCommand command = BuildStringCommand(oraConn, storedProcName, parameters);
command.ExecuteNonQuery();
return command.Parameters["ReturnValue"].Value.ToString();
}
}
/// <summary>
/// 创建 OracleCommand 对象实例(用来返回一个整数值)
/// </summary>
/// <param name="connection">连接字符串</param>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>OracleCommand 对象实例</returns>
private static OracleCommand BuildIntCommand(OracleConnection connection, string storedProcName, IDataParameter[] parameters)
{
OracleCommand command = BuildQueryCommand(connection, storedProcName, parameters);
command.Parameters.Add(new OracleParameter("ReturnValue",
OracleType.Int32, 10, ParameterDirection.ReturnValue,
false, 0, 0, string.Empty, DataRowVersion.Default, null));
return command;
}
/// <summary>
/// 创建 OracleCommand 对象实例(用来返回一个整数值)
/// </summary>
/// <param name="connection">连接字符串</param>
/// <param name="storedProcName">存储过程名</param>
/// <param name="parameters">存储过程参数</param>
/// <returns>OracleCommand 对象实例</returns>
private static OracleCommand BuildStringCommand(OracleConnection connection, string storedProcName, IDataParameter[] parameters)
{
OracleCommand command = BuildQueryCommand(connection, storedProcName, parameters);
command.Parameters.Add(new OracleParameter("ReturnValue",
OracleType.VarChar, 255, ParameterDirection.ReturnValue,
false, 0, 0, string.Empty, DataRowVersion.Default, null));
return command;
}
/// <summary>
/// 使用默认连接字符串进行分页查询，并将总记录数放在DataSet中名字为RecCount的表中。
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="selectColumns">查询结果列</param>
/// <param name="condition">查询条件</param>
/// <param name="size">分页大小</param>
/// <param name="pageIndex">查询页</param>
/// <param name="sortColumns">排序字段</param>
/// <param name="sortDirection">排序方向</param>
/// <returns>DataSet</returns>
public static DataSet QueryWithCount(string tableName, string selectColumns, string condition, int size, int pageIndex, string sortColumns, string sortDirection)
{
string sql = "select " + selectColumns + " from " + tableName;
if (condition != "")
{
sql += " where " + condition;
}
sql += " order by " + sortColumns + " " + sortDirection;
using (OracleConnection oarConn = new OracleConnection(dbConnectionString))
{
using (OracleDataAdapter oda = new OracleDataAdapter(sql, oarConn))
{
DataSet ds = new DataSet();
oda.Fill(ds, pageIndex * size, size, tableName);
sql = "select count(*) as COUNTER from " + tableName;
if (condition != "")
{
sql += " where " + condition;
}
oda.SelectCommand.CommandText = sql;
oda.Fill(ds, "RecCount");
return ds;
}
}
}
/// <summary>
/// 使用默认连接字符串进行分页查询，并将总记录数放在DataSet中名字为RecCount的表中。
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="selectColumns">查询结果列</param>
/// <param name="condition">查询条件</param>
/// <param name="groupBy">Group字段</param>
/// <param name="size">分页大小</param>
/// <param name="pageIndex">查询页</param>
/// <param name="sortColumns">排序字段</param>
/// <param name="sortDirection">排序方向</param>
/// <returns>DataSet</returns>
public static DataSet QueryWithCount(string tableName, string selectColumns, string condition, string groupBy, int size, int pageIndex, string sortColumns, string sortDirection)
{
string sql = "select " + selectColumns + " from " + tableName;
if (condition != "")
{
sql += " where " + condition;
}
if (groupBy != "")
{
sql += " Group by " + groupBy;
}
sql += " order by " + sortColumns + " " + sortDirection;
using (OracleConnection sConn = new OracleConnection(dbConnectionString))
{
using (OracleDataAdapter oda = new OracleDataAdapter(sql, sConn))
{
DataSet ds = new DataSet();
oda.Fill(ds, pageIndex * size, size, tableName);
if (groupBy != "")
{
sql = "select count(*) as COUNTER from " + "(Select " + selectColumns + " from " + tableName +
" where 1=1 and " + condition + " group by " + groupBy + ") a";
}
else
{
sql = "select count(*) as COUNTER from " + tableName;
if (condition != "")
{
sql += " where " + condition;
}
}
oda.SelectCommand.CommandText = sql;
oda.Fill(ds, "RecCount");
return ds;
}
}
}
}
}
dataset访问Oraclel数据库相关推荐
- 用SqlDataAdapter.Update(DataSet Ds)更新数据库
一. 用SqlDataAdapter.Update(DataSet Ds)更新数据库. 1. DbDataAdapter调用 Update 方法时,DataAdapter 将分析已作出的更改并执行相应 ...
- 抽象工厂模式：实现ASP.NET访问不同数据库
在ASP.NET网站开发中可能会遇到要更换数据库,如将Aceess换为SQL Server ,由于Aceess引用System.Data.OleDb命名空间,SQL Server引用System.Da ...
- C#访问postgresql数据库类MyPostDB的实现
为了访问PostgreSQL数据库,需要从pgfoundry网站,下载Npgsql .Net Data Provider for Postgresql的组件. 访问 URL:http://pgfoun ...
- ado.net能访问oracle,利用ADO.NET访问Oracle数据库的实现
1.前言随着互联网的发展,人们对Web网页的要求越来越多的趋向于动态交互性,而这很大程度上依赖于Web数据库.因为动态交互需要强大的信息系统支持,信息数据以数据库形式表示更容易更新和管理.通过网页如何 ...
- 014-使用 Records 访问多种数据库
使用 Records 访问多种数据库 使用 Records 访问多种数据库 1.以 MySQL 使用为例 1.1 基本用法 1.2 数据导出功能 1.3 批量操作 1.4 事务支持 使用 Record ...
- 图文详解Silverlight访问MSSQL数据库
在银光中国网(SilverlightChina.Net)有一篇"Silverlight与常用数据库互操作系列"文章,其中介绍了使用Silverlight存取不同数据库的方法和步骤. ...
- Linux下eclipse及mysql安装,c++访问mysql数据库
这两天在学习linux下用c++访问mysql,碰到一堆问题,记录一下. 1.mysql安装: 公司的电脑是64位的,安装的是64为的RHEL4,安装如下三个包: MySQL-client-5.1.4 ...
- android与mysql数据库同步_android开发 如何通过web服务器访问MYSQL数据库并且使其数据同步到android SQLite数据库？...
通过web服务器访问MYSQL数据库有以下几个过程: 1.在MySql下创建自己的数据库和自己的表单 2.连接数据库. 3.访问数据库 1.创建web工程 (服务器端) 在Myeclipse下新建一个 ...
- 在T-SQL语句中访问远程数据库(openrowset/opendatasource/openquery)
原文:在T-SQL语句中访问远程数据库(openrowset/opendatasource/openquery) 1.启用Ad Hoc Distributed Queries 在使用openrowse ...
最新文章
- Numpy入门教程：06. 排序，搜索和计数
- 安卓开发仿微信图片拖拽_使用Android 模仿微信朋友圈图片拖拽返回
- java 151建议_编写高质量代码改善java程序的151个建议——导航开篇
- 专家票选！ 2020 年度 10 篇人工智能经典论文（6-10）
- LeetCode 983. 最低票价（动态规划）
- 3-3：常见任务和主要工具之网络
- android h5控制锁屏,WebView播放H5课件时，锁屏解锁后，页面重新绘制的问题
- 全网最新Spring Boot2.5.1整合Activiti5.22.0企业实战教程＜监听器篇＞
- ubuntu关闭服务需要身份验证
- 读取城市坐标，计算任意两个城市之间的距离。
- 利用 LSTM 神经网络预测股价走势
- Linux应急响应入侵排查思路
- Spring Cloud Euraka（ 服务注册中心）
- VS2010 Visual Assist X破解方法
- GitLab CI/CD 初体验
- python爬取新浪微博大V的所有微博内容
- 2020年重磅喜讯！热烈祝贺王家林大咖人工智能及大数据领域经典著作《Apache Spark+AI全息代码解密》清华大学出版社发行上市!
- 张小龙-年薪近3亿的微信之父，他是如何做到的？
- 鹏业BIM三维安装算量软件一次购买还是收年费
- 数据仓库 OLAP