void IResultWriter.WriteRows(object[][] rows, int rowCount)
{
_logResultWriter.WriteRows(rows, rowCount);
_readRowCount += rowCount;
var message = $"{_readRowCount},{_insertedRowCount},{_readRowCount - _insertedRowCount} (rows read,inserted,queued).";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, message));
var targetRows = new object[rowCount][];
for (var rowIndex = 0; rowIndex < rowCount; rowIndex++)
{
var sourceRow = rows[rowIndex];
var columnCount = sourceRow.Length;
var targetRow = new object[columnCount];
Array.Copy(sourceRow, targetRow, columnCount);
targetRows[rowIndex] = targetRow;
}
var queueItem = new QueueItem
{
Rows = targetRows
};
_queue.Enqueue(queueItem);
_enqueueEvent.Set();
while (!_cancellationToken.IsCancellationRequested && _queue.Count > 5)
{
_waitMilliseconds += 500;
Log.Write(LogLevel.Trace, "this.waitMilliseconds: {0}", _waitMilliseconds);
_cancellationToken.WaitHandle.WaitOne(500);
}
}
void IResultWriter.WriteRows(object[][] rows, int rowCount)
{
_logResultWriter.WriteRows(rows, rowCount);
_readRowCount += rowCount;
var message = $"{_readRowCount} row(s) read.";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, message));
var targetRows = new object[rowCount][];
for (var rowIndex = 0; rowIndex < rowCount; rowIndex++)
{
var sourceRow = rows[rowIndex];
var columnCount = sourceRow.Length;
var targetRow = new object[columnCount];
Array.Copy(sourceRow, targetRow, columnCount);
targetRows[rowIndex] = targetRow;
}
var queueItem = new QueueItem
{
Rows = targetRows
};
_queue.Enqueue(queueItem);
_enqueueEvent.Set();
while (!_cancellationToken.IsCancellationRequested && _queue.Count > 10)
{
_cancellationToken.WaitHandle.WaitOne(500);
}
}
void IResultWriter.AfterCloseReader(int affectedRows)
{
var duration = Stopwatch.GetTimestamp() - _beforeExecuteReaderTimestamp;
var header = StopwatchTimeSpan.ToString(duration, 3);
var stringBuilder = new StringBuilder();
stringBuilder.Append($"Command[{_commandCount - 1}] completed.");
if (affectedRows >= 0)
{
stringBuilder.Append($" {affectedRows} row(s) affected.");
}
var message = stringBuilder.ToString();
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, header, message));
if (_query != null)
{
var directory = _fileName != null?Path.GetDirectoryName(_fileName) : Path.GetTempPath();
var results = _query.Results.EmptyIfNull().Zip(_results, ToResult).ToReadOnlyList();
var query = new DbRequest(directory, _query.Name, _query.Using, _query.Namespace, _commandText, 0, _parameters, results);
var queryBuilder = new DbRequestBuilder(query);
var csharpSourceCode = queryBuilder.Build();
var path = Path.Combine(query.Directory, $"{query.Name}.generated.cs");
File.WriteAllText(path, csharpSourceCode, Encoding.UTF8);
_query = null;
_parameters = null;
_commandText = null;
_results = null;
}
}
void IResultWriter.BeforeExecuteReader(AsyncDataAdapterCommand asyncDataAdapterCommand)
{
_beforeExecuteReaderTimestamp = Stopwatch.GetTimestamp();
++_commandCount;
var command = asyncDataAdapterCommand.Command;
var message = $"Command[{_commandCount - 1}] executing from line {asyncDataAdapterCommand.LineIndex + 1}...\r\n{command.CommandText}";
var parameters = command.Parameters;
if (!parameters.IsNullOrEmpty())
{
message += "\r\n" + command.Parameters.ToLogString();
}
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, message));
_query = asyncDataAdapterCommand.Query;
if (_query != null)
{
_fileName = asyncDataAdapterCommand.FileName;
_parameters = asyncDataAdapterCommand.Parameters;
_commandText = asyncDataAdapterCommand.CommandText;
_results = new List <Result>();
}
}
void IResultWriter.WriteTableBegin(DataTable schemaTable)
{
_logResultWriter.WriteTableBegin(schemaTable);
if (isJsonAuto)
{
var column = FoundationDbColumnFactory.Create(schemaTable.Rows[0]);
isJsonAuto = column.DataType == typeof(string);
}
if (isJsonAuto)
{
Assert.IsNull(_path);
var identifier = LocalTime.Default.Now.ToString("yyyy-MM-dd HHmmss.fff");
var tempPath = Path.GetTempPath();
_path = Path.Combine(tempPath, identifier + ".json");
_textWriter = new StreamWriter(_path, false, Encoding.UTF8);
_formattedPath = Path.Combine(tempPath, identifier + "formatted.json");
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Information, null, $"Formatted JSON file: {_formattedPath}"));
}
else
{
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Error, null, "This is not FOR JSON AUTO"));
}
}
void IResultWriter.End()
{
var duration = Stopwatch.GetTimestamp() - _beginTimestamp;
var header = StopwatchTimeSpan.ToString(duration, 3);
var message = $"Query completed {_commandCount} command(s).";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, header, message));
}
void IResultWriter.FirstRowReadEnd(string[] dataTypeNames)
{
var duration = Stopwatch.GetTimestamp() - _firstRowReadBeginTimestamp;
var header = $"{StopwatchTimeSpan.ToString(duration, 3)} Command[{_commandCount-1}]";
var message = $"Result[{_tableCount - 1}] first row read completed.";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, header, message));
}
void IResultWriter.WriteTableEnd()
{
var duration = Stopwatch.GetTimestamp() - _writeTableBeginTimestamp;
var header = StopwatchTimeSpan.ToString(duration, 3);
var message =
$"Command[{_commandCount - 1}] result[{_tableCount - 1}] finished. Table[{_tableCount - 1},{_query?.Results[_tableCount - 1]}] has {_fieldCount} column(s), {_rowCount} row(s).";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, header, message));
}
private void OnStateChange(object sender, StateChangeEventArgs e)
{
var text = $"Connection.State changed. OriginalState: {e.OriginalState}, CurrentState: {e.CurrentState}";
InvokeInfoMessage(new[]
{
InfoMessageFactory.Create(InfoMessageSeverity.Information, null, text)
});
}
void IResultWriter.WriteTableEnd()
{
var duration = Stopwatch.GetTimestamp() - _writeTableBeginTimestamp;
var header = $"{StopwatchTimeSpan.ToString(duration, 3)} Command[{_commandCount-1}]";
var message =
$"Result[{_tableCount - 1}] finished. Table[{_tableCount - 1},{_query?.Results[_tableCount - 1]}] has {SingularOrPlural(_fieldCount, "column", "columns")}, {SingularOrPlural(_rowCount, "row", "rows")}.";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, header, message));
}
public override async Task OnConnected(WebSocket socket)
{
await base.OnConnected(socket);
var socketId = WebSocketConnectionManager.GetId(socket);
var message = InfoMessageFactory.GetSocketId(socketId);
await SendMessageToAllAsync(message);
}
private void OnInfoMessage(object sender, OracleInfoMessageEventArgs e)
{
var sb = new StringBuilder();
sb.AppendLine(e.Message);
sb.Append("Source: ");
sb.Append(e.Source);
InvokeInfoMessage(new[] { InfoMessageFactory.Create(InfoMessageSeverity.Information, null, sb.ToString()) });
}
private void sqlBulkCopy_SqlRowsCopied(object sender, SqlRowsCopiedEventArgs e)
{
var message = $"{e.RowsCopied} rows copied to destination.";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, message));
if (_cancellationToken.IsCancellationRequested)
{
e.Abort = true;
}
}
private void sqlBulkCopy_SqlRowsCopied(object sender, SqlRowsCopiedEventArgs e)
{
_rowCount += e.RowsCopied;
var message = $"{_rowCount} rows copied.";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, message));
if (_cancelRequested)
{
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, "Aborting bulk copy..."));
e.Abort = true;
}
}
private void Connect()
{
var connectionForm = new ConnectionForm(_statusBar, _colorTheme);
if (connectionForm.ShowDialog() == DialogResult.OK)
{
var connectionProperties = connectionForm.ConnectionProperties;
var queryForm = new QueryForm(this, MdiChildren.Length, connectionProperties.Provider, connectionProperties.ConnectionString,
connectionProperties.Connection, _statusBar, _colorTheme);
queryForm.MdiParent = this;
if (SelectedFont != null)
{
queryForm.Font = SelectedFont;
}
queryForm.FormClosing += queryForm_FormClosing;
switch (WindowState)
{
case FormWindowState.Normal:
var width = Math.Max(ClientSize.Width + 70, 100);
var height = Math.Max(ClientSize.Height - 120, 50);
queryForm.ClientSize = new Size(width, height);
break;
case FormWindowState.Maximized:
//queryForm.WindowState = FormWindowState.Maximized;
break;
default:
break;
}
var message = $@"Connection opened in {StopwatchTimeSpan.ToString(connectionForm.Duration, 3)} seconds.
ServerVersion: {connectionProperties.Connection.ServerVersion}";
var infoMessage = InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, message);
queryForm.AddInfoMessage(infoMessage);
queryForm.Show();
if (WindowState == FormWindowState.Maximized)
{
queryForm.WindowState = FormWindowState.Maximized;
}
}
}
void IResultWriter.AfterExecuteReader(int fieldCount)
{
var duration = Stopwatch.GetTimestamp() - _beforeExecuteReaderTimestamp;
var header = $"{StopwatchTimeSpan.ToString(duration, 3)} Command[{_commandCount-1}]";
var stringBuilder = new StringBuilder();
stringBuilder.Append($"Executing reader...");
if (fieldCount > 0)
{
stringBuilder.Append($" Field count: {fieldCount}");
}
var message = stringBuilder.ToString();
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, header, message));
_tableCount = 0;
_fieldCount = fieldCount;
}
internal static List <InfoMessage> ToInfoMessages(SqlErrorCollection sqlErrors, DateTime creationTime)
{
Assert.IsNotNull(sqlErrors);
var messages = new List <InfoMessage>(sqlErrors.Count);
foreach (SqlError sqlError in sqlErrors)
{
var severity = sqlError.Class == 0
? InfoMessageSeverity.Information
: InfoMessageSeverity.Error;
var header = sqlError.GetHeader();
var message = sqlError.Message;
messages.Add(InfoMessageFactory.Create(severity, header, message));
}
return(messages);
}
List <InfoMessage> IProvider.ToInfoMessages(Exception exception)
{
var now = LocalTime.Default.Now;
List <InfoMessage> infoMessages;
if (exception is SqlException sqlException)
{
infoMessages = ToInfoMessages(sqlException.Errors, LocalTime.Default.Now);
}
else
{
var message = exception.ToLogString();
var infoMessage = InfoMessageFactory.Create(InfoMessageSeverity.Error, null, message);
infoMessages = new List <InfoMessage>
{
infoMessage
};
}
return(infoMessages);
}
private void InsertItems(IEnumerable <QueueItem> items)
{
foreach (var item in items)
{
var rows = item.Rows;
var dataTable = new DataTable();
for (var rowIndex = 0; rowIndex < rows.Length; rowIndex++)
{
var row = rows[rowIndex];
var dataRow = dataTable.NewRow();
for (var columnIndex = 0; columnIndex < row.Length; columnIndex++)
{
var sourceValue = row[columnIndex];
var converter = _converters[columnIndex];
object destinationValue;
if (converter != null)
{
destinationValue = converter(sourceValue);
}
else
{
destinationValue = sourceValue;
}
dataRow[columnIndex] = destinationValue;
}
dataTable.Rows.Add(dataRow);
_insertedRowCount++;
}
_sqlBulkCopy.WriteToServer(dataTable);
}
var message = $"{_insertedRowCount} rows inserted.";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, message));
}
public override bool Read()
{
bool read;
if (_command.Cancelled)
{
read = false;
}
else
{
if (_first)
{
_first = false;
var serverPath = (string)_command.Parameters["serverPath"].Value;
_item = _command.Connection.VersionControlServer.GetItem(serverPath);
_localPath = ValueReader.GetValueOrDefault <string>(_command.Parameters["localPath"].Value);
if (_localPath == null)
{
_localPath = Path.GetTempPath();
_localPath = Path.Combine(_localPath, DateTime.Now.ToString("yyyyMMdd HHmmss.fff"));
switch (_item.ItemType)
{
case ItemType.File:
case ItemType.Folder:
var name = VersionControlPath.GetFileName(_item.ServerItem);
_localPath = Path.Combine(_localPath, name);
break;
default:
throw new NotImplementedException();
}
}
var queryForm = (QueryForm)DataCommanderApplication.Instance.MainForm.ActiveMdiChild;
queryForm.AddInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Information, null, $"localPath: {_localPath}"));
if (!VersionControlPath.IsValidPath(serverPath))
{
throw new ArgumentException($"The parameter serverPath '{serverPath}' is invalid.");
}
_queue.Enqueue(_item);
}
if (_queue.Count > 0)
{
var current = _queue.Dequeue();
var values = new object[4];
values[0] = current.ServerItem;
values[1] = current.ItemType;
values[2] = current.CheckinDate;
values[3] = current.ContentLength;
Values = values;
var name = VersionControlPath.GetFileName(current.ServerItem);
string path;
if (_item.ServerItem.Length + 1 <= current.ServerItem.Length)
{
var secondPath = current.ServerItem.Substring(_item.ServerItem.Length + 1);
secondPath = secondPath.Replace(VersionControlPath.Separator, Path.DirectorySeparatorChar);
path = Path.Combine(_localPath, secondPath);
}
else
{
path = _localPath;
}
switch (current.ItemType)
{
case ItemType.File:
Log.Write(LogLevel.Trace, "Downloading {0}...", current.ServerItem);
current.DownloadFile(path);
var checkingDate = current.CheckinDate;
var fileInfo = new FileInfo(path);
fileInfo.LastWriteTime = checkingDate;
fileInfo.Attributes = FileAttributes.ReadOnly;
break;
case ItemType.Folder:
if (!Directory.Exists(path))
{
var directoryInfo = Directory.CreateDirectory(path);
if (!directoryInfo.Exists)
{
throw new ArgumentException($"The directory '{path}' does not exist.");
}
}
var itemSet = current.VersionControlServer.GetItems(current.ServerItem, RecursionType.OneLevel);
foreach (var childItem in itemSet.Items.Skip(1))
{
_queue.Enqueue(childItem);
}
break;
default:
throw new NotImplementedException();
}
read = true;
}
else
{
read = false;
}
}
return(read);
}
public override bool Read()
{
bool read;
if (_first)
{
_first = false;
var parameters = _command.Parameters;
var path = (string)parameters["path"].Value;
RecursionType recursion;
var parameter = parameters.FirstOrDefault(p => p.ParameterName == "recursion");
if (parameter != null)
{
var recursionString = ValueReader.GetValueOrDefault <string>(parameter.Value);
recursion = Enum <RecursionType> .Parse(recursionString);
}
else
{
recursion = RecursionType.Full;
}
var versionControlServer = _command.Connection.VersionControlServer;
var workspaces = versionControlServer.QueryWorkspaces(null, null, Environment.MachineName);
Workspace workspace = null;
WorkingFolder workingFolder = null;
foreach (var currentWorkspace in workspaces)
{
workingFolder = currentWorkspace.TryGetWorkingFolderForServerItem(path);
if (workingFolder != null)
{
workspace = currentWorkspace;
var itemSpec = new ItemSpec(path, recursion);
var extendedItems = currentWorkspace.GetExtendedItems(new[] { itemSpec }, DeletedState.Any, ItemType.Any);
_items = extendedItems[0];
}
}
if (workingFolder == null)
{
throw new Exception($"Workspace not found for '{path}'");
}
string name;
if (workspace != null)
{
name = workspace.Name;
}
else
{
name = "(not found)";
}
var queryForm = (QueryForm)DataCommanderApplication.Instance.MainForm.ActiveMdiChild;
queryForm.AddInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Information, null,
$"\r\nworkspace.Name: {name}\r\nworkingFolder.LocalItem: {workingFolder.LocalItem}"));
}
if (_items != null && _index < _items.Length)
{
var item = _items[_index];
var values = new object[]
{
item.SourceServerItem,
item.ChangeType.ToString(),
item.LockOwner,
item.LockStatus.ToString(),
item.IsLatest,
item.HasOtherPendingChange,
item.VersionLatest,
item.VersionLocal
};
Values = values;
read = true;
_index++;
}
else
{
read = false;
}
return(read);
}
void OnInfoMessage(object sender, OleDbInfoMessageEventArgs e)
{
var text = e.Message;
InvokeInfoMessage(new[] { InfoMessageFactory.Create(InfoMessageSeverity.Information, null, text) });
}
public string GetIP(WebSocket socket, string ip)
{
var message = InfoMessageFactory.GetClientIp(ip);
return(message);
}
private void InsertItems(IEnumerable <QueueItem> items)
{
var sb = new StringBuilder();
foreach (var item in items)
{
var rows = item.Rows;
for (var rowIndex = 0; rowIndex < rows.Length; rowIndex++)
{
var row = rows[rowIndex];
for (var columnIndex = 0; columnIndex < row.Length; columnIndex++)
{
var sourceValue = row[columnIndex];
var converter = _converters[columnIndex];
object destinationValue;
if (converter != null)
{
destinationValue = converter(sourceValue);
}
else
{
destinationValue = sourceValue;
}
_parameters[columnIndex].Value = destinationValue;
}
if (_canConvertCommandToString)
{
if (sb.Length > 0)
{
sb.AppendLine();
}
var commandText = _destinationProvider.CommandToString(_insertCommand);
sb.Append(commandText);
}
else
{
_insertCommand.ExecuteNonQuery();
}
_insertedRowCount++;
}
}
if (sb.Length > 0)
{
var stopwatch = new Stopwatch();
var commandText = sb.ToString();
try
{
var executor = _destinationConnection.Connection.CreateCommandExecutor();
executor.ExecuteNonQuery(new CreateCommandRequest(commandText, null, CommandType.Text, 3600, _insertCommand.Transaction));
}
catch (Exception e)
{
Log.Write(LogLevel.Error, "CommandText:\r\n{0}\r\nException:{1}", commandText, e.ToLogString());
throw;
}
}
var message =
$"{_readRowCount},{_insertedRowCount},{_readRowCount - _insertedRowCount},{_waitMilliseconds} (rows read,inserted,queued,wait).";
_addInfoMessage(InfoMessageFactory.Create(InfoMessageSeverity.Verbose, null, message));
}
