/// <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>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);
}
/// <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);
}
// 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
)
);
}
}
}
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);
}
protected Table(IValueManager manager, Schema.ITableType tableType) : base(manager, tableType)
{
}
public TableValue(IValueManager manager, Schema.ITableType tableType, NativeTable table) : base(manager, tableType)
{
_table = table;
}
