/// <summary>
///
/// </summary>
/// <param name="importer"></param>
/// <param name="data"></param>
/// <param name="npgsqlDbType"></param>
private static void BinaryImportWrite(NpgsqlBinaryImporter importer,
object data,
NpgsqlDbType?npgsqlDbType)
{
if (data == null)
{
importer.WriteNull();
}
else
{
if (npgsqlDbType != null)
{
if (data is Enum)
{
if (npgsqlDbType == NpgsqlDbType.Integer ||
npgsqlDbType == NpgsqlDbType.Bigint ||
npgsqlDbType == NpgsqlDbType.Smallint)
{
data = Convert.ToInt32(data);
}
else if (npgsqlDbType == NpgsqlDbType.Text)
{
data = Convert.ToString(data);
}
}
importer.Write(data, npgsqlDbType.Value);
}
else
{
importer.Write(data);
}
}
}
public void Save(NpgsqlBinaryImporter writer)
{
writer.StartRow();
writer.Write(this["firstname"], NpgsqlTypes.NpgsqlDbType.Varchar);
writer.Write(this["lastname"], NpgsqlTypes.NpgsqlDbType.Varchar);
writer.Write(DateTime.Parse(this["date-of-birth"]), NpgsqlTypes.NpgsqlDbType.Date);
writer.Write(this["phone"], NpgsqlTypes.NpgsqlDbType.Varchar);
}
public static void WriteNullableDouble(this NpgsqlBinaryImporter importer, double?val)
{
if (val.HasValue)
{
importer.Write(val.Value, NpgsqlDbType.Double);
}
else
{
importer.Write <double?>(null, NpgsqlDbType.Double);
}
}
public static void WriteValue(this NpgsqlBinaryImporter importer, string value, int len)
{
if (string.IsNullOrEmpty(value))
{
importer.Write(DBNull.Value, NpgsqlDbType.Varchar);
}
else
{
importer.Write(value, NpgsqlDbType.Varchar);
}
}
public static void WriteNullableLong(this NpgsqlBinaryImporter importer, long?val)
{
if (val.HasValue)
{
importer.Write(val.Value, NpgsqlDbType.Bigint);
}
else
{
importer.Write <long?>(null, NpgsqlDbType.Bigint);
}
}
public static void WriteValue(this NpgsqlBinaryImporter importer, string value)
{
if (string.IsNullOrEmpty(value))
{
importer.Write(string.Empty, NpgsqlDbType.Text);
}
else
{
importer.Write(value, NpgsqlDbType.Text);
}
}
private void WriteLevel(NpgsqlBinaryImporter writer, LogEvent logEvent)
{
if (_columnOptions.Level.StoreAsSmallint)
{
var level = (int)logEvent.Level;
writer.Write(level, NpgsqlDbType.Smallint);
}
else
{
var level = logEvent.Level.ToString();
writer.Write(level, NpgsqlDbType.Text);
}
}
// This method may be used instead of NpgsqlBulkCodeBuilder
private void WriteRow <T>(T item, MappingInfo[] mapInfos, NpgsqlBinaryImporter importer)
{
foreach (var mapItem in mapInfos)
{
var value = mapItem.Property.GetValue(item);
importer.Write(value, mapItem.NpgsqlType);
}
}
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);
}
}
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>
/// For __RepoDb_OrderColumn
/// </summary>
/// <param name="importer"></param>
/// <param name="identityBehavior"></param>
/// <param name="index"></param>
private static void EnsureCustomizedOrderColumn(NpgsqlBinaryImporter importer,
BulkImportIdentityBehavior identityBehavior,
int index)
{
if (identityBehavior == BulkImportIdentityBehavior.ReturnIdentity)
{
importer.Write(index, NpgsqlDbType.Integer);
}
}
/// <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);
}
/// <summary>
/// Writes text value in bulk manner.
/// </summary>
public static void WriteNullable(this NpgsqlBinaryImporter writer, string?value, NpgsqlDbType dbType)
{
if (value != null)
{
writer.Write(value, dbType);
}
else
{
writer.WriteNull();
}
}
protected void Write <T>(NpgsqlBinaryImporter importer, T value, NpgsqlDbType type)
{
if (value == null)
{
importer.WriteNull();
}
else
{
importer.Write(value, type);
}
}
protected void Write <T>(NpgsqlBinaryImporter importer, T?value, NpgsqlDbType type) where T : struct
{
if (value == null)
{
importer.WriteNull();
}
else
{
importer.Write(value.Value, type);
}
}
/// <summary>
/// Writes nullable structure in bulk manner.
/// </summary>
public static void WriteNullable <T>(this NpgsqlBinaryImporter writer, T?value, NpgsqlDbType dbType) where T : struct
{
if (value.HasValue)
{
writer.Write(value.Value, dbType);
}
else
{
writer.WriteNull();
}
}
public static void WriteValue(this NpgsqlBinaryImporter binaryImporter, StatusEnum?value)
{
if (value.HasValue)
{
binaryImporter.Write((byte)value.Value, NpgsqlDbType.Smallint);
}
else
{
binaryImporter.WriteNull();
}
}
public static void WriteNullable <T>(this NpgsqlBinaryImporter writer, T value, NpgsqlDbType npgsqlDbType)
{
if (value == null)
{
writer.WriteNull();
}
else
{
writer.Write(value, npgsqlDbType);
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var table = new DataTable("practicetable2");
table.Columns.Add("num", typeof(int));
table.Columns.Add("numstring", typeof(string));
table.Columns.Add("description", typeof(string));
table.Columns.Add("someid", typeof(Guid));
for (int i = 0; i < 10; i++)
{
var row = table.NewRow();
row["num"] = i;
row["numstring"] = i.ToString();
// Commented below line to test for null case.
// row["description"] = "sfsdf";
row["someid"] = Guid.NewGuid();
table.Rows.Add(row);
}
for (int i = 0; i < table.Columns.Count; i++)
{
var column = table.Columns[i];
Console.WriteLine($"full name: {column.DataType.FullName}");
}
using (var conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;Database=joyn_fdgcommon_dev;User Id=postgres;Password=admin;"))
{
conn.Open();
using (NpgsqlBinaryImporter writer = conn.BeginBinaryImport("copy stage.practicetable2 from stdin(FORMAT BINARY)"))
{
for (int i = 0; i < table.Rows.Count; i++)
{
DataRow row = table.Rows[i];
writer.StartRow();
for (int j = 0; j < table.Columns.Count; j++)
{
var column = table.Columns[j];
var value = row[column.ColumnName];
if (value != null)
{
writer.Write(row[column.ColumnName]);
}
else
{
Console.WriteLine("writing null");
writer.WriteNull();
}
}
}
writer.Complete();
}
}
}
public static void WriteValue(this NpgsqlBinaryImporter binaryImporter, long?value)
{
if (value.HasValue)
{
binaryImporter.Write(value.Value, NpgsqlDbType.Bigint);
}
else
{
binaryImporter.WriteNull();
}
}
/// <summary>
/// when used within npgsql conn BeginBinaryImport allow to write safely nullable as null
/// </summary>
public static void SafeWrite <T>(this NpgsqlBinaryImporter wr, T obj)
{
if (obj == null)
{
wr.WriteNull();
}
else
{
wr.Write(obj);
}
}
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);
}
}
}
private void WriteToStream(NpgsqlBinaryImporter writer, IEnumerable <LogEvent> entities)
{
foreach (var entity in entities)
{
writer.StartRow();
foreach (var columnKey in _columnOptions.Keys)
{
writer.Write(_columnOptions[columnKey].GetValue(entity, _formatProvider), _columnOptions[columnKey].DbType);
}
}
}
public static void SetValuesBinaryImporter <T>(this NpgsqlBinaryImporter importer, IEnumerable <T> o) where T : class
{
foreach (var entity in o)
{
importer.StartRow();
var props = entity.GetType().GetProperties();
foreach (var prop in props)
{
var type = GetNpgsqlDbType(prop.PropertyType);
importer.Write(prop, type);
}
}
}
/// <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();
}
}
}
public static void WriteValue(this NpgsqlBinaryImporter importer, short value)
{
importer.Write(value, NpgsqlDbType.Smallint);
}
public static void WriteValue(this NpgsqlBinaryImporter importer, DateTime value)
{
importer.Write(value, NpgsqlDbType.Timestamp);
}
private static void AddToTxImporter(NpgsqlBinaryImporter txImporter, long txInternalId, byte[] txExternalId, byte[] txPayload, DateTime?receivedAt, string callbackUrl,
string callbackToken, string callbackEncryption, bool?merkleProof, string merkleFormat, bool?dsCheck,
long?n, byte[] prevTxId, long?prevN, bool unconfirmedAncestor)
{
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)merkleFormat ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Varchar);
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);
txImporter.Write((object)unconfirmedAncestor ?? DBNull.Value, NpgsqlTypes.NpgsqlDbType.Boolean);
}
public static void WriteValue(this NpgsqlBinaryImporter importer, OperationType value)
{
importer.Write((byte)value, NpgsqlDbType.Smallint);
}
