protected override void InternalClose() { while (_sourceTables.Count > 0) { PopSourceTable(); } if (_sourceRow != null) { _sourceRow.Dispose(); _sourceRow = null; } if (_targetRow != null) { _targetRow.Dispose(); _targetRow = null; } if (_scan != null) { _scan.Dispose(); _scan = null; } if (_buffer != null) { _buffer.Drop(Manager); _buffer = null; } _tableType = null; _sequenceColumnIndex = -1; }
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); }
protected override void InternalClose() { if (_scan != null) { _scan.Dispose(); _scan = null; } if (_buffer != null) { _buffer.Drop(Manager); _buffer = null; } if (_leftTable != null) { _leftTable.Dispose(); _leftTable = null; } if (_rightTable != null) { _rightTable.Dispose(); _rightTable = null; } if (_sourceRow != null) { _sourceRow.Dispose(); _sourceRow = null; } }
protected override void InternalOpen() { // TODO: Rewrite this... Schema.TableType tableType = new Schema.TableType(); Schema.BaseTableVar tableVar = new Schema.BaseTableVar(tableType); Schema.TableVarColumn newColumn; foreach (Schema.TableVarColumn column in Node.TableVar.Columns) { newColumn = (Schema.TableVarColumn)column.Copy(); tableType.Columns.Add(newColumn.Column); tableVar.Columns.Add(newColumn); } Schema.Order order = new Schema.Order(); Schema.OrderColumn newOrderColumn; Schema.OrderColumn orderColumn; for (int index = 0; index < Node.Order.Columns.Count; index++) { orderColumn = Node.Order.Columns[index]; newOrderColumn = new Schema.OrderColumn(tableVar.Columns[orderColumn.Column], orderColumn.Ascending, orderColumn.IncludeNils); newOrderColumn.Sort = orderColumn.Sort; newOrderColumn.IsDefaultSort = orderColumn.IsDefaultSort; order.Columns.Add(newOrderColumn); } tableVar.Orders.Add(order); _table = new NativeTable(Manager, tableVar); PopulateTable(); _scan = new Scan(Manager, _table, _table.ClusteredIndex, ScanDirection.Forward, null, null); _scan.Open(); }
public TableScan(IValueManager manager, NativeTable table, Schema.Order key, ScanDirection direction, Row firstKey, Row lastKey) : base(manager, table.TableType) { _nativeTable = table; _key = key; _direction = direction; _firstKey = firstKey; _lastKey = lastKey; }
/// <remarks> Scan range keys are inclusive. </remarks> public Scan(IValueManager manager, NativeTable table, NativeRowTree accessPath, ScanDirection direction, IRow firstKey, IRow lastKey) { _manager = manager; _table = table; _accessPath = accessPath; _direction = direction; _firstKey = firstKey; _lastKey = lastKey; }
protected override void InternalClose() { if (_scan != null) { _scan.Dispose(); } _scan = null; if (_table != null) { _table.Drop(Manager); _table = null; } }
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); }
public static void DisposeValue(IValueManager manager, object tempValue) { IDataValue localTempValue = tempValue as IDataValue; if (localTempValue != null) { localTempValue.Dispose(); return; } if (tempValue is StreamID) { manager.StreamManager.Deallocate((StreamID)tempValue); return; } NativeRow nativeRow = tempValue as NativeRow; if (nativeRow != null) { for (int index = 0; index < nativeRow.Values.Length; index++) { DisposeValue(manager, nativeRow.Values[index]); } return; } NativeList nativeList = tempValue as NativeList; if (nativeList != null) { for (int index = 0; index < nativeList.Values.Count; index++) { DisposeValue(manager, nativeList.Values[index]); } } NativeTable nativeTable = tempValue as NativeTable; if (nativeTable != null) { DisposeNative(manager, nativeTable.TableType, nativeTable); } }
protected override void InternalOpen() { _sourceTables = new Stack(Program.Stack.MaxStackDepth, Program.Stack.MaxCallDepth); _sourceTables.PushWindow(0); _parentRows = new Stack(Program.Stack.MaxStackDepth, Program.Stack.MaxCallDepth); _parentRows.PushWindow(0); PushSourceTable(null); _sourceRow = new Row(Manager, ((TableNode)Node.Nodes[0]).DataType.RowType); _tableType = new Schema.TableType(); _tableVar = new Schema.BaseTableVar(_tableType, Program.TempDevice); Schema.TableVarColumn newColumn; foreach (Schema.TableVarColumn column in Node.TableVar.Columns) { newColumn = (Schema.TableVarColumn)column.Copy(); _tableType.Columns.Add(newColumn.Column); _tableVar.Columns.Add(newColumn); } if (Node.SequenceColumnIndex < 0) { newColumn = new Schema.TableVarColumn(new Schema.Column(Keywords.Sequence, Program.DataTypes.SystemInteger), Schema.TableVarColumnType.Stored); _tableType.Columns.Add(newColumn.Column); _tableVar.Columns.Add(newColumn); _sequenceColumnIndex = _tableVar.Columns.Count - 1; } else { _sequenceColumnIndex = Node.SequenceColumnIndex; } _targetRow = new Row(Manager, _tableType.RowType); Schema.Key key = new Schema.Key(); key.Columns.Add(_tableVar.Columns[_sequenceColumnIndex]); _tableVar.Keys.Add(key); _buffer = new NativeTable(Manager, _tableVar); _scan = new Scan(Manager, _buffer, _buffer.ClusteredIndex, ScanDirection.Forward, null, null); _scan.Open(); _sequence = 0; _empty = false; InternalNext(); _empty = _scan.EOF(); _scan.First(); }
protected override void InternalOpen() { _sourceRow = new Row(Manager, Node.DataType.RowType); _leftTable = (ITable)Node.Nodes[0].Execute(Program); try { _rightTable = (ITable)Node.Nodes[1].Execute(Program); } catch { _leftTable.Dispose(); throw; } Schema.TableType tableType = new Schema.TableType(); Schema.BaseTableVar tableVar = new Schema.BaseTableVar(tableType, Program.TempDevice); Schema.TableVarColumn newColumn; foreach (Schema.TableVarColumn column in _leftTable.Node.TableVar.Columns) { newColumn = column.Inherit(); tableType.Columns.Add(column.Column); tableVar.Columns.Add(column); } Schema.Key key = new Schema.Key(); foreach (Schema.TableVarColumn column in Node.TableVar.Keys.MinimumKey(true).Columns) { key.Columns.Add(tableVar.Columns[column.Name]); } tableVar.Keys.Add(key); _buffer = new NativeTable(Manager, tableVar); PopulateBuffer(); _scan = new Scan(Manager, _buffer, _buffer.ClusteredIndex, ScanDirection.Forward, null, null); _scan.Open(); }
public LocalTable(TableNode tableNode, Program program) : base(tableNode, program) { _nativeTable = new NativeTable(program.ValueManager, tableNode.TableVar); _key = program.OrderFromKey(program.FindClusteringKey(tableNode.TableVar)); }
public static object CopyValue(IValueManager manager, object value) { IDataValue dataValue = value as IDataValue; if (dataValue != null) { return(dataValue.Copy()); } ICloneable cloneable = value as ICloneable; if (cloneable != null) { return(cloneable.Clone()); } #if SILVERLIGHT System.Array array = value as System.Array; if (array != null) { return(array.Clone()); } #endif if (value is StreamID) { return(manager.StreamManager.Reference((StreamID)value)); } NativeRow nativeRow = value as NativeRow; if (nativeRow != null) { NativeRow newRow = new NativeRow(nativeRow.Values.Length); for (int index = 0; index < nativeRow.Values.Length; index++) { #if USEDATATYPESINNATIVEROW newRow.DataTypes[index] = nativeRow.DataTypes[index]; #endif newRow.Values[index] = CopyValue(manager, nativeRow.Values[index]); } return(newRow); } NativeList nativeList = value as NativeList; if (nativeList != null) { NativeList newList = new NativeList(); for (int index = 0; index < nativeList.Values.Count; index++) { newList.DataTypes.Add(nativeList.DataTypes[index]); newList.Values.Add(CopyValue(manager, nativeList.Values[index])); } return(newList); } NativeTable nativeTable = value as NativeTable; if (nativeTable != null) { return(CopyNative(manager, nativeTable.TableType, nativeTable)); } return(value); }
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); }
public TableValue(IValueManager manager, Schema.ITableType tableType, NativeTable table) : base(manager, tableType) { _table = table; }
/// <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); }