public static bool TypeAheadAccountCode(Int32 ALedgerNumber, string ASearch,
bool APostingOnly,
bool AExcludePosting,
bool AActiveOnly,
bool ABankAccountOnly,
Int32 ALimit,
out DataTable AResult)
{
TDBTransaction Transaction = null;
DataTable result = new DataTable();
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref Transaction,
delegate
{
string SqlStmt = TDataBase.ReadSqlFile("Finance.TypeAheadAccountCode.sql");
OdbcParameter[] parameters = new OdbcParameter[5];
parameters[0] = new OdbcParameter("LedgerNumber", OdbcType.Int);
parameters[0].Value = ALedgerNumber;
parameters[1] = new OdbcParameter("AccountCode", OdbcType.VarChar);
parameters[1].Value = "%" + ASearch + "%";
parameters[2] = new OdbcParameter("ShortDesc", OdbcType.VarChar);
parameters[2].Value = "%" + ASearch + "%";
parameters[3] = new OdbcParameter("LongDesc", OdbcType.VarChar);
parameters[3].Value = "%" + ASearch + "%";
parameters[4] = new OdbcParameter("PostingOnly", OdbcType.TinyInt);
parameters[4].Value = APostingOnly;
SqlStmt += " LIMIT " + ALimit.ToString();
result = DBAccess.GDBAccessObj.SelectDT(SqlStmt, "Search", Transaction, parameters);
});
AResult = result;
return(result.Rows.Count > 0);
}
public override DbParameter AppendParamter(List <DbParameter> _params, string parameterName, ColumnInfo col, Type type, object value)
{
if (string.IsNullOrEmpty(parameterName))
{
parameterName = $"p_{_params?.Count}";
}
var dbtype = (OdbcType)_orm.CodeFirst.GetDbInfo(type)?.type;
switch (dbtype)
{
case OdbcType.Bit:
if (value == null)
{
value = null;
}
else
{
value = (bool)value == true ? 1 : 0;
}
dbtype = OdbcType.Int;
break;
case OdbcType.Char:
case OdbcType.NChar:
case OdbcType.VarChar:
case OdbcType.NVarChar:
case OdbcType.Text:
case OdbcType.NText:
value = string.Concat(value);
break;
}
var ret = new OdbcParameter {
ParameterName = QuoteParamterName(parameterName), OdbcType = dbtype, Value = value
};
_params?.Add(ret);
return(ret);
}
public void TestTimeStamp()
{
TDBTransaction t = new TDBTransaction();
TDataBase db = DBAccess.Connect("Test", FDataBase);
bool SubmissionOK = true;
db.WriteTransaction(ref t,
ref SubmissionOK,
delegate
{
string countSql = "SELECT COUNT(*) FROM PUB_s_system_defaults";
int count = Convert.ToInt32(db.ExecuteScalar(countSql, t));
string code = "test" + (count + 1).ToString();
string insertSql = String.Format(
"INSERT INTO PUB_s_system_defaults(s_default_code_c, s_default_description_c, s_default_value_c, s_modification_id_t) VALUES('{0}', '{1}','{2}',NOW())",
code,
"test",
"test");
Assert.AreEqual(1, db.ExecuteNonQuery(insertSql, t));
string getTimeStampSql = String.Format(
"SELECT s_modification_id_t FROM PUB_s_system_defaults WHERE s_default_code_c = '{0}'",
code);
DateTime timestamp = Convert.ToDateTime(db.ExecuteScalar(getTimeStampSql, t));
string updateSql = String.Format(
"UPDATE PUB_s_system_defaults set s_modification_id_t = NOW(), s_default_description_c = '{0}' where s_default_code_c = '{1}' AND s_modification_id_t = ?",
"test2",
code);
OdbcParameter param = new OdbcParameter("timestamp", OdbcType.DateTime);
param.Value = timestamp;
Assert.AreEqual(1, db.ExecuteNonQuery(updateSql, t, new OdbcParameter[] { param }), "update by timestamp");
});
}
public static DataTable FetchPervasiveData(string dataSet, string sql, OdbcParameter param1)
{
DataTable table = new DataTable();
string strAccessConn = @"Dsn=" + odbcName + ";";
using (var conn = new OdbcConnection(strAccessConn))
{
conn.ConnectionTimeout = 600;
using (var cmd = new OdbcCommand(sql, conn))
{
if (param1 != null)
{
cmd.Parameters.Add(param1);
}
OdbcDataAdapter myDataAdapter = new OdbcDataAdapter(cmd);
cmd.CommandTimeout = 0; //no wait time
conn.Open();
myDataAdapter.Fill(table);
conn.Close();
}
}
return(table);
}
public static void ModificarArchivo(int idExpediente, int idMovimiento, int nombreArchivo)
{
OdbcConnection conexion = new OdbcConnection(NegocioBase.getConnectionString());
OdbcParameter parametro = new OdbcParameter();
OdbcCommand comando = new OdbcCommand();
try
{
comando.Connection = conexion;
conexion.Open();
comando.CommandType = CommandType.StoredProcedure;
comando.CommandText = "call SP_ModificarArchivo(?,?,?)";
comando.Parameters.AddWithValue("_idExpediente", idExpediente);
comando.Parameters.AddWithValue("_idMovimiento", idMovimiento);
comando.Parameters.AddWithValue("_nombreArchivo", nombreArchivo);
comando.ExecuteNonQuery();
conexion.Close();
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
///
/// </summary>
/// <param name="BackupServerFileId"></param>
/// <param name="loginID"></param>
/// <param name="conn"></param>
/// <returns></returns>
public int DeleteBackupServerFileById(int BackupServerFileId, string loginID, OdbcConnection conn)
{
int result = -1;
string sql = "UPDATE backupServerFile SET deleteFlg = 1,"
+ "deleter = ?,"
+ "deleteDate = ?"
+ " WHERE id = ?";
OdbcParameter[] para = new OdbcParameter[] {
new OdbcParameter("@deleter", loginID),
new OdbcParameter("@deleteDate", DateTime.Now),
new OdbcParameter("@id", BackupServerFileId)
};
try
{
result = db.Udaquery(sql, conn, para);
}
catch (Exception e)
{
throw e;
}
return(result);
}
public static IDataParameter IDataParameterGetParameter(DataProvider providerType)
{
IDataParameter iDataParameter = null;
switch (providerType)
{
case DataProvider.SqlServer:
iDataParameter = new SqlParameter();
break;
case DataProvider.OleDb:
iDataParameter = new OleDbParameter();
break;
case DataProvider.Odbc:
iDataParameter = new OdbcParameter();
break;
//case DataProvider.Oracle:
// iDataParameter = newOracleParameter();
// break;
}
return(iDataParameter);
}
/// <summary>
/// copy the ODBC parameters, but apply unicode conversion
/// </summary>
/// <param name="AParameterArray">Array of DbParameter that is to be converted.</param>
/// <param name="ASqlStatement">SQL Statement will stay the same.</param>
/// <returns>modified array of ODBCParameters (unicode)</returns>
public DbParameter[] ConvertOdbcParameters(DbParameter[] AParameterArray, ref string ASqlStatement)
{
OdbcParameter[] ReturnValue = new OdbcParameter[AParameterArray.Length];
OdbcParameter[] ArrayOdbc = (OdbcParameter[])AParameterArray;
// QUESTION: is this only called once, or do we have a problem with ConvertFrmUnicode to be called twice?
for (int Counter = 0; Counter < AParameterArray.Length; Counter++)
{
ReturnValue[Counter] = new OdbcParameter(ArrayOdbc[Counter].ParameterName, ArrayOdbc[Counter].OdbcType);
if (ArrayOdbc[Counter].OdbcType == OdbcType.VarChar)
{
ReturnValue[Counter].Value = ConvertFromUnicode(Convert.ToString(ArrayOdbc[Counter].Value));
}
else
{
ReturnValue[Counter].Value = ArrayOdbc[Counter].Value;
}
}
return(ReturnValue);
}
/// <summary>
///
/// </summary>
/// <param name="MonitorServerFileId"></param>
/// <param name="transferFlg"></param>
/// <param name="transferNum"></param>
/// <param name="conn"></param>
/// <returns></returns>
public int UpdateNGTransferFlg(string MonitorServerFileId, int transferFlg, int transferNum, OdbcConnection conn)
{
int result = -1;
string sql = "UPDATE monitorServerFile SET transferFlg = ?,transferNum = ?,updater = 'exe',"
+ "updateDate = ?"
+ " WHERE id = ?";
OdbcParameter[] para = new OdbcParameter[] {
new OdbcParameter("@transferFlg", transferFlg),
new OdbcParameter("@transferNum", transferNum),
new OdbcParameter("@updateDate", DateTime.Now),
new OdbcParameter("@id", MonitorServerFileId)
};
try
{
result = db.Udaquery(sql, conn, para);
}
catch (Exception e)
{
throw e;
}
return(result);
}
public int ExecuteCommand(string safeSql, CommandType type, int index)
{
int num;
try
{
using (OdbcCommand command = new OdbcCommand(safeSql, this.Connection))
{
command.CommandType = type;
OdbcParameter parameter = new OdbcParameter("@rid", SqlDbType.Int)
{
Value = index
};
command.Parameters.Add(parameter);
num = command.ExecuteNonQuery();
}
}
catch (Exception exception)
{
throw exception;
}
return(num);
}
public static IDataParameter GetParameter(DataProvider providerType)
{
IDataParameter iDataParameter = null;
switch (providerType.Validate())
{
case DataProvider.SqlServer:
iDataParameter = new SqlParameter();
break;
case DataProvider.OleDb:
iDataParameter = new OleDbParameter();
break;
case DataProvider.Odbc:
iDataParameter = new OdbcParameter();
break;
case DataProvider.Oracle:
throw new NotImplementedException();
}
return(iDataParameter);
}
/// <summary>
///
/// </summary>
/// <param name="MonitorServerFolderId"></param>
/// <param name="loginID"></param>
/// <param name="conn"></param>
/// <returns></returns>
public int DeleteMonitorServerFolderById(int MonitorServerFolderId, string loginID, OdbcConnection conn)
{
int result = -1;
string sql = "UPDATE monitorServerFolder SET deleteFlg = 1,"
+ "deleter = ？,"
+ "deleteDate = ？"
+ " WHERE id = ？";
OdbcParameter[] para = new OdbcParameter[] {
new OdbcParameter("@deleter", loginID),
new OdbcParameter("@deleteDate", DateTime.Now),
new OdbcParameter("@id", MonitorServerFolderId)
};
try
{
result = db.Udaquery(sql, conn, para);
}
catch (Exception e)
{
throw e;
}
return(result);
}
//This method returns a specific parameter object
//based on the value of a DataBaseProvider enum
public static DbParameter GetParameter(DataBaseProvider dataProvider)
{
DbParameter parameter = null;
switch (dataProvider)
{
case DataBaseProvider.SqlServer:
parameter = new SqlParameter();
break;
case DataBaseProvider.OleDb:
parameter = new OleDbParameter();
break;
case DataBaseProvider.Odbc:
parameter = new OdbcParameter();
break;
default:
break;
}
return(parameter);
}
public override DbParameter AppendParamter(List <DbParameter> _params, string parameterName, ColumnInfo col, Type type, object value)
{
if (string.IsNullOrEmpty(parameterName))
{
parameterName = $"p_{_params?.Count}";
}
if (value?.Equals(DateTime.MinValue) == true)
{
value = new DateTime(1970, 1, 1);
}
var ret = new OdbcParameter {
ParameterName = QuoteParamterName(parameterName)
};
var tp = _orm.CodeFirst.GetDbInfo(type)?.type;
if (tp != null)
{
ret.OdbcType = (OdbcType)tp.Value;
}
ret.Value = value;
_params?.Add(ret);
return(ret);
}
public void SP_sf_update_sms(string BDate, int priority)
{
try
{
con_obj.db_Connection_open();
_conn = connection._conn;
OdbcParameter parm1 = new OdbcParameter();
OdbcParameter parm2 = new OdbcParameter();
OdbcCommand cmd = new OdbcCommand("{call sf_update_sms(?,?)}", _conn);
cmd.CommandType = CommandType.StoredProcedure;
parm1 = cmd.Parameters.Add("ad_date", OdbcType.Date);
parm1.Value = BDate;
parm2 = cmd.Parameters.Add("ai_priority", OdbcType.Int);
parm2.Value = priority;
cmd.ExecuteScalar();
_conn.Close();
}
catch (Exception Ex)
{
//MessageBox.Show("Error 104" + Ex.Message, "CCSMS");
Track_obj.Text_Tracker(Convert.ToString(Ex));
}
}
/// <summary>
/// 通过sql查询单列内容
/// </summary>
/// <param name="conn">连接</param>
/// <param name="o">参数对象</param>
/// <param name="sql">sql语句</param>
/// <returns></returns>
public int getCountBySql(OdbcConnection conn, Object o, string sql)
{
Hashtable ht = getModelValue(o);//有效数据
int paramCount = ht.Count;
OdbcParameter[] sp = new OdbcParameter[paramCount];
getQuerySql(ht, "", sp);
DataTable dt = null;
if (ht.Count != 0)
{
dt = this.Squery(sql, conn, sp);
}
else
{
dt = this.Squery(sql, conn);
}
if (dt.Rows.Count != 0)
{
return(Convert.ToInt32(dt.Rows[0][0]));
}
return(-1);
}
private static void SaveSession(TDBTransaction AWriteTransaction)
{
string sql = "SELECT COUNT(*) FROM PUB_s_session WHERE s_session_id_c = ?";
OdbcParameter[] parameters = new OdbcParameter[1];
parameters[0] = new OdbcParameter("s_session_id_c", OdbcType.VarChar);
parameters[0].Value = FSessionID;
string SerializedSessionValues = JsonConvert.SerializeObject(FSessionValues);
if (SerializedSessionValues.Length > 65500)
{
throw new Exception("TSession.SaveSession: the session should not get that big: " + SerializedSessionValues.Length.ToString());
}
if (Convert.ToInt32(AWriteTransaction.DataBaseObj.ExecuteScalar(sql, AWriteTransaction, parameters)) == 1)
{
parameters = new OdbcParameter[2];
parameters[0] = new OdbcParameter("s_session_values_c", OdbcType.Text);
parameters[0].Value = SerializedSessionValues;
parameters[1] = new OdbcParameter("s_session_id_c", OdbcType.VarChar);
parameters[1].Value = FSessionID;
sql = "UPDATE PUB_s_session SET s_session_values_c = ? WHERE s_session_id_c = ?";
}
else
{
parameters = new OdbcParameter[3];
parameters[0] = new OdbcParameter("s_session_values_c", OdbcType.Text);
parameters[0].Value = SerializedSessionValues;
parameters[1] = new OdbcParameter("s_session_id_c", OdbcType.VarChar);
parameters[1].Value = FSessionID;
parameters[2] = new OdbcParameter("s_valid_until_d", OdbcType.DateTime);
parameters[2].Value = DateTime.Now.AddHours(SessionValidHours);
sql = "INSERT INTO PUB_s_session (s_session_values_c, s_session_id_c, s_valid_until_d) VALUES (?,?,?)";
}
AWriteTransaction.DataBaseObj.ExecuteNonQuery(sql, AWriteTransaction, parameters);
}
/// <summary>
/// todoComment
/// </summary>
/// <param name="databaseConnection"></param>
/// <param name="pv_ledger_number_i"></param>
/// <param name="pv_account_code_c"></param>
/// <param name="accountType">returns the type of account, ie. Income, Expense, Assets, Liab, Equity</param>
/// <param name="postingAccount">returns true if the account is a posting account
/// </param>
/// <param name="debitCreditIndicator"></param>
/// <returns></returns>
private bool TAccountInfo(TDataBase databaseConnection,
System.Int32 pv_ledger_number_i,
String pv_account_code_c,
out String accountType,
out bool postingAccount,
out bool debitCreditIndicator)
{
bool ReturnValue;
string strSql;
DataTable tab;
ReturnValue = false;
debitCreditIndicator = false;
accountType = "";
List <OdbcParameter> parameters = new List <OdbcParameter>();
OdbcParameter param = new OdbcParameter("accountcode", OdbcType.VarChar);
param.Value = pv_account_code_c;
parameters.Add(param);
postingAccount = false;
strSql = "SELECT a_account_type_c, a_posting_status_l, a_debit_credit_indicator_l FROM PUB_a_account" +
" WHERE a_ledger_number_i = " + pv_ledger_number_i.ToString() +
" AND a_account_code_c = ?";
tab =
databaseConnection.SelectDT(strSql, "AccountType", databaseConnection.Transaction,
parameters.ToArray());
if (tab.Rows.Count > 0)
{
accountType = Convert.ToString(tab.Rows[0]["a_account_type_c"]);
postingAccount = (Boolean)tab.Rows[0]["a_posting_status_l"];
debitCreditIndicator = (Boolean)tab.Rows[0]["a_debit_credit_indicator_l"];
ReturnValue = true;
}
return(ReturnValue);
}
/// <summary>
///
/// </summary>
/// <param name="BackupServer"></param>
/// <param name="conn"></param>
/// <returns></returns>
public int UpdateBackupServer(BackupServer BackupServer, OdbcConnection conn)
{
int result = -1;
string sql = "UPDATE backupServer SET backupServerName = ?,"
+ " backupServerIP = ?,"
+ " memo = ?, "
+ " account =?,"
+ " password =?,"
+ " startFile =?,"
+ " ssbpath =?,"
+ " updater =?,"
+ " updateDate =?,"
+ " synchronismFlg = 0"
+ " WHERE id = ?";
OdbcParameter[] para = new OdbcParameter[] {
new OdbcParameter("@backupServerName", BackupServer.backupServerName),
new OdbcParameter("@backupServerIP", BackupServer.backupServerIP),
new OdbcParameter("@memo", BackupServer.memo),
new OdbcParameter("@account", BackupServer.account),
new OdbcParameter("@password", BackupServer.password),
new OdbcParameter("@startFile", BackupServer.startFile),
new OdbcParameter("@ssbpath", BackupServer.ssbpath),
new OdbcParameter("@updater", BackupServer.updater),
new OdbcParameter("@updateDate", BackupServer.updateDate),
new OdbcParameter("@id", BackupServer.id)
};
try
{
result = db.Udaquery(sql, conn, para);
}
catch (Exception e)
{
throw e;
}
return(result);
}
public static void update(Cronograma cronograma)
{
try
{
Conexion.abrirConexion();
List <OdbcParameter> lista = new List <OdbcParameter>();
OdbcParameter p1, p2, px;
p1 = new OdbcParameter();
p2 = new OdbcParameter();
px = new OdbcParameter();
px.ParameterName = "@id";
px.OdbcType = OdbcType.Int;
px.Value = cronograma.Id;
lista.Add(px);
p1.ParameterName = "@fechaInicio";
p1.OdbcType = OdbcType.Date;
p1.Value = cronograma.Fecha_Inicio;
lista.Add(p1);
p2.ParameterName = "@fechaConclusion";
p2.OdbcType = OdbcType.Date;
p2.Value = cronograma.Fecha_Conclusion;
lista.Add(p2);
Conexion.EjecutarProcedimientoAlmacenado("updateCronograma", lista, "Escritura");
}
catch (Exception)
{
return;
}
finally
{
Conexion.cerrarConexion();
}
}
public static void Agregar(ExpedienteMVL expedienteMVL)
{
OdbcConnection conexion = new OdbcConnection(NegocioBase.getConnectionString());
OdbcParameter parametro = new OdbcParameter();
OdbcTransaction transaccion;
OdbcCommand comando = new OdbcCommand("call SP_InsertarExpedienteMVL(?,?,?,?,?,?,?)", conexion);
try
{
comando.Parameters.AddWithValue("_idExpediente", expedienteMVL.idExpediente);
comando.Parameters.AddWithValue("_idMovimientoSolicitud", expedienteMVL.idMovimiento);
comando.Parameters.AddWithValue("_idMovimientoRecepcion", expedienteMVL.idMovimientoRecepcion);
comando.Parameters.AddWithValue("_idMovimientoDevolucion", expedienteMVL.idMovimientoDevolucion);
comando.Parameters.AddWithValue("_codigoExpedienteMVL", expedienteMVL.codigoExpedienteMVL);
comando.Parameters.AddWithValue("_numeroExpedienteMVL", expedienteMVL.numeroExpedienteMVL);
comando.Parameters.AddWithValue("_anioExpediente", expedienteMVL.anioExpediente);
comando.Connection = conexion;
conexion.Open();
transaccion = conexion.BeginTransaction();
comando.Transaction = transaccion;
comando.ExecuteNonQuery();
transaccion.Commit();
conexion.Close();
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (conexion.State == ConnectionState.Open)
{
conexion.Close();
}
}
}
protected void supprimerVille(object sender, EventArgs e)
{
string code = ((MemoryButton)sender).code;
List <Emplacement> copie = new List <Emplacement>(emplacementAffiche);
foreach (Emplacement ville in copie)
{
if (ville.CodeINSEE == code)
{
emplacementAffiche.Remove(ville);
}
}
//rettirer les arrondissement correspondant de la liste noire
Connexion c = new Connexion();
OdbcCommand selectArrond = new OdbcCommand();
selectArrond.CommandText = "select * from arrondissement where VilleINSEE = ?";
OdbcParameter paramINSEE = new OdbcParameter("", OdbcType.VarChar);
paramINSEE.Value = code;
selectArrond.Parameters.Add(paramINSEE);
DataRowCollection drc = c.exeRequetteParametree(selectArrond).Tables[0].Rows;
foreach (DataRow dr in drc)
{
foreach (Arrondissement arrNoir in listeArrondissementNoire)
{
if (arrNoir.CP == dr["Code Postal"].ToString())
{
listeArrondissementNoire.Remove(arrNoir);
break;
}
}
}
rafraichirEmplacementAffiche();
}
private void EjecutarComando(TipoComando sqlCommandType, PedidoEntity entidad) {
OdbcConnection connection = null;
OdbcCommand command = null;
try {
connection = (OdbcConnection)connectionDA.GetOpenedConnection();
IDataParameter paramId = new OdbcParameter("?", OdbcType.Int);
paramId.Value = entidad.IdPedido;
switch (sqlCommandType) {
case TipoComando.Insertar:
command = new OdbcCommand(SQLInsert, connection);
CrearParametros(command, entidad);
break;
case TipoComando.Actualizar:
command = new OdbcCommand(SQLUpdate, connection);
CrearParametros(command, entidad);
command.Parameters.Add(paramId);
break;
case TipoComando.Eliminar:
command = new OdbcCommand(SQLDelete, connection);
command.Parameters.Add(paramId);
CrearParametros(command, entidad);
break;
}
command.ExecuteNonQuery();
connection.Close();
} catch (Exception ex) {
throw new daException(ex);
} finally {
if (command != null) { command.Dispose(); }
if (connection != null) { connection.Dispose(); }
}
}
public override DbParameter[] GetDbParamtersByObject(string sql, object obj) =>
Utils.GetDbParamtersByObject <OdbcParameter>(sql, obj, null, (name, type, value) =>
{
var dbtype = (OdbcType?)_orm.CodeFirst.GetDbInfo(type)?.type;
switch (dbtype)
{
case OdbcType.Bit:
if (value == null)
{
value = null;
}
else
{
value = (bool)value == true ? 1 : 0;
}
dbtype = OdbcType.Int;
break;
case OdbcType.Char:
case OdbcType.NChar:
case OdbcType.VarChar:
case OdbcType.NVarChar:
case OdbcType.Text:
case OdbcType.NText:
value = string.Concat(value);
break;
}
var ret = new OdbcParameter {
ParameterName = $":{name}"
};
if (dbtype != null)
{
ret.OdbcType = dbtype.Value;
}
ret.Value = value;
return(ret);
});
// <Snippet1>
public void CreateMyProc(OdbcConnection connection)
{
OdbcCommand command = connection.CreateCommand();
command.CommandText = "{ call MyProc(?,?,?) }";
OdbcParameter param = new OdbcParameter();
param.DbType = DbType.Int32;
param.Value = 1;
command.Parameters.Add(param);
param = new OdbcParameter();
param.DbType = DbType.Decimal;
param.Value = 1;
command.Parameters.Add(param);
param = new OdbcParameter();
param.DbType = DbType.Decimal;
param.Value = 1;
command.Parameters.Add(param);
command.ExecuteNonQuery();
}
private int FillFilmsTable(OdbcCommand command, string title, DateTime releaseDate, int langageId)
{
command.CommandText = "{? = call AddFilm(?, ?, ?)}";
OdbcParameter filmId = command.Parameters.AddWithValue("@return_value", OdbcType.Int);
filmId.Direction = ParameterDirection.ReturnValue;
OdbcParameter titleParameter = command.Parameters.Add("@title", OdbcType.NVarChar, 100);
titleParameter.Value = title;
OdbcParameter releaseDateParameter = command.Parameters.Add("@releaseDate", OdbcType.DateTime);
releaseDateParameter.Value = releaseDate.ToString();
OdbcParameter languageParameter = command.Parameters.Add("@languageId", OdbcType.Int);
languageParameter.Value = langageId;
command.ExecuteNonQuery();
return((int)filmId.Value);
}
public void OdbcTypeTest()
{
OdbcParameter param = new OdbcParameter();
Assert.AreEqual(OdbcType.NVarChar, param.OdbcType, "#1");
// change test
param.OdbcType = OdbcType.Int;
Assert.AreEqual(OdbcType.Int, param.OdbcType, "#2");
param = new OdbcParameter("test", 10);
Assert.AreEqual(OdbcType.NVarChar, param.OdbcType, "#3");
param.OdbcType = OdbcType.Real;
Assert.AreEqual(OdbcType.Real, param.OdbcType, "#4");
Assert.AreEqual(10, param.Value, "#5");
param = new OdbcParameter("test", OdbcType.NText);
Assert.AreEqual(null, param.Value, "#6");
Assert.AreEqual(OdbcType.NText, param.OdbcType, "#7");
param = new OdbcParameter("test", OdbcType.Binary);
Assert.AreEqual(null, param.Value, "#8");
Assert.AreEqual(OdbcType.Binary, param.OdbcType, "#9");
}
public void Unsuspense()
{
// The equivalent try/catch block that is used for Suspense() was removed 27 Jan 2015 in order to fix
// the issue in Mantis #3730
OdbcParameter[] ParametersArray;
ParametersArray = new OdbcParameter[2];
ParametersArray[0] = new OdbcParameter("", OdbcType.Int);
ParametersArray[0].Value = ledgerNumber;
ParametersArray[1] = new OdbcParameter("", OdbcType.VarChar);
ParametersArray[1].Value = strAcount;
TDBTransaction transaction = null;
bool SubmissionOK = true;
DBAccess.GDBAccessObj.BeginAutoTransaction(ref transaction, ref SubmissionOK,
delegate
{
string strSQL = "DELETE FROM PUB_" + ASuspenseAccountTable.GetTableDBName() + " ";
strSQL += "WHERE " + ASuspenseAccountTable.GetLedgerNumberDBName() + " = ? ";
strSQL += "AND " + ASuspenseAccountTable.GetSuspenseAccountCodeDBName() + " = ? ";
DBAccess.GDBAccessObj.ExecuteNonQuery(strSQL, transaction, ParametersArray);
});
}
private void UnloadTestData_GetBatchInfo()
{
OdbcParameter[] ParametersArray;
ParametersArray = new OdbcParameter[2];
ParametersArray[0] = new OdbcParameter("", OdbcType.Int);
ParametersArray[0].Value = FLedgerNumber;
ParametersArray[1] = new OdbcParameter("", OdbcType.VarChar);
ParametersArray[1].Value = strTestDataBatchDescription;
TDBTransaction transaction = new TDBTransaction();
TDataBase db = DBAccess.Connect("UnloadTestData_GetBatchInfo");
bool SubmissionOK = true;
db.WriteTransaction(ref transaction, ref SubmissionOK,
delegate
{
string strSQL = "DELETE FROM PUB_" + ABatchTable.GetTableDBName() + " ";
strSQL += "WHERE " + ABatchTable.GetLedgerNumberDBName() + " = ? " +
"AND " + ABatchTable.GetBatchDescriptionDBName() + " = ? ";
db.ExecuteNonQuery(
strSQL, transaction, ParametersArray);
});
db.CloseDBConnection();
}
public void Unsuspense()
{
try
{
OdbcParameter[] ParametersArray;
ParametersArray = new OdbcParameter[2];
ParametersArray[0] = new OdbcParameter("", OdbcType.Int);
ParametersArray[0].Value = ledgerNumber;
ParametersArray[1] = new OdbcParameter("", OdbcType.VarChar);
ParametersArray[1].Value = strAcount;
TDBTransaction transaction = DBAccess.GDBAccessObj.BeginTransaction();
string strSQL = "DELETE FROM PUB_" + ASuspenseAccountTable.GetTableDBName() + " ";
strSQL += "WHERE " + ASuspenseAccountTable.GetLedgerNumberDBName() + " = ? ";
strSQL += "AND " + ASuspenseAccountTable.GetSuspenseAccountCodeDBName() + " = ? ";
DBAccess.GDBAccessObj.ExecuteNonQuery(strSQL, transaction, ParametersArray);
DBAccess.GDBAccessObj.CommitTransaction();
}
catch (Exception)
{
Assert.Fail("No database access to run the test");
}
}
/// <summary>
/// Returns this instance as a OleDbParameter.
/// </summary>
/// <returns></returns>
protected internal OdbcParameter getOdbcParameter()
{
OdbcParameter res = new OdbcParameter();
res.DbType = DbType;
res.Direction = Direction;
res.IsNullable = IsNullable;
res.ParameterName = ParameterName;
res.SourceColumn = SourceColumn;
res.SourceVersion = SourceVersion;
res.SourceColumnNullMapping = SourceColumnNullMapping;
res.Value = Value;
return res;
}
