/// <summary>
/// Writes to the stream.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="entities">The entities.</param>
private void WriteToStream(NpgsqlBinaryImporter writer, IEnumerable <LogEvent> entities)
{
foreach (var entity in entities)
{
writer.StartRow();
foreach (var columnKey in this.ColumnNamesWithoutSkipped())
{
writer.Write(
this.columnOptions[columnKey].GetValue(entity, this.formatProvider),
this.columnOptions[columnKey].DbType);
}
}
}
/// <summary>
/// Mapping values from properties which have a corresponding data row.
/// Matching is done based on Column name and property key
/// </summary>
private void WriteAdditionalColumns(NpgsqlBinaryImporter writer, LogEvent logEvent)
{
foreach (var column in _columnOptions.AdditionalDataColumns)
{
logEvent.Properties.TryGetValue(column.PropertyName, out LogEventPropertyValue propertyValue);
var scalarValue = propertyValue as ScalarValue;
if (scalarValue != null)
{
writer.Write(scalarValue.ToString(), column.ColumnType);
}
else
{
writer.WriteNull();
}
}
}
private void WriteTags(NpgsqlBinaryImporter writer, OsmGeo item, Action <Tag> processTag = null)
{
if (item.Tags != null)
{
List <string> tags = new List <string>(item.Tags.Count);
foreach (var tag in item.Tags)
{
tags.Add($"{tag.Key}={tag.Value}");
processTag?.Invoke(tag);
}
writer.Write(tags.ToArray(), NpgsqlTypes.NpgsqlDbType.Array | NpgsqlTypes.NpgsqlDbType.Text);
}
else
{
writer.Write <string[]>(null, NpgsqlTypes.NpgsqlDbType.Array | NpgsqlTypes.NpgsqlDbType.Text);
}
}
/// <summary>
///
/// </summary>
/// <param name="importer"></param>
/// <param name="reader"></param>
/// <param name="mappings"></param>
/// <param name="identityBehavior"></param>
private static int BinaryImport(NpgsqlBinaryImporter importer,
DbDataReader reader,
IEnumerable <NpgsqlBulkInsertMapItem> mappings,
BulkImportIdentityBehavior identityBehavior)
{
return(BinaryImportWrite(importer,
() => reader.Read(),
() => reader,
(current) =>
{
foreach (var mapping in mappings)
{
BinaryImportWrite(importer, current[mapping.SourceColumn], mapping.NpgsqlDbType);
}
},
identityBehavior));
}
private void WriteRegularColumns(NpgsqlBinaryImporter writer, LogEvent logEvent)
{
foreach (var column in _columnOptions.Store)
{
switch (column)
{
case StandardColumn.Message:
var message = logEvent.RenderMessage(_formatProvider);
writer.WriteNullable(message, NpgsqlDbType.Text);
break;
case StandardColumn.MessageTemplate:
var messageTemplate = logEvent.MessageTemplate.Text;
writer.WriteNullable(messageTemplate, NpgsqlDbType.Text);
break;
case StandardColumn.Level:
WriteLevel(writer, logEvent);
break;
case StandardColumn.TimeStamp:
var timestamp = _columnOptions.TimeStamp.ConvertToUtc ? logEvent.Timestamp.DateTime.ToUniversalTime() : logEvent.Timestamp.DateTime;
writer.Write(timestamp, NpgsqlDbType.TimestampTZ);
break;
case StandardColumn.Exception:
var exception = logEvent.Exception?.ToString();
writer.WriteNullable(exception, NpgsqlDbType.Text);
break;
case StandardColumn.Properties:
var propertiesJson = ConvertPropertiesToJsonStructure(logEvent.Properties);
writer.Write(propertiesJson, NpgsqlDbType.Jsonb);
break;
case StandardColumn.LogEvent:
var logEventJson = LogEventToJson(logEvent);
writer.Write(logEventJson, NpgsqlDbType.Jsonb);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
/// <summary>
/// Пишет значение в импортер
/// </summary>
protected virtual void WriteValue(NpgsqlBinaryImporter writer, object value, bool valueSpecified, NpgsqlDbType?type = null)
{
if (!valueSpecified || value == null || value == DBNull.Value)
{
writer.WriteNull();
}
else if (type.HasValue)
{
writer.Write(value, type.Value);
}
else
{
writer.Write(value);
}
//Запись о том что столбец передан
writer.Write(valueSpecified);
}
private void AddToTxImporter(NpgsqlBinaryImporter txImporter, long txInternalId, byte[] txExternalId, byte[] txPayload, DateTime?receivedAt, string callbackUrl,
string callbackToken, string callbackEncryption, bool?merkleProof, bool?dsCheck, long?n, byte[] prevTxId, long?prevN)
{
txImporter.StartRow();
txImporter.Write(txInternalId, NpgsqlTypes.NpgsqlDbType.Bigint);
txImporter.Write(txExternalId, NpgsqlTypes.NpgsqlDbType.Bytea);
txImporter.Write((object)txPayload ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Bytea);
txImporter.Write((object)receivedAt ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Timestamp);
txImporter.Write((object)callbackUrl ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Varchar);
txImporter.Write((object)callbackToken ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Varchar);
txImporter.Write((object)callbackEncryption ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Varchar);
txImporter.Write((object)merkleProof ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Boolean);
txImporter.Write((object)dsCheck ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Boolean);
txImporter.Write((object)n ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Bigint);
txImporter.Write((object)prevTxId ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Bytea);
txImporter.Write((object)prevN ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Bigint);
}
/// <summary>
///
/// </summary>
/// <param name="importer"></param>
/// <param name="dictionaries"></param>
/// <param name="mappings"></param>
/// <param name="identityBehavior"></param>
private static int BinaryImport(NpgsqlBinaryImporter importer,
IEnumerable <IDictionary <string, object> > dictionaries,
IEnumerable <NpgsqlBulkInsertMapItem> mappings,
BulkImportIdentityBehavior identityBehavior)
{
var enumerator = dictionaries.GetEnumerator();
return(BinaryImportWrite(importer,
() => enumerator.MoveNext(),
() => enumerator.Current,
(dictionary) =>
{
foreach (var mapping in mappings)
{
BinaryImportWrite(importer, dictionary[mapping.SourceColumn], mapping.NpgsqlDbType);
}
},
identityBehavior));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="importer"></param>
/// <param name="tableName"></param>
/// <param name="entities"></param>
/// <param name="mappings"></param>
/// <param name="entityType"></param>
/// <param name="identityBehavior"></param>
private static int BinaryImport <TEntity>(NpgsqlBinaryImporter importer,
string tableName,
IEnumerable <TEntity> entities,
IEnumerable <NpgsqlBulkInsertMapItem> mappings,
Type entityType,
BulkImportIdentityBehavior identityBehavior)
where TEntity : class
{
var func = Compiler.GetNpgsqlBinaryImporterWriteFunc <TEntity>(tableName,
mappings,
entityType);
var enumerator = entities.GetEnumerator();
return(BinaryImportWrite(importer,
() => enumerator.MoveNext(),
() => enumerator.Current,
(entity) => func(importer, entity),
identityBehavior));
}
/// <summary>
///
/// </summary>
/// <param name="importer"></param>
/// <param name="reader"></param>
/// <param name="mappings"></param>
/// <param name="identityBehavior"></param>
/// <param name="cancellationToken"></param>
private static async Task <int> BinaryImportAsync(NpgsqlBinaryImporter importer,
DbDataReader reader,
IEnumerable <NpgsqlBulkInsertMapItem> mappings,
BulkImportIdentityBehavior identityBehavior,
CancellationToken cancellationToken = default)
{
return(await BinaryImportWriteAsync(importer,
async() => await reader.ReadAsync(cancellationToken),
async() => await Task.FromResult(reader),
async (current) =>
{
foreach (var mapping in mappings)
{
await BinaryImportWriteAsync(importer, current[mapping.SourceColumn],
mapping.NpgsqlDbType, cancellationToken);
}
},
identityBehavior,
cancellationToken : cancellationToken));
}
/// <summary>
///
/// </summary>
/// <param name="importer"></param>
/// <param name="data"></param>
/// <param name="npgsqlDbType"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private static async Task BinaryImportWriteAsync(NpgsqlBinaryImporter importer,
object data,
NpgsqlDbType?npgsqlDbType,
CancellationToken cancellationToken = default)
{
if (data == null)
{
await importer.WriteNullAsync(cancellationToken);
}
else
{
if (npgsqlDbType != null)
{
await importer.WriteAsync(data, npgsqlDbType.Value, cancellationToken);
}
else
{
await importer.WriteAsync(data, cancellationToken);
}
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="importer"></param>
/// <param name="tableName"></param>
/// <param name="entities"></param>
/// <param name="mappings"></param>
/// <param name="entityType"></param>
/// <param name="identityBehavior"></param>
/// <param name="cancellationToken"></param>
private static async Task <int> BinaryImportAsync <TEntity>(NpgsqlBinaryImporter importer,
string tableName,
IEnumerable <TEntity> entities,
IEnumerable <NpgsqlBulkInsertMapItem> mappings,
Type entityType,
BulkImportIdentityBehavior identityBehavior,
CancellationToken cancellationToken = default)
where TEntity : class
{
var func = Compiler.GetNpgsqlBinaryImporterWriteAsyncFunc <TEntity>(tableName,
mappings,
entityType);
var enumerator = entities.GetEnumerator();
return(await BinaryImportWriteAsync(importer,
async() => await Task.FromResult(enumerator.MoveNext()),
async() => await Task.FromResult(enumerator.Current),
async (entity) => await func(importer, entity, cancellationToken),
identityBehavior,
cancellationToken));
}
public static void SerializeColumn(Column c, object value, NpgsqlBinaryImporter importer)
{
if (value == DBNull.Value)
{
importer.WriteNull();
}
else
{
var type = GetPgType(c.Type, c.IsMax);
var s = value as string;
if (s == null)
{
importer.Write(value, type);
}
else
{
s = Regex.Replace(s, "\0", ""); //null characters are not allowed in Postgres
importer.Write(s, type);
}
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <param name="importer"></param>
/// <param name="moveNext"></param>
/// <param name="getCurrent"></param>
/// <param name="write"></param>
/// <param name="identityBehavior"></param>
/// <returns></returns>
private static int BinaryImportWrite <TEntity>(NpgsqlBinaryImporter importer,
Func <bool> moveNext,
Func <TEntity> getCurrent,
Action <TEntity> write,
BulkImportIdentityBehavior identityBehavior)
where TEntity : class
{
var result = 0;
while (moveNext())
{
importer.StartRow();
EnsureCustomizedOrderColumn(importer, identityBehavior, result);
write(getCurrent());
result++;
}
importer.Complete();
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="importer"></param>
/// <param name="rows"></param>
/// <param name="mappings"></param>
/// <param name="identityBehavior"></param>
/// <param name="cancellationToken"></param>
private static async Task <int> BinaryImportAsync(NpgsqlBinaryImporter importer,
IEnumerable <DataRow> rows,
IEnumerable <NpgsqlBulkInsertMapItem> mappings,
BulkImportIdentityBehavior identityBehavior,
CancellationToken cancellationToken = default)
{
var enumerator = rows.GetEnumerator();
return(await BinaryImportWriteAsync(importer,
async() => await Task.FromResult(enumerator.MoveNext()),
async() => await Task.FromResult(enumerator.Current),
async (row) =>
{
foreach (var mapping in mappings)
{
await BinaryImportWriteAsync(importer, row[mapping.SourceColumn],
mapping.NpgsqlDbType, cancellationToken);
}
},
identityBehavior,
cancellationToken));
}
/// <summary>
///
/// </summary>
/// <param name="importer"></param>
/// <param name="dictionaries"></param>
/// <param name="mappings"></param>
/// <param name="identityBehavior"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private static async Task <int> BinaryImportExplicitAsync(NpgsqlBinaryImporter importer,
IEnumerable <IDictionary <string, object> > dictionaries,
IEnumerable <NpgsqlBulkInsertMapItem> mappings,
BulkImportIdentityBehavior identityBehavior,
CancellationToken cancellationToken = default)
{
var enumerator = dictionaries.GetEnumerator();
return(await BinaryImportWriteAsync(importer,
async() => await Task.FromResult(enumerator.MoveNext()),
async() => await Task.FromResult(enumerator.Current),
async (dictionary) =>
{
foreach (var mapping in mappings)
{
await BinaryImportWriteAsync(importer, dictionary[mapping.SourceColumn],
mapping.NpgsqlDbType, cancellationToken);
}
},
identityBehavior,
cancellationToken));
}
public static void WriteValue(this NpgsqlBinaryImporter importer, long value)
{
importer.Write(value, NpgsqlDbType.Bigint);
}
private void WriteEvent(NpgsqlBinaryImporter writer, LogEvent logEvent)
{
writer.StartRow();
WriteRegularColumns(writer, logEvent);
WriteAdditionalColumns(writer, logEvent);
}
public abstract void Import(NpgsqlBinaryImporter writer);
public static void WriteValue(this NpgsqlBinaryImporter binaryImporter, string value, NpgsqlDbType npgsqlDbType)
{
binaryImporter.Write(value, npgsqlDbType);
}
public static void WriteValue(this NpgsqlBinaryImporter binaryImporter, byte[] value)
{
binaryImporter.Write(value, NpgsqlDbType.Bytea);
}
public static void WriteValue(this NpgsqlBinaryImporter importer, OperationType value)
{
importer.Write((byte)value, NpgsqlDbType.Smallint);
}
internal Task WriteValues(TEntity entity, NpgsqlBinaryImporter binaryImporter, CancellationToken cancellationToken)
{
return(_valueWriter.Invoke(entity, binaryImporter, cancellationToken));
}
public static void WriteValue(this NpgsqlBinaryImporter importer, DateTime value)
{
importer.Write(value, NpgsqlDbType.Timestamp);
}
public static void WriteValue(this NpgsqlBinaryImporter importer, short value)
{
importer.Write(value, NpgsqlDbType.Smallint);
}
public static void WriteValue(this NpgsqlBinaryImporter binaryImporter, decimal value)
{
binaryImporter.Write(value, NpgsqlDbType.Numeric);
}
public abstract void LoadRow(NpgsqlBinaryImporter writer, T document, ITenant tenant, ISerializer serializer);
protected abstract bool ImportRow(NpgsqlBinaryImporter importer, T model);
public abstract Task LoadRowAsync(NpgsqlBinaryImporter writer, T document, ITenant tenant, ISerializer serializer, CancellationToken cancellation);
public static void WriteValue(this NpgsqlBinaryImporter importer, int value)
{
importer.Write(value, NpgsqlDbType.Integer);
}
