public void ChangeDatabase(string databaseName)
{
if (string.IsNullOrWhiteSpace(databaseName) || string.Equals(databaseName, Database, StringComparison.OrdinalIgnoreCase))
{
return;
}
AssertExecutionStart();
//turns out, you can't issue an env change token to change the database, it responds saying it doesn't know how to process such a token
SendPacket(new NormalPacket(new LanguageToken
{
HasParameters = false,
CommandText = $"USE {databaseName}"
}));
var messageHandler = new MessageTokenHandler(EventNotifier);
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
ReceiveTokens(envChangeTokenHandler, messageHandler);
AssertExecutionCompletion();
messageHandler.AssertNoErrors();
}
public void SetTextSize(int textSize)
{
//todo: may need to remove this, user scripts could change the textsize value
if (_environment.TextSize == textSize)
{
return;
}
SendPacket(new NormalPacket(OptionCommandToken.CreateSetTextSize(textSize)));
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
var messageHandler = new MessageTokenHandler(EventNotifier);
var dataReaderHandler = new DataReaderTokenHandler();
var doneHandler = new DoneTokenHandler();
ReceiveTokens(
envChangeTokenHandler,
messageHandler,
dataReaderHandler,
doneHandler);
messageHandler.AssertNoErrors();
_environment.TextSize = textSize;
}
public void AssertHandlesTextSizeChange()
{
var environment = new DbEnvironment();
var handler = new EnvChangeTokenHandler(environment, string.Empty);
handler.Handle(OptionCommandToken.CreateSetTextSize(9999));
Assert.AreEqual(9999, environment.TextSize);
}
public void Login()
{
//socket is established already
//login
SendPacket(
new LoginPacket(
_parameters.ClientHostName,
_parameters.Username,
_parameters.Password,
_parameters.ProcessId,
_parameters.ApplicationName,
_parameters.Server,
"us_english",
_parameters.Charset,
"ADO.NET",
_environment.PacketSize,
new ClientCapabilityToken(_parameters.EnableServerPacketSize),
_parameters.EncryptPassword));
var ackHandler = new LoginTokenHandler();
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
var messageHandler = new MessageTokenHandler(EventNotifier);
ReceiveTokens(
ackHandler,
envChangeTokenHandler,
messageHandler);
messageHandler.AssertNoErrors();
if (!ackHandler.ReceivedAck)
{
IsDoomed = true;
throw new InvalidOperationException("No login ack found");
}
if (ackHandler.LoginStatus == LoginAckToken.LoginStatus.TDS_LOG_NEGOTIATE)
{
NegotiatePassword(ackHandler.Message.MessageId, ackHandler.Parameters.Parameters, _parameters.Password);
}
else if (ackHandler.LoginStatus != LoginAckToken.LoginStatus.TDS_LOG_SUCCEED)
{
throw new AseException("Login failed.\n", 4002); //just in case the server doesn't respond with an appropriate EED token
}
ServerVersion = ackHandler.Token.ProgramVersion;
Created = DateTime.UtcNow;
SetState(InternalConnectionState.Ready);
}
public void SetAnsiNull(bool enabled)
{
SendPacket(new NormalPacket(OptionCommandToken.CreateSetAnsiNull(enabled)));
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
var messageHandler = new MessageTokenHandler(EventNotifier);
var doneHandler = new DoneTokenHandler();
ReceiveTokens(
envChangeTokenHandler,
messageHandler,
doneHandler);
messageHandler.AssertNoErrors();
}
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;
}
}
}
public void AssertHandlesPacketSizeChange()
{
var environment = new DbEnvironment();
var handler = new EnvChangeTokenHandler(environment, string.Empty);
handler.Handle(new EnvironmentChangeToken()
{
Changes = new[]
{
new EnvironmentChangeToken.EnvironmentChange()
{
Type = EnvironmentChangeToken.ChangeType.TDS_ENV_PACKSIZE,
NewValue = "512"
}
}
});
Assert.AreEqual(512, environment.PacketSize);
}
public void AssertHandlesDbEnvChange()
{
var environment = new DbEnvironment();
var handler = new EnvChangeTokenHandler(environment, string.Empty);
handler.Handle(new EnvironmentChangeToken()
{
Changes = new[]
{
new EnvironmentChangeToken.EnvironmentChange()
{
Type = EnvironmentChangeToken.ChangeType.TDS_ENV_DB,
NewValue = "MyDB"
}
}
});
Assert.AreEqual("MyDB", environment.Database);
}
public void AssertUnknownCharset_EmitsAseException()
{
var environment = new DbEnvironment();
var handler = new EnvChangeTokenHandler(environment, string.Empty);
string unknownCharsetName = "UNKNOWN-CHARSET";
var exception = Assert.Throws <AseException>(() => handler.Handle(new EnvironmentChangeToken()
{
Changes = new[]
{
new EnvironmentChangeToken.EnvironmentChange()
{
Type = EnvironmentChangeToken.ChangeType.TDS_ENV_CHARSET,
NewValue = unknownCharsetName
}
}
}));
Assert.IsTrue(exception.Message.Contains(unknownCharsetName));
}
public void AssertHandlesCharsetChange(string tokenNewCharset, string clientRequestedCharset, string expectedEncodingName)
{
var environment = new DbEnvironment();
var handler = new EnvChangeTokenHandler(environment, clientRequestedCharset);
handler.Handle(new EnvironmentChangeToken()
{
Changes = new[]
{
new EnvironmentChangeToken.EnvironmentChange()
{
Type = EnvironmentChangeToken.ChangeType.TDS_ENV_CHARSET,
NewValue = tokenNewCharset
}
}
});
Encoding expectedEncoding = Encoding.GetEncoding(expectedEncodingName);
Assert.AreSame(expectedEncoding, environment.Encoding);
}
private void DoEncrypt3Scheme(ParametersToken.Parameter[] parameters, string password)
{
var encryptedPassword = Encryption.EncryptPassword3((int)parameters[0].Value, (byte[])parameters[1].Value, (byte[])parameters[2].Value, Encoding.ASCII.GetBytes(password));
SendPacket(new NormalPacket(Encryption.BuildEncrypt3Tokens(encryptedPassword)));
// 5. Expect an ack
var ackHandler = new LoginTokenHandler();
var envChangeTokenHandler = new EnvChangeTokenHandler(_environment, _parameters.Charset);
var messageHandler = new MessageTokenHandler(EventNotifier);
ReceiveTokens(
ackHandler,
envChangeTokenHandler,
messageHandler);
messageHandler.AssertNoErrors();
if (ackHandler.LoginStatus != LoginAckToken.LoginStatus.TDS_LOG_SUCCEED)
{
throw new AseException("Login failed.\n", 4002); //just in case the server doesn't respond with an appropriate EED token
}
}
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;
}
}
}
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);
}
}
