public async ValueTask SendQuery(
ClientQueryMessage.Builder messageBuilder,
IReadOnlyCollection <IClickHouseTableWriter>?tables,
bool async,
CancellationToken cancellationToken)
{
CheckDisposed();
var writer = _client._writer;
try
{
var settings = _client._settings;
messageBuilder.ClientName = settings.ClientName;
messageBuilder.ClientVersion = settings.ClientVersion;
messageBuilder.Host = settings.Host;
messageBuilder.RemoteAddress = ((IPEndPoint)_client._client.Client.RemoteEndPoint).ToString();
messageBuilder.ProtocolRevision = Math.Min(Revisions.CurrentRevision, _client.ServerInfo.Revision);
messageBuilder.CompressionEnabled = _client._settings.Compress;
var queryMessage = messageBuilder.Build();
if (queryMessage.Settings != null)
{
if (_client.ServerInfo.Revision < Revisions.MinRevisionWithSettingsSerializedAsStrings)
{
throw new ClickHouseException(
ClickHouseErrorCodes.ProtocolRevisionNotSupported,
$"Query settings are not supported. Current protocol revision is {_client.ServerInfo.Revision}. Minimal required protocol revision is {Revisions.MinRevisionWithSettingsSerializedAsStrings}.");
}
}
queryMessage.Write(writer);
if (tables != null)
{
foreach (var table in tables)
{
WriteTable(table);
}
}
WriteTable(ClickHouseEmptyTableWriter.Instance);
}
catch (Exception ex)
{
writer.Discard();
throw ClickHouseHandledException.Wrap(ex);
}
await WithCancellationToken(cancellationToken, ct => writer.Flush(async, ct));
}
public async ValueTask SendQuery(
string query,
IReadOnlyCollection <IClickHouseTableWriter>?tables,
bool async,
CancellationToken cancellationToken)
{
CheckDisposed();
var writer = _client._writer;
try
{
var settings = _client._settings;
var queryMessage = new ClientQueryMessage.Builder
{
ClientName = settings.ClientName,
ClientVersion = settings.ClientVersion,
Host = settings.Host,
RemoteAddress = ((IPEndPoint)_client._client.Client.RemoteEndPoint).ToString(),
ProtocolRevision = Revisions.CurrentRevision,
QueryKind = QueryKind.InitialQuery,
Query = query,
CompressionEnabled = _client._settings.Compress
}.Build();
queryMessage.Write(writer);
if (tables != null)
{
foreach (var table in tables)
{
WriteTable(table);
}
}
WriteTable(ClickHouseEmptyTableWriter.Instance);
}
catch (Exception ex)
{
await writer.Discard(async, CancellationToken.None);
throw ClickHouseHandledException.Wrap(ex);
}
await WithCancellationToken(cancellationToken, ct => writer.Flush(async, ct));
}
private async ValueTask <ClickHouseColumnWriter> CreateColumnWriter(string insertFormatCommand, bool async, CancellationToken cancellationToken)
{
var connectionState = _connectionState;
if (connectionState.TcpClient == null)
{
Debug.Assert(connectionState.State != ConnectionState.Open);
throw new ClickHouseException(ClickHouseErrorCodes.ConnectionClosed, "The connection is closed.");
}
ClickHouseTcpClient.Session?session = null;
bool cancelOnFailure = false;
try
{
session = await connectionState.TcpClient.OpenSession(async, null, CancellationToken.None, cancellationToken);
var messageBuilder = new ClientQueryMessage.Builder {
QueryKind = QueryKind.InitialQuery, Query = insertFormatCommand
};
await session.SendQuery(messageBuilder, null, async, cancellationToken);
cancelOnFailure = true;
var msg = await session.ReadMessage(async, cancellationToken);
switch (msg.MessageCode)
{
case ServerMessageCode.Error:
throw ((ServerErrorMessage)msg).Exception.CopyWithQuery(insertFormatCommand);
case ServerMessageCode.TableColumns:
break;
default:
throw new ClickHouseException(ClickHouseErrorCodes.ProtocolUnexpectedResponse, $"Unexpected server message. Received the message of type {msg.MessageCode}.");
}
msg = await session.ReadMessage(async, cancellationToken);
ClickHouseTable data;
switch (msg.MessageCode)
{
case ServerMessageCode.Error:
throw ((ServerErrorMessage)msg).Exception.CopyWithQuery(insertFormatCommand);
case ServerMessageCode.Data:
data = await session.ReadTable((ServerDataMessage)msg, null, async, cancellationToken);
break;
default:
throw new ClickHouseException(ClickHouseErrorCodes.ProtocolUnexpectedResponse, $"Unexpected server message. Received the message of type {msg.MessageCode}.");
}
return(new ClickHouseColumnWriter(session, data.Header.Columns));
}
catch (ClickHouseServerException)
{
if (session != null)
{
await session.Dispose(async);
}
throw;
}
catch (ClickHouseHandledException)
{
if (session != null)
{
await session.Dispose(async);
}
throw;
}
catch (Exception ex)
{
if (session != null)
{
var aggrEx = await session.SetFailed(ex, cancelOnFailure, async);
if (aggrEx != null)
{
throw aggrEx;
}
}
throw;
}
}
