public void Delete(ServerProcess AProcess, Row ARow)
{
// Delete the row from all indexes
Row LClusteredKey = GetIndexData(AProcess, FClusteredIndex.KeyRowType, new Row[] { ARow });
try
{
using (SearchPath LSearchPath = new SearchPath())
{
int LEntryNumber;
bool LResult = FClusteredIndex.FindKey(AProcess, LClusteredKey.Stream, null, LSearchPath, out LEntryNumber);
if (!LResult)
{
throw new IndexException(IndexException.Codes.KeyNotFound);
}
Row LClusteredData = AProcess.RowManager.RequestRow(AProcess, FClusteredIndex.DataRowType, LSearchPath.DataNode.Data(LEntryNumber));
try
{
foreach (TableBufferIndex LBufferIndex in Indexes)
{
if (LBufferIndex != FClusteredIndex)
{
Row LKey = GetIndexData(AProcess, LBufferIndex.KeyRowType, new Row[] { LClusteredKey, LClusteredData });
try
{
LBufferIndex.Delete(AProcess, LKey.Stream);
}
finally
{
AProcess.RowManager.ReleaseRow(LKey);
}
}
}
}
finally
{
AProcess.RowManager.ReleaseRow(LClusteredData);
}
}
FClusteredIndex.Delete(AProcess, LClusteredKey.Stream);
}
finally
{
AProcess.RowManager.ReleaseRow(LClusteredKey);
}
}
public void Update(ServerProcess AProcess, Row AOldRow, Row ANewRow)
{
// AOldRow must have at least the columns of the clustered index key
Row LOldClusteredKey = GetIndexData(AProcess, FClusteredIndex.KeyRowType, new Row[] { AOldRow });
try
{
bool LIsClusteredIndexKeyAffected = GetIsIndexAffected(FClusteredIndex.KeyRowType, ANewRow);
bool LIsClusteredIndexDataAffected = GetIsIndexAffected(FClusteredIndex.DataRowType, ANewRow);
Row LNewClusteredKey = null;
Row LNewClusteredData = null;
try
{
// Update the row in each index
using (SearchPath LSearchPath = new SearchPath())
{
int LEntryNumber;
bool LResult = FClusteredIndex.FindKey(AProcess, LOldClusteredKey.Stream, null, LSearchPath, out LEntryNumber);
if (!LResult)
{
throw new IndexException(IndexException.Codes.KeyNotFound);
}
Row LOldClusteredData = AProcess.RowManager.RequestRow(AProcess, FClusteredIndex.DataRowType, LSearchPath.DataNode.Data(LEntryNumber));
try
{
bool LIsIndexAffected;
foreach (TableBufferIndex LBufferIndex in Indexes)
{
if (LBufferIndex != FClusteredIndex)
{
LIsIndexAffected = GetIsIndexAffected(LBufferIndex.KeyRowType, ANewRow);
if (LIsClusteredIndexKeyAffected || LIsIndexAffected)
{
Row LOldIndexKey = GetIndexData(AProcess, LBufferIndex.KeyRowType, new Row[] { LOldClusteredKey, LOldClusteredData });
try
{
Row LNewIndexKey = null;
Row LNewIndexData = null;
try
{
if (LIsIndexAffected)
{
LNewIndexKey = GetIndexData(AProcess, LBufferIndex.KeyRowType, new Row[] { ANewRow, LOldClusteredKey, LOldClusteredData });
}
if (LIsClusteredIndexKeyAffected)
{
LNewIndexData = GetIndexData(AProcess, LBufferIndex.DataRowType, new Row[] { ANewRow, LOldClusteredKey, LOldClusteredData });
}
if (LIsIndexAffected && LIsClusteredIndexKeyAffected)
{
LBufferIndex.Update(AProcess, LOldIndexKey.Stream, LNewIndexKey.Stream, LNewIndexData.Stream);
LNewIndexKey.ValuesOwned = false;
LNewIndexData.ValuesOwned = false;
}
else if (LIsIndexAffected)
{
LBufferIndex.Update(AProcess, LOldIndexKey.Stream, LNewIndexKey.Stream);
LNewIndexKey.ValuesOwned = false;
}
else if (LIsClusteredIndexKeyAffected)
{
LBufferIndex.Update(AProcess, LOldIndexKey.Stream, LOldIndexKey.Stream, LNewIndexData.Stream);
LNewIndexData.ValuesOwned = false;
}
}
finally
{
if (LNewIndexKey != null)
{
AProcess.RowManager.ReleaseRow(LNewIndexKey);
}
if (LNewIndexData != null)
{
AProcess.RowManager.ReleaseRow(LNewIndexData);
}
}
}
finally
{
AProcess.RowManager.ReleaseRow(LOldIndexKey);
}
}
}
}
if (LIsClusteredIndexKeyAffected)
{
LNewClusteredKey = GetIndexData(AProcess, FClusteredIndex.KeyRowType, new Row[] { ANewRow, LOldClusteredKey, LOldClusteredData });
}
if (LIsClusteredIndexDataAffected)
{
LNewClusteredData = GetIndexData(AProcess, FClusteredIndex.DataRowType, new Row[] { ANewRow, LOldClusteredData });
}
}
finally
{
AProcess.RowManager.ReleaseRow(LOldClusteredData);
}
}
if (LIsClusteredIndexKeyAffected && LIsClusteredIndexDataAffected)
{
FClusteredIndex.Update(AProcess, LOldClusteredKey.Stream, LNewClusteredKey.Stream, LNewClusteredData.Stream);
LNewClusteredKey.ValuesOwned = false;
LNewClusteredData.ValuesOwned = false;
}
else if (LIsClusteredIndexKeyAffected)
{
FClusteredIndex.Update(AProcess, LOldClusteredKey.Stream, LNewClusteredKey.Stream);
LNewClusteredKey.ValuesOwned = false;
}
else if (LIsClusteredIndexDataAffected)
{
FClusteredIndex.Update(AProcess, LOldClusteredKey.Stream, LOldClusteredKey.Stream, LNewClusteredData.Stream);
LNewClusteredData.ValuesOwned = false;
}
}
finally
{
if (LNewClusteredKey != null)
{
AProcess.RowManager.ReleaseRow(LNewClusteredKey);
}
if (LNewClusteredData != null)
{
AProcess.RowManager.ReleaseRow(LNewClusteredData);
}
}
}
finally
{
AProcess.RowManager.ReleaseRow(LOldClusteredKey);
}
}
/// <summary>Inserts the given row into all the indexes of the TableBuffer.</summary>
/// <param name="ARow">The given row must conform to the structure of the TableBuffer.</param>
public void Insert(ServerProcess AProcess, Row ARow)
{
// Insert the row into all indexes
Row LKey;
Row LData;
int LColumnIndex;
#if USEINTERNALID
Scalar LScalar = new Scalar(AProcess, (Schema.IScalarType)FInternalIDColumn.DataType, Guid.NewGuid());
#endif
foreach (TableBufferIndex LBufferIndex in Indexes)
{
LKey = AProcess.RowManager.RequestRow(AProcess, LBufferIndex.KeyRowType);
try
{
LData = AProcess.RowManager.RequestRow(AProcess, LBufferIndex.DataRowType);
try
{
LKey.ValuesOwned = false;
LData.ValuesOwned = false;
for (int LIndex = 0; LIndex < LKey.DataType.Columns.Count; LIndex++)
#if USEINTERNALID
if (LKey.DataType.Columns[LIndex].Name == CInternalIDColumnName)
{
LKey[LIndex] = LScalar;
}
else
#endif
{
LColumnIndex = ARow.DataType.Columns.IndexOf(LKey.DataType.Columns[LIndex].Name);
if (((Row)ARow).HasValue(LColumnIndex))
{
LKey[LIndex] = ARow[LColumnIndex];
}
else
{
LKey.ClearValue(LIndex);
}
}
for (int LIndex = 0; LIndex < LData.DataType.Columns.Count; LIndex++)
#if USEINTERNALID
if (LData.DataType.Columns[LIndex].Name == CInternalIDColumnName)
{
LData[LIndex] = LScalar;
}
else
#endif
{
LColumnIndex = ARow.DataType.Columns.IndexOf(LData.DataType.Columns[LIndex].Name);
if (((Row)ARow).HasValue(LColumnIndex))
{
LData[LIndex] = ARow[LColumnIndex];
}
else
{
LData.ClearValue(LIndex);
}
}
LBufferIndex.Insert(AProcess, LKey.Stream, LData.Stream);
}
finally
{
AProcess.RowManager.ReleaseRow(LData);
}
}
finally
{
AProcess.RowManager.ReleaseRow(LKey);
}
}
}
