public override object CopyNativeAs(Schema.IDataType dataType)
{
// We need to construct a new TableVar here because otherwise the native table
// will be constructed with the keys inferred for the source, resulting in
// incorrect access plans (see Defect #33978 for more).
Schema.ResultTableVar tableVar = new Schema.ResultTableVar(Node);
tableVar.Owner = Program.Plan.User;
tableVar.EnsureTableVarColumns();
Program.EnsureKey(tableVar);
if (!Active)
{
Open();
}
else
{
Reset();
}
NativeTable nativeTable = new NativeTable(Manager, tableVar);
while (Next())
{
using (IRow row = Select())
{
nativeTable.Insert(Manager, row);
}
}
return(nativeTable);
}
public override void ReadFromPhysical(byte[] buffer, int offset)
{
_table.Truncate(Manager);
Streams.IConveyor int32Conveyor = Manager.GetConveyor(Manager.DataTypes.SystemInteger);
if (buffer[offset] != 0)
{
offset++;
int rowSize;
int count = (int)int32Conveyor.Read(buffer, offset);
for (int index = 0; index < count; index++)
{
rowSize = (int)int32Conveyor.Read(buffer, offset);
offset += sizeof(int);
using (IRow row = (IRow)DataValue.FromPhysical(Manager, _table.RowType, buffer, offset))
{
_table.Insert(Manager, row);
}
offset += rowSize;
}
}
}
protected void PopulateBuffer()
{
while (_leftTable.Next())
{
_leftTable.Select(_sourceRow);
_buffer.Insert(Manager, _sourceRow);
}
while (_rightTable.Next())
{
_rightTable.Select(_sourceRow);
if (!_buffer.HasRow(Manager, _sourceRow))
{
_buffer.Insert(Manager, _sourceRow);
}
}
}
public override object CopyNativeAs(Schema.IDataType dataType)
{
NativeTable newTable = new NativeTable(Manager, _table.TableVar);
using (Scan scan = new Scan(Manager, _table, _table.ClusteredIndex, ScanDirection.Forward, null, null))
{
scan.Open();
while (scan.Next())
{
using (IRow row = scan.GetRow())
{
newTable.Insert(Manager, row);
}
}
}
return(newTable);
}
protected override bool InternalNext()
{
if (!_scan.Next())
{
ITable table;
while (_sourceTables.Count > 0)
{
// Retrieve the current cursor to be iterated
table = (ITable)_sourceTables[0];
bool contextPopped = false;
bool contextPushed = false;
if (_sourceTables.Count > 1)
{
// Push it's parent row context, if necessary
Program.Stack.Push(_parentRows.Peek(0));
contextPushed = true;
}
try
{
if (table.Next())
{
_sequence++;
table.Select(_sourceRow);
if (contextPushed)
{
contextPopped = true;
Program.Stack.Pop();
}
_targetRow.ClearValues();
for (int index = 0; index < _sourceRow.DataType.Columns.Count; index++)
{
_targetRow[index] = _sourceRow[index];
}
if (Node.LevelColumnIndex >= 0)
{
_targetRow[Node.LevelColumnIndex] = _sourceTables.Count;
}
if (_sequenceColumnIndex >= 0)
{
_targetRow[_sequenceColumnIndex] = _sequence;
}
_buffer.Insert(Manager, _targetRow);
if (!_scan.FindKey(_targetRow))
{
throw new RuntimeException(RuntimeException.Codes.NewRowNotFound);
}
// Use the current row to push a new cursor looking for children of this row
PushSourceTable(_sourceRow);
return(true);
}
else
{
// The current cursor has been exhausted, pop it.
PopSourceTable();
}
}
finally
{
if (contextPushed && !contextPopped)
{
Program.Stack.Pop();
}
}
}
return(false);
}
return(true);
}
protected override void InternalInsert(IRow oldRow, IRow newRow, BitArray valueFlags, bool uncheckedValue)
{
_nativeTable.Insert(Manager, newRow);
}
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);
}
/// <summary>
/// Converts the C# host representation of a value to the "Native" representation (using NativeLists, NativeRows, and NativeTables)
/// </summary>
/// <param name="dataType">The target data type for the conversion.</param>
/// <param name="value">The source value to be converted.</param>
/// <returns>The value in its "Native" representation.</returns>
public static object ToNativeOf(IValueManager valueManager, Schema.IDataType dataType, object value)
{
if (value != null)
{
var scalarType = dataType as Schema.IScalarType;
if (scalarType != null)
{
if (scalarType.Equals(valueManager.DataTypes.SystemString) && !(value is String))
{
return(value.ToString()); // The usual scenario would be an enumerated type...
}
if (scalarType.Equals(valueManager.DataTypes.SystemDateTime) && value is DateTimeOffset)
{
return(new DateTime(((DateTimeOffset)value).Ticks));
}
return(value); // Otherwise, return the C# representation directly
}
var listType = dataType as Schema.IListType;
if (listType != null && value != null)
{
var listValue = value as ListValue;
if (listValue != null)
{
return(listValue);
}
var nativeList = value as NativeList;
if (nativeList != null)
{
return(nativeList);
}
var iList = value as IList;
if (iList != null)
{
var newList = new NativeList();
for (int index = 0; index < iList.Count; index++)
{
newList.DataTypes.Add(listType.ElementType);
newList.Values.Add(ToNativeOf(valueManager, listType.ElementType, iList[index]));
}
return(newList);
}
throw new RuntimeException(RuntimeException.Codes.InternalError, String.Format("Unexpected type for property: {0}", value.GetType().FullName));
}
var tableType = dataType as Schema.ITableType;
if (tableType != null && value != null)
{
var tableValue = value as TableValue;
if (tableValue != null)
{
return(tableValue);
}
var nativeTable = value as NativeTable;
if (nativeTable != null)
{
return(nativeTable);
}
var iDictionary = value as IDictionary;
if (iDictionary != null)
{
var newTableVar = new Schema.BaseTableVar(tableType);
newTableVar.EnsureTableVarColumns();
// Assume the first column is the key, this is potentially problematic, but without key information in table types, not much else we can do....
// The assumption here is that the C# representation of a "table" is a dictionary
newTableVar.Keys.Add(new Schema.Key(new Schema.TableVarColumn[] { newTableVar.Columns[0] }));
var newTable = new NativeTable(valueManager, newTableVar);
foreach (DictionaryEntry entry in iDictionary)
{
using (Row row = new Row(valueManager, newTableVar.DataType.RowType))
{
row[0] = ToNativeOf(valueManager, tableType.Columns[0].DataType, entry.Key);
row[1] = ToNativeOf(valueManager, tableType.Columns[1].DataType, entry.Value);
newTable.Insert(valueManager, row);
}
}
return(newTable);
}
throw new RuntimeException(RuntimeException.Codes.InternalError, String.Format("Unexpected type for property: {0}", value.GetType().FullName));
}
}
return(value);
}