/// <summary>Returns the host representation of the given native value. This is a by-reference operation.</summary>
public static IDataValue FromNative(IValueManager manager, Schema.IDataType dataType, object tempValue)
{
// This code is duplicated in the Copy method and the FromNative overloads for performance
Schema.IScalarType scalarType = dataType as Schema.IScalarType;
if (scalarType != null)
{
if (tempValue is StreamID)
{
return(new Scalar(manager, scalarType, (StreamID)tempValue));
}
if (scalarType.IsGeneric)
{
return(new Scalar(manager, (Schema.ScalarType)manager.GetRuntimeType(tempValue.GetType()), tempValue));
}
return(new Scalar(manager, scalarType, tempValue));
}
if (tempValue == null)
{
return(null);
}
Schema.IRowType rowType = dataType as Schema.IRowType;
if (rowType != null)
{
return(new Row(manager, rowType, (NativeRow)tempValue));
}
Schema.IListType listType = dataType as Schema.IListType;
if (listType != null)
{
return(new ListValue(manager, listType, (NativeList)tempValue));
}
Schema.ITableType tableType = dataType as Schema.ITableType;
if (tableType != null)
{
return(new TableValue(manager, tableType, (NativeTable)tempValue));
}
Schema.ICursorType cursorType = dataType as Schema.ICursorType;
if (cursorType != null)
{
return(new CursorValue(manager, cursorType, (int)tempValue));
}
var runtimeType = manager.GetRuntimeType(tempValue);
if (runtimeType != null)
{
return(FromNative(manager, runtimeType, tempValue));
}
throw new RuntimeException(RuntimeException.Codes.InvalidValueType, dataType == null ? "<null>" : dataType.GetType().Name);
}
private void Create(IValueManager manager)
{
TableType = TableVar.DataType;
RowType = TableType.RowType;
Schema.RowType keyRowType;
Schema.RowType dataRowType;
// Create the map index required to store data as described by the given table variable
keyRowType = new Schema.RowType(Key.Columns);
dataRowType = new Schema.RowType();
foreach (Schema.Column column in TableVar.DataType.Columns)
{
dataRowType.Columns.Add(new Schema.Column(column.Name, column.DataType));
}
Index =
new NativeRowMap
(
Key,
EqualitySorts,
keyRowType,
dataRowType
);
}
/// <summary>
/// The recursive portion of the find key algorithm invoked by the FindKey method of the parent Index.
/// </summary>
public bool FindKey(Schema.IRowType keyRowType, NativeRow key, RowTreeSearchPath rowTreeSearchPath, out int entryNumber)
{
rowTreeSearchPath.Add(this);
if (Node.NodeType == NativeRowTreeNodeType.Routing)
{
// Perform a binary search among the keys in this node to determine which streamid to follow for the next node
bool result = NodeSearch(keyRowType, key, out entryNumber);
// If the key was found, use the given entry number, otherwise, use the one before the given entry
entryNumber = result ? entryNumber : (entryNumber - 1);
return
(new RowTreeNode
(
Manager,
Tree,
RoutingNode.Nodes[entryNumber],
LockMode.Shared
).FindKey
(
keyRowType,
key,
rowTreeSearchPath,
out entryNumber
));
}
else
{
// Perform a binary search among the keys in this node to determine which entry, if any, is equal to the given key
return(NodeSearch(keyRowType, key, out entryNumber));
}
}
public Row RequestRow(IServerProcess AProcess, Schema.IRowType ARowType, NativeRow ARow)
{
Row LRow = GetRow();
LRow.Open(AProcess, ARowType, ARow);
return(LRow);
}
// Statement
public override Statement EmitStatement(EmitMode mode)
{
if (_dataType is Schema.RowType)
{
RowSelectorExpression expression = new RowSelectorExpression();
if (_specifiedRowType != null)
{
expression.TypeSpecifier = DataType.EmitSpecifier(mode);
}
Schema.IRowType rowType = _specifiedRowType != null ? _specifiedRowType : DataType;
for (int index = 0; index < rowType.Columns.Count; index++)
{
expression.Expressions.Add(new NamedColumnExpression((Expression)Nodes[index].EmitStatement(mode), rowType.Columns[index].Name));
}
expression.Modifiers = Modifiers;
return(expression);
}
else
{
EntrySelectorExpression expression = new EntrySelectorExpression();
for (int index = 0; index < DataType.Columns.Count; index++)
{
expression.Expressions.Add(new NamedColumnExpression((Expression)Nodes[index].EmitStatement(mode), DataType.Columns[index].Name));
}
expression.Modifiers = Modifiers;
return(expression);
}
}
/// <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);
}
}
public Row RequestRow(IServerProcess AProcess, Schema.IRowType ARowType, Stream AStream)
{
Row LRow = GetRow();
LRow.Open(AProcess, ARowType, AStream);
return(LRow);
}
private RemoteFetchData InternalFetch(Schema.IRowType rowType, Guid[] bookmarks, int count, bool skipCurrent)
{
Row[] rows = new Row[Math.Abs(count)];
try
{
for (int index = 0; index < rows.Length; index++)
{
rows[index] = new Row(_plan.Process.ServerProcess.ValueManager, rowType);
rows[index].ValuesOwned = false;
}
CursorGetFlags flags;
int localCount = _serverCursor.Fetch(rows, bookmarks, count, skipCurrent, out flags);
RemoteFetchData fetchData = new RemoteFetchData();
fetchData.Body = new RemoteRowBody[localCount];
for (int index = 0; index < localCount; index++)
{
fetchData.Body[index].Data = rows[index].AsPhysical;
}
fetchData.Flags = flags;
return(fetchData);
}
finally
{
for (int index = 0; index < rows.Length; index++)
{
if (rows[index] != null)
{
rows[index].Dispose();
}
}
}
}
protected virtual void InternalOpen()
{
// get a table object to supply the data
_plan.SetActiveCursor(this);
try
{
_program.Start(_params);
_programStarted = true;
long startTicks = TimingUtility.CurrentTicks;
CursorNode cursorNode = _plan.CursorNode;
//LCursorNode.EnsureApplicationTransactionJoined(FPlan.ServerProcess);
_sourceTable = (ITable)_plan.CursorNode.SourceNode.Execute(_program);
_sourceTable.Open();
_sourceRowType = _sourceTable.DataType.RowType;
_program.Statistics.ExecuteTime = TimingUtility.TimeSpanFromTicks(startTicks);
}
catch
{
InternalClose();
throw;
}
}
public Row(IValueManager manager, Schema.IRowType dataType) : base(manager, dataType)
{
_row = new NativeRow(DataType.Columns.Count);
#if USEDATATYPESINNATIVEROW
for (int index = 0; index < DataType.Columns.Count; index++)
{
_row.DataTypes[index] = DataType.Columns[index].DataType;
}
#endif
ValuesOwned = true;
}
private bool GetIsIndexAffected(Schema.IRowType rowType, IRow row)
{
foreach (Schema.Column column in rowType.Columns)
{
if (row.DataType.Columns.ContainsName(column.Name))
{
return(true);
}
}
return(false);
}
protected Expression EmitBrowseVariantExpression(Schema.Order originOrder, Schema.IRowType origin, int originIndex, bool forward, bool inclusive)
{
return
(new OrderExpression
(
new RestrictExpression
(
_sourceExpression,
EmitBrowseConditionExpression(originIndex < 0 ? Order : originOrder, originIndex < 0 ? null : origin, forward, inclusive)
),
(from c in (new Schema.Order(Order, !forward)).Columns select(OrderColumnDefinition) c.EmitStatement(EmitMode.ForCopy)).ToArray()
));
}
/// <summary>Returns the host representation of the given native value. This is a by-reference operation.</summary>
public static IDataValue FromNativeRow(IValueManager manager, Schema.IRowType rowType, NativeRow nativeRow, int nativeRowIndex)
{
// This code is duplicated in the Copy method and the FromNative overloads for performance
#if USEDATATYPESINNATIVEROW
Schema.IDataType dataType = nativeRow.DataTypes[nativeRowIndex];
if (dataType == null)
{
dataType = rowType.Columns[nativeRowIndex].DataType;
}
#else
Schema.IDataType dataType = ARowType.Columns[ANativeRowIndex].DataType;
#endif
Schema.IScalarType scalarType = dataType as Schema.IScalarType;
if (scalarType != null)
{
return(new RowInternedScalar(manager, scalarType, nativeRow, nativeRowIndex));
}
Schema.IRowType localRowType = dataType as Schema.IRowType;
if (localRowType != null)
{
return(new Row(manager, localRowType, (NativeRow)nativeRow.Values[nativeRowIndex]));
}
Schema.IListType listType = dataType as Schema.IListType;
if (listType != null)
{
return(new ListValue(manager, listType, (NativeList)nativeRow.Values[nativeRowIndex]));
}
Schema.ITableType tableType = dataType as Schema.ITableType;
if (tableType != null)
{
return(new TableValue(manager, tableType, (NativeTable)nativeRow.Values[nativeRowIndex]));
}
Schema.ICursorType cursorType = dataType as Schema.ICursorType;
if (cursorType != null)
{
return(new CursorValue(manager, cursorType, (int)nativeRow.Values[nativeRowIndex]));
}
var runtimeType = manager.GetRuntimeType(nativeRow.Values[nativeRowIndex]);
if (runtimeType != null)
{
return(new RowInternedScalar(manager, (Schema.IScalarType)runtimeType, nativeRow, nativeRowIndex));
}
throw new RuntimeException(RuntimeException.Codes.InvalidValueType, dataType == null ? "<null>" : dataType.GetType().Name);
}
public IDataValue Copy()
{
// This code is duplicated in the FromNative and CopyAs methods for performance...
object tempValue = CopyNative();
Schema.IScalarType scalarType = DataType as Schema.IScalarType;
if (scalarType != null)
{
if (tempValue is StreamID)
{
Scalar scalar = new Scalar(Manager, scalarType, (StreamID)tempValue);
scalar.ValuesOwned = true;
return(scalar);
}
return(new Scalar(Manager, scalarType, tempValue));
}
Schema.IRowType rowType = DataType as Schema.IRowType;
if (rowType != null)
{
Row row = new Row(Manager, rowType, (NativeRow)tempValue);
row.ValuesOwned = true;
return(row);
}
Schema.IListType listType = DataType as Schema.IListType;
if (listType != null)
{
ListValue list = new ListValue(Manager, listType, (NativeList)tempValue);
list.ValuesOwned = true;
return(list);
}
Schema.ITableType tableType = DataType as Schema.ITableType;
if (tableType != null)
{
TableValue table = new TableValue(Manager, tableType, (NativeTable)tempValue);
table.ValuesOwned = true;
return(table);
}
Schema.ICursorType cursorType = DataType as Schema.ICursorType;
if (cursorType != null)
{
return(new CursorValue(Manager, cursorType, (int)tempValue));
}
throw new RuntimeException(RuntimeException.Codes.InvalidValueType, DataType == null ? "<null>" : DataType.GetType().Name);
}
/// <summary>Returns the host representation of the given native value. This is a by-reference operation.</summary>
public static IDataValue FromNativeList(IValueManager manager, Schema.IListType listType, NativeList nativeList, int nativeListIndex)
{
// This code is duplicated in the Copy method and the FromNative overloads for performance
Schema.IDataType dataType = nativeList.DataTypes[nativeListIndex];
if (dataType == null)
{
dataType = listType.ElementType;
}
Schema.IScalarType scalarType = dataType as Schema.IScalarType;
if (scalarType != null)
{
return(new ListInternedScalar(manager, scalarType, nativeList, nativeListIndex));
}
Schema.IRowType rowType = dataType as Schema.IRowType;
if (rowType != null)
{
return(new Row(manager, rowType, (NativeRow)nativeList.Values[nativeListIndex]));
}
Schema.IListType localListType = dataType as Schema.IListType;
if (localListType != null)
{
return(new ListValue(manager, localListType, (NativeList)nativeList.Values[nativeListIndex]));
}
Schema.ITableType tableType = dataType as Schema.ITableType;
if (tableType != null)
{
return(new TableValue(manager, tableType, (NativeTable)nativeList.Values[nativeListIndex]));
}
Schema.ICursorType cursorType = dataType as Schema.ICursorType;
if (cursorType != null)
{
return(new CursorValue(manager, cursorType, (int)nativeList.Values[nativeListIndex]));
}
var runtimeType = manager.GetRuntimeType(nativeList.Values[nativeListIndex]);
if (runtimeType != null)
{
return(new ListInternedScalar(manager, (Schema.IScalarType)runtimeType, nativeList, nativeListIndex));
}
throw new RuntimeException(RuntimeException.Codes.InvalidValueType, nativeList.DataTypes[nativeListIndex] == null ? "<null>" : nativeList.DataTypes[nativeListIndex].GetType().Name);
}
protected PlanNode EmitBrowseConditionNode
(
Plan plan,
Schema.Order order,
Schema.IRowType origin,
bool forward,
bool inclusive
)
{
PlanNode node = null;
for (int orderIndex = order.Columns.Count - 1; orderIndex >= 0; orderIndex--)
{
if ((origin != null) && (orderIndex < origin.Columns.Count))
{
node =
Compiler.AppendNode
(
plan,
node,
Instructions.Or,
EmitBrowseOriginNode(plan, order, forward, inclusive, orderIndex)
);
}
else
#if USEINCLUDENILSWITHBROWSE
if (order.Columns[orderIndex].Column.IsNilable && !order.Columns[orderIndex].IncludeNils)
#endif
{
node =
Compiler.AppendNode
(
plan,
node,
Instructions.And,
EmitBrowseNilNode(plan, order.Columns[orderIndex].Column, false)
);
}
}
if (node == null)
{
node = new ValueNode(plan.DataTypes.SystemBoolean, inclusive);
}
return(node);
}
public override object CopyNativeAs(Schema.IDataType dataType)
{
if (_row == null)
{
return(null);
}
if (Object.ReferenceEquals(DataType, dataType))
{
NativeRow newRow = new NativeRow(DataType.Columns.Count);
if (_row != null)
{
for (int index = 0; index < DataType.Columns.Count; index++)
{
#if USEDATATYPESINNATIVEROW
newRow.DataTypes[index] = _row.DataTypes[index];
newRow.Values[index] = CopyNative(Manager, _row.DataTypes[index], _row.Values[index]);
#else
newRow.Values[index] = CopyNative(Manager, DataType.Columns[index].DataType, FRow.Values[index]);
#endif
}
}
return(newRow);
}
else
{
NativeRow newRow = new NativeRow(DataType.Columns.Count);
Schema.IRowType newRowType = (Schema.IRowType)dataType;
if (_row != null)
{
for (int index = 0; index < DataType.Columns.Count; index++)
{
int newIndex = newRowType.Columns.IndexOfName(DataType.Columns[index].Name);
#if USEDATATYPESINNATIVEROW
newRow.DataTypes[newIndex] = _row.DataTypes[index];
newRow.Values[newIndex] = CopyNative(Manager, _row.DataTypes[index], _row.Values[index]);
#else
newRow.Values[newIndex] = CopyNative(Manager, DataType.Columns[index].DataType, FRow.Values[index]);
#endif
}
}
return(newRow);
}
}
/// <summary>Returns the host representation of the given physical value.</summary>
public static IDataValue FromPhysical(IValueManager manager, Schema.IDataType dataType, byte[] buffer, int offset)
{
Schema.IScalarType scalarType = dataType as Schema.IScalarType;
if (scalarType != null)
{
Scalar scalar = new Scalar(manager, scalarType, null);
scalar.ReadFromPhysical(buffer, offset);
return(scalar);
}
Schema.IRowType rowType = dataType as Schema.IRowType;
if (rowType != null)
{
Row row = new Row(manager, rowType);
row.ReadFromPhysical(buffer, offset);
return(row);
}
Schema.IListType listType = dataType as Schema.IListType;
if (listType != null)
{
ListValue list = new ListValue(manager, listType);
list.ReadFromPhysical(buffer, offset);
return(list);
}
Schema.ITableType tableType = dataType as Schema.ITableType;
if (tableType != null)
{
TableValue table = new TableValue(manager, tableType, null);
table.ReadFromPhysical(buffer, offset);
return(table);
}
Schema.ICursorType cursorType = dataType as Schema.ICursorType;
if (cursorType != null)
{
CursorValue cursor = new CursorValue(manager, cursorType, -1);
cursor.ReadFromPhysical(buffer, offset);
return(cursor);
}
throw new RuntimeException(RuntimeException.Codes.InvalidValueType, dataType == null ? "<null>" : dataType.GetType().Name);
}
protected Expression EmitBrowseConditionExpression
(
Schema.Order order,
Schema.IRowType origin,
bool forward,
bool inclusive
)
{
Expression expression = null;
for (int orderIndex = order.Columns.Count - 1; orderIndex >= 0; orderIndex--)
{
if ((origin != null) && (orderIndex < origin.Columns.Count))
{
expression =
AppendExpression
(
expression,
Instructions.Or,
EmitBrowseOriginExpression(order, forward, inclusive, orderIndex)
);
}
else
#if USEINCLUDENILSWITHBROWSE
if (order.Columns[orderIndex].Column.IsNilable && !order.Columns[orderIndex].IncludeNils)
#endif
{
expression =
AppendExpression
(
expression,
Instructions.And,
EmitBrowseNilExpression(order.Columns[orderIndex].Column, false)
);
}
}
if (expression == null)
{
expression = new ValueExpression(inclusive, TokenType.Boolean);
}
return(expression);
}
private Row GetIndexData(IValueManager manager, Schema.IRowType rowType, IRow[] sourceRows)
{
Row row = new Row(manager, rowType);
try
{
int columnIndex;
bool found;
for (int index = 0; index < row.DataType.Columns.Count; index++)
{
found = false;
foreach (Row sourceRow in sourceRows)
{
columnIndex = sourceRow.DataType.Columns.IndexOfName(row.DataType.Columns[index].Name);
if (columnIndex >= 0)
{
if (sourceRow.HasValue(columnIndex))
{
row[index] = sourceRow.GetNativeValue(columnIndex);
}
else
{
row.ClearValue(index);
}
found = true;
break;
}
}
if (found)
{
continue;
}
throw new RuntimeException(RuntimeException.Codes.UnableToConstructIndexKey);
}
return(row);
}
catch
{
row.Dispose();
throw;
}
}
/// <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);
}
}
protected virtual void InternalClose()
{
try
{
try
{
try
{
if (_bookmarks != null)
{
InternalDisposeBookmarks();
_bookmarks = null;
}
}
finally
{
if (_sourceTable != null)
{
_sourceTable.Dispose();
_sourceTable = null;
_sourceRowType = null;
}
}
}
finally
{
if (_programStarted)
{
_program.Stop(_params);
}
}
}
finally
{
_plan.ClearActiveCursor();
}
}
/// <summary>
/// Performs a binary search among the entries in this node for the given key. Will always return an
/// entry index in AEntryNumber, which is the index of the entry that was found if the method returns true,
/// otherwise it is the index where the key should be inserted if the method returns false.
/// </summary>
public bool NodeSearch(Schema.IRowType keyRowType, NativeRow key, out int entryNumber)
{
int lo = (Node.NodeType == NativeRowTreeNodeType.Routing ? 1 : 0);
int hi = Node.EntryCount - 1;
int index = 0;
int result = -1;
while (lo <= hi)
{
index = (lo + hi) / 2;
result = Tree.Compare(Manager, Tree.KeyRowType, Node.Keys[index], keyRowType, key);
if (result == 0)
{
break;
}
else if (result > 0)
{
hi = index - 1;
}
else // if (LResult < 0) unnecessary
{
lo = index + 1;
}
}
if (result == 0)
{
entryNumber = index;
}
else
{
entryNumber = lo;
}
return(result == 0);
}
public int Compare(IValueManager manager, Schema.IRowType indexKeyRowType, NativeRow indexKey, Schema.IRowType compareKeyRowType, NativeRow compareKey)
{
// If AIndexKeyRowType is null, the index key must have the structure of an index key,
// Otherwise, the IndexKey row could be a subset of the actual index key.
// In that case, AIndexKeyRowType is the RowType for the IndexKey row.
// It is the caller's responsibility to ensure that the passed IndexKey RowType
// is a subset of the actual IndexKey with order intact.
//Row LIndexKey = new Row(AManager, AIndexKeyRowType, AIndexKey);
// If ACompareContext is null, the compare key must have the structure of an index key,
// Otherwise the CompareKey could be a subset of the actual index key.
// In that case, ACompareContext is the RowType for the CompareKey row.
// It is the caller's responsibility to ensure that the passed CompareKey RowType
// is a subset of the IndexKey with order intact.
//Row LCompareKey = new Row(AManager, ACompareKeyRowType, ACompareKey);
int result = 0;
for (int index = 0; index < indexKeyRowType.Columns.Count; index++)
{
if (index >= compareKeyRowType.Columns.Count)
{
break;
}
if ((indexKey.Values[index] != null) && (compareKey.Values[index] != null))
{
if (indexKeyRowType.Columns[index].DataType is Schema.ScalarType)
{
result = manager.EvaluateSort(Key.Columns[index], indexKey.Values[index], compareKey.Values[index]);
}
else
{
using (var indexValue = DataValue.FromNative(manager, indexKey.DataTypes[index], indexKey.Values[index]))
{
using (var compareValue = DataValue.FromNative(manager, compareKey.DataTypes[index], compareKey.Values[index]))
{
result = manager.EvaluateSort(Key.Columns[index], indexValue, compareValue);
}
}
}
}
else if (indexKey.Values[index] != null)
{
result = Key.Columns[index].Ascending ? 1 : -1;
}
else if (compareKey.Values[index] != null)
{
result = Key.Columns[index].Ascending ? -1 : 1;
}
else
{
result = 0;
}
if (result != 0)
{
break;
}
}
//LIndexKey.Dispose();
//LCompareKey.Dispose();
return(result);
}
/// <summary>
/// Searches for the given key within the index. ARowTreeSearchPath and AEntryNumber together give the
/// location of the key in the index. If the search is successful, the entry exists, otherwise
/// the EntryNumber indicates where the entry should be placed for an insert.
/// </summary>
/// <param name="key">The key to be found.</param>
/// <param name="rowTreeSearchPath">A <see cref="RowTreeSearchPath"/> which will contain the set of nodes along the search path to the key.</param>
/// <param name="entryNumber">The EntryNumber where the key either is, or should be, depending on the result of the find.</param>
/// <returns>A boolean value indicating the success or failure of the find.</returns>
public bool FindKey(IValueManager manager, Schema.IRowType keyRowType, NativeRow key, RowTreeSearchPath rowTreeSearchPath, out int entryNumber)
{
return(new RowTreeNode(manager, this, Root, LockMode.Shared).FindKey(keyRowType, key, rowTreeSearchPath, out entryNumber));
}
public override void DetermineDataType(Plan plan)
{
DetermineModifiers(plan);
Nodes[0] = Compiler.EmitOrderNode(plan, SourceNode, new Schema.Order(_quotaOrder), true);
_dataType = new Schema.TableType();
_tableVar = new Schema.ResultTableVar(this);
_tableVar.Owner = plan.User;
_tableVar.InheritMetaData(SourceTableVar.MetaData);
CopyTableVarColumns(SourceTableVar.Columns);
DetermineRemotable(plan);
bool quotaOrderIncludesKey = false;
foreach (Schema.Key key in SourceNode.TableVar.Keys)
{
if (Compiler.OrderIncludesKey(plan, _quotaOrder, key))
{
quotaOrderIncludesKey = true;
break;
}
}
if (quotaOrderIncludesKey)
{
if ((Nodes[1].IsLiteral) && ((int)plan.EvaluateLiteralArgument(Nodes[1], "quota") == 1))
{
Schema.Key key = new Schema.Key();
key.IsInherited = true;
TableVar.Keys.Add(key);
}
else
{
CopyKeys(SourceTableVar.Keys);
}
}
else
{
CopyKeys(SourceTableVar.Keys);
}
CopyOrders(SourceTableVar.Orders);
if (SourceNode.Order != null)
{
Order = CopyOrder(SourceNode.Order);
}
#if UseReferenceDerivation
#if UseElaborable
if (plan.CursorContext.CursorCapabilities.HasFlag(CursorCapability.Elaborable))
#endif
CopyReferences(plan, SourceTableVar);
#endif
plan.EnterRowContext();
try
{
#if USENAMEDROWVARIABLES
_quotaRowType = new Schema.RowType(_quotaOrder.Columns);
plan.Symbols.Push(new Symbol(Keywords.Left, _quotaRowType));
#else
Schema.IRowType leftRowType = new Schema.RowType(FQuotaOrder.Columns, Keywords.Left);
APlan.Symbols.Push(new Symbol(String.Empty, leftRowType));
#endif
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Right, _quotaRowType));
#else
Schema.IRowType rightRowType = new Schema.RowType(FQuotaOrder.Columns, Keywords.Right);
APlan.Symbols.Push(new Symbol(String.Empty, rightRowType));
#endif
try
{
_equalNode =
#if USENAMEDROWVARIABLES
Compiler.CompileExpression(plan, Compiler.BuildRowEqualExpression(plan, Keywords.Left, Keywords.Right, _quotaRowType.Columns, _quotaRowType.Columns));
#else
Compiler.CompileExpression(APlan, Compiler.BuildRowEqualExpression(APlan, leftRowType.Columns, rightRowType.Columns));
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
}
// TODO: Compile row types for each index, saving column indexes to prevent the need for lookup during insert, update, and delete.
private void Create(IValueManager manager)
{
TableType = TableVar.DataType;
RowType = TableType.RowType;
Schema.RowType keyRowType;
Schema.RowType dataRowType;
// Create the indexes required to store data as described by the given table variable
// Determine Fanout, Capacity, Clustering Key
Schema.Order clusteringKey = manager.FindClusteringOrder(TableVar);
keyRowType = new Schema.RowType(clusteringKey.Columns);
dataRowType = new Schema.RowType();
foreach (Schema.Column column in TableVar.DataType.Columns)
{
if (!clusteringKey.Columns.Contains(column.Name))
{
dataRowType.Columns.Add(new Schema.Column(column.Name, column.DataType));
}
}
// Add an internal identifier for uniqueness of keys in nonunique indexes
#if USEINTERNALID
_internalIDColumn = new Schema.TableVarColumn(new Schema.Column(InternalIDColumnName, manager.DataTypes.SystemGuid), Schema.TableVarColumnType.InternalID);
dataRowType.Columns.Add(_internalIDColumn.Column);
#endif
// Create the Clustered index
ClusteredIndex =
new NativeRowTree
(
clusteringKey,
keyRowType,
dataRowType,
_fanout,
_capacity,
true
);
// DataLength and DataColumns for all non clustered indexes is the key length and columns of the clustered key
dataRowType = keyRowType;
// Create non clustered indexes for each key and order (unique sets)
Schema.Order key;
foreach (Schema.Key nonClusteredKey in TableVar.Keys)
{
if (!nonClusteredKey.IsSparse && nonClusteredKey.Enforced)
{
if (!manager.OrderIncludesKey(ClusteredIndex.Key, nonClusteredKey))
{
key = manager.OrderFromKey(nonClusteredKey);
if (!NonClusteredIndexes.Contains(key))
{
keyRowType = new Schema.RowType(key.Columns);
NonClusteredIndexes.Add
(
new NativeRowTree
(
key,
keyRowType,
dataRowType,
_fanout,
_capacity,
false
)
);
}
}
}
else
{
// This is a potentially non-unique index, so add a GUID to ensure uniqueness of the key in the BTree
key = manager.OrderFromKey(nonClusteredKey);
#if USEINTERNALID
Schema.OrderColumn uniqueColumn = new Schema.OrderColumn(_internalIDColumn, key.IsAscending);
uniqueColumn.Sort = manager.GetUniqueSort(uniqueColumn.Column.DataType);
key.Columns.Add(uniqueColumn);
#endif
if (!NonClusteredIndexes.Contains(key))
{
keyRowType = new Schema.RowType(key.Columns);
NonClusteredIndexes.Add
(
new NativeRowTree
(
key,
keyRowType,
dataRowType,
_fanout,
_capacity,
false
)
);
}
}
}
foreach (Schema.Order order in TableVar.Orders)
{
// This is a potentially non-unique index, so add a GUID to ensure uniqueness of the key in the BTree
key = new Schema.Order(order);
#if USEINTERNALID
if (!manager.OrderIncludesOrder(key, clusteringKey))
{
Schema.OrderColumn uniqueColumn = new Schema.OrderColumn(_internalIDColumn, order.IsAscending);
uniqueColumn.Sort = manager.GetUniqueSort(uniqueColumn.Column.DataType);
key.Columns.Add(uniqueColumn);
}
#endif
if (!NonClusteredIndexes.Contains(key))
{
keyRowType = new Schema.RowType(key.Columns);
NonClusteredIndexes.Add
(
new NativeRowTree
(
key,
keyRowType,
dataRowType,
_fanout,
_capacity,
false
)
);
}
}
}
// The given object[] is assumed to contains values of the appropriate type for the given data type
public Row(IValueManager manager, Schema.IRowType dataType, NativeRow row) : base(manager, dataType)
{
_row = row;
ValuesOwned = false;
}
public void ProcessFetchData(RemoteFetchData fetchData, Guid[] bookmarks, bool isFirst)
{
_buffer.BufferDirection = _bufferDirection;
Schema.IRowType rowType = DataType.RowType;
if (_bufferDirection == BufferDirection.Forward)
{
for (int index = 0; index < fetchData.Body.Length; index++)
{
LocalRow row = new LocalRow(new Row(_plan._process.ValueManager, rowType), bookmarks[index]);
row.Row.AsPhysical = fetchData.Body[index].Data;
_buffer.Add(row);
AddBookmarkIfNotEmpty(bookmarks[index]);
}
if ((fetchData.Body.Length > 0) && !isFirst)
{
_bufferIndex = 0;
}
else
{
_bufferIndex = -1;
}
if ((fetchData.Flags & CursorGetFlags.EOF) != 0)
{
_sourceCursorIndex = _buffer.Count;
}
else
{
_sourceCursorIndex = _buffer.Count - 1;
}
}
else
{
for (int index = 0; index < fetchData.Body.Length; index++)
{
LocalRow row = new LocalRow(new Row(_plan._process.ValueManager, rowType), bookmarks[index]);
row.Row.AsPhysical = fetchData.Body[index].Data;
_buffer.Insert(0, row);
AddBookmarkIfNotEmpty(bookmarks[index]);
}
if ((fetchData.Body.Length > 0) && !isFirst)
{
_bufferIndex = _buffer.Count - 1;
}
else
{
_bufferIndex = _buffer.Count;
}
if ((fetchData.Flags & CursorGetFlags.BOF) != 0)
{
_sourceCursorIndex = -1;
}
else
{
_sourceCursorIndex = 0;
}
}
SetFlags(fetchData.Flags);
_bufferFull = true;
}
public static object CopyNative(IValueManager manager, Schema.IDataType dataType, object tempValue)
{
// This code is duplicated in the descendent CopyNative methods for performance
if (tempValue == null)
{
return(tempValue);
}
Schema.IScalarType scalarType = dataType as Schema.IScalarType;
if (scalarType != null)
{
if (tempValue is StreamID)
{
return(manager.StreamManager.Reference((StreamID)tempValue));
}
ICloneable cloneable = tempValue as ICloneable;
if (cloneable != null)
{
return(cloneable.Clone());
}
if (scalarType.IsCompound)
{
return(CopyNative(manager, scalarType.CompoundRowType, tempValue));
}
return(tempValue);
}
Schema.IRowType rowType = dataType as Schema.IRowType;
if (rowType != null)
{
NativeRow nativeRow = (NativeRow)tempValue;
NativeRow newRow = new NativeRow(rowType.Columns.Count);
for (int index = 0; index < rowType.Columns.Count; index++)
{
#if USEDATATYPESINNATIVEROW
newRow.DataTypes[index] = nativeRow.DataTypes[index];
newRow.Values[index] = CopyNative(manager, nativeRow.DataTypes[index], nativeRow.Values[index]);
#else
newRow.Values[index] = CopyNative(AManager, rowType.Columns[index].DataType, nativeRow.Values[index]);
#endif
}
return(newRow);
}
Schema.IListType listType = dataType as Schema.IListType;
if (listType != null)
{
NativeList nativeList = (NativeList)tempValue;
NativeList newList = new NativeList();
for (int index = 0; index < nativeList.DataTypes.Count; index++)
{
newList.DataTypes.Add(nativeList.DataTypes[index]);
newList.Values.Add(CopyNative(manager, nativeList.DataTypes[index], nativeList.Values[index]));
}
return(newList);
}
Schema.ITableType tableType = dataType as Schema.ITableType;
if (tableType != null)
{
NativeTable nativeTable = (NativeTable)tempValue;
NativeTable newTable = new NativeTable(manager, nativeTable.TableVar);
using (Scan scan = new Scan(manager, nativeTable, nativeTable.ClusteredIndex, ScanDirection.Forward, null, null))
{
scan.Open();
while (scan.Next())
{
using (IRow row = scan.GetRow())
{
newTable.Insert(manager, row);
}
}
}
return(newTable);
}
Schema.ICursorType cursorType = dataType as Schema.ICursorType;
if (cursorType != null)
{
return(tempValue);
}
var runtimeType = manager.GetRuntimeType(tempValue);
if (runtimeType != null)
{
return(CopyNative(manager, runtimeType, tempValue));
}
throw new RuntimeException(RuntimeException.Codes.InvalidValueType, dataType == null ? "<null>" : dataType.GetType().Name);
}
