public static void WriteQueueToXml(IDataQueue queue, Stream fw, string dbName, string tableName)
{
DataTable table = ConnTools.DataTableFromStructure(queue.GetRowFormat);
table.TableName = tableName;
List <string> fldnames = new List <string>();
foreach (IColumnStructure col in queue.GetRowFormat.Columns)
{
fldnames.Add(col.ColumnName);
}
XmlWriter xw = XmlTextWriter.Create(fw, new XmlWriterSettings {
Encoding = Encoding.UTF8, CheckCharacters = false
});
//XmlTextWriter xw = new XmlTextWriter(fw, Encoding.UTF8);
//xw.Settings = new XmlWriterSettings { CheckCharacters = false };
xw.WriteStartDocument();
xw.WriteStartElement(dbName);
// mono has bug in writing schema
if (!Core.IsMono)
{
table.WriteXmlSchema(xw);
}
List <string> ids = new List <string>();
foreach (IColumnStructure col in queue.GetRowFormat.Columns)
{
ids.Add(XmlTool.NormalizeIdentifier(col.ColumnName));
}
try
{
while (!queue.IsEof)
{
IBedRecord row = queue.GetRecord();
xw.WriteStartElement(tableName);
for (int i = 0; i < row.FieldCount; i++)
{
row.ReadValue(i);
var type = row.GetFieldType();
if (type == TypeStorage.Null)
{
continue;
}
xw.WriteElementString(ids[i], XmlTool.ObjectToString(row.GetValue(i)));
}
xw.WriteEndElement();
}
}
finally
{
queue.CloseReading();
}
xw.WriteEndElement();
xw.WriteEndDocument();
xw.Flush();
}
public virtual void FillTable(ITableStructure table, IDataQueue queue, TableCopyOptions opts)
{
var colnames = from c in queue.GetRowFormat.Columns select c.ColumnName;
bool autoinc = queue.GetRowFormat.FindAutoIncrementColumn() != null;
if (autoinc)
{
m_dmp.AllowIdentityInsert(table.FullName, true);
}
try
{
while (!queue.IsEof)
{
IBedRecord row = queue.GetRecord();
m_dmp.PutCmd("^insert ^into %f (%,i) ^values (%,v)", table, colnames, row);
}
}
finally
{
queue.CloseReading();
}
if (autoinc)
{
m_dmp.AllowIdentityInsert(table.FullName, false);
}
}
public void WriteRecord(StreamWriter fw, ITableStructure table, IBedRecord record, int index, object manager)
{
var mgr = (Manager)manager;
if (index > 0)
{
fw.Write(ProcessTemplate(RowSeparator));
}
fw.Write(ProcessTemplate(RowBegin));
bool was = false;
for (int i = 0; i < record.FieldCount; i++)
{
record.ReadValue(i);
mgr.formatter.ReadFrom(record);
if (was)
{
fw.Write(ProcessTemplate(CellSeparator));
}
fw.Write(ProcessTemplate(CellBegin));
string val = XmlTool.ObjectToString(mgr.formatter.GetText());
fw.Write(ProcessTemplate(CellValue, "$[VALUE]", val, "$[NAME]", record.GetName(i)));
fw.Write(ProcessTemplate(CellEnd));
was = true;
}
fw.Write(ProcessTemplate(RowEnd));
}
internal void SaveRecord(IBedRecord rec)
{
long pos0 = Data.Length;
BedTool.SaveRecord(rec.FieldCount, rec, m_writer);
Lengths.Add((int)(Data.Length - pos0));
}
public IBedRecord GetRecord()
{
try
{
Element res = m_queue.Get();
if (res.IsEof)
{
throw new Exception("DAE-00223 Eof reached");
}
IBedRecord rec = res.Record;
foreach (var ada in m_outputAdapters)
{
rec = ada.AdaptRecord(rec, ProgressInfo);
}
return(rec);
}
catch (QueueClosedError)
{
if (m_error != null)
{
throw new QueueClosedError("DAE-00224", m_error);
}
throw new QueueClosedError("DAE-00225");
}
}
internal BedRow(BedTable table, IBedRecord original, BedRowState initialState, ITableStructure structure)
{
m_table = table;
m_fields = new FieldRec[m_table.Structure.Columns.Count];
m_original = original;
m_structure = structure;
RowState = initialState;
}
public static string[] GetFieldNames(this IBedRecord record)
{
string[] res = new string[record.FieldCount];
for (int i = 0; i < res.Length; i++)
{
res[i] = record.GetName(i);
}
return(res);
}
public override IBedRecord Transform(IBedRecord record)
{
object[] values = new object[m_target.Columns.Count];
for (int i = 0; i < m_dstIndexes.Count; i++)
{
values[i] = record.GetValue(m_dstIndexes[i]);
}
return(new ArrayDataRecord(m_target, values));
}
public static object[] GetValuesByCols(this IBedRecord record, int[] cols)
{
object[] values = new object[cols.Length];
for (int i = 0; i < cols.Length; i++)
{
values[i] = record.GetValue(cols[i]);
}
return(values);
}
protected override void RunBulkCopy(IDataQueue queue)
{
int okRowCount = 0, failRowCount = 0;
List <string> insertErrors = new List <string>();
ITableStructure dst = queue.GetRowFormat;
var conn = (NpgsqlConnection)Connection.SystemConnection;
NpgsqlCommand command = new NpgsqlCommand(Connection.Dialect.GenerateScript(d => d.Put("^copy %f (%,i) ^from ^stdin", DestinationTable.FullName, from c in dst.Columns select c.ColumnName)), conn);
NpgsqlCopyIn cin = new NpgsqlCopyIn(command, conn);
try
{
cin.Start();
var fw = new BinaryWriter(cin.CopyStream);
while (!queue.IsEof)
{
IBedRecord rec = queue.GetRecord();
for (int i = 0; i < rec.FieldCount; i++)
{
if (i > 0)
{
fw.Write((byte)'\t');
}
rec.ReadValue(i);
WriteField(rec, fw);
}
fw.Write((byte)'\r');
fw.Write((byte)'\n');
okRowCount++;
}
fw.Flush();
cin.End();
}
catch (Exception err)
{
cin.Cancel("canceled");
ProgressInfo.LogMessageDetail(
"INSERT", DatAdmin.LogLevel.Error,
String.Format("{0}", Texts.Get("s_error_inserting_into_table$table", "table", DestinationTable.FullName)), err.ToString());
throw;
}
if (failRowCount > 0)
{
ProgressInfo.LogMessageDetail(
"INSERT", DatAdmin.LogLevel.Error,
String.Format("{0}, OK:{1}, FAIL:{2}", Texts.Get("s_error_inserting_into_table$table", "table", DestinationTable.FullName), okRowCount, failRowCount),
insertErrors.CreateDelimitedText("\r\n")
);
}
else
{
ProgressInfo.LogMessage("INSERT", DatAdmin.LogLevel.Info, Texts.Get("s_inserted_into_table$table$rows", "table", DestinationTable.FullName, "rows", okRowCount));
}
}
public void PutRecord(IBedRecord record)
{
object[] values = new object[record.FieldCount];
record.GetValues(values);
IBedRecord input = new ArrayDataRecord(m_putFormat, values);
IBedRecord trans = m_transform.Transform(input);
m_queue.Put(new Element {
Record = trans
});
}
private List <string> DoCreateUpdateQuery(string askquery)
{
// buffer for update command
var dh = CreateHolderDumper();
var dmp = dh.Dumper;
using (var cmd = m_syn.m_source.Connection.SystemConnection.CreateCommand())
{
cmd.CommandText = askquery;
using (IBedReader reader = m_syn.m_source.GetAnyDDA().AdaptReader(cmd.ExecuteReader()))
{
while (reader.Read())
{
IBedRecord rec = reader;
foreach (var recada in m_outputAdapters)
{
rec = recada.AdaptRecord(rec, m_syn.Progress);
}
dmp.Put("update %f set ", m_item.Target.Table);
for (int i = 0; i < m_dstInfo.DataCols.Length; i++)
{
rec.ReadValue(i + m_dstInfo.KeyCols.Length);
if (i > 0)
{
dmp.Put(", ");
}
dmp.Put("%i=%v", m_dstInfo.DataCols[i], rec);
}
dmp.Put(" where ");
for (int i = 0; i < m_dstInfo.KeyCols.Length; i++)
{
if (i > 0)
{
dmp.Put(" and ");
}
rec.ReadValue(i);
if (rec.GetFieldType() == TypeStorage.Null)
{
dmp.Put("%i ^is ^null", m_dstInfo.KeyCols[i]);
}
else
{
dmp.Put("%i=%v", m_dstInfo.KeyCols[i], rec);
}
}
dmp.EndCommand();
}
}
}
return(dh.Scripts);
}
public override void FillTable(ITableStructure table, IDataQueue queue, TableCopyOptions opts)
{
var colnames = from c in queue.GetRowFormat.Columns select c.ColumnName;
bool autoinc = queue.GetRowFormat.FindAutoIncrementColumn() != null;
if (autoinc)
{
m_dmp.AllowIdentityInsert(table.FullName, true);
}
try
{
if (Cfg != null && Cfg.JoinInserts)
{
int rowsInBatch = 0;
while (!queue.IsEof)
{
if (Cfg.BatchLimit > 0 && rowsInBatch >= Cfg.BatchLimit)
{
m_dmp.EndCommand();
rowsInBatch = 0;
}
if (rowsInBatch > 0)
{
m_dmp.Put(";\n");
}
IBedRecord row = queue.GetRecord();
m_dmp.Put("^insert ^into %f (%,i) ^values (%,v)", table, colnames, row);
rowsInBatch++;
}
if (rowsInBatch > 0)
{
m_dmp.EndCommand();
}
}
else
{
while (!queue.IsEof)
{
IBedRecord row = queue.GetRecord();
m_dmp.PutCmd("^insert ^into %f (%,i) ^values (%,v)", table, colnames, row);
}
}
}
finally
{
queue.CloseReading();
}
if (autoinc)
{
m_dmp.AllowIdentityInsert(table.FullName, false);
}
}
public IBedRecord AdaptRecord(IBedRecord record, ILogger logger)
{
ArrayDataRecord res = new ArrayDataRecord(record.Structure);
for (int i = 0; i < res.FieldCount; i++)
{
record.ReadValue(i);
res.SeekValue(i);
m_dda.AdaptValue(record, m_dstColTypes[i], res, m_outputConv, logger);
}
return(res);
}
public static void WriteQueueToStream(IDataQueue queue, Stream fw, BedDataStats stats)
{
BinaryWriter bw = new BinaryWriter(fw);
bw.Write(SIGNATURE);
bw.Write((int)2); // version
var ts = queue.GetRowFormat;
bw.Write7BitEncodedInt(ts.Columns.Count);
var pk = ts.FindConstraint <IPrimaryKey>();
foreach (IColumnStructure col in ts.Columns)
{
bw.Write(col.ColumnName);
bw.Write((byte)col.DataType.DefaultStorage);
ColFlags flags = 0;
if (pk != null && pk.Columns.IndexOfIf(c => c.ColumnName == col.ColumnName) >= 0)
{
flags |= ColFlags.ISPK;
}
bw.Write((byte)flags);
}
MemoryStream rowdata = new MemoryStream();
BinaryWriter bwrow = new BinaryWriter(rowdata);
try
{
while (!queue.IsEof)
{
rowdata.Position = 0;
rowdata.SetLength(0);
IBedRecord row = queue.GetRecord();
BedTool.SaveRecord(ts.Columns.Count, row, bwrow);
bw.Write7BitEncodedInt((int)rowdata.Length);
rowdata.WriteTo(bw.BaseStream);
if (stats != null)
{
stats.Rows++;
stats.Bytes += (int)rowdata.Length;
stats.Bytes += 4;
}
}
}
finally
{
queue.CloseReading();
}
// write EOF mark
bw.Write7BitEncodedInt(-1);
}
private void ProcessRecord(IBedRecord record, TemplateEnviroment env, int index)
{
if (index > 0 && m_separ != null)
{
m_separ.Run(env);
}
m_engine.Globals["_row_"] = record;
for (int fi = 0; fi < record.FieldCount; fi++)
{
m_engine.Globals["_" + record.GetName(fi).ToLower() + "_"] = record.GetValue(fi).SafeToString();
}
m_body.Run(env);
}
private void DoFillOnBackground(IDataQueue queue)
{
try
{
m_state = TabularDataViewState.Loading;
//DataTable curbuf = null;
Chunk curchunk = null;
try
{
while (!queue.IsEof)
{
if (curchunk == null)
{
curchunk = new Chunk();
}
IBedRecord rec = queue.GetRecord();
curchunk.SaveRecord(rec);
if (curchunk.Count >= BUFFER_SIZE)
{
FlushChunk(curchunk);
curchunk = null;
}
}
}
finally
{
queue.CloseReading();
}
if (curchunk != null)
{
FlushChunk(curchunk);
}
m_state = TabularDataViewState.Prepared;
}
catch (Exception e)
{
Errors.Report(e);
m_state = TabularDataViewState.Error;
queue.PutError(e);
}
finally
{
queue.CloseWriting();
}
if (LoadedNextData != null)
{
LoadedNextData(this, new LoadedNextDataArgs(m_serializedRows));
}
}
public static object[] GetValuesByCols(this IBedRecord record, DmlfColumnRef[] cols, DmlfResultFieldCollection result)
{
if (result == null)
{
return(record.GetValuesByCols(cols.GetNames()));
}
object[] values = new object[cols.Length];
for (int i = 0; i < cols.Length; i++)
{
int index = result.GetColumnIndex(cols[i]);
values[i] = record.GetValue(index);
}
return(values);
}
private void ProcessRecord(IDatabaseSource db, IBedRecord record)
{
string filename = FileNameTemplate;
Dictionary <string, string> vars = new Dictionary <string, string>();
Dictionary <string, object> extnames = new Dictionary <string, object>();
for (int fi = 0; fi < record.FieldCount; fi++)
{
vars["#" + record.GetName(fi).ToUpper() + "#"] = record.GetValue(fi).SafeToString();
extnames["_" + record.GetName(fi).ToUpper() + "_"] = record.GetValue(fi).SafeToString();
}
filename = filename.ReplaceAll(vars);
WriteContent(db, filename, vars, extnames);
}
//public static void SaveField(IDataRecord record, int index, BinaryWriter stream)
//{
// if (record.IsDBNull(index))
// {
// stream.Write((byte)TypeStorage.Null);
// return;
// }
// Type type = record.GetFieldType(index);
// try
// {
// switch (Type.GetTypeCode(type))
// {
// case TypeCode.Boolean:
// {
// bool val = record.GetBoolean(index);
// stream.Write((byte)TypeStorage.Boolean);
// stream.Write(val);
// }
// break;
// case TypeCode.Byte:
// {
// byte val = record.GetByte(index);
// stream.Write((byte)TypeStorage.Byte);
// stream.Write(val);
// }
// break;
// case TypeCode.Int16:
// {
// short val = record.GetInt16(index);
// stream.Write((byte)TypeStorage.Int16);
// stream.Write(val);
// }
// break;
// case TypeCode.Int32:
// {
// int val = record.GetInt32(index);
// stream.Write((byte)TypeStorage.Int32);
// stream.Write(val);
// }
// break;
// case TypeCode.Int64:
// {
// long val = record.GetInt64(index);
// stream.Write((byte)TypeStorage.Int64);
// stream.Write(val);
// }
// break;
// case TypeCode.DateTime:
// {
// DateTime val = record.GetDateTime(index);
// stream.Write((byte)TypeStorage.DateTime);
// stream.Write(val.ToBinary());
// }
// break;
// case TypeCode.Decimal:
// {
// decimal val = record.GetDecimal(index);
// stream.Write((byte)TypeStorage.Decimal);
// stream.Write(val);
// }
// break;
// case TypeCode.Single:
// {
// float val = record.GetFloat(index);
// stream.Write((byte)TypeStorage.Float);
// stream.Write(val);
// }
// break;
// case TypeCode.Double:
// {
// double val = record.GetDouble(index);
// stream.Write((byte)TypeStorage.Double);
// stream.Write(val);
// }
// break;
// case TypeCode.String:
// {
// string val = record.GetString(index);
// stream.Write((byte)TypeStorage.String);
// stream.Write(val);
// }
// break;
// default:
// if (type == typeof(Guid))
// {
// Guid val = record.GetGuid(index);
// stream.Write((byte)TypeStorage.Guid);
// stream.Write(val.ToByteArray());
// }
// else if (type == typeof(byte[]))
// {
// byte[] val = (byte[])record.GetValue(index);
// stream.Write((byte)TypeStorage.ByteArray);
// stream.Write7BitEncodedInt(val.Length);
// stream.Write(val);
// }
// else
// {
// // serialize as string
// string val = record.GetValue(index).ToString();
// stream.Write((byte)TypeStorage.String);
// stream.Write(val);
// }
// break;
// }
// }
// catch
// {
// try
// {
// object val = record[index];
// // try to write boxed value (not very effective)
// SaveField(val, stream);
// }
// catch
// {
// string val = record.GetString(index);
// stream.Write((byte)TypeStorage.String);
// stream.Write(val);
// }
// }
//}
//public static void SaveField(object value, BinaryWriter stream)
//{
// if (value == null || value == DBNull.Value)
// {
// stream.Write((byte)TypeStorage.Null);
// return;
// }
// Type type = value.GetType();
// switch (Type.GetTypeCode(type))
// {
// case TypeCode.Boolean:
// {
// bool val = (bool)value;
// stream.Write((byte)TypeStorage.Boolean);
// stream.Write(val);
// }
// break;
// case TypeCode.Byte:
// {
// byte val = (byte)value;
// stream.Write((byte)TypeStorage.Byte);
// stream.Write(val);
// }
// break;
// case TypeCode.Int16:
// {
// short val = (short)value;
// stream.Write((byte)TypeStorage.Int16);
// stream.Write(val);
// }
// break;
// case TypeCode.Int32:
// {
// int val = (int)value;
// stream.Write((byte)TypeStorage.Int32);
// stream.Write(val);
// }
// break;
// case TypeCode.Int64:
// {
// long val = (long)value;
// stream.Write((byte)TypeStorage.Int64);
// stream.Write(val);
// }
// break;
// case TypeCode.DateTime:
// {
// DateTime val = (DateTime)value;
// stream.Write((byte)TypeStorage.DateTime);
// stream.Write(val.ToBinary());
// }
// break;
// case TypeCode.Decimal:
// {
// decimal val = (decimal)value;
// stream.Write((byte)TypeStorage.Decimal);
// stream.Write(val);
// }
// break;
// case TypeCode.Single:
// {
// float val = (float)value;
// stream.Write((byte)TypeStorage.Float);
// stream.Write(val);
// }
// break;
// case TypeCode.Double:
// {
// double val = (double)value;
// stream.Write((byte)TypeStorage.Double);
// stream.Write(val);
// }
// break;
// case TypeCode.String:
// {
// string val = (string)value;
// stream.Write((byte)TypeStorage.String);
// stream.Write(val);
// }
// break;
// default:
// if (type == typeof(Guid))
// {
// Guid val = (Guid)value;
// stream.Write((byte)TypeStorage.Guid);
// stream.Write(val.ToByteArray());
// }
// else if (type == typeof(byte[]))
// {
// byte[] val = (byte[])value;
// stream.Write((byte)TypeStorage.ByteArray);
// stream.Write7BitEncodedInt(val.Length);
// stream.Write(val);
// }
// else
// {
// // serialize as string
// string val = value.ToString();
// stream.Write((byte)TypeStorage.String);
// stream.Write(val);
// }
// break;
// }
//}
public static void SaveRecord(int fldcount, IBedRecord record, BinaryWriter stream)
{
var fw = new StreamValueWriter(stream);
if (fldcount != record.FieldCount)
{
throw new InternalError("DAE-00023 field count mitchmatch");
}
for (int i = 0; i < fldcount; i++)
{
record.ReadValue(i);
fw.ReadFrom(record);
}
}
public void WriteRecord(StreamWriter fw, ITableStructure table, IBedRecord record, int index, object manager)
{
if (m_dda == null)
{
m_dda = (m_dialect ?? GenericDialect.Instance).CreateDataAdapter();
}
fw.Write("INSERT INTO ");
fw.Write(m_tableName);
fw.Write(" (");
bool was = false;
for (int i = 0; i < record.FieldCount; i++)
{
if (was)
{
fw.Write(",");
}
fw.Write(record.GetName(i));
was = true;
}
fw.Write(") VALUES (");
was = false;
for (int i = 0; i < record.FieldCount; i++)
{
if (was)
{
fw.Write(",");
}
record.ReadValue(i);
fw.Write(m_dda.GetSqlLiteral(record));
//TypeStorage type = record.GetFieldType();
//if (record.IsDBNull(i))
//{
// fw.Write("NULL");
//}
//else
//{
// fw.Write(m_quoteCharacter);
// string val = XmlTool.ObjectToString(record.GetValue(i));
// val = val.Replace("" + m_quoteCharacter, m_escapedQuote);
// fw.Write(val);
// fw.Write(m_quoteCharacter);
//}
was = true;
}
fw.Write(")");
fw.Write(m_statementSeparator.ReplaceCEscapes());
}
public void WriteRecord(System.IO.StreamWriter fw, ITableStructure table, IBedRecord record, int index, object manager)
{
var mgr = (Manager)manager;
m_fmt.Writer = fw;
m_fmt.BeginRow(false);
for (int i = 0; i < record.FieldCount; i++)
{
record.ReadValue(i);
mgr.formatter.ReadFrom(record);
m_fmt.Cell(mgr.formatter.GetText());
}
m_fmt.EndRow(false);
m_fmt.Writer = null;
}
public override void GenerateSqlRow(IBedRecord row, ISqlDumper dmp, string[] selcolumns)
{
string[] colnames = GetColumns(ValueColumns, row.Structure, selcolumns);
var vals = new ValueTypeHolder[colnames.Length];
for (int i = 0; i < colnames.Length; i++)
{
vals[i] = new ValueTypeHolder(row.GetValue(colnames[i]), row.Structure.Columns[colnames[i]].DataType);
}
dmp.PutCmd("^insert ^into %f (%,i) ^values (%,v)",
FullTableName,
colnames,
vals
);
}
protected void GenerateWhere(IBedRecord row, ISqlDumper dmp, string[] selcolumns)
{
dmp.Put(" ^where ");
bool was = false;
foreach (string col in GetColumns(WhereColumns, row.Structure, selcolumns))
{
if (was)
{
dmp.Put(" ^and ");
}
dmp.Put("%i = %v", col, row.GetValue(col));
was = true;
}
}
public static SynFootprint FromReader(IBedRecord record, int keylen, BedValueHolder holder, BedValueConvertor conv, IDataSynAdapter adapter)
{
var res = new SynFootprint();
res.KeyData = new string[keylen];
for (int i = 0; i < keylen; i++)
{
record.ReadValue(i);
conv.ConvertValue(record, TypeStorage.String, holder);
res.KeyData[i] = holder.GetString();
}
record.ReadValue(keylen);
res.Hash = adapter.ReadHash(record, conv, holder);
return(res);
}
public ArrayDataRecord(IBedRecord record, int[] colindexes, ITableStructure changedStructure)
{
if (colindexes.Length != changedStructure.Columns.Count)
{
throw new InternalError("DAE-00052 ArrayDataRecord(): colnames.count != colindexes.count");
}
m_values = new object[colindexes.Length];
for (int i = 0; i < colindexes.Length; i++)
{
if (colindexes[i] >= 0)
{
m_values[i] = record.GetValue(colindexes[i]);
}
}
m_structure = changedStructure;
}
public override void FillTable(ITableStructure table, IDataQueue queue, TableCopyOptions opts)
{
var colnames = from c in queue.GetRowFormat.Columns select c.ColumnName;
try
{
if (Wcfg != null && Wcfg.ExtendedInserts)
{
int rowsInBatch = 0;
while (!queue.IsEof)
{
if (Wcfg.BatchLimit > 0 && rowsInBatch >= Wcfg.BatchLimit)
{
m_dmp.EndCommand();
rowsInBatch = 0;
}
if (rowsInBatch == 0)
{
m_dmp.Put("^insert ^into %f (%,i) ^values\n", table, colnames);
}
else
{
m_dmp.Put(",\n");
}
IBedRecord row = queue.GetRecord();
m_dmp.Put("(%,v)", row);
rowsInBatch++;
}
if (rowsInBatch > 0)
{
m_dmp.EndCommand();
}
}
else
{
while (!queue.IsEof)
{
IBedRecord row = queue.GetRecord();
m_dmp.PutCmd("^insert ^into %f (%,i) ^values (%,v)", table, colnames, row);
}
}
}
finally
{
queue.CloseReading();
}
}
public override void GenerateSqlRow(IBedRecord row, ISqlDumper dmp, string[] selcolumns)
{
dmp.Put("^update %f ^set ", FullTableName);
bool was = false;
foreach (string col in GetColumns(ValueColumns, row.Structure, selcolumns))
{
if (was)
{
dmp.Put(", ");
}
dmp.Put("%i = %v", col, new ValueTypeHolder(row.GetValue(col), row.Structure.Columns[col].DataType));
was = true;
}
GenerateWhere(row, dmp, selcolumns);
dmp.EndCommand();
}
public void WriteRecord(StreamWriter fw, ITableStructure table, IBedRecord record, int index, object manager)
{
var mgr = (Manager)manager;
string[] data = mgr.data;
CsvWriter cw = CreateWriter(fw);
// write data
for (int i = 0; i < data.Length; i++)
{
record.ReadValue(i);
mgr.formatter.ReadFrom(record);
data[i] = mgr.formatter.GetText();
}
cw.WriteRow(data);
}
private List <string> DoCreateInsertQuery(string askquery)
{
var dh = CreateHolderDumper();
var dmp = dh.Dumper;
var autoinccol = m_dstInfo.Model.FindAutoIncrementColumn();
bool idins = autoinccol != null &&
(m_dstInfo.KeyCols.Contains(autoinccol.ColumnName) || m_dstInfo.DataCols.Contains(autoinccol.ColumnName));
if (idins)
{
dmp.AllowIdentityInsert(m_item.Target.Table, true);
}
using (var cmd = m_syn.m_source.Connection.SystemConnection.CreateCommand())
{
cmd.CommandText = askquery;
using (IBedReader reader = m_syn.m_source.GetAnyDDA().AdaptReader(cmd.ExecuteReader()))
{
while (reader.Read())
{
IBedRecord rec = reader;
foreach (var recada in m_outputAdapters)
{
rec = recada.AdaptRecord(rec, m_syn.Progress);
}
dmp.Put("insert into %f (%,i %s %,i) values (%,v)",
m_item.Target.Table,
m_dstInfo.KeyCols,
m_dstInfo.DataCols.Length > 0 ? "," : "",
m_dstInfo.DataCols,
rec
);
dmp.EndCommand();
}
}
}
if (idins)
{
dmp.AllowIdentityInsert(m_item.Target.Table, false);
}
return(dh.Scripts);
}
