/// <summary>
/// 使对象实体化,根据IsPersistent决定是更新还是插入操作
/// 如果IsPersistent为True，则自动会进行Update操作，在使用Retrieve()后会自动赋上此值，如：
/// entity.Retrieve();
/// if(entity.IsPersistent)
/// {会进行更新操作}
/// 虽然IsPersistent是public的，但一般的情况下，不建议进行赋值。
/// </summary>
public int Save()
{
PersistenceBroker broker = PersistenceBroker.Instance();
this._IsSaveInMemory = broker.GetClassMap(thisType.Name).IsSaveToMemory;
return(broker.SaveObject(this));
}
/// <summary>
/// 执行存储过程,返回DataTable
/// </summary>
/// <param name="storeProcName">存储过程名</param>
/// <param name="ps">存储过程所需参数数组</param>
/// <param name="dbName">数据库名</param>
/// <returns>存储过程返回的DataTable</returns>
public static DataTable RunProcedure(string storeProcName, IDataParameter[] ps, string dbName)
{
IDbCommand cmd = Query.BuildQueryCommand(storeProcName, ps, dbName);
PersistenceBroker broker = PersistenceBroker.Instance();
return(broker.ExecuteQuery(cmd, dbName));
}
/// <summary>
/// 根据对象的主键获取唯一对象
/// 注意，这个方法必须与只能通过主键来获取，因为只有主键在逻辑能确定唯一
/// 支持双主键，如果是双主键，则两个主键属性必须都要赋上
/// 如果不能通过主键唯一确定的，则可以通过RetrieveCriteria对象来获取。
/// </summary>
/// <returns></returns>
public bool Retrieve()
{
PersistenceBroker broker = PersistenceBroker.Instance();
this._IsSaveInMemory = broker.GetClassMap(thisType.Name).IsSaveToMemory;
return(broker.RetrieveObject(this, true, false));
}
/// <summary>
/// 生成一个Query实例
/// </summary>
/// <param name="className">EntityObject的类名</param>
public Query(string className)
{
ClassMap cm = PersistenceBroker.Instance().GetClassMap(className);
this.queryClass = cm;
sTemp = " AS " + cm.RelationalDatabase.QuotationMarksStart;
endQuostationMarks = cm.RelationalDatabase.QuotationMarksEnd;
}
//public static DataTable PageQuery(string needfields, string fromcondition,string keyfields ,string keyfieldsdeclare, int pagesize, int pages, out int counts, string db)
//{
// string sqlCreate = "declare @indextable table(indextableid int identity(1,1) PRIMARY KEY," + keyfieldsdeclare + ") ;";
// string KeySql = "select "+keyfields+" from "+fromcondition+" ";
// string sqlKeyinsert = "insert into @indextable(" + keyfields + ") " + KeySql + ";";
// string sqlCt = "select recrowcount= @@rowcount;";
// string[] needf = needfields.Split(new char[] { ',' });
// for (int i = 0; i < needf.Length; i++)
// {
// needf[i] = "t1."+needf[i].ToString();
// }
// string sqlSearch = "select "+string.Join(",",needf)+" from @indextable t0,(" + orgSql + ") t1 where t0.indextableid>=" + ((page - 1) * pageSize + 1).ToString() + " and t0.indextableid<" + (page * pageSize + 1).ToString() + tempKey3;
//}
/// <summary>
/// 执行Sql语句返回影响条数
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="dbName">操作的数据库名</param>
/// <returns>SQL语句影响条数</returns>
public static int ProcessSqlNonQuery(string sql, string dbName)
{
PersistenceBroker broker = PersistenceBroker.Instance();
IDbCommand cmd = broker.GetCommand(dbName);
cmd.CommandText = sql;
Logger.Write(sql); //add by duhu
return(broker.Execute(dbName, cmd));
}
/// <summary>
/// 生成一个Query实例
/// </summary>
/// <param name="classType">EntityObject对象的Type实例</param>
/// <param name="DatabaseName">多帐套数据库的数据库名</param>
public Query(Type classType, string DatabaseName)
{
string className = EntityObject.GetClassName(classType);
ClassMap cm = PersistenceBroker.Instance().GetClassMap(className);
this.queryClass = cm;
sTemp = " AS " + cm.RelationalDatabase.QuotationMarksStart;
endQuostationMarks = cm.RelationalDatabase.QuotationMarksEnd;
this.DatabaseName = DatabaseName;
}
/// <summary>
/// 执行Sql语句返回DataTable
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="dbName">操作的数据库名</param>
/// <returns>SQL语句查询结果集</returns>
public static DataSet ProcessMultiSql(string sql, string dbName)
{
PersistenceBroker broker = PersistenceBroker.Instance();
IDbCommand cmd = broker.GetCommand(dbName);
cmd.CommandTimeout = 120;
cmd.CommandText = sql;
Logger.Write(sql); //add by duhu
return(broker.ExecuteMultiQuery(cmd, dbName));
}
/// <summary>
/// 环境初始化
/// </summary>
public void Initialize()
{
if (this.m_DatabaseMapFile == "*")
{
throw new PlException("请先设置xml文件的位置!", ErrorTypes.PesistentError);
}
else
{
PersistenceBroker.Instance();
}
}
/// <summary>
/// 执行查询，并返回查询所返回结果集的第一行第一列。忽略额外的行或列
/// </summary>
/// <returns></returns>
public object ExecuteScalar()
{
PersistenceBroker broker = PersistenceBroker.Instance();
RelationalDatabase rdb = broker.GetDatabaseCopy(this.DatabaseName);
IDbCommand cmd = rdb.GetCommand();
cmd.CommandText = this.BuildForQuery(cmd);
DataTable dt = broker.ExecuteQuery(cmd, this.DatabaseName);
if (dt.Rows.Count == 0)
{
return(null);
}
else
{
return(dt.Rows[0][0]);
}
}
//创建新的Sql命令对象：需要的参数加入IDbCommand.Parameters集合
private static IDbCommand BuildQueryCommand(string storedProcName, IDataParameter[] param, string dbName)
{
PersistenceBroker broker = PersistenceBroker.Instance();
IDbCommand cmd = broker.GetCommand(dbName);
cmd.CommandText = storedProcName;
cmd.CommandType = CommandType.StoredProcedure;
if (param != null)
{
for (int i = 0; i < param.Length; i++)
{
IDataParameter p = param[i];
cmd.Parameters.Add(p);
}
}
return(cmd);
}
/// <summary>
/// add by tintown 2008-7-3使用Parameter的方式进行传参执行SQL
///如：string sql = "select top 100 * from Line_TCPF_Line where memberid=@id";
///IDataParameter para = PersistenceLayer.Query.GetParameter("hotel");
///para.ParameterName = "@id";
/// para.Value = 6632;
/// IDataParameter[] paras = new IDataParameter[1];
///paras[0] = para;
/// DataTable dt = PersistenceLayer.Query.ProcessSql(sql, paras, "hotel");
/// </summary>
/// <param name="sql">自己写的SQL语句</param>
/// <param name="param">参数数组</param>
/// <param name="dbName">数据源名</param>
/// <returns>查询结果集</returns>
public static DataTable ProcessSql(string sql, IDataParameter[] param, string dbName)
{
PersistenceBroker broker = PersistenceBroker.Instance();
IDbCommand cmd = broker.GetCommand(dbName);
cmd.CommandTimeout = 120;
cmd.CommandText = sql;
if (param != null)
{
for (int i = 0; i < param.Length; i++)
{
IDataParameter p = param[i];
cmd.Parameters.Add(p);
}
}
Logger.Write(sql); // add by duhu
return(broker.ExecuteQuery(cmd, dbName));
}
/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="storeProcName">存储过程名</param>
/// <param name="param">存储过程所需参数数组</param>
/// <param name="affected">存储过程影响的行数</param>
/// <param name="dbName">数据库名</param>
/// <returns>存储过程的返回代码</returns>
public static int RunProcedure(string storeProcName, IDataParameter[] param, out int affected, string dbName)
{
int result;
PersistenceBroker broker;
broker = PersistenceBroker.Instance();
IDbCommand cmd = Query.BuildQueryCommand(storeProcName, param, dbName);
//增加返回值参数
IDataParameter p = cmd.CreateParameter();
p.Direction = ParameterDirection.ReturnValue;
p.ParameterName = "ReturnValue";
p.DbType = DbType.Int32;
cmd.Parameters.Insert(0, p);
affected = broker.Execute(dbName, cmd);
p = (IDataParameter)cmd.Parameters["ReturnValue"];
result = (int)p.Value;
return(result);
}
/// <summary>
/// 执行查询，并返回查询结果集
/// </summary>
/// <returns>查询结果</returns>
public DataTable Execute()
{
PersistenceBroker broker = PersistenceBroker.Instance();
RelationalDatabase rdb = broker.GetDatabaseCopy(this.DatabaseName);
IDbCommand cmd = rdb.GetCommand();
cmd.CommandText = this.BuildForQuery(cmd);
string cmdText = cmd.CommandText;
if (rdb.Vendor == DatabaseVendor.Oracle)
{
int topInd = cmdText.IndexOf("Top");
if (topInd != -1)
{
cmdText = cmdText.Substring(0, topInd) + cmdText.Substring(topInd + 6);
//使用ORCALE添加rownum的方法重装SQL语句
cmdText = PersistenceBroker.AddOracleTopWhere(cmdText, this.Top);
}
}
cmd.CommandText = cmdText;
return(broker.ExecuteQuery(cmd, this.DatabaseName));
}
/// <summary>
/// 事务处理
/// </summary>
/// <returns>如果事务成功返回true，失败返回false</returns>
public bool Process()
{
bool result = true;
try
{
PersistenceBroker broker = PersistenceBroker.Instance();
//if (broker.MultiDatabase )
//{
result = broker.ProcessTransactionMultiDatabases(this);
//}
//else
//{
// broker.ProcessTransactionSingleDatabase (this);
//}
}
catch (Exception e)
{
result = false;
throw e;
}
return(result);
}
/// <summary>
/// constructor
/// </summary>
public EntityObject()
{
this.thisType = this.GetType();
this._IsSaveInMemory = PersistenceBroker.Instance().GetClassMap(thisType.Name).IsSaveToMemory;
}
/// <summary>
/// 追加数据源，此方法提供代码追加数据源的可能性
/// 在多帐套的情况下，一般是需要动态追加数据源的
/// 如果数据源名称重复，则会自动覆盖原连接，如果数据源名称不同，则会自动追加进去。
///
/// </summary>
/// <param name="name">数据源名</param>
/// <param name="databaseType">类型</param>
/// <param name="connectionString">连接字符串</param>
public void AppendDatabase(string name, DatabaseType databaseType, string connectionString)
{
string thisNameSpace = this.ToString().Substring(0, this.ToString().LastIndexOf('.') + 1);
PersistenceBroker.Instance().AppendDatabase(name, thisNameSpace + databaseType.ToString(), connectionString);
}
/// <summary>
/// 手动加载ClassMap文件。
/// </summary>
/// <param name="classMapPath">ClassMap地址</param>
public void LoadClassMap(string classMapPath)
{
PersistenceBroker.Instance().LoadClassMap(classMapPath);
}
/// <summary>
/// 返回一个IDataParameter,是SqlParameter,还是OleDbParameter
/// 由databaseName对应数据库的数据库类型确定
/// </summary>
/// <param name="databaseName">数据库名</param>
/// <returns></returns>
public static IDataParameter GetParameter(string databaseName)
{
PersistenceBroker broker = PersistenceBroker.Instance();
return(broker.GetCommand(databaseName).CreateParameter());
}
/// <summary>
/// 获取数据源的数据库提供者
/// </summary>
/// <param name="dbName">数据源名称</param>
/// <returns></returns>
public DatabaseVendor GetDatabaseVendor(string dbName)
{
return(PersistenceBroker.Instance().GetDatabase(dbName).Vendor);
}
