private void GrowRecordCapacity()
{
if (NewCapacity(recordCapacity) < NormalizedMinimumCapacity(minimumCapacity))
{
RecordCapacity = NormalizedMinimumCapacity(minimumCapacity);
}
else
{
RecordCapacity = NewCapacity(recordCapacity);
}
// set up internal map : record --> row
DataRow[] newRows = table.NewRowArray(recordCapacity);
if (rows != null)
{
Array.Copy(rows, 0, newRows, 0, Math.Min(lastFreeRecord, rows.Length));
}
rows = newRows;
}
internal static void WriteTable (XmlWriter writer, DataTable table, XmlWriteMode mode, DataRowVersion version)
{
DataRow[] rows = table.NewRowArray(table.Rows.Count);
table.Rows.CopyTo (rows, 0);
WriteTable (writer, rows, mode, version, true);
}
public DataRow[] SelectRows()
{
bool needSorting = true;
InitCandidateColumns();
if (_expression is BinaryNode)
{
AnalyzeExpression((BinaryNode)_expression);
if (!_candidatesForBinarySearch)
{
_linearExpression = _expression;
}
if (_linearExpression == _expression)
{
for (int i = 0; i < _candidateColumns.Length; i++)
{
if (_candidateColumns[i] != null)
{
_candidateColumns[i].equalsOperator = false;
_candidateColumns[i].expr = null;
}
}
}
else
{
needSorting = !FindClosestCandidateIndex();
}
}
else
{
_linearExpression = _expression;
}
if (_index == null && (_indexFields.Length > 0 || _linearExpression == _expression))
{
needSorting = !FindSortIndex();
}
if (_index == null)
{
CreateIndex();
needSorting = false;
}
if (_index.RecordCount == 0)
{
return(_table.NewRowArray(0));
}
Range range;
if (_matchedCandidates == 0)
{
range = new Range(0, _index.RecordCount - 1);
Debug.Assert(!needSorting, "What are we doing here if no real reuse of this index ?");
_linearExpression = _expression;
return(GetLinearFilteredRows(range));
}
else
{
range = GetBinaryFilteredRecords();
if (range.Count == 0)
{
return(_table.NewRowArray(0));
}
if (_matchedCandidates < _nCandidates)
{
BuildLinearExpression();
}
if (!needSorting)
{
return(GetLinearFilteredRows(range));
}
else
{
_records = GetLinearFilteredRecords(range);
_recordCount = _records.Length;
if (_recordCount == 0)
{
return(_table.NewRowArray(0));
}
Sort(0, _recordCount - 1);
return(GetRows());
}
}
}
public DataRow[] SelectRows()
{
bool needSorting = true;
InitCandidateColumns();
if (this.expression is BinaryNode)
{
AnalyzeExpression((BinaryNode)this.expression);
if (!candidatesForBinarySearch)
{
this.linearExpression = this.expression;
}
if (this.linearExpression == this.expression)
{
for (int i = 0; i < candidateColumns.Length; i++)
{
if (candidateColumns[i] != null)
{
candidateColumns[i].equalsOperator = false;
candidateColumns[i].expr = null;
}
}
}
else
{
needSorting = !FindClosestCandidateIndex();
}
}
else
{
this.linearExpression = this.expression;
}
if (index == null && (IndexFields.Length > 0 || this.linearExpression == this.expression))
{
needSorting = !FindSortIndex();
}
if (index == null)
{
CreateIndex();
needSorting = false;
}
if (index.RecordCount == 0)
{
return(table.NewRowArray(0));
}
Range range;
if (matchedCandidates == 0) // Microsoft : Either dont have rowFilter or only linear search expression
{
range = new Range(0, index.RecordCount - 1);
Debug.Assert(!needSorting, "What are we doing here if no real reuse of this index ?");
this.linearExpression = this.expression;
return(GetLinearFilteredRows(range));
}
else
{
range = GetBinaryFilteredRecords();
if (range.Count == 0)
{
return(table.NewRowArray(0));
}
if (matchedCandidates < nCandidates)
{
BuildLinearExpression();
}
if (!needSorting)
{
return(GetLinearFilteredRows(range));
}
else
{
this.records = GetLinearFilteredRecords(range);
this.recordCount = this.records.Length;
if (this.recordCount == 0)
{
return(table.NewRowArray(0));
}
Sort(0, this.recordCount - 1);
return(GetRows());
}
}
}
private int Update (DataTable dataTable, DataTableMapping tableMapping)
{
DataRow [] rows = dataTable.NewRowArray(dataTable.Rows.Count);
dataTable.Rows.CopyTo (rows, 0);
return Update (rows, tableMapping);
}
