// Change
protected override bool InternalChange(Program program, IRow oldRow, IRow newRow, BitArray valueFlags, string columnName)
{
if (PropagateChange)
{
// select the current row from the base node using the given row
IRow sourceRow = new Row(program.ValueManager, SourceNode.DataType.RowType);
try
{
newRow.CopyTo(sourceRow);
IRow currentRow = null;
if (!program.ServerProcess.ServerSession.Server.IsEngine)
{
currentRow = SourceNode.Select(program, sourceRow);
}
try
{
if (currentRow == null)
{
currentRow = new Row(program.ValueManager, SourceNode.DataType.RowType);
}
newRow.CopyTo(currentRow);
BitArray localValueFlags = valueFlags != null ? new BitArray(currentRow.DataType.Columns.Count) : null;
if (localValueFlags != null)
{
for (int index = 0; index < localValueFlags.Length; index++)
{
int rowIndex = newRow.DataType.Columns.IndexOfName(currentRow.DataType.Columns[index].Name);
localValueFlags[index] = rowIndex >= 0 ? valueFlags[rowIndex] : false;
}
}
bool changed = SourceNode.Change(program, oldRow, currentRow, localValueFlags, columnName);
if (changed)
{
currentRow.CopyTo(newRow);
}
return(changed);
}
finally
{
currentRow.Dispose();
}
}
finally
{
sourceRow.Dispose();
}
}
return(false);
}
public override void JoinApplicationTransaction(Program program, IRow row)
{
if (_sequenceColumnIndex >= 0)
{
// Exclude any columns from AKey which were included by this node
Schema.RowType rowType = new Schema.RowType();
foreach (Schema.Column column in row.DataType.Columns)
{
if (SourceNode.DataType.Columns.ContainsName(column.Name))
{
rowType.Columns.Add(column.Copy());
}
}
Row localRow = new Row(program.ValueManager, rowType);
try
{
row.CopyTo(localRow);
SourceNode.JoinApplicationTransaction(program, localRow);
}
finally
{
localRow.Dispose();
}
}
else
{
base.JoinApplicationTransaction(program, row);
}
}
/// <summary>
/// Returns a row that is guaranteed to contain the same columns in the same order as the node order.
/// If the given row does not satisfy this requirement, a row of the proper row type is created and the values from the given row are copied into it.
/// </summary>
protected IRow EnsureKeyRow(IRow key)
{
if (IsKeyRow(key))
{
return(key);
}
else
{
Schema.IRowType rowType = DataType.CreateRowType(String.Empty, false);
Schema.Order order = Order;
for (int index = 0; index < order.Columns.Count; index++)
{
//int LColumnIndex = AKey.DataType.Columns.IndexOfName(LOrder.Columns[LIndex].Column.Name);
//if (LColumnIndex >= 0)
rowType.Columns.Add(order.Columns[index].Column.Column.Copy());
// BTR 4/25/2005 -> There is no difference between not having the column, and having the column, but not having a value.
// as such, I see no reason to throw this error, simply create the row and leave the column empty.
//else
// throw new RuntimeException(RuntimeException.Codes.InvalidSearchArgument);
}
Row localKey = new Row(Manager, rowType);
key.CopyTo(localKey);
return(localKey);
}
}
/// <summary> Creates this nodes immediate children. Avoids duplication. </summary>
public void BuildChildren()
{
// Open a dynamic navigable browse cursor on the child expression
IServerCursor cursor = DBTreeView.OpenChildCursor(_key);
try
{
DBTreeNode existingNode;
Row key;
string text;
int index = 0;
int columnIndex;
while (cursor.Next())
{
key = new Row(DBTreeView._process.ValueManager, new Schema.RowType(((TableDataSet)DBTreeView.Source.DataSet).Order.Columns));
try
{
using (IRow row = cursor.Select())
{
row.CopyTo(key);
columnIndex = row.DataType.Columns.IndexOf(DBTreeView.ColumnName);
if (columnIndex < 0)
{
throw new ControlsException(ControlsException.Codes.DataColumnNotFound, DBTreeView.ColumnName);
}
if (row.HasValue(columnIndex))
{
text = ((IScalar)row.GetValue(columnIndex)).AsDisplayString;
}
else
{
text = DBTreeView.NoValueText;
}
existingNode = FindChild(key);
if (existingNode != null)
{
existingNode.Text = text;
existingNode.SetKey(key);
index = existingNode.Index;
}
else
{
Nodes.Insert(index, new DBTreeNode(text, key));
}
index++;
}
}
catch
{
key.Dispose();
throw;
}
}
}
finally
{
DBTreeView.CloseChildCursor(cursor);
}
}
private IRow EnsureKeyRow(IRow key)
{
IRow localKey = key;
bool isKeyRow = key.DataType.Columns.Count <= _accessPath.KeyRowType.Columns.Count;
for (int index = 0; index < _accessPath.KeyRowType.Columns.Count; index++)
{
if (index >= key.DataType.Columns.Count)
{
break;
}
else
{
if (!Schema.Object.NamesEqual(key.DataType.Columns[index].Name, _accessPath.KeyRowType.Columns[index].Name))
{
isKeyRow = false;
break;
}
}
}
if (!isKeyRow)
{
localKey = new Row(_manager, _accessPath.KeyRowType);
key.CopyTo(localKey);
}
return(localKey);
}
private void PerformInsert(Program program, TableNode tableNode, IRow oldRow, IRow newRow, BitArray valueFlags, bool uncheckedValue)
{
switch (PropagateInsert)
{
case PropagateAction.True:
tableNode.Insert(program, oldRow, newRow, valueFlags, uncheckedValue);
break;
case PropagateAction.Ensure:
case PropagateAction.Ignore:
using (Row sourceRow = new Row(program.ValueManager, tableNode.DataType.RowType))
{
newRow.CopyTo(sourceRow);
using (IRow currentRow = tableNode.Select(program, sourceRow))
{
if (currentRow != null)
{
if (PropagateInsert == PropagateAction.Ensure)
{
tableNode.Update(program, currentRow, newRow, valueFlags, false, uncheckedValue);
}
}
else
{
tableNode.Insert(program, oldRow, newRow, valueFlags, uncheckedValue);
}
}
}
break;
}
}
protected void InternalInsertRight(Program program, IRow oldRow, IRow newRow, BitArray valueFlags, bool uncheckedValue)
{
switch (PropagateInsertRight)
{
case PropagateAction.True:
RightNode.Insert(program, oldRow, newRow, valueFlags, uncheckedValue);
break;
case PropagateAction.Ensure:
case PropagateAction.Ignore:
using (Row rightRow = new Row(program.ValueManager, RightNode.DataType.RowType))
{
newRow.CopyTo(rightRow);
using (IRow currentRow = RightNode.Select(program, rightRow))
{
if (currentRow != null)
{
if (PropagateInsertRight == PropagateAction.Ensure)
{
RightNode.Update(program, currentRow, newRow, valueFlags, false, uncheckedValue);
}
}
else
{
RightNode.Insert(program, oldRow, newRow, valueFlags, uncheckedValue);
}
}
}
break;
}
}
protected override bool InternalNext()
{
if (!InternalEOF())
{
if (_sourceTable.Next())
{
_sourceTable.Select(_compareRow);
if (_hasLastCompareRow)
{
Program.Stack.Push(_compareRow);
try
{
Program.Stack.Push(_lastCompareRow);
try
{
object result = Node.EqualNode.Execute(Program);
if ((result == null) || !(bool)result)
{
_sourceCounter++;
_compareRow.CopyTo(_lastCompareRow);
}
}
finally
{
Program.Stack.Pop();
}
}
finally
{
Program.Stack.Pop();
}
}
else
{
_sourceCounter++;
_compareRow.CopyTo(_lastCompareRow);
_hasLastCompareRow = true;
}
return(!InternalEOF());
}
}
return(false);
}
protected IRow NewParentRow(IRow currentRow)
{
#if USENAMEDROWVARIABLES
Row row = new Row(Manager, currentRow.DataType);
#else
Row row = new Row(Manager, new Schema.RowType(ACurrentRow.DataType.Columns, Keywords.Parent));
#endif
currentRow.CopyTo(row);
return(row);
}
public override object InternalExecute(Program program)
{
object result;
IRow sourceRow = (IRow)Nodes[0].Execute(program);
#if NILPROPOGATION
if ((sourceRow == null) || sourceRow.IsNil)
{
return(null);
}
#endif
try
{
Row newRow = new Row(program.ValueManager, DataType);
try
{
program.Stack.Push(sourceRow);
try
{
sourceRow.CopyTo(newRow);
for (int index = _extendColumnOffset; index < newRow.DataType.Columns.Count; index++)
{
result = Nodes[index - _extendColumnOffset + 1].Execute(program);
if (result != null)
{
try
{
newRow[index] = result;
}
finally
{
DataValue.DisposeValue(program.ValueManager, result);
}
}
}
}
finally
{
program.Stack.Pop();
}
return(newRow);
}
catch
{
newRow.Dispose();
throw;
}
}
finally
{
sourceRow.Dispose();
}
}
protected virtual void InternalUpdate(IRow row, BitArray valueFlags, bool uncheckedValue)
{
using (IRow localRow = Select())
{
Node.Update(Program, localRow, row, valueFlags, Isolation != CursorIsolation.Isolated, uncheckedValue);
if (CursorType == CursorType.Dynamic)
{
row.CopyTo(localRow);
OptimisticRefresh(localRow);
}
}
}
protected override void InternalUpdate(IRow row, BitArray valueFlags, bool uncheckedValue)
{
using (IRow localRow = Select())
{
_nativeTable.Update(Manager, localRow, row);
if (CursorType == CursorType.Dynamic)
{
row.CopyTo(localRow);
Refresh(localRow);
}
}
}
/// <summary> Updates data values for this node from the current row of the DataView. </summary>
/// <param name="AView"></param>
protected internal virtual void Update(DataSet dataSet)
{
DataField field = dataSet.Fields[DBTreeView.ColumnName];
Text = field.HasValue() ? field.AsDisplayString : DBTreeView.NoValueText;
Text = Text.Trim();
using (IRow key = DBTreeView.Source.DataSet.GetKey())
{
_key.ClearValues();
key.CopyTo(_key);
}
}
protected override void InternalExecuteInsert(Program program, IRow oldRow, IRow newRow, BitArray valueFlags, bool uncheckedValue)
{
switch (PropagateInsertLeft)
{
case PropagateAction.True:
if (!uncheckedValue)
{
ValidatePredicate(program, newRow);
}
LeftNode.Insert(program, oldRow, newRow, valueFlags, uncheckedValue);
break;
case PropagateAction.Ensure:
case PropagateAction.Ignore:
if (!uncheckedValue)
{
ValidatePredicate(program, newRow);
}
using (Row leftRow = new Row(program.ValueManager, LeftNode.DataType.RowType))
{
newRow.CopyTo(leftRow);
using (IRow currentRow = LeftNode.Select(program, leftRow))
{
if (currentRow != null)
{
if (PropagateInsertLeft == PropagateAction.Ensure)
{
LeftNode.Update(program, currentRow, newRow, valueFlags, false, uncheckedValue);
}
}
else
{
LeftNode.Insert(program, oldRow, newRow, valueFlags, uncheckedValue);
}
}
}
break;
}
}
public override void JoinApplicationTransaction(Program program, IRow row)
{
Schema.RowType rowType = new Schema.RowType();
foreach (Schema.Column column in row.DataType.Columns)
{
rowType.Columns.Add(column.Copy());
}
foreach (Schema.Column column in SourceNode.DataType.Columns)
{
if (!DataType.Columns.ContainsName(column.Name))
{
rowType.Columns.Add(column.Copy());
}
}
Row localRow = new Row(program.ValueManager, rowType);
try
{
row.CopyTo(localRow);
// Get the SourceNode select set for this row, and join on each result
foreach (var sourceRow in SourceNode.SelectAll(program, localRow))
{
try
{
base.JoinApplicationTransaction(program, sourceRow);
}
finally
{
sourceRow.Dispose();
}
}
}
finally
{
localRow.Dispose();
}
}
protected override void InternalSelect(IRow row)
{
_sourceTable.Select(_sourceRow);
_sourceRow.CopyTo(row);
Program.Stack.Push(_sourceRow);
try
{
int nodeIndex;
int columnIndex;
for (int index = 0; index < DataType.Columns.Count; index++)
{
columnIndex = row.DataType.Columns.IndexOfName(DataType.Columns[index].Name);
if (columnIndex >= 0)
{
nodeIndex = (index - Node.AggregateColumnOffset) + 1;
if (nodeIndex >= 1)
{
row[columnIndex] = Node.Nodes[nodeIndex].Execute(Program);
}
else
{
if (_sourceRow.HasValue(index))
{
row[columnIndex] = _sourceRow[index];
}
else
{
row.ClearValue(columnIndex);
}
}
}
}
}
finally
{
Program.Stack.Pop();
}
}
/// <summary>
/// Returns a row that is guaranteed to contain the same or fewer columns in the same order as the node order,
/// and once a column is null, the rest of the columns are null as well. If the given row does not satisfy this
/// requirement, a row of the proper row type is created and the values from the given row are copied into it.
/// If no such row can be created, null is returned.
/// </summary>
protected IRow EnsurePartialKeyRow(IRow key)
{
if (IsPartialKeyRow(key))
{
return(key);
}
else
{
bool isNull = false;
Schema.IRowType rowType = DataType.CreateRowType(String.Empty, false);
Schema.Order order = Order;
for (int index = 0; index < order.Columns.Count; index++)
{
int columnIndex = key.DataType.Columns.IndexOfName(order.Columns[index].Column.Name);
if (columnIndex >= 0)
{
rowType.Columns.Add(order.Columns[index].Column.Column.Copy());
if (isNull && key.HasValue(columnIndex))
{
return(null);
}
if (!key.HasValue(index))
{
isNull = true;
}
}
else
{
break;
}
}
Row localKey = new Row(Manager, rowType);
key.CopyTo(localKey);
return(localKey);
}
}
public override void JoinApplicationTransaction(Program program, IRow row)
{
// Exclude any columns from AKey which were included by this node
Schema.RowType rowType = new Schema.RowType();
foreach (Schema.Column column in row.DataType.Columns)
{
if (!((IList)_redefineColumnOffsets).Contains(_tableVar.DataType.Columns.IndexOfName(column.Name)))
{
rowType.Columns.Add(column.Copy());
}
}
Row localRow = new Row(program.ValueManager, rowType);
try
{
row.CopyTo(localRow);
SourceNode.JoinApplicationTransaction(program, localRow);
}
finally
{
localRow.Dispose();
}
}
protected override void InternalSelect(IRow row)
{
_sourceTable.Select(_sourceRow);
_sourceRow.CopyTo(row);
int index;
int columnIndex;
Program.Stack.Push(_sourceRow);
try
{
for (index = 1; index < Node.Nodes.Count; index++)
{
columnIndex = row.DataType.Columns.IndexOfName(Node.DataType.Columns[Node.ExtendColumnOffset + index - 1].Name);
if (columnIndex >= 0)
{
object objectValue = Node.Nodes[index].Execute(Program);
try
{
if (row.DataType.Columns[columnIndex].DataType is Schema.ScalarType)
{
objectValue = ValueUtility.ValidateValue(Program, (Schema.ScalarType)row.DataType.Columns[columnIndex].DataType, objectValue);
}
row[columnIndex] = objectValue;
}
finally
{
DataValue.DisposeValue(Program.ValueManager, objectValue);
}
}
}
}
finally
{
Program.Stack.Pop();
}
}
// Change
protected override bool InternalChange(Program program, IRow oldRow, IRow newRow, BitArray valueFlags, string columnName)
{
if (PropagateChange)
{
TableNode sourceNode = SourceNode;
IRow localOldRow;
if (!(oldRow.DataType.Columns.Equivalent(DataType.Columns)))
{
localOldRow = new Row(program.ValueManager, DataType.RowType);
oldRow.CopyTo(localOldRow);
}
else
{
localOldRow = oldRow;
}
try
{
IRow localNewRow;
if (!(newRow.DataType.Columns.Equivalent(DataType.Columns)))
{
localNewRow = new Row(program.ValueManager, DataType.RowType);
newRow.CopyTo(localNewRow);
}
else
{
localNewRow = newRow;
}
try
{
Row oldSourceRow = new Row(program.ValueManager, sourceNode.DataType.RowType, (NativeRow)localOldRow.AsNative);
try
{
oldSourceRow.ValuesOwned = false;
Row newSourceRow = new Row(program.ValueManager, sourceNode.DataType.RowType, (NativeRow)localNewRow.AsNative);
try
{
newSourceRow.ValuesOwned = false;
bool changed = sourceNode.Change(program, oldSourceRow, newSourceRow, valueFlags, columnName == String.Empty ? String.Empty : newSourceRow.DataType.Columns[localNewRow.DataType.Columns.IndexOfName(columnName)].Name);
if (changed && (newRow != localNewRow))
{
localNewRow.CopyTo(newRow);
}
return(changed);
}
finally
{
newSourceRow.Dispose();
}
}
finally
{
oldSourceRow.Dispose();
}
}
finally
{
if (!ReferenceEquals(newRow, localNewRow))
{
localNewRow.Dispose();
}
}
}
finally
{
if (!ReferenceEquals(oldRow, localOldRow))
{
localOldRow.Dispose();
}
}
}
return(false);
}
/// <summary> Creates root nodes and their immediate children. </summary>
protected void BuildTree()
{
if ((!_link.Active) || _link.DataSet.IsEmpty() || !IsSetup())
{
ClearTree();
}
else
{
if (_link.DataSet.State != DataSetState.Insert)
{
BeginUpdate();
try
{
EnsureParamsValid();
// Open a dynamic navigable browse cursor on the root expression
PrepareRootPlan();
IServerCursor cursor = _rootPlan.Open(_rootParams);
try
{
Row key;
int columnIndex;
string text;
while (cursor.Next())
{
key = new Row(_process.ValueManager, new Schema.RowType(((TableDataSet)_link.DataSet).Order.Columns));
try
{
using (IRow row = cursor.Select())
{
row.CopyTo(key);
columnIndex = row.DataType.Columns.IndexOf(ColumnName);
if (row.HasValue(columnIndex))
{
text = ((IScalar)row.GetValue(columnIndex)).AsDisplayString;
}
else
{
text = NoValueText;
}
}
Nodes.Add(new DBTreeNode(text, key));
}
catch
{
key.Dispose();
throw;
}
}
}
finally
{
_rootPlan.Close(cursor);
}
foreach (DBTreeNode node in Nodes)
{
node.BuildChildren();
}
}
finally
{
EndUpdate();
}
}
}
}
// Must be called with the original stack
protected BrowseTableItem CreateTable(IRow origin, bool forward, bool inclusive)
{
// Prepare the context variable to contain the origin value (0 if this is an unanchored set)
object contextVar;
Row localOrigin;
if (origin == null)
{
localOrigin = null;
contextVar = 0;
}
else
{
if ((origin.DataType.Columns.Count > 0) && (Schema.Object.Qualifier(origin.DataType.Columns[0].Name) != Keywords.Origin))
{
localOrigin = new Row(Manager, new Schema.RowType(origin.DataType.Columns, Keywords.Origin));
}
else
{
localOrigin = new Row(Manager, new Schema.RowType(origin.DataType.Columns));
}
origin.CopyTo(localOrigin);
contextVar = localOrigin;
}
int originIndex = ((localOrigin == null) ? -1 : localOrigin.DataType.Columns.Count - 1);
bool localInclusive = (localOrigin == null) ? true : inclusive;
// Ensure the browse node has the appropriate browse variant
lock (Node)
{
if (!Node.HasBrowseVariant(originIndex, forward, localInclusive))
{
Program.ServerProcess.PushGlobalContext();
try
{
Node.CompileBrowseVariant(Program, originIndex, forward, localInclusive);
}
finally
{
Program.ServerProcess.PopGlobalContext();
}
}
}
// Execute the variant with the current context variable
Program.Stack.Push(contextVar);
try
{
PlanNode browseVariantNode = Node.GetBrowseVariantNode(Program.Plan, originIndex, forward, localInclusive);
#if TRACEBROWSEEVENTS
Trace.WriteLine(String.Format("BrowseTableItem created with query: {0}", new D4TextEmitter().Emit(browseVariantNode.EmitStatement(EmitMode.ForCopy))));
#endif
return
(new BrowseTableItem
(
this,
(ITable)browseVariantNode.Execute(Program),
contextVar,
localOrigin,
forward,
inclusive
));
}
finally
{
Program.Stack.Pop();
}
}
