private void WriteToStream(NpgsqlBinaryImporter writer, IEnumerable <TEntity> entities)
{
long rowNumber = 1;
long colNumber = 1;
string colName = null;
IEnumerable <TEntity> enumerable = entities as TEntity[] ?? entities.ToArray();
try
{
foreach (var entity in enumerable)
{
writer.StartRow();
colNumber = 1;
foreach (var columnDefinition in Columns)
{
colName = columnDefinition.ColumnName;
columnDefinition.Write(writer, entity);
colNumber++;
}
rowNumber++;
}
}
catch (Exception ex)
{
ex.Data["RowNumber"] = rowNumber;
ex.Data["ColumnNumber"] = colNumber;
ex.Data["ColumnName"] = colName;
ex.Data["TotalRows"] = enumerable.Count();
throw;
}
}
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 BulkCopy(IEnumerable <T> source, NpgsqlBinaryImporter writer)
{
foreach (var row in source)
{
writer.StartRow();
PerformBulkCopyDataRow(writer, row);
}
writer.Complete();
}
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();
}
}
}
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);
}
}
}
private void WriteToStream(NpgsqlBinaryImporter writer, IEnumerable <TEntity> entities)
{
foreach (var entity in entities)
{
writer.StartRow();
foreach (var columnDefinition in Columns)
{
columnDefinition.Write(writer, entity);
}
}
}
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);
}
}
}
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>
/// <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);
}
private void WriteEvent(NpgsqlBinaryImporter writer, LogEvent logEvent)
{
writer.StartRow();
WriteRegularColumns(writer, logEvent);
WriteAdditionalColumns(writer, logEvent);
}
private bool InternalExecScript(string table, string schema, object script, out uint count)
{
count = 0;
try
{
if (script is DataTable dt)
{
using (NpgsqlBinaryImporter writer = conn.BeginBinaryImport(
$"copy {ProcessTableName(table, schema)} from stdin binary"))
{
foreach (DataRow row in dt.Rows)
{
object[] values = row.ItemArray;
writer.StartRow();
for (int i = 0; i < values.Length; i++)
{
object value = values[i];
if (value == DBNull.Value || value == null)
{
writer.WriteNull();
}
else if (dt.Columns[i].DataType == typeof(bool))
{
writer.Write((bool)value, NpgsqlDbType.Bit);
}
else
{
writer.Write(value);
}
}
}
}
count = (uint)dt.Rows.Count;
return(true);
}
else if (script is MergeScript ms)
{
if (Execute(ms.PrepareSQL, null, out _))
{
try
{
if (InternalExecScript(ms.TableName, schema, ms.Data, out count))
{
if (Execute(ms.UpdateSQL, null, out _))
{
if (string.IsNullOrEmpty(ms.InsertSQL) || Execute(ms.InsertSQL, null, out _))
{
return(true);
}
}
}
}
finally
{
Execute(ms.CleanSQL, null, out _);
}
}
}
else if (script is UpdateScript us)
{
if (Execute(us.UpdateSQL, null, out count))
{
if (count == 0)
{
return(Execute(us.InsertSQL, null, out count));
}
else
{
return(true);
}
}
}
else if (script is string sql)
{
return(Execute(sql, null, out count));
}
}
catch (Exception ex)
{
LastError = $"{table}：{ex.Message}";
Logger.WriteLogExcept(LogTitle, ex);
}
return(false);
}
public virtual void Import(NpgsqlBinaryImporter writer)
{
writer.StartRow();
writer.WriteValue(Timestamp);
}
/// <summary>
/// Starts writing a single row, must be invoked before writing any columns.
/// </summary>
public void StartRow()
{
_binaryImporter.StartRow();
}
public static void PerformBulkCopy(this IDataReader dr, NpgsqlBinaryImporter writer, DataColumnCollection columns = null)
{
columns ??= dr.GetSchemaTable().Columns;
while (dr.Read())
{
writer.StartRow();
foreach (DataColumn col in columns)
{
switch (dr[col.Ordinal])
{
case bool x:
writer.Write(x);
break;
case byte x:
writer.Write(x);
break;
case sbyte x:
writer.Write(x);
break;
case short x:
writer.Write(x);
break;
case ushort x:
writer.Write(x);
break;
case int x:
writer.Write(x);
break;
case uint x:
writer.Write(x);
break;
case long x:
writer.Write(x);
break;
case ulong x:
writer.Write(x);
break;
case double x:
writer.Write(x);
break;
case float x:
writer.Write(x);
break;
case Guid x:
writer.Write(x);
break;
case DateTime x:
writer.Write(x);
break;
case TimeSpan x:
writer.Write(x);
break;
case char x:
writer.Write(x);
break;
case string x:
writer.Write(x);
break;
case null:
writer.WriteNull();
break;
}
}
}
writer.Complete();
}
