public void ExecuteSqlTran(Hashtable SQLStringList)
{
using (AseConnection connection = new AseConnection(this.connectionString))
{
connection.Open();
using (AseTransaction transaction = connection.BeginTransaction())
{
AseCommand cmd = new AseCommand();
try
{
foreach (DictionaryEntry entry in SQLStringList)
{
string cmdText = entry.Key.ToString();
AseParameter[] cmdParms = (AseParameter[])entry.Value;
this.PrepareCommand(cmd, connection, transaction, cmdText, cmdParms);
cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
transaction.Commit();
}
}
catch
{
transaction.Rollback();
throw;
}
}
}
}
public Task <int> ExecuteNonQueryTaskRunnable(AseCommand command, AseTransaction transaction)
{
var rowsAffectedSource = new TaskCompletionSource <int>();
InternalExecuteNonQueryAsync(command, transaction, rowsAffectedSource);
return(rowsAffectedSource.Task);
}
public object ExecuteScalar(AseCommand command, AseTransaction transaction)
{
using (var reader = (IDataReader)ExecuteReader(CommandBehavior.SingleRow, command, transaction))
{
if (reader.Read())
{
return(reader[0]);
}
}
return(null);
}
public void ConstructTransaction_WithArgs_SetsProperties()
{
// Arrange
var connection = new AseConnection();
var isolationLevel = IsolationLevel.Serializable;
// Act
var transaction = new AseTransaction(connection, isolationLevel);
// Assert
Assert.AreEqual(connection, transaction.Connection);
Assert.AreEqual(isolationLevel, transaction.IsolationLevel);
}
public int ExecuteNonQuery(AseCommand command, AseTransaction transaction)
{
try
{
var execTask = ExecuteNonQueryTaskRunnable(command, transaction);
execTask.Wait();
return(execTask.Result);
}
catch (AggregateException ae)
{
ExceptionDispatchInfo.Capture(ae.InnerException ?? ae).Throw();
throw;
}
}
public void RepeatedDisposal_DoesNotThrow()
{
// Arrange
var mockConnection = new Mock <IDbConnection>();
var isolationLevel = IsolationLevel.Serializable;
var mockCommandIsolationLevel = new Mock <IDbCommand>();
var mockCommandBeginTransaction = new Mock <IDbCommand>();
var mockCommandRollbackTransaction = new Mock <IDbCommand>();
mockCommandIsolationLevel
.SetupAllProperties()
.Setup(x => x.ExecuteNonQuery())
.Returns(0);
mockCommandBeginTransaction
.SetupAllProperties()
.Setup(x => x.ExecuteNonQuery())
.Returns(0);
mockCommandRollbackTransaction
.SetupAllProperties()
.Setup(x => x.ExecuteNonQuery())
.Returns(0);
mockConnection
.Setup(x => x.BeginTransaction(isolationLevel))
.Returns(() =>
{
// Simulate what AseConnection.BeginTransaction() does.
var t = new AseTransaction(mockConnection.Object, isolationLevel);
t.Begin();
return(t);
});
mockConnection
.SetupSequence(x => x.CreateCommand())
.Returns(mockCommandIsolationLevel.Object)
.Returns(mockCommandBeginTransaction.Object)
.Returns(mockCommandRollbackTransaction.Object);
// Act
var connection = mockConnection.Object;
var transaction = connection.BeginTransaction(isolationLevel);
transaction.Dispose(); // Implicit rollback
transaction.Dispose(); // Should do nothing
}
private void InternalExecuteQueryAsync(AseCommand command, AseTransaction transaction, TaskCompletionSource <DbDataReader> readerSource, CommandBehavior behavior)
{
AssertExecutionStart();
try
{
SendPacket(new NormalPacket(BuildCommandTokens(command, behavior)));
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
var doneHandler = new DoneTokenHandler();
var messageHandler = new MessageTokenHandler(EventNotifier);
var dataReaderHandler = new DataReaderTokenHandler();
var responseParameterTokenHandler = new ResponseParameterTokenHandler(command.AseParameters);
ReceiveTokens(
envChangeTokenHandler,
doneHandler,
messageHandler,
dataReaderHandler,
responseParameterTokenHandler);
AssertExecutionCompletion(doneHandler);
if (transaction != null && doneHandler.TransactionState == TranState.TDS_TRAN_ABORT)
{
transaction.MarkAborted();
}
messageHandler.AssertNoErrors();
if (doneHandler.Canceled)
{
readerSource.TrySetCanceled(); // If we have already begun returning data, then this will get lost.
}
else
{
#if ENABLE_SYSTEM_DATA_COMMON_EXTENSIONS
readerSource.TrySetResult(new AseDataReader(dataReaderHandler.Results(), command, behavior));
#else
readerSource.TrySetResult(new AseDataReader(dataReaderHandler.Results(), behavior));
#endif
}
}
catch (Exception ex)
{
readerSource.TrySetException(ex); // If we have already begun returning data, then this will get lost.
}
}
private void InternalExecuteNonQueryAsync(AseCommand command, AseTransaction transaction, TaskCompletionSource <int> rowsAffectedSource)
{
AssertExecutionStart();
try
{
SendPacket(new NormalPacket(BuildCommandTokens(command, CommandBehavior.Default)));
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
var messageHandler = new MessageTokenHandler(EventNotifier);
var responseParameterTokenHandler = new ResponseParameterTokenHandler(command.AseParameters);
var doneHandler = new DoneTokenHandler();
ReceiveTokens(
envChangeTokenHandler,
messageHandler,
responseParameterTokenHandler,
doneHandler);
AssertExecutionCompletion(doneHandler);
if (transaction != null && doneHandler.TransactionState == TranState.TDS_TRAN_ABORT)
{
transaction.MarkAborted();
}
messageHandler.AssertNoErrors();
if (doneHandler.Canceled)
{
rowsAffectedSource.TrySetCanceled();
}
else
{
rowsAffectedSource.TrySetResult(doneHandler.RowsAffected);
}
}
catch (Exception ex)
{
if (!rowsAffectedSource.TrySetException(ex))
{
throw;
}
}
}
private void InternalExecuteAsync(AseCommand command, AseTransaction transaction, TaskCompletionSource <int> rowsAffectedSource = null, TaskCompletionSource <DbDataReader> readerSource = null, CommandBehavior behavior = CommandBehavior.Default)
{
AssertExecutionStart();
try
{
SendPacket(new NormalPacket(BuildCommandTokens(command, behavior)));
var doneHandler = new DoneTokenHandler();
var messageHandler = new MessageTokenHandler(EventNotifier);
var dataReaderHandler = readerSource != null ? new DataReaderTokenHandler() : null;
ReceiveTokens(
new EnvChangeTokenHandler(_environment),
messageHandler,
dataReaderHandler,
new ResponseParameterTokenHandler(command.AseParameters),
doneHandler);
AssertExecutionCompletion(doneHandler);
if (transaction != null && doneHandler.TransactionState == TranState.TDS_TRAN_ABORT)
{
transaction.MarkAborted();
}
messageHandler.AssertNoErrors();
if (doneHandler.Canceled)
{
rowsAffectedSource?.SetCanceled();
readerSource?.SetCanceled();
}
else
{
rowsAffectedSource?.SetResult(doneHandler.RowsAffected);
readerSource?.SetResult(new AseDataReader(dataReaderHandler.Results(), command, behavior));
}
}
catch (Exception ex)
{
rowsAffectedSource?.SetException(ex);
readerSource?.SetException(ex);
}
}
private void PrepareCommand(AseCommand cmd, AseConnection conn, AseTransaction trans, string cmdText, AseParameter[] cmdParms)
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
cmd.Connection = conn;
cmd.CommandText = cmdText;
if (trans != null)
{
cmd.Transaction = trans;
}
cmd.CommandType = CommandType.Text;
if (cmdParms != null)
{
foreach (AseParameter parameter in cmdParms)
{
cmd.Parameters.Add(parameter);
}
}
}
public DbDataReader ExecuteReader(CommandBehavior behavior, AseCommand command, AseTransaction transaction)
{
return(null);
}
private void InternalExecuteQueryAsync(AseCommand command, AseTransaction transaction, TaskCompletionSource <DbDataReader> readerSource, CommandBehavior behavior)
{
AssertExecutionStart();
#if ENABLE_SYSTEM_DATA_COMMON_EXTENSIONS
var dataReader = new AseDataReader(command, behavior, EventNotifier);
#else
var dataReader = new AseDataReader(behavior, EventNotifier);
#endif
try
{
SendPacket(new NormalPacket(BuildCommandTokens(command, behavior)));
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
var doneHandler = new DoneTokenHandler();
var dataReaderHandler = new StreamingDataReaderTokenHandler(readerSource, dataReader, EventNotifier);
var responseParameterTokenHandler = new ResponseParameterTokenHandler(command.AseParameters);
Logger.Instance?.WriteLine();
Logger.Instance?.WriteLine("---------- Receive Tokens ----------");
try
{
#if ENABLE_ARRAY_POOL
using (var tokenStream = new TokenReceiveStream(_networkStream, _environment, _arrayPool))
#else
using (var tokenStream = new TokenReceiveStream(_networkStream, _environment))
#endif
{
foreach (var receivedToken in _reader.Read(tokenStream, _environment))
{
if (envChangeTokenHandler.CanHandle(receivedToken.Type))
{
envChangeTokenHandler.Handle(receivedToken);
}
if (doneHandler.CanHandle(receivedToken.Type))
{
doneHandler.Handle(receivedToken);
}
if (dataReaderHandler.CanHandle(receivedToken.Type))
{
dataReaderHandler.Handle(receivedToken);
}
if (responseParameterTokenHandler.CanHandle(receivedToken.Type))
{
responseParameterTokenHandler.Handle(receivedToken);
}
}
}
}
finally
{
LastActive = DateTime.UtcNow;
}
// This tells the data reader to stop waiting for more results.
dataReader.CompleteAdding();
AssertExecutionCompletion(doneHandler);
if (transaction != null && doneHandler.TransactionState == TranState.TDS_TRAN_ABORT)
{
transaction.MarkAborted();
}
dataReaderHandler.AssertNoErrors();
if (doneHandler.Canceled)
{
readerSource.TrySetCanceled(); // If we have already begun returning data, then this will get lost.
}
else
{
readerSource.TrySetResult(dataReader); // Catchall - covers cases where no data is returned by the server.
}
}
catch (Exception ex)
{
// If we have already begun returning data, then this will get lost.
if (!readerSource.TrySetException(ex))
{
throw;
}
}
}
public void ExplicitRollback_WithValidTransaction_InteractsWithTheDbCommandCorrectly()
{
// Arrange
var mockConnection = new Mock <IDbConnection>();
var isolationLevel = IsolationLevel.Serializable;
var mockCommandIsolationLevel = new Mock <IDbCommand>();
var mockCommandBeginTransaction = new Mock <IDbCommand>();
var mockCommandRollbackTransaction = new Mock <IDbCommand>();
mockCommandIsolationLevel
.SetupAllProperties()
.Setup(x => x.ExecuteNonQuery())
.Returns(0);
mockCommandBeginTransaction
.SetupAllProperties()
.Setup(x => x.ExecuteNonQuery())
.Returns(0);
mockCommandRollbackTransaction
.SetupAllProperties()
.Setup(x => x.ExecuteNonQuery())
.Returns(0);
mockConnection
.Setup(x => x.BeginTransaction(isolationLevel))
.Returns(() =>
{
// Simulate what AseConnection.BeginTransaction() does.
var t = new AseTransaction(mockConnection.Object, isolationLevel);
t.Begin();
return(t);
});
mockConnection
.SetupSequence(x => x.CreateCommand())
.Returns(mockCommandIsolationLevel.Object)
.Returns(mockCommandBeginTransaction.Object)
.Returns(mockCommandRollbackTransaction.Object);
// Act
var connection = mockConnection.Object;
var transaction = connection.BeginTransaction(isolationLevel);
transaction.Rollback(); // Explicit rollback
transaction.Dispose();
// Assert
mockCommandIsolationLevel.VerifySet(x => { x.CommandText = "SET TRANSACTION ISOLATION LEVEL 3"; });
mockCommandIsolationLevel.VerifySet(x => { x.CommandType = CommandType.Text; });
mockCommandIsolationLevel.Verify();
mockCommandBeginTransaction.VerifySet(x => { x.CommandText = "BEGIN TRANSACTION"; });
mockCommandBeginTransaction.VerifySet(x => { x.CommandType = CommandType.Text; });
mockCommandBeginTransaction.VerifySet(x => { x.Transaction = transaction; });
mockCommandBeginTransaction.Verify();
mockCommandRollbackTransaction.VerifySet(x => { x.CommandText = "ROLLBACK TRANSACTION"; });
mockCommandRollbackTransaction.VerifySet(x => { x.CommandType = CommandType.Text; });
mockCommandRollbackTransaction.VerifySet(x => { x.Transaction = transaction; });
mockCommandRollbackTransaction.Verify();
}
static int Main(string[] args)
{
int
Result = -1,
tmpInt;
decimal
tmpDecimal;
object
tmpObject;
StreamWriter
fstr_out = null;
string
tmpString,
OutputFileName = "log.log";
#if WITH_TRACE
string
TraceFileName = "trace.log";
#endif
AseConnection
conn = null;
AseCommand
cmd = null;
AseTransaction
Transaction = null;
AseDataReader
reader = null;
AseParameter
Parameter = null;
AseDataAdapter
da = null;
DataTable
tmpDataTable = null;
try
{
try
{
fstr_out = new StreamWriter(OutputFileName, false, System.Text.Encoding.GetEncoding(1251));
fstr_out.AutoFlush = true;
#if WITH_REFLECTION
Assembly[]
asms = AppDomain.CurrentDomain.GetAssemblies();
Assembly
asm = null;
foreach (Assembly a in asms)
{
if (a.FullName.ToLower().IndexOf("sybase.data.aseclient") > -1)
{
asm = a;
}
fstr_out.WriteLine("Assembly.CodeBase: " + a.CodeBase);
fstr_out.WriteLine("Assembly.EscapedCodeBase: " + a.EscapedCodeBase);
fstr_out.WriteLine("Assembly.FullName: " + a.FullName);
fstr_out.WriteLine("Assembly.GlobalAssemblyCache: " + a.GlobalAssemblyCache.ToString().ToLower());
fstr_out.WriteLine("Assembly.ImageRuntimeVersion: " + a.ImageRuntimeVersion);
fstr_out.WriteLine("Assembly.Location: " + a.Location);
fstr_out.WriteLine();
}
if (asm != null)
{
Type[]
alltypes = asm.GetTypes();
for (tmpInt = 0; tmpInt < alltypes.Length; ++tmpInt)
{
fstr_out.WriteLine("Обнаружено: " + alltypes[tmpInt].Name);
if (alltypes[tmpInt].Name.CompareTo("AseConnection") == 0)
{
Type
t = alltypes[tmpInt];
FieldInfo[]
fi = t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
fstr_out.WriteLine("Анализ Field, определенных в " + t.Name);
foreach (FieldInfo f in fi)
{
fstr_out.Write(" " + f.Name);
fstr_out.WriteLine();
}
fstr_out.WriteLine();
PropertyInfo[]
//pi_=t.GetProperties(BindingFlags.Instance|BindingFlags.NonPublic|BindingFlags.Static); // AseConnection.Language
pi_ = t.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
fstr_out.WriteLine("Анализ Property, определенных в " + t.Name);
foreach (PropertyInfo p_ in pi_)
{
fstr_out.Write(" " + p_.Name);
fstr_out.WriteLine();
}
fstr_out.WriteLine();
fstr_out.WriteLine("Поддерживаемые методы:");
ParameterInfo[]
pi;
MethodInfo[]
mi;
//mi=t.GetMethods();
mi = t.GetMethods(BindingFlags.DeclaredOnly
| BindingFlags.Instance
| BindingFlags.Public);
foreach (MethodInfo m in mi)
{
fstr_out.Write(" " + m.ReturnType.Name + " " + m.Name + "(");
pi = m.GetParameters();
for (int i = 0; i < pi.Length; ++i)
{
fstr_out.Write(pi[i].ParameterType.Name + " " + pi[i].Name);
if (i + 1 < pi.Length)
{
fstr_out.Write(", ");
}
}
fstr_out.WriteLine(")");
}
fstr_out.WriteLine();
}
}
fstr_out.WriteLine();
}
#endif
#if WITH_TRACE
_strmWriter = new StreamWriter(TraceFileName, false, System.Text.Encoding.GetEncoding(1251));
_strmWriter.AutoFlush = true;
#endif
if ((tmpString = ConfigurationSettings.AppSettings["connectionString"]) == null ||
tmpString == string.Empty)
{
fstr_out.WriteLine("ConfigurationSettings.AppSettings[\"connectionString\"] is empty!!!");
return(Result);
}
conn = new AseConnection(tmpString);
conn.InfoMessage += new AseInfoMessageEventHandler(conn_InfoMessage);
conn.StateChange += new System.Data.StateChangeEventHandler(conn_StateChange);
#if WITH_TRACE
conn.TraceEnter += new TraceEnterEventHandler(conn_TraceEnter);
conn.TraceExit += new TraceExitEventHandler(conn_TraceExit);
#endif
conn.Open();
fstr_out.WriteLine("AseConnection.ConnectionString: " + conn.ConnectionString);
fstr_out.WriteLine("AseConnection.ConnectionTimeout: " + conn.ConnectionTimeout);
fstr_out.WriteLine("AseConnection.Database: " + conn.Database);
fstr_out.WriteLine("AseConnection.NamedParameters: " + conn.NamedParameters.ToString().ToLower());
fstr_out.WriteLine("AseConnection.State: " + conn.State);
fstr_out.WriteLine("AseConnection.DriverVersion: " + AseConnection.DriverVersion);
//fstr_out.WriteLine("AseConnection.Language: "+AseConnection.Language);
fstr_out.WriteLine();
cmd = conn.CreateCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = "select @@spid";
if ((tmpObject = cmd.ExecuteScalar()) != null)
{
tmpString = Convert.ToString(tmpObject);
}
#if TEST_CHARSET
cmd.CommandText = "select cast(val as date) from T4 where GroupId=4 and Id=1";
if (da == null)
{
da = new AseDataAdapter(cmd);
}
else
{
da.SelectCommand = cmd;
}
if (tmpDataTable == null)
{
tmpDataTable = new DataTable();
}
else
{
tmpDataTable.Reset();
}
da.Fill(tmpDataTable);
#endif
#if TEST_EXECUTE_NON_QUERY
if (cmd == null)
{
cmd = conn.CreateCommand();
}
cmd.NamedParameters = false;
cmd.CommandType = CommandType.Text;
cmd.Parameters.Clear();
cmd.CommandText = "update Victim set Val = ? where Id = ?";
cmd.Parameters.Add("Val", AseDbType.Integer);
cmd.Parameters.Add("Id", AseDbType.Integer);
for (int Id = 1; Id <= 5; Id += 2)
{
cmd.Parameters["Val"].Value = Id;
cmd.Parameters["Id"].Value = Id;
tmpInt = cmd.ExecuteNonQuery();
}
cmd.NamedParameters = true;
#endif
#if TEST_BLOB
if (cmd == null)
{
cmd = conn.CreateCommand();
}
cmd.CommandType = CommandType.Text;
FileStream
fs;
byte[]
Blob;
#if TEST_BLOB_SAVE
tmpString = "@FImage";
cmd.CommandText = "update TestTypes set FImage = " + tmpString;
cmd.Parameters.Clear();
cmd.Parameters.Add(tmpString, AseDbType.Image);
fs = new FileStream("welcome.bmp", FileMode.Open, FileAccess.Read);
Blob = new byte[fs.Length];
fs.Read(Blob, 0, Blob.Length);
cmd.Parameters[tmpString].Value = Blob;
tmpInt = cmd.ExecuteNonQuery();
#endif
cmd.Parameters.Clear();
cmd.CommandText = "select * from TestTypes";
reader = cmd.ExecuteReader();
do
{
if (reader.HasRows)
{
for (int i = 0; i < reader.FieldCount; ++i)
{
fstr_out.WriteLine(reader.GetName(i) + " GetDataTypeName(): \"" + reader.GetDataTypeName(i) + "\" GetFieldType(): \"" + reader.GetFieldType(i) + "\"");
}
tmpInt = reader.GetOrdinal("FImage");
while (reader.Read())
{
tmpString = "FromBlob.bmp";
if (File.Exists(tmpString))
{
File.Delete(tmpString);
}
Blob = (byte[])reader["FImage"];
fs = new FileStream(tmpString, FileMode.Create);
fs.Write(Blob, 0, Blob.Length);
fs.Close();
tmpString = "FromBlob_1.bmp";
if (File.Exists(tmpString))
{
File.Delete(tmpString);
}
Blob = new byte[reader.GetBytes(tmpInt, 0, null, 0, int.MaxValue)];
reader.GetBytes(tmpInt, 0, Blob, 0, Blob.Length);
fs = new FileStream(tmpString, FileMode.Create);
fs.Write(Blob, 0, Blob.Length);
fs.Close();
}
}
}while(reader.NextResult());
reader.Close();
#endif
#if TEST_SMTH
if (cmd == null)
{
cmd = conn.CreateCommand();
}
cmd.CommandType = CommandType.Text;
cmd.CommandText = "select * from TestDate order by FDate";
cmd.Parameters.Clear();
if (da == null)
{
da = new AseDataAdapter(cmd);
}
else
{
da.SelectCommand = cmd;
}
if (tmpDataTable != null)
{
tmpDataTable.Reset();
}
else
{
tmpDataTable = new DataTable();
}
da.Fill(tmpDataTable);
tmpString = "";
for (int i = 0; i < tmpDataTable.Rows.Count; ++i)
{
if (tmpString != string.Empty)
{
tmpString += " ";
}
tmpString += Convert.ToDateTime(tmpDataTable.Rows[i]["FDate"]).ToString("yyyy-MM-dd");
}
cmd.NamedParameters = false;
cmd.CommandText = "update TestTypes set FDatetime = ?";
cmd.Parameters.Clear();
cmd.Parameters.Add("FDate", AseDbType.DateTime).Value = DateTime.Now;
tmpInt = cmd.ExecuteNonQuery();
cmd.NamedParameters = true;
cmd.CommandText = "update TestTypes set FDatetime = @FDatetime";
cmd.Parameters.Clear();
cmd.Parameters.Add("@FDatetime", AseDbType.DateTime).Value = DateTime.Now;
tmpInt = cmd.ExecuteNonQuery();
#endif
#if TEST_DATA_ADAPTER_FILL_SCHEMA
if (cmd == null)
{
cmd = conn.CreateCommand();
}
cmd.CommandType = CommandType.Text;
cmd.CommandText = "select * from Staff";
if (da == null)
{
da = new AseDataAdapter(cmd);
}
else
{
da.SelectCommand = cmd;
}
if (tmpDataTable != null)
{
tmpDataTable.Reset();
}
else
{
tmpDataTable = new DataTable();
}
da.FillSchema(tmpDataTable, SchemaType.Source);
#endif
#if TEST_STORED_PROCEDURES
if (cmd == null)
{
cmd = conn.CreateCommand();
}
object[]
tmpObjects = new object[] { 5, 6 };
cmd.CommandType = CommandType.StoredProcedure;
cmd.NamedParameters = false;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "mathtutor";
for (int i = 0; i < tmpObjects.Length; ++i)
{
Parameter = new AseParameter();
Parameter.ParameterName = "Param" + i;
switch (Type.GetTypeCode(tmpObjects[i].GetType()))
{
case System.TypeCode.Int32:
{
Parameter.DbType = DbType.Int32;
break;
}
}
Parameter.Value = tmpObjects[i];
cmd.Parameters.Add(Parameter);
}
Parameter = new AseParameter();
Parameter.ParameterName = "Param3";
Parameter.DbType = DbType.Int32;
Parameter.Direction = ParameterDirection.Output;
cmd.Parameters.Add(Parameter);
cmd.ExecuteNonQuery();
tmpInt = !Convert.IsDBNull(cmd.Parameters["Param3"].Value) ? Convert.ToInt32(cmd.Parameters["Param3"].Value) : Int32.MinValue;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "sp_TestTypes_Decimal_10_6";
AseCommandBuilder.DeriveParameters(cmd);
cmd.Parameters["@FDecimal_10_6"].Value = 123.45m;
cmd.ExecuteNonQuery();
tmpDecimal = !Convert.IsDBNull(cmd.Parameters["@FDecimal_10_6_out"].Value) ? Convert.ToDecimal(cmd.Parameters["@FDecimal_10_6_out"].Value) : decimal.MinValue;
cmd.Parameters.Clear();
cmd.CommandType = CommandType.Text;
cmd.CommandText = "{? = call sp_TestTypes_Decimal_10_6(? ,?)}";
cmd.NamedParameters = false;
Parameter = new AseParameter("@RETURN_VALUE", AseDbType.Integer);
Parameter.Direction = ParameterDirection.ReturnValue;
cmd.Parameters.Add(Parameter);
Parameter = new AseParameter("@FDecimal_10_6", AseDbType.Decimal); //AseDbType.Numeric
//Parameter=new AseParameter();
//Parameter.ParameterName="@FDecimal_10_6";
//Parameter.DbType=DbType.Decimal;
//Parameter.AseDbType=AseDbType.Decimal; //AseDbType.Numeric
Parameter.Direction = ParameterDirection.Input;
//Parameter.Precision=10;
//Parameter.Scale=6;
Parameter.Value = 123.45m;
cmd.Parameters.Add(Parameter);
Parameter = new AseParameter("@FDecimal_10_6_out", AseDbType.Decimal); //AseDbType.Numeric
Parameter.Direction = ParameterDirection.Output;
Parameter.Precision = 10;
Parameter.Scale = 6;
cmd.Parameters.Add(Parameter);
cmd.ExecuteNonQuery();
tmpDecimal = !Convert.IsDBNull(cmd.Parameters["@FDecimal_10_6_out"].Value) ? Convert.ToDecimal(cmd.Parameters["@FDecimal_10_6_out"].Value) : decimal.MinValue;
tmpDecimal = 2;
if (cmd == null)
{
cmd = conn.CreateCommand();
}
cmd.Parameters.Clear();
cmd.CommandType = CommandType.Text;
cmd.CommandText = "{call UpdateTestTypes(?)}";
cmd.NamedParameters = false;
Parameter = new AseParameter("@rate", AseDbType.Decimal);
Parameter.Direction = ParameterDirection.Input;
Parameter.Value = tmpDecimal;
cmd.Parameters.Add(Parameter);
/*
* if(cmd==null)
* cmd=conn.CreateCommand();
*
* cmd.CommandType=CommandType.StoredProcedure;
* cmd.CommandText="UpdateTestTypes";
* AseCommandBuilder.DeriveParameters(cmd);
* cmd.Parameters["@Decimal_18_4"].Value=tmpDecimal;
*/
tmpInt = cmd.ExecuteNonQuery();
cmd.CommandType = CommandType.StoredProcedure;
for (int size = 255; size <= 258; ++size)
{
cmd.CommandText = "sp_ReturnAndOutputVarChar" + size;
AseCommandBuilder.DeriveParameters(cmd);
cmd.ExecuteNonQuery();
tmpString = !Convert.IsDBNull(cmd.Parameters["@OutParam"].Value) ? Convert.ToString(cmd.Parameters["@OutParam"].Value) : "NULL";
}
conn.ChangeDatabase("master");
cmd.CommandText = "testdb..sp_ReturnAndOutput";
AseCommandBuilder.DeriveParameters(cmd);
conn.ChangeDatabase("testdb");
#endif
Transaction = conn.BeginTransaction(IsolationLevel.ReadCommitted);
if (cmd == null)
{
cmd = conn.CreateCommand();
}
cmd.Transaction = Transaction;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "sp_Staff_Save";
//cmd.CommandText="sp_TestTypes";
fstr_out.WriteLine("AseCommandBuilder.DeriveParameters(\"" + cmd.CommandText + "\")");
AseCommandBuilder.DeriveParameters(cmd);
foreach (AseParameter parameter in cmd.Parameters)
{
fstr_out.WriteLine("\tParameterIndex: " + parameter.ParameterIndex + Environment.NewLine +
"\tParameterName: " + parameter.ParameterName + Environment.NewLine +
"\tDirection: " + parameter.Direction + Environment.NewLine +
"\tDbType: " + parameter.DbType + Environment.NewLine +
"\tAseDbType: " + parameter.AseDbType + Environment.NewLine +
"\tSize: " + parameter.Size + Environment.NewLine +
"\tPrecision: " + parameter.Precision + Environment.NewLine +
"\tScale: " + parameter.Scale + Environment.NewLine +
"\tIsNullable: " + parameter.IsNullable.ToString().ToLower() + Environment.NewLine +
"\tSourceColumn: " + parameter.SourceColumn + Environment.NewLine +
"\tSourceVersion: " + parameter.SourceVersion + Environment.NewLine);
}
fstr_out.WriteLine();
conn.ChangeDatabase("veksel");
cmd.CommandText = "sp_CONTRACT_SAVE";
fstr_out.WriteLine("AseCommandBuilder.DeriveParameters(\"" + cmd.CommandText + "\")");
AseCommandBuilder.DeriveParameters(cmd);
foreach (AseParameter parameter in cmd.Parameters)
{
fstr_out.WriteLine("\tParameterIndex: " + parameter.ParameterIndex + Environment.NewLine +
"\tParameterName: " + parameter.ParameterName + Environment.NewLine +
"\tDirection: " + parameter.Direction + Environment.NewLine +
"\tDbType: " + parameter.DbType + Environment.NewLine +
"\tAseDbType: " + parameter.AseDbType + Environment.NewLine +
"\tSize: " + parameter.Size + Environment.NewLine +
"\tPrecision: " + parameter.Precision + Environment.NewLine +
"\tScale: " + parameter.Scale + Environment.NewLine +
"\tIsNullable: " + parameter.IsNullable.ToString().ToLower() + Environment.NewLine +
"\tSourceColumn: " + parameter.SourceColumn + Environment.NewLine +
"\tSourceVersion: " + parameter.SourceVersion + Environment.NewLine);
}
fstr_out.WriteLine();
Transaction.Rollback();
Transaction = null;
Result = 0;
}
catch (AseException eException)
{
Console.WriteLine(eException.GetType().FullName + Environment.NewLine +
"Errors:" + Environment.NewLine + ErrorsToString(eException.Errors) + Environment.NewLine +
"Message: " + eException.Message + Environment.NewLine +
"Source: " + eException.Source + Environment.NewLine +
"StackTrace:" + Environment.NewLine + eException.StackTrace + Environment.NewLine +
"TargetSite: " + eException.TargetSite + Environment.NewLine);
}
catch (Exception eException)
{
Console.WriteLine(eException.GetType().FullName + Environment.NewLine +
"Message: " + eException.Message + Environment.NewLine +
"Source: " + eException.Source + Environment.NewLine +
"StackTrace:" + Environment.NewLine + eException.StackTrace + Environment.NewLine +
"TargetSite: " + eException.TargetSite + Environment.NewLine +
"InnerException:" + Environment.NewLine + eException.InnerException.GetType().FullName + Environment.NewLine +
"InnerException.Message: " + eException.InnerException.Message + Environment.NewLine +
"InnerException.Source: " + eException.InnerException.Source + Environment.NewLine +
"InnerException.StackTrace:" + Environment.NewLine + eException.InnerException.StackTrace + Environment.NewLine +
"InnerException.TargetSite: " + eException.InnerException.TargetSite);
}
}
finally
{
if (Transaction != null)
{
try
{
Transaction.Rollback();
}
catch
{
;
}
}
if (reader != null && !reader.IsClosed)
{
reader.Close();
}
if (cmd != null)
{
cmd.Dispose();
}
if (conn != null && conn.State == System.Data.ConnectionState.Open)
{
conn.Close();
}
if (fstr_out != null)
{
fstr_out.Close();
}
#if WITH_TRACE
if (_strmWriter != null)
{
_strmWriter.Close();
}
#endif
}
return(Result);
}
public Task <DbDataReader> ExecuteReaderTaskRunnable(CommandBehavior behavior, AseCommand command, AseTransaction transaction)
{
var readerSource = new TaskCompletionSource <DbDataReader>();
InternalExecuteQueryAsync(command, transaction, readerSource, behavior);
return(readerSource.Task);
}
public Task <int> ExecuteNonQueryTaskRunnable(AseCommand command, AseTransaction transaction)
{
return(Task.FromResult(0));
}
public int ExecuteNonQuery(AseCommand command, AseTransaction transaction)
{
return(0);
}
/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/// <summary> </summary>
/// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public int AddAndEnrichClaims(ClaimsSubmission req, string tableName, string httpContextUser)
{
int claimsInserted = 0;
TableName = tableName;
req.SetClaims(); // Build claim list from string input
SybaseConnString = HomeController.SybaseConnString;
using (var conn = new AseConnection(SybaseConnString))
{
AseTransaction trans = conn.BeginTransaction(); // START LOCKING TABLE HERE!!!
try
{
conn.Open();
AseCommand cmd;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// INSERT NEW CLAIM DELETIONS TO STAGING TABLES
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
foreach (var claim in req.ClaimList)
{
try
{
cmd = new AseCommand("SP_XC_CLAIM_REJECTION_INSERT", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add(new AseParameter("@TABLE_NAME", TableName));
cmd.Parameters.Add(new AseParameter("@CLCL_ID", claim.ClaimId));
cmd.Parameters.Add(new AseParameter("@CREATED_BY_USER", httpContextUser));
if (cmd.ExecuteNonQuery() > 0)
{
claimsInserted++;
}
else
{
req.InvalidClaimList.Add(claim.ClaimId);
}
}
catch (Exception e)
{
if (e.ToString().ToUpper().Contains("DUPLICATE KEY ROW"))
{
req.DupClaimList.Add(claim.ClaimId);
}
System.Console.WriteLine("**ERROR INSERTING CLAIMS** : {0}", e.ToString());
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// NOW ENRICH THE NEWLY INSERTED CLAIM DELETIONS
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if (TableName.ToUpper().Contains("NPI"))
{
cmd = new AseCommand("SP_XC_CLAIM_REJECTION_ENRICH_NPI", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.ExecuteNonQuery();
}
else if (TableName.ToUpper().Contains("NAME"))
{
cmd = new AseCommand("SP_XC_CLAIM_REJECTION_ENRICH_NAME", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.ExecuteNonQuery();
}
else if (TableName.ToUpper().Contains("TIN"))
{
cmd = new AseCommand("SP_XC_CLAIM_REJECTION_ENRICH_TIN", conn);
cmd.CommandType = CommandType.StoredProcedure;
cmd.ExecuteNonQuery();
}
trans.Commit(); // COMMIT THE TRANSACTION
}
catch (Exception e)
{
Console.WriteLine("*****************************************");
Console.WriteLine("INSERT ERROR!! --ROLLBACK TRANSACTION--");
Console.WriteLine("*****************************************");
Console.WriteLine(e.ToString());
trans.Rollback(); // **** Abort transaction ****
throw e;
}
}
return(claimsInserted);
}
private void InternalExecuteQueryAsync(AseCommand command, AseTransaction transaction, TaskCompletionSource <DbDataReader> readerSource, CommandBehavior behavior,
ReaderSourceType readerSourceType = ReaderSourceType.Standard)
{
AssertExecutionStart();
try
{
SendPacket(new NormalPacket(BuildCommandTokens(command, behavior)));
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
var doneHandler = new DoneTokenHandler();
var messageHandler = new MessageTokenHandler(EventNotifier);
// Only one of these two data readers will not be null
var dataReaderHandler = readerSourceType == ReaderSourceType.Standard ? new DataReaderTokenHandler() : null;
var dataReaderEventHandler = readerSourceType == ReaderSourceType.ForCallback ? new DataReaderCallbackTokenHandler(behavior, EventNotifier) : null;
var responseParameterTokenHandler = new ResponseParameterTokenHandler(command.AseParameters);
if (readerSourceType == ReaderSourceType.ForCallback)
{
ReceivePartialTokens(
envChangeTokenHandler,
doneHandler,
messageHandler,
dataReaderEventHandler,
responseParameterTokenHandler);
}
else
{
ReceiveTokens(
envChangeTokenHandler,
doneHandler,
messageHandler,
dataReaderHandler,
responseParameterTokenHandler);
}
AssertExecutionCompletion(doneHandler);
if (transaction != null && doneHandler.TransactionState == TranState.TDS_TRAN_ABORT)
{
transaction.MarkAborted();
}
messageHandler.AssertNoErrors();
if (doneHandler.Canceled)
{
readerSource.TrySetCanceled(); // If we have already begun returning data, then this will get lost.
}
else
{
if (dataReaderHandler != null)
#if ENABLE_SYSTEM_DATA_COMMON_EXTENSIONS
{ readerSource.TrySetResult(new AseDataReader(dataReaderHandler.Results(), command, behavior)); }
#else
{ readerSource.TrySetResult(new AseDataReader(dataReaderHandler.Results(), behavior)); }
#endif
else if (dataReaderEventHandler != null)
{
// Set this so that Task.Wait will stop waiting
readerSource.SetResult(null);
}
}
public DbDataReader ExecuteReader(CommandBehavior behavior, AseCommand command, AseTransaction transaction)
{
try
{
var readerTask = ExecuteReaderTaskRunnable(behavior, command, transaction);
readerTask.Wait();
return(readerTask.Result);
}
catch (AggregateException ae)
{
ExceptionDispatchInfo.Capture(ae.InnerException ?? ae).Throw();
throw;
}
}
public Task <DbDataReader> ExecuteReaderTaskRunnable(CommandBehavior behavior, AseCommand command, AseTransaction transaction)
{
return(Task.FromResult <DbDataReader>(null));
}
public object ExecuteScalar(AseCommand command, AseTransaction transaction)
{
return(null);
}
public void ExecuteCallbackReader(CommandBehavior behavior, AseCommand command, AseTransaction transaction,
ResultRowCallbackHandler resultRowHandler, ResultSetCallbackHandler resultSetHandler = null)
{
}
