public void AvrDataRowExCopyTest()
{
var originalTable = new AvrDataTable();
var rowDTO = new AvrDataRowDTO(1, 2, 2);
rowDTO.SetInt(0, 1);
rowDTO.SetInt(1, 2);
rowDTO.SetObject(2, "xx");
rowDTO.SetObject(3, true);
rowDTO.SetDateTime(4, new DateTime(2000, 1, 1));
AvrDataRowEx original = originalTable.NewRow(rowDTO);
Assert.AreEqual(1, original[0]);
Assert.AreEqual(2, original[1]);
Assert.AreEqual("xx", original[2]);
Assert.AreEqual(true, original[3]);
Assert.AreEqual(new DateTime(2000, 1, 1), original[4]);
AvrDataRowEx copy = (AvrDataRowEx)original.Clone();
Assert.IsNotNull(copy);
Assert.AreNotSame(copy, original);
Assert.AreEqual(original.Count, copy.Count);
for (int i = 0; i < original.Count; i++)
{
Assert.AreEqual(original[i], copy[i]);
}
}
public void GetPivotSummaryTypeTest()
{
using (var pivot = new PivotDetailPanel())
{
AvrDataTable dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
List <WinPivotGridField> list = AvrPivotGridHelper.CreateFields <WinPivotGridField>(dataTable);
pivot.PivotGrid.Fields.AddRange(list.ToArray());
pivot.PivotGrid.SetDataSourceAndCreateFields(dataTable);
Assert.IsTrue(Configuration.SummaryTypeDictionary.ContainsKey(typeof(string)));
CustomSummaryType type = Configuration.SummaryTypeDictionary[typeof(string)];
Assert.AreEqual(CustomSummaryType.Count, type);
Assert.IsTrue(Configuration.SummaryTypeDictionary.ContainsKey(typeof(DateTime)));
type = Configuration.SummaryTypeDictionary[typeof(DateTime)];
Assert.AreEqual(CustomSummaryType.Max, type);
Assert.IsFalse(Configuration.SummaryTypeDictionary.ContainsKey(typeof(bool)));
type = Configuration.DefaltSummaryType;
Assert.AreEqual(CustomSummaryType.Count, type);
Assert.IsTrue(Configuration.SummaryTypeDictionary.ContainsKey(typeof(int)));
type = Configuration.SummaryTypeDictionary[typeof(int)];
Assert.AreEqual(CustomSummaryType.Sum, type);
Assert.IsTrue(Configuration.SummaryTypeDictionary.ContainsKey(typeof(long)));
type = Configuration.SummaryTypeDictionary[typeof(long)];
Assert.AreEqual(CustomSummaryType.Sum, type);
}
}
public void AvrDataTableRejectChangesTest()
{
QueryTableHeaderModel model = GetQueryTableHeaderModel();
var table = new AvrDataTable(model, 1024);
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
Assert.AreEqual(2, table.Rows.Count);
table.RejectChanges();
Assert.AreEqual(0, table.Rows.Count);
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
Assert.AreEqual(2, table.Rows.Count);
table.AcceptChanges();
table.RejectChanges();
Assert.AreEqual(2, table.Rows.Count);
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
Assert.AreEqual(3, table.Rows.Count);
table.RejectChanges();
Assert.AreEqual(2, table.Rows.Count);
table.Rows.Add(table.NewRow(new object[table.Columns.DistinctCount]));
Assert.AreEqual(3, table.Rows.Count);
table.AcceptChanges();
table.RejectChanges();
Assert.AreEqual(3, table.Rows.Count);
}
public void AvrDataTableCloneTest()
{
QueryTableHeaderModel model = GetQueryTableHeaderModel();
var original = new AvrDataTable(model, 1024);
original.Rows.Add(original.NewRow(new object[original.Columns.DistinctCount]));
original.Rows.Add(original.NewRow(new object[original.Columns.DistinctCount]));
Assert.AreEqual(2, original.Rows.Count);
AvrDataTable clone = original.Clone();
Assert.IsNotNull(clone);
Assert.AreNotSame(clone, original);
Assert.AreEqual(0, clone.Rows.Count);
Assert.AreEqual(original.TableName, clone.TableName);
Assert.AreEqual(clone.Columns.Count, original.Columns.Count);
Assert.AreEqual(clone.Columns.DistinctCount, original.Columns.DistinctCount);
Assert.AreEqual(clone.Columns.Properties.Count, original.Columns.Properties.Count);
foreach (var column in original.Columns)
{
Assert.IsTrue(clone.Columns.Contains(column.ColumnName));
Assert.IsFalse(clone.Columns.Contains(column));
}
}
private static IEnumerable <PivotGridFieldBase> CreateDiagnosisField()
{
var result = new List <PivotGridFieldBase>();
var grid = new AvrPivotGrid();
var dataTable = new AvrDataTable(CreateTestDataSource());
grid.SetDataSourceAndCreateFields(dataTable);
Assert.AreEqual(8 * 2, grid.BaseFields.Count);
PivotGridFieldBase diagnosisField = grid.BaseFields[6 * 2];
Assert.AreEqual("sflHC_Diagnosis_idfLayoutSearchField_51530730000000", diagnosisField.FieldName);
var diagnosis = new List <object> {
"Botulism", "Anthrax - Pulmonary"
};
diagnosisField.FilterValues.SetValues(diagnosis, PivotFilterType.Included, false);
result.Add(diagnosisField);
PivotGridFieldBase ageField = grid.BaseFields[1 * 2];
Assert.AreEqual("sflHC_PatientAge_idfLayoutSearchField_51536690000000", ageField.FieldName);
var age = new List <object> {
66, 20
};
ageField.FilterValues.SetValues(age, PivotFilterType.Excluded, true);
result.Add(ageField);
return(result);
}
public static void QueryLineListToExcel(string fileName, AvrDataTable data, ExportType type)
{
using (var npoiExcelWrapper = new NpoiExcelWrapper(type))
{
npoiExcelWrapper.Export(fileName, data);
}
}
public void AvrDataTableCopyTest()
{
QueryTableHeaderModel model = GetQueryTableHeaderModel();
var original = new AvrDataTable(model, 1024);
original.Rows.Add(original.NewRow(new object[original.Columns.DistinctCount]));
Assert.AreEqual(1, original.Rows.Count);
AvrDataTable copy = original.Copy();
Assert.IsNotNull(copy);
Assert.AreEqual(original.TableName, copy.TableName);
Assert.AreNotSame(copy, original);
Assert.IsTrue(copy.Rows.Count > 0);
for (int i = 0; i < original.Count; i++)
{
var row = (AvrDataRow)original[i];
var copyRow = (AvrDataRow)copy[i];
Assert.AreNotSame(row, copyRow);
Assert.IsNotNull(row.Array);
Assert.IsNotNull(copyRow.Array);
Assert.AreNotSame(row.Array, copyRow.Array);
Assert.AreEqual(row.Count, copyRow.Count);
for (int j = 0; j < row.Count; j++)
{
Assert.AreEqual(row[j], copyRow[j]);
}
}
}
private ISheet CreateNewSheet(string sheetName, int sheetIndex, AvrDataTable data)
{
if (sheetIndex > 0)
{
sheetName = string.Format("{0} {1}", sheetName, sheetIndex);
}
var sheet = Workbook.CreateSheet(sheetName);
// Create the header row
var excelRow = sheet.CreateRow(0);
var colIndex = 0;
foreach (var col in data.Columns)
{
var cell = excelRow.CreateCell(colIndex);
var caption = col.Caption ?? col.ColumnName;
cell.SetCellValue(caption);
cell.CellStyle = GetCellStyle(CellType.Header);
if (IsDate(col.DataType) || IsNumeric(col.DataType))
{
cell.CellStyle.Alignment = HorizontalAlignment.Right;
}
else
{
cell.CellStyle.Alignment = HorizontalAlignment.Left;
}
sheet.AutoSizeColumn(colIndex);
colIndex++;
}
//
return(sheet);
}
public void PivotReportFormFieldsReflectionTest()
{
PivotGridField field1;
PivotGridField field2;
PivotGridField field3;
using (var pivotGridControl = new AvrPivotGrid())
{
var dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
pivotGridControl.SetDataSourceAndCreateFields(dataTable);
pivotGridControl.Fields[0].Width = 1000;
pivotGridControl.Fields[0].Visible = false;
field1 = ReflectionHelper.CreateAndCopyProperties(pivotGridControl.Fields[0]);
field2 = ReflectionHelper.CreateAndCopyProperties(pivotGridControl.Fields[2]);
field3 = ReflectionHelper.CreateAndCopyProperties(pivotGridControl.Fields[4]);
}
Assert.AreEqual("sflHC_PatientAge_Caption", field1.Caption);
Assert.AreEqual("sflHC_PatientDOB_Caption", field2.Caption);
Assert.AreEqual("sflHC_CaseID_Caption", field3.Caption);
Assert.AreEqual(1000, field1.Width);
Assert.AreEqual(false, field1.Visible);
}
public static List <byte[]> QueryLineListToExcel(AvrDataTable data, ExportType type)
{
using (var npoiExcelWrapper = new NpoiExcelWrapper(type))
{
return(npoiExcelWrapper.Export(data));
}
}
public AvrPivotGridModel(AvrPivotSettings pivotSettings, AvrDataTable realPivotData)
: base(realPivotData)
{
bv.common.Core.Utils.CheckNotNull(pivotSettings, "pivotSettings");
PivotSettings = pivotSettings;
ControlPivotGridSettings = null;
}
private Dictionary <string, byte[]> ExportToByteArrays(string fileName, AvrDataTable data)
{
using (new CultureInfoTransaction(new CultureInfo("en-US")))
{
var sheetName = GetSheetName(data);
var sheet = CreateNewSheet(sheetName, 0, data);
var currentNpoiRowIndex = 1;
var sheetIndex = 0;
var fileNameSuffix = "";
var result = new Dictionary <string, byte[]>();
for (var rowIndex = 0; rowIndex < data.Rows.Count; rowIndex++)
{
if (currentNpoiRowIndex >= m_MaxRowsCount)
{
currentNpoiRowIndex = 1;
sheetIndex++;
if (Workbook is HSSFWorkbook)
{
sheet = CreateNewSheet(sheetName, sheetIndex, data);
}
else
{
fileNameSuffix = sheetIndex.ToString(CultureInfo.InvariantCulture);
result.Add(AppendFileNameWithSuffix(fileName, fileNameSuffix), SaveWorkbook(Workbook));
ResetWorkbook(ExportType.Xlsx);
sheet = CreateNewSheet(sheetName, 0, data);
}
}
var excelRow = sheet.CreateRow(currentNpoiRowIndex++);
var colIndex = 0;
foreach (var column in data.Columns)
{
var cell = excelRow.CreateCell(colIndex);
colIndex++;
cell.CellStyle = GetCellStyle(CellType.Normal);
var row = data.Rows[rowIndex];
if (row[column.Ordinal] == DBNull.Value)
{
SetEmptyCellFormat(cell, column.DataType);
continue;
}
SetCellValue(cell, row[column.Ordinal]);
}
}
if (fileNameSuffix != "")
{
fileNameSuffix = (++sheetIndex).ToString(CultureInfo.InvariantCulture);
}
result.Add(AppendFileNameWithSuffix(fileName, fileNameSuffix), SaveWorkbook(Workbook));
return(result);
}
}
private AvrPivotViewModel CreateAvrPivotViewModelInternal(long layoutId, string lang)
{
LayoutDetailDataSet layoutDataSet = GetLayoutDataSet(layoutId);
LayoutDetailDataSet.LayoutRow layoutRow = GetLayoutRow(layoutDataSet);
m_SharedPresenter.SharedModel.SelectedQueryId = layoutRow.idflQuery;
m_SharedPresenter.SharedModel.SelectedLayoutId = layoutId;
m_Trace.Trace(TraceTitle, string.Format("Layout {0} structure read from DB", layoutId));
var validatorWaiter = new LayoutSilentValidatorWaiter();
var filter = layoutRow.blnApplyPivotGridFilter ? layoutRow.strPivotGridSettings : string.Empty;
var queryResult = AvrMainFormPresenter.ExecQueryInternal(layoutRow.idflQuery, lang,
layoutRow.blnUseArchivedData, filter, validatorWaiter, false, QueryExecutor);
//var queryResult = AvrMainFormPresenter.ExecQueryInternal(layoutRow.idflQuery, lang,
// layoutRow.blnUseArchivedData, layoutRow.strPivotGridSettings, validatorWaiter, false, QueryExecutor);
m_Trace.Trace(TraceTitle, string.Format("Data for layout {0} received from AVR Cashe ", layoutId));
AvrDataTable preparedQueryTable = AvrPivotGridHelper.GetPreparedDataSource(layoutDataSet.LayoutSearchField,
layoutRow.idflQuery, layoutId, queryResult.QueryTable, false);
m_AvrPivot.SetDataSourceAndCreateFields(preparedQueryTable);
RestorePivotSettings(layoutDataSet);
using (m_AvrPivot.BeginTransaction())
{
List <IAvrPivotGridField> fields = m_AvrPivot.AvrFields.ToList();
var result = new LayoutValidateResult();
if (layoutRow.blnShowMissedValuesInPivotGrid)
{
result = AvrPivotGridHelper.AddMissedValuesAndValidateComplexity(m_AvrPivot.DataSource, fields,
validatorWaiter.Validator);
}
if (!result.IsCancelOrUserDialogCancel())
{
result = AvrPivotGridHelper.FillEmptyValuesAndValidateComplexity(m_AvrPivot.DataSource, fields,
validatorWaiter.Validator);
}
if (result.IsCancelOrUserDialogCancel())
{
m_AvrPivot.HideData = true;
}
m_AvrPivot.RefreshData();
}
m_Trace.Trace(TraceTitle, string.Format("Layout {0} builded", layoutId));
PivotGridDataLoadedCommand command = m_AvrPivot.CreatePivotDataLoadedCommand(layoutRow.strLayoutName);
m_Trace.Trace(TraceTitle, string.Format("View model for layout {0}, language {1} created", layoutId, lang));
return(command.Model);
}
private static string GetSheetName(AvrDataTable data)
{
if (string.IsNullOrEmpty(data.TableName))
{
data.TableName = "Sheet";
}
return(EscapeSheetName(data.TableName));
}
public void AvrTableToTableTest()
{
var originalTable = DataHelper.GenerateTestTable();
var avrTable = new AvrDataTable(originalTable);
AccessTests.RemoveCopyColumns(avrTable);
var finalTable = avrTable.ToDataTable();
BinarySerializerTests.AssertTablesAreEqual(originalTable, finalTable);
}
public void UpdatePivotCaptionTest()
{
using (var pivotGridControl = new AvrPivotGrid())
{
var dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
pivotGridControl.SetDataSourceAndCreateFields(dataTable);
Assert.AreEqual("sflHC_PatientAge_Caption", pivotGridControl.Fields[0].Caption);
Assert.AreEqual("sflHC_PatientDOB_Caption", pivotGridControl.Fields[2].Caption);
Assert.AreEqual("sflHC_CaseID_Caption", pivotGridControl.Fields[4].Caption);
}
}
public void UpdatePivotDataTest()
{
using (var pivotGridControl = new AvrPivotGrid())
{
var dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
Assert.AreEqual(6, dataTable.Columns.Count);
pivotGridControl.SetDataSourceAndCreateFields(dataTable);
Assert.AreEqual(dataTable.Columns.Count, pivotGridControl.Fields.Count);
}
}
public void Export(string fileName, AvrDataTable data)
{
var exportDictionary = ExportToByteArrays(fileName, data);
foreach (var export in exportDictionary)
{
using (var stream = new FileStream(export.Key, FileMode.Create))
{
var xlsBytes = export.Value;
stream.Write(xlsBytes, 0, xlsBytes.Length);
stream.Close();
}
}
}
public void PivotReportFormPivotReflectionTest()
{
XRPivotGrid xrPivotGrid;
using (var pivotGrid = new AvrPivotGrid())
{
var dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
pivotGrid.SetDataSourceAndCreateFields(dataTable);
xrPivotGrid = new XRPivotGrid();
ReflectionHelper.CopyCommonProperties(pivotGrid, xrPivotGrid);
Assert.AreEqual(pivotGrid.DataSource.RealPivotData, xrPivotGrid.DataSource);
Assert.AreNotEqual(pivotGrid.Fields.Count, xrPivotGrid.Fields.Count);
}
Assert.AreEqual(0, xrPivotGrid.Fields.Count);
}
public void AvrDataRowCopyTest()
{
var originalTable = new AvrDataTable();
var array = new[] { 1, 2, (object)"xx", true, new DateTime(2000, 1, 1) };
AvrDataRow original = originalTable.NewRow(array);
AvrDataRow copy = (AvrDataRow)original.Clone();
Assert.IsNotNull(copy);
Assert.AreNotSame(copy, original);
Assert.AreEqual(original.Count, copy.Count);
Assert.AreNotSame(original.Array, copy.Array);
for (int i = 0; i < original.Count; i++)
{
Assert.AreEqual(original[i], copy[i]);
}
}
public static DataTable DeserializeToTable(BaseTableDTO dto)
{
List <BaseColumnModel> deserializedHeader = DeserializeHeader(dto.Header);
var result = new DataTable();
result.BeginInit();
result.TableName = dto.TableName;
foreach (BaseColumnModel columnModel in deserializedHeader)
{
var column = new DataColumn(columnModel.Name, columnModel.FinalType)
{
Caption = columnModel.Caption
};
result.Columns.Add(column);
}
result.EndInit();
AvrDataTable avrTable = new AvrDataTable(result);
result.BeginLoadData();
Type[] types = deserializedHeader.Select(c => c.FinalType).ToArray();
foreach (BaseTablePacketDTO packet in dto.BodyPackets)
{
DeserializeBodyPacket(packet, types, avrTable);
}
avrTable.AcceptChanges();
foreach (AvrDataRowBase avrRow in avrTable.Rows)
{
object[] array = new object[avrRow.Count];
for (int j = 0; j < avrRow.Count; j++)
{
array[j] = avrRow[j];
}
result.Rows.Add(array);
}
result.AcceptChanges();
result.EndLoadData();
return(result);
}
public static AvrPivotGridModel FillData(ref long queryId, long layoutId)
{
var service = new WebLayoutDB();
var sessionDataSet = (LayoutDetailDataSet)service.GetDetail(layoutId);
if (queryId <= 0)
{
queryId = ((LayoutDetailDataSet.LayoutRow)sessionDataSet.Layout.Rows[0]).idflQuery;
}
var helper = new LayoutHelper(sessionDataSet);
var settings = new AvrPivotSettings(queryId, layoutId);
helper.InitAvrPivotSettings(settings);
bool isNewObject;
string errorMessage;
AvrDataTable data = LayoutPivotGridHelper.GetPivotData(
helper.LayoutDataSet,
queryId,
layoutId,
settings.UseArchiveData,
settings.ApplyFilter ? settings.FilterCriteriaString :string.Empty,
out isNewObject, out errorMessage);
if (!string.IsNullOrEmpty(errorMessage))
{
throw new AvrException(errorMessage);
}
settings.Fields = AvrPivotGridHelper.CreateFields <WebPivotGridField>(data);
helper.PrepareWebFields(settings);
List <IAvrPivotGridField> fields = settings.Fields.Cast <IAvrPivotGridField>().ToList();
LayoutValidateResult result = helper.LoadPivotFromDB(new AvrPivotGridData(data), fields, isNewObject);
var model = new AvrPivotGridModel(settings, data);
if (result.IsCancelOrUserDialogCancel())
{
model.HideDataForComplexLayout();
}
return(model);
}
private static AvrPivotGridData GetTestData()
{
var table = new AvrDataTable();
for (int i = 0; i < 10; i++)
{
var rowDTO = new AvrDataRowDTO(1, 2, 2);
rowDTO.SetInt(0, i);
rowDTO.SetInt(1, 2 * i);
rowDTO.SetObject(2, "xx_" + i);
rowDTO.SetObject(3, true);
rowDTO.SetDateTime(4, new DateTime(2000, 1, i + 1));
AvrDataRowEx row = table.NewRow(rowDTO);
table.ThreadSafeAdd(row);
}
table.AcceptChanges();
return(new AvrPivotGridData(table));
}
public void PivotDataTransactionTest()
{
using (var pivot = new PivotDetailPanel())
{
AvrDataTable dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
pivot.PivotGrid.SetDataSourceAndCreateFields(dataTable);
for (int i = 0; i < 2; i++)
{
using (var transaction = (DataTransaction)pivot.PivotGrid.BeginTransaction())
{
Assert.IsTrue(transaction.HasData);
using (var innerTransaction = (DataTransaction)pivot.PivotGrid.BeginTransaction())
{
Assert.IsFalse(innerTransaction.HasData);
}
Assert.IsTrue(transaction.HasData);
}
}
}
}
public void ExportBigData()
{
AvrDataTable data = CreateBigData(30, 100000);
string fileName = Path.GetTempPath() + "testBig.xls";
using (var npoiExcelWrapper = new NpoiExcelWrapper(ExportType.Xls))
{
npoiExcelWrapper.Export(fileName, data);
Assert.IsTrue(File.Exists(fileName));
}
fileName = Path.GetTempPath() + "testBig1.xlsx";
using (var npoiExcelWrapper = new NpoiExcelWrapper(ExportType.Xlsx))
{
npoiExcelWrapper.Export(fileName, data);
Assert.IsTrue(File.Exists(NpoiExcelWrapper.AppendFileNameWithSuffix(fileName, "1")));
Assert.IsTrue(File.Exists(NpoiExcelWrapper.AppendFileNameWithSuffix(fileName, "2")));
Assert.IsTrue(File.Exists(NpoiExcelWrapper.AppendFileNameWithSuffix(fileName, "3")));
Assert.IsTrue(File.Exists(NpoiExcelWrapper.AppendFileNameWithSuffix(fileName, "4")));
}
}
public void PivotLayoutTest()
{
using (var pivot = new PivotDetailPanel())
{
AvrDataTable dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
pivot.PivotGrid.SetDataSourceAndCreateFields(dataTable);
string fileXml;
pivot.PivotGrid.SaveLayoutToXml("1.xml");
using (var reader = new StreamReader("1.xml"))
{
fileXml = reader.ReadToEnd();
Console.WriteLine(@"file xml length={0}", fileXml.Length);
}
string streamXml = GetLayoutXml(pivot.PivotGrid);
Assert.AreEqual(streamXml, fileXml);
SetLayoutXml(pivot.PivotGrid, streamXml);
}
}
public void ZlibLayoutTest()
{
string streamXml;
using (PresenterFactory.BeginSharedPresenterTransaction(m_Container, new BaseForm()))
{
using (var pivotGrid = new AvrPivotGrid())
{
var dataTable = new AvrDataTable(DataHelper.GenerateTestTable());
pivotGrid.SetDataSourceAndCreateFields(dataTable);
streamXml = ViewReportTests.GetLayoutXml(pivotGrid);
}
}
byte[] bytes = BinaryCompressor.ZipString(streamXml);
string uncompressed = BinaryCompressor.UnzipString(bytes);
Assert.AreEqual(streamXml, uncompressed);
}
public static void DeserializeBodyPacket(StreamTablePacketDTO packet, Type[] types, AvrDataTable table)
{
Utils.CheckNotNull(packet, "packet");
DeserializeBodyPacket(packet.RowCount, types, table, packet.StreamCreator);
}
public static void DeserializeBodyPacket(int rowsCount, Type[] types, AvrDataTable table, Func <Stream> streamCreator)
{
Utils.CheckNotNull(types, "types");
Utils.CheckNotNull(streamCreator, "streamCreator");
Stream stream = streamCreator();
if (stream == null)
{
throw new AvrException("Could not deserialize avr table packet: stream creator is null");
}
int colsCount = types.Length;
var internIndexes = new int[colsCount];
var internStrings = new string[colsCount][];
for (int i = 0; i < internStrings.Length; i++)
{
internStrings[i] = new string[sbyte.MaxValue];
}
ExpressionEvaluator filter = null;
if (!string.IsNullOrEmpty(table.RowFilterExpression))
{
var descriptor = new AvrRowEvaluatorContextDescriptor(table);
var criteriaOperator = CriteriaOperator.Parse(table.RowFilterExpression);
filter = new ExpressionEvaluator(descriptor, criteriaOperator);
}
var rowDTO = CreateAvrDataRowDTO(types);
using (var reader = new BinaryReader(stream))
{
for (int i = 0; i < rowsCount; i++)
{
for (int j = 0; j < colsCount; j++)
{
sbyte status = reader.ReadSByte();
if (status > 0)
{
Type type = types[j];
if (type == m_TypeOfString)
{
string val;
var internIndex = internIndexes[j];
if (internIndex < sbyte.MaxValue)
{
if (status == 1)
{
val = reader.ReadString();
internStrings[j][internIndex] = val;
internIndexes[j] = internIndex + 1;
}
else
{
val = internStrings[j][status - 2];
}
}
else
{
val = reader.ReadString();
}
rowDTO.SetObject(j, val);
}
else if (type == m_TypeOfDateTime)
{
var value = new DateTime(reader.ReadInt64());
rowDTO.SetDateTime(j, value);
}
else if (type == m_TypeOfInt32)
{
rowDTO.SetInt(j, reader.ReadInt32());
}
else if (type == m_TypeOfInt64)
{
rowDTO.SetObject(j, reader.ReadInt64());
}
else if (type == m_TypeOfInt16)
{
rowDTO.SetObject(j, reader.ReadInt16());
}
else if (type == m_TypeOfDouble)
{
rowDTO.SetObject(j, reader.ReadDouble());
}
else if (type == m_TypeOfDecimal)
{
rowDTO.SetObject(j, reader.ReadDecimal());
}
else if (type == m_TypeOfSingle)
{
rowDTO.SetObject(j, reader.ReadSingle());
}
else if (type == m_TypeOfBoolean)
{
rowDTO.SetObject(j, reader.ReadBoolean());
}
else if (type == m_TypeOfByte)
{
rowDTO.SetObject(j, reader.ReadByte());
}
}
}
AvrDataRowBase newRow = table.NewRow(rowDTO);
if (filter == null || filter.Fit(newRow))
{
table.ThreadSafeAdd(newRow);
}
rowDTO.Reset();
}
}
stream.Dispose();
}
public List <byte[]> Export(AvrDataTable data)
{
var exportDictionary = ExportToByteArrays(string.Empty, data);
return(exportDictionary.Values.ToList());
}
