public DataSet ExecuteDataSet(MsDatParameters db_params)
{
var _sqlstr = String.Format("SELECT * FROM {0}\n", m_tblName);
var _index = 0;
var _where = "";
foreach (MsDatParameter _p in db_params)
{
if (String.IsNullOrEmpty(_where) == true)
{
_where += " WHERE ";
}
if (String.IsNullOrEmpty(_p.Field) == true)
{
_where += String.Format("{0}={1}", _p.Name.Substring(1), _p.Name);
}
else
{
_where += String.Format("{0}={1}", _p.Field, _p.Name);
}
if (_index != db_params.Count - 1)
{
_where += " AND ";
}
_index++;
}
_sqlstr += _where;
return(DatHelper.ExecuteDataSet(ConnectionString, _sqlstr, db_params));
}
//-----------------------------------------------------------------------------------------------------------------------------
//multi task crash string c#
//-----------------------------------------------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="xml_params"></param>
/// <returns></returns>
public static MsDatParameters ToArguments(this String xml_params)
{
var _result = new MsDatParameters();
_result.PutXmlString(xml_params);
return(_result);
}
private void _bldCommand(string name, string sql_text, MsDatParameters db_parms)
{
if (String.IsNullOrEmpty(name) == true)
{
Name = _splitTableName(sql_text);
}
else
{
Name = name;
}
Text = sql_text;
var _dbps = new MsDatParameters();
if (db_parms != null)
{
foreach (MsDatParameter _dbp in db_parms)
{
_dbps.Add(_dbp.Name, _dbp.FieldType, _dbp.Type, _dbp.Direction, _dbp.Value);
}
}
Value = _dbps;
}
/// <summary>
///
/// </summary>
/// <param name="db_params"></param>
public MsDatParameters(MsDatParameters db_params)
{
foreach (var _parm in db_params)
{
Add(_parm);
}
}
/// <summary>
///
/// </summary>
/// <param name="package"></param>
/// <returns></returns>
public static MsDatParameters ToParameters(this XmlPackage package)
{
var _result = new MsDatParameters();
_result.PutXmlPackage(package);
return(_result);
}
//-----------------------------------------------------------------------------------------------------------------------------
// ExecuteProc
//-----------------------------------------------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="connection_string"></param>
/// <param name="stored_procedure_name"></param>
/// <returns></returns>
public MsDatParameters GetSqlParameters(string connection_string, string stored_procedure_name)
{
var _dbps = new MsDatParameters();
SqlParameter[] _sbps = SqlHelperParameterCache.GetSpParameterSet(connection_string, stored_procedure_name);
foreach (SqlParameter _s in _sbps)
{
_dbps.Add(_s.ParameterName, _s.SqlDbType, _s.Direction, DBNull.Value);
}
return(_dbps);
}
public DataSet WriteBinary(string connection_string, string command_text, MsDatParameters db_params, out int no_reccord)
{
_cleanBinarySet();
_fillBinarySet(connection_string, command_text, db_params);
no_reccord = 0;
if (_writeBinarySet() == true)
{
_readBinarySet(1, out no_reccord);
}
return(DatStore);
}
public bool CheckExistence(MsDatParameters db_params)
{
bool _result;
DataSet _ds = ExecuteDataSet(db_params);
if (DatHelper.IsNullOrEmpty(_ds) == false)
{
_result = true;
}
else
{
_result = false;
}
return(_result);
}
/// <summary>
/// XmlString형식을 DatParametes 형식으로 변환 합니다.
/// </summary>
/// <param name="xml_params"></param>
public void PutXmlString(string xml_params)
{
xml_params = Serialization.SNG.DecompressText(xml_params);
MsDatParameters _dbps = (MsDatParameters)Serialization.SNG.StringToClass(typeof(MsDatParameters), xml_params);
foreach (MsDatParameter _p in _dbps)
{
Add(_p.Name, _p.FieldType, _p.Type, _p.Direction, _p.Value);
}
foreach (MsDatParameter _p in this)
{
Type _type = Type.GetType(_p.FieldType);
if (_type.IsSealed == false || _type.BaseType == typeof(Array))
{
_p.Value = Serialization.SNG.StringToClass(_type, _p.Value.ToString());
}
}
}
/// <summary>
/// This method assigns an array of values to an array of SqlParameters
/// </summary>
/// <param name="commandParameters">Array of SqlParameters to be assigned values</param>
/// <param name="parameterValues">Array of objects holding the values to be assigned</param>
private void _returnParameterValue(SqlParameter[] commandParameters, MsDatParameters parameterValues)
{
if (commandParameters != null && parameterValues != null)
{
for (int i = 0; i < commandParameters.Length; i++)
{
SqlParameter _cp = commandParameters[i];
if (_cp.Direction == ParameterDirection.Input)
{
continue;
}
//Update the Return Value
if (_cp.Direction == ParameterDirection.ReturnValue)
{
foreach (MsDatParameter _pv in parameterValues)
{
if (_pv.Direction == ParameterDirection.ReturnValue)
{
_pv.Value = _cp.Value;
break;
}
}
}
else
{
foreach (MsDatParameter _pv in parameterValues)
{
if (_pv.Name.ToLower() == _cp.ParameterName.ToLower())
{
_pv.Value = _cp.Value;
break;
}
}
}
}
}
}
public int ExecuteText(string connection_string, MsDatParameters db_params, params string[] command_texts)
{
var _result = 0;
using (SqlConnection _sqlconn = new SqlConnection(connection_string))
{
_sqlconn.Open();
SqlTransaction transaction = _sqlconn.BeginTransaction();
try
{
for (int i = 0; i < command_texts.Length; i++)
{
if (command_texts[i] != null && command_texts[i] != "")
{
MsSqlHelper.ExecuteNonQuery(transaction, CommandType.Text, command_texts[i], (SqlParameter[])db_params);
_result++;
}
}
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
_result = -1;
throw new Exception("ExecuteText", ex);
}
finally
{
_sqlconn.Close();
}
}
return(_result);
}
//-----------------------------------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------------------------------
public DataSet SelectTopSet(string connection_string, string command_text, MsDatParameters db_params)
{
_fillBinarySet(connection_string, _topCommandTextBuild(command_text), db_params);
return(DatStore);
}
//-----------------------------------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------------------------------
private void _fillBinarySet(string connection_string, string command_text, MsDatParameters db_params)
{
DatStore.Merge(DatHelper.SelectDataSet(connection_string, command_text, db_params));
}
/// <summary>
///
/// </summary>
/// <param name="db_params"></param>
/// <returns></returns>
public static string ToXmlString(this MsDatParameters db_params)
{
return(((MsDatParameters)db_params.Clone()).GetXmlString());
}
public MsDatCommand(string name, string sql_text, MsDatParameters db_parms)
{
_bldCommand(name, sql_text, db_parms);
}
public DataSet ExecuteDataSet(string connection_string, string command_text, MsDatParameters db_params)
{
return(MsSqlHelper.ExecuteDataSet(connection_string, CommandType.Text, command_text, (SqlParameter[])db_params));
}
/// <summary>
///
/// </summary>
/// <param name="connection_string"></param>
/// <param name="stored_procedure_name"></param>
/// <param name="db_params"></param>
/// <returns></returns>
public DataSet ExecuteProcSet(string connection_string, string stored_procedure_name, MsDatParameters db_params)
{
var _result = new DataSet();
SqlParameter[] _params = (SqlParameter[])db_params;
_result = MsSqlHelper.ExecuteProcSet(connection_string, stored_procedure_name, _params);
{
_returnParameterValue(_params, db_params);
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="t"></param>
public MsDatEnumerator(MsDatParameters t)
{
_t = t.BaseGetAllValues();
}
public SqlDataReader ExecuteReader(string connection_string, string command_text, MsDatParameters db_params)
{
return(MsSqlHelper.ExecuteReader(connection_string, CommandType.Text, command_text, (SqlParameter[])db_params));
}
public DataSet ExecuteDataSet(string sql_string, MsDatParameters db_params)
{
return(DatHelper.ExecuteDataSet(ConnectionString, sql_string, db_params));
}
public void Add(string sql_text, MsDatParameters db_parms)
{
Add(base.Count.ToString(), (object)new MsDatCommand(sql_text, db_parms));
}
public int RecordCount(string connection_string, string command_text, MsDatParameters db_params)
{
_fillBinarySet(connection_string, _recordCountCommandTextBuild(command_text), db_params);
return((int)DatStore.Tables[0].Rows[0][0]);
}
public object SelectScalar(string sql_string, MsDatParameters db_params)
{
return(DatHelper.SelectScalar(ConnectionString, sql_string, db_params));
}
public DataSet SelectDataSet(string connection_string, string command_text, MsDatParameters db_params)
{
MsDatCommand _dbc = new MsDatCommand(command_text);
return(MsSqlHelper.SelectDataSet(connection_string, CommandType.Text, command_text, _dbc.Name, (SqlParameter[])db_params));
}
//-----------------------------------------------------------------------------------------------------------------------------
/// SelectScalar
//-----------------------------------------------------------------------------------------------------------------------------
public object SelectScalar(string connection_string, string command_text, MsDatParameters db_params)
{
return(MsSqlHelper.ExecuteScalar(connection_string, CommandType.Text, command_text, (SqlParameter[])db_params));
}
public void Add(string name, string sql_text, MsDatParameters db_parms)
{
Add(name, (object)new MsDatCommand(name, sql_text, db_parms));
}
//-----------------------------------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="db_params"></param>
/// <param name="kind_of_packing"></param>
/// <returns></returns>
public static XmlPackage ToXmlPackage(this MsDatParameters db_params, MKindOfPacking kind_of_packing = MKindOfPacking.Encrypted)
{
return(((MsDatParameters)db_params.Clone()).GetXmlPackage(kind_of_packing));
}
