public override IEnumerator ReceivePayload(VisualPayload payload)
{
foreach (var entry in CsvField.GetEntries(payload.Data))
{
string csvString = CsvField.GetValue(entry);
if (string.IsNullOrEmpty(csvString))
{
yield break;
}
var values = csvString.Split(',');
NumberOfElementsTarget.SetValue(Mathf.FloorToInt(values.Length / 4f), entry);
for (int i = 0; i < values.Length / 4; i++)
{
Entry1Target.SetValue(values[4 * i], entry);
Entry2Target.SetValue(values[4 * i + 1], entry);
Entry3Target.SetValue(values[4 * i + 2], entry);
Entry4Target.SetValue(values[4 * i + 3], entry);
var iterator = PerEntryState.Transmit(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
}
}
private static SqlCommand MakeCommand(SqlConnection connection, IEnumerable <ColumnDef> columnDefs, CsvRecord headers)
{
//TODO: ensure that all the not-nullable columns have corresponding headers (this will include the primary key fields).
//TODO: ensure that all the columns in headers are actually in the table.
var toReturn = connection.CreateCommand();
var tableName = columnDefs.First().TableName;
/*
* update [dbo].[DinerType]
* set [Description] = @Description,
* [Code] = @Code
* where [Id] = @Id
*
* insert into [dbo].[DinerType] ([Id], [Description], [Code]) select @Id, @Description, @Code where not exists(select * from [dbo].[DinerType] where [Id] = @Id)
*/
string setClause = GetNonPkSetClause(columnDefs, headers);
string pkWhereClause = GetPkWhereClause(columnDefs);
string insertColumnListClause = GetInsertColumnListClause(headers);
string insertSelectColumnListClause = GetInsertSelectColumnListClause(headers);
//the setClause might be an empty string when this is a linking table
string commandText = "";
if (!string.IsNullOrEmpty(setClause))
{
commandText = string.Format("update [dbo].[{0}] {1} {2}", tableName, setClause, pkWhereClause);
}
commandText += string.Format(
@"
insert into [dbo].[{0}] ({2}) select {3} where not exists (select * from [dbo].[{0}] {1})",
tableName, pkWhereClause, insertColumnListClause, insertSelectColumnListClause);
if (columnDefs.Any(cd => cd.IsIdentity))
{
commandText = "set identity_insert [dbo].[" + tableName + "] on\r\n" + commandText +
"\r\nset identity_insert [dbo].[" +
tableName + "] off\r\n";
}
toReturn.CommandText = commandText;
foreach (CsvField header in headers.Fields)
{
CsvField header1 = header;
var columnDef = columnDefs.First(cd => string.Equals(cd.ColumnName, header1.Value, StringComparison.OrdinalIgnoreCase));
toReturn.Parameters.Add(MakeParameter(columnDef));
}
toReturn.CommandType = CommandType.Text;
return(toReturn);
}
// Token: 0x06000094 RID: 148 RVA: 0x00004DE8 File Offset: 0x00002FE8
public LogIndex(string logFilePath, CsvTable table, CsvField columnToIndex, bool isActive)
{
this.logFilePath = logFilePath;
this.table = table;
this.columnToIndex = columnToIndex;
this.columnIdToIndex = table.NameToIndex(columnToIndex.Name);
this.normalizeMethod = columnToIndex.NormalizeMethod;
this.indexFileDirectory = Path.Combine(Path.GetDirectoryName(logFilePath), "index");
this.isActive = isActive;
}
public void ParseAllFields()
{
for (int i = 0; i < this.unparsedRow.Schema.Fields.Length; i++)
{
CsvField csvField = this.unparsedRow.Schema.Fields[i];
Type type = csvField.Type;
string name = csvField.Name;
this.ParseField(name, type);
}
}
/// <summary>
/// Convert the current CSV to a csv object
/// allows to set false the second parameter to indicate that there is no headers
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private CsvContent ParseCsvData(string path)
{
var csv = new CsvContent();
var parser = new ParseCsv(Configuration);
var parsedFile = parser.FromFile(path);
var enumerable = parsedFile as IList <string>[] ?? parsedFile.ToArray();
if (Configuration.GetContainsHeaders())
{
var headrs = enumerable.Take(1);
var counter = 0;
foreach (var headlist in headrs)
{
foreach (var element in headlist)
{
var head = new CsvField();
head.Field = element == null ? "" : element.ToString();
head.Position = counter;
csv.Headers.Add(head);
counter++;
}
}
}
//skip the first row if contains headers
var rows = enumerable.Skip((Configuration.GetContainsHeaders() ? 1 : 0));
foreach (var row in rows)
{
var counter = 0;
var rowline = new CsvRow();
foreach (string element in row)
{
rowline.FieldValue.Add(new CsvField {
Value = element == null ? "" : element.ToString(), Position = counter, Field = (csv.Headers.Any() ? csv.Headers.ElementAt(counter).Field:"")
});
counter++;
}
csv.Rows.Add(rowline);
}
return(csv);
}
/// <summary>
/// Find and return the value of one of the mandatory (non-flight-property)
/// fields
/// </summary>
/// <typeparam name="U"></typeparam>
/// <param name="count"></param>
/// <param name="name"></param>
/// <param name="record"></param>
/// <returns></returns>
private U GetMandatoryFieldValue <U>(int count, string name, string[] record) where U : IConvertible
{
// Locate the field with this name
CsvField field = _fields.FirstOrDefault(f => f.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
if (field == null)
{
// Not found, so an an error to the errors collection and throw
// an exception
string message = $"Missing field '{name}' at record '{count}'";
LastError = new CsvReaderError {
Record = count, Message = message
};
throw new FieldNotFoundException(message);
}
U value;
try
{
// Attempt to convert the value for this field to type U
value = field.Get <U>(record);
}
catch (Exception ex)
{
LastError = new CsvReaderError
{
Record = count,
Message = $"Error getting value for field '{name}' at record {count}",
Exception = ex.Message
};
throw;
}
return(value);
}
