public void checkLongCharLengthWithClipper()
{
var fieldLength = 750;
string writtenValue;
using (
Stream fos =
File.Open(TestClipLongPath(),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
{
var writer = new DBFWriter();
var field = new DBFField("F1", NativeDbType.Char, fieldLength);
writer.Fields = new[] { field };
writtenValue = GetCharacters(fieldLength);
writer.AddRecord(writtenValue);
writer.Write(fos);
}
using (
Stream fis =
File.Open(TestClipLongPath(),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
{
var reader = new DBFReader(fis);
Assert.That(reader.Fields.First().FieldLength, EqualTo(fieldLength));
var readValues = reader.NextRecord();
Assert.That(readValues[0], EqualTo(writtenValue), "Written Value not equaling Read");
}
}
public void checkDataType_M()
{
var fieldLength = 2400;
MemoValue writtenValue;
using (Stream fos = File.Open(TestMemoPath(), FileMode.OpenOrCreate, FileAccess.ReadWrite))
using (var writer = new DBFWriter
{
DataMemoLoc = Path.ChangeExtension(TestMemoPath(), "DBT")
})
{
var field = new DBFField("F1", NativeDbType.Memo);
writer.Fields = new[] { field };
writtenValue = new MemoValue(GetCharacters(fieldLength));
writer.AddRecord(writtenValue);
writer.Write(fos);
}
using (Stream fis = File.Open(TestMemoPath(), FileMode.OpenOrCreate, FileAccess.ReadWrite))
using (var reader = new DBFReader(fis)
{
DataMemoLoc = Path.ChangeExtension(TestMemoPath(), "DBT")
})
{
var readValues = reader.NextRecord();
Assert.That(readValues[0], EqualTo(writtenValue), "Written Value not equaling Read");
}
}
public void checkDataType_N()
{
Decimal writtenValue;
using (
Stream fos =
File.Open(TestPath(),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
using (var writer = new DBFWriter())
{
var field = new DBFField("F1", NativeDbType.Numeric, 15, 0);
writer.Fields = new[] { field };
writtenValue = 123456789012345L;
writer.AddRecord(writtenValue);
writer.Write(fos);
}
using (
Stream fis =
File.Open(TestPath(),
FileMode.Open,
FileAccess.Read))
using (var reader = new DBFReader(fis))
{
var readValues = reader.NextRecord();
Assert.That(readValues[0], EqualTo(writtenValue), "Written Value Equals Read");
}
}
public void checkRAFwriting()
{
println("Writing in RAF mode ... ");
if (File.Exists(TestRAFPath()))
{
File.Delete(TestRAFPath());
}
using (var writer = new DBFWriter(TestRAFPath()))
{
var fields = new DBFField[2];
fields[0] = new DBFField("F1", NativeDbType.Char, 10);
fields[1] = new DBFField("F2", NativeDbType.Numeric, 2);
writer.Fields = fields;
writer.WriteRecord("Red", 10);
writer.WriteRecord("Blue", 20);
}
println("done.");
println("Appending to this file");
using (var writer = new DBFWriter(TestRAFPath()))
{
writer.WriteRecord("Green", 33);
writer.WriteRecord("Yellow", 44);
}
println("done.");
}
public static object[] GetFields()
{
var fDocnum = new DBFField {
Name = "docnum", DataType = NativeDbType.Char, FieldLength = 12
};
var fEmail = new DBFField {
Name = "email", DataType = NativeDbType.Char, FieldLength = 50
};
var fStatus = new DBFField {
Name = "status", DataType = NativeDbType.Char, FieldLength = 1
};
return(new[] { fDocnum, fEmail, fStatus });
}
public void WriteSample([CallerMemberName] string name = null)
{
var field = new DBFField {
Name = "F1", DataType = NativeDbType.Numeric
};
var writer = new DBFWriter {
Fields = new[] { field }
};
writer.AddRecord(3);
using (
Stream fos =
File.Open(TestPath(name),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
{
writer.Write(fos);
}
}
public void checkProxy()
{
var fieldLength = 2400;
string writtenValue;
using (
Stream fos =
File.Open(TestSelectPath(),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
{
using (var writer = new DBFWriter {
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
;
var field = new DBFField("F1", NativeDbType.Memo);
var field2 = new DBFField("F2", NativeDbType.Numeric, 10);
var field3 = new DBFField("F3", NativeDbType.Char, 10);
writer.Fields = new[] { field, field2, field3 };
writtenValue = "alpha";
writer.AddRecord(new MemoValue(GetCharacters(fieldLength)), 10, writtenValue);
writer.Write(fos);
}
}
using (
Stream fis =
File.Open(TestSelectPath(),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
{
using (var reader = new DBFReader(fis)
{
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
var readValues = reader.AllRecords <ITestInterface>();
Assert.That(readValues.First().F3, StartsWith(writtenValue), "Written Value not equaling Read");
}
}
}
public void checkSelectDynamic()
{
var fieldLength = 2400;
string writtenValue;
string writtenMemo;
using (
Stream fos =
File.Open(TestSelectPath(),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
using (var writer = new DBFWriter
{
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
var field = new DBFField("F1", NativeDbType.Memo);
var field2 = new DBFField("F2", NativeDbType.Numeric, 10);
var field3 = new DBFField("F3", NativeDbType.Char, 10);
writer.Fields = new[] { field, field2, field3 };
writtenValue = "alpha";
writtenMemo = GetCharacters(fieldLength);
writer.AddRecord(new MemoValue(writtenMemo), 10, writtenValue);
writer.Write(fos);
}
using (
Stream fis =
File.Open(TestSelectPath(),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
using (var reader = new DBFReader(fis)
{
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
reader.SetSelectFields("F1", "F3");
var readValues = reader.DynamicAllRecords().First();
Assert.That(readValues.F1.ToString(), EqualTo(writtenMemo), "Written Value not equaling Read");
Assert.That(readValues.F3, EqualTo(writtenValue), "Written Value not equaling Read");
}
}
public void checkDynamicProxyWhere()
{
var fieldLength = 2400;
string writtenValue;
using (
Stream fos =
File.Open(TestSelectPath(),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
using (var writer = new DBFWriter
{
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
var field = new DBFField("F1", NativeDbType.Memo);
var field2 = new DBFField("F2", NativeDbType.Numeric, 10);
var field3 = new DBFField("F3", NativeDbType.Char, 10);
writer.Fields = new[] { field, field2, field3 };
writtenValue = "alpha";
writer.AddRecord(new MemoValue(GetCharacters(fieldLength)), 10, writtenValue);
writer.AddRecord(new MemoValue(GetCharacters(fieldLength)), 12, "beta");
writer.Write(fos);
}
using (var reader = new DBFReader(TestSelectPath())
{
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
var readValues = reader.DynamicAllRecords();
Assert.That(Equals(readValues.Count(), 2), "All Records not matching");
}
using (var reader = new DBFReader(TestSelectPath())
{
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
var readValues = reader.DynamicAllRecords(whereColumn: "F2", whereColumnEquals: 10);
Assert.That(Equals(readValues.Count(), 1), "All Records not matching");
}
using (var reader = new DBFReader(TestSelectPath())
{
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
var readValues = reader.DynamicAllRecords(whereColumn: "F2", whereColumnEquals: 12);
Assert.That(Equals(readValues.Count(), 1), "All Records not matching");
}
using (var reader = new DBFReader(TestSelectPath())
{
DataMemoLoc = Path.ChangeExtension(TestSelectPath(), "DBT")
})
{
var readValues = reader.DynamicAllRecords(whereColumn: "F2", whereColumnEquals: 13);
Assert.That(Equals(readValues.Count(), 0), "All Records not matching");
}
}
private void ExportData()
{
var fileName = Project.Current.MapPath(FileName);
if (string.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException("Filename is not provided.");
}
if (!Overwrite && File.Exists(fileName))
{
throw new Exception($"File '{FileName}' already exists.");
}
if (Overwrite && File.Exists(fileName))
{
File.Delete(fileName);
}
using var stream = new FileStream(fileName, FileMode.CreateNew, FileAccess.Write);
using var dataReader = GetDataSourceReader(_Output, DataSource,
new DataSourceParameters()
{
IgnoreErrors = this.IgnoreErrors, Columns = this.SelectColumns, SkipColumns = this.SkipColumns
});
var writer = new DBFWriter(stream);
var dbFields = new List <DBFField>();
int columnCount = dataReader.FieldCount;
var schema = dataReader.GetSchemaTable();
for (int i = 0; i < columnCount; i++)
{
var fieldName = dataReader.GetName(i) ?? string.Empty;
var name = fieldName.Length <= 10 ? fieldName : fieldName.Substring(0, 10);
var type = dataReader.GetFieldType(i);
DBFField dbField = null;
switch (Type.GetTypeCode(type))
{
case TypeCode.Empty:
case TypeCode.Object:
case TypeCode.DBNull:
throw new Exception($"Type '{type.FullName}' cannot be exported into DBF.");
case TypeCode.Boolean:
dbField = new DBFField(name, NativeDbType.Logical);
break;
case TypeCode.Char:
int charSize = GetColumnMaxLength(name);
dbField = new DBFField(name, NativeDbType.Char, charSize);
break;
case TypeCode.SByte:
dbField = new DBFField(name, NativeDbType.Numeric, 5);
break;
case TypeCode.Byte:
dbField = new DBFField(name, NativeDbType.Numeric, 5);
break;
case TypeCode.Int16:
dbField = new DBFField(name, NativeDbType.Numeric, 6);
break;
case TypeCode.UInt16:
dbField = new DBFField(name, NativeDbType.Numeric, 6);
break;
case TypeCode.Int32:
dbField = new DBFField(name, NativeDbType.Numeric, 12);
break;
case TypeCode.UInt32:
dbField = new DBFField(name, NativeDbType.Numeric, 12);
break;
case TypeCode.Int64:
dbField = new DBFField(name, NativeDbType.Numeric, 19);
break;
case TypeCode.UInt64:
dbField = new DBFField(name, NativeDbType.Numeric, 19);
break;
case TypeCode.Single:
dbField = new DBFField(name, NativeDbType.Float, 19, 4);
break;
case TypeCode.Double:
dbField = new DBFField(name, NativeDbType.Float, 19, 4);
break;
case TypeCode.Decimal:
dbField = new DBFField(name, NativeDbType.Float, 19, 4);
break;
case TypeCode.DateTime:
dbField = new DBFField(name, NativeDbType.Date);
break;
case TypeCode.String:
int strSize = GetColumnMaxLength(fieldName);
dbField = new DBFField(name, NativeDbType.Char, strSize);
break;
}
dbFields.Add(dbField);
}
writer.Fields = dbFields.ToArray();
object[] values = new object[columnCount];
int[] lengths = new int[columnCount];
for (int i = 0; i < writer.Fields.Length; i++)
{
lengths[i] = writer.Fields[i].FieldLength;
}
while (dataReader.Read())
{
for (int i = 0; i < columnCount; i++)
{
object value = dataReader.GetValue(i);
if (value is string str && str.Length > lengths[i])
{
value = str.Substring(0, lengths[i]);
}
values[i] = value;
}
writer.WriteRecord(values);
}
int GetColumnMaxLength(string columnName)
{
const int DefaultStringColumnSize = 254;
if (schema == null || schema.Rows.Count <= 0)
{
return(DefaultStringColumnSize);
}
if (schema.Columns["ColumnName"] == null || schema.Columns["ColumnSize"] == null)
{
return(DefaultStringColumnSize);
}
foreach (DataRow row in schema.Rows)
{
var colName = Convert.ToString(row["ColumnName"]);
if (string.Compare(colName, columnName, true) == 0)
{
int size = Convert.ToInt32(row["ColumnSize"]);
if (size > 0 && size <= DefaultStringColumnSize)
{
return(size);
}
return(DefaultStringColumnSize);
}
}
return(DefaultStringColumnSize);
}
}
