public void DeleteVersionShouldExecuteDeleteDataExpression() { var processor = new Mock <IMigrationProcessor>(); var runner = new Mock <IMigrationRunner>(); runner.SetupGet(r => r.Processor).Returns(processor.Object); var conventions = new MigrationConventions(); var asm = Assembly.GetExecutingAssembly(); var loader = new VersionLoader(runner.Object, asm, conventions); Func <IDataDefinition, bool> predicate = definition => { if (definition is ExplicitDataDefinition) { IDataValue kvp = ((ExplicitDataDefinition)definition).Data.First(); return(kvp.ColumnName == loader.VersionTableMetaData.ColumnName && kvp.Value.Equals(1L)); } else { return(false); } }; processor.Setup(p => p.Process(It.Is <DeleteDataExpression>(expression => expression.SchemaName == loader.VersionTableMetaData.SchemaName && expression.TableName == loader.VersionTableMetaData.TableName && expression.Rows.All(predicate)))).Verifiable(); loader.DeleteVersion(1); processor.VerifyAll(); }
/// <summary>Disposes the given native value.</summary> public static void DisposeNative(IValueManager manager, Schema.IDataType dataType, object tempValue) { if (tempValue == null) { return; } Schema.IScalarType scalarType = dataType as Schema.IScalarType; if (scalarType != null) { if (tempValue is StreamID) { manager.StreamManager.Deallocate((StreamID)tempValue); } if (scalarType.IsCompound) { DisposeNative(manager, scalarType.CompoundRowType, tempValue); } return; } using (IDataValue dataValue = DataValue.FromNative(manager, dataType, tempValue)) { dataValue.ValuesOwned = true; } }
private Image LoadImage(string imageExpression) { try { using (IDataValue imageData = FrontendSession.Pipe.RequestDocument(imageExpression)) { var streamCopy = new MemoryStream(); Stream stream = imageData.OpenStream(); try { StreamUtility.CopyStream(stream, streamCopy); } finally { stream.Close(); } return(Image.FromStream(streamCopy)); } } catch (Exception exception) { Dataphoria.Warnings.AppendError(this, exception, true); // Don't rethrow } return(null); }
public CombinedVariant([NotNull] IDataValue value, [NotNull] Variable variable, [NotNull] IReadOnlyList <VariableVariant> source, [NotNull] AnalysisContext context) : base(variable, context) { Value = value ?? throw new ArgumentNullException(nameof(value)); Storage = new CombinedVariableVariant(source); }
private IDataValue ConditionAssign(IValue right, [NotNull] AnalysisContext context, [NotNull] IDataValue oldValue) { var rightRange = context.ResolveToRange(right); switch (right) { case {} when rightRange != null: { return(new DataValueInterval(rightRange, oldValue.Constraints)); } case LiteralBase rightLiteral: { return(new DataValueLiteral(rightLiteral, oldValue.Constraints)); } case IVariantWithStorageVariable rightVariant: { return(new DataValueLValueRef(rightVariant.StorageVariable, oldValue.Constraints)); } } return(null); }
/// <summary>This is a by-reference access of the value, changes made to the resulting DataValue will be refelected in the actual row.</summary> public object this[int index] { get { #if USEDATATYPESINNATIVEROW if (_row.DataTypes[index] is Schema.IScalarType) #else if (DataType.Columns[AIndex].DataType is Schema.IScalarType) #endif { return(_row.Values[index]); } return(FromNativeRow(Manager, DataType, _row, index)); } set { if (_row.Values[index] != null) #if USEDATATYPESINNATIVEROW { DataValue.DisposeNative(Manager, _row.DataTypes[index], _row.Values[index]); } #else { DataValue.DisposeNative(Manager, DataType.Columns[AIndex].DataType, FRow.Values[AIndex]); } #endif IDataValue tempValue = value as IDataValue; if (tempValue != null) { #if USEDATATYPESINNATIVEROW _row.DataTypes[index] = tempValue.DataType; #endif _row.Values[index] = tempValue.CopyNative(); } else if (value != null) { #if USEDATATYPESINNATIVEROW if ((DataType.Columns[index].DataType.Equals(Manager.DataTypes.SystemGeneric)) || (DataType.Columns[index].DataType.Equals(Manager.DataTypes.SystemScalar))) { _row.DataTypes[index] = Manager.GetRuntimeType(value.GetType()); } else { _row.DataTypes[index] = DataType.Columns[index].DataType; } _row.Values[index] = DataValue.CopyNative(Manager, _row.DataTypes[index], value); #else FRow.Values[AIndex] = DataValue.CopyNative(Manager, DataType.Columns[AIndex].DataType, value); #endif } else { #if USEDATATYPESINNATIVEROW _row.DataTypes[index] = DataType.Columns[index].DataType; #endif _row.Values[index] = null; } if (_row.ModifiedFlags != null) { _row.ModifiedFlags[index] = true; } } }
public override bool TryGetValue(string key, out IDataValue value) { TDataValue v; var ret = Dictionary.TryGetValue(key, out v); value = v; return(ret); }
public override bool TryGetValue(string key, out IDataValue value) { string v; var ret = Dictionary.TryGetValue(key, out v); value = CommonExtensions.ToDataValue <TDataValue>(v); return(ret); }
internal Exemplar(DateTimeOffset timestamp, IDataValue value, ActivityTraceId traceId, ActivitySpanId spanId, KeyValuePair <string, object>[] filteredTags) { this.Timestamp = timestamp; this.FilteredTags = filteredTags; this.SpanId = spanId; this.TraceId = traceId; this.value = value; }
public void Update <T>(T value) where T : struct { lock (this.lockUpdate) { this.value = new DataValue <T>(value); } }
/// <summary> /// Converts an <see cref="IDataValue"/> instance to a contact with a concrete type. /// </summary> /// <typeparam name="TDataValue">The concrete contact type.</typeparam> /// <param name="value">The <see cref="IDataValue"/> to convert</param> /// <returns>The converted contact.</returns> public static TDataValue ToDataValue <TDataValue>(this IDataValue value) where TDataValue : class, IDataValue, new() { return(value == null ? null : value as TDataValue ?? new TDataValue { Item = value.Item }); }
internal static void checkValuedPropertyValue(IDataValue propValue, DataType expectedType) { // check the expected values when the property value has an actual value Assert.AreEqual(expectedType, propValue.ValueType, string.Format("ValueType should be {0}", Enum.GetName(typeof(DataType), expectedType))); Assert.IsNotNull(propValue.Value, "Value should not be null"); Assert.IsFalse(propValue.IsIndeterminate, "The value should not be indeterminate"); Assert.IsFalse(propValue.IsVaries, "The value should not vary"); }
internal static void checkDefaultPropertyValue(IDataValue propValue, DataType expectedType) { // check the expected default values Assert.AreEqual(expectedType, propValue.ValueType, string.Format("ValueType should be {0}", Enum.GetName(typeof(DataType), expectedType))); Assert.IsNull(propValue.Value, "Value should be null"); Assert.IsTrue(propValue.IsIndeterminate, "The value should be indeterminate"); Assert.IsFalse(propValue.IsVaries, "The value should not vary"); }
protected override int compareValue(object obj) { // handle comparison based on the IDataValue interface if (obj is IDataValue) { IDataValue dataValueObj = obj as IDataValue; return(m_value.CompareTo(dataValueObj.AsBoolean())); } return(m_value.CompareTo(obj)); }
protected override int compareValue(object obj) { // handle comparison based on the IDataValue interface if (obj is IDataValue) { IDataValue dataValueObj = obj as IDataValue; return(m_value.CompareTo(dataValueObj.AsDouble())); } // TODO: needs fuzzy equality support return(m_value.CompareTo(obj)); }
public CombinedItemVariant([NotNull] IDataValue value, [NotNull] Variable arrayStorage, [NotNull] TypeReference typeRef, [NotNull] ValueInterval index, [NotNull] IReadOnlyList <ItemValueVariantBase> source, [NotNull] AnalysisContext context) : base(arrayStorage, typeRef, context) { Index = index ?? throw new ArgumentNullException(nameof(index)); Value = value ?? throw new ArgumentNullException(nameof(value)); Values = source ?? throw new ArgumentNullException(nameof(source)); if (source.Count == 0) { throw new ArgumentException("Value cannot be an empty collection.", nameof(source)); } }
public IEnumerable <ItemValueVariantBase> this[AnalysisContext context, IDataValue item] { get { var range = context.ResolveToRange(item); return(this[context, range]); } set { var range = context.ResolveToRange(item); this[context, range] = value; } }
public override void WriteToPhysical(byte[] buffer, int offset, bool expandStreams) { // Write scalar header byte header = (byte)(IsNil ? 0 : 1); header |= (byte)(IsNative ? 2 : 0); header |= (byte)(expandStreams ? 4 : 0); buffer[offset] = header; offset++; if (!IsNil) { if (IsNative) { if (DataType.IsCompound) { _writeValue.WriteToPhysical(buffer, offset, expandStreams); _writeValue.Dispose(); _writeValue = null; } else { Streams.IConveyor conveyor = Manager.GetConveyor(DataType); if (conveyor.IsStreaming) { _writeStream.Position = 0; _writeStream.Read(buffer, offset, (int)_writeStream.Length); _writeStream.Close(); } else { conveyor.Write(Value, buffer, offset); } } } else { if (expandStreams) { _writeStream.Position = 0; _writeStream.Read(buffer, offset, (int)_writeStream.Length); _writeStream.Close(); } else { ((StreamID)Value).Write(buffer, offset); } } } }
private static int ReadResult(StringBuilder LResult, IServerExpressionPlan LPlan) { int rowCount; if (LPlan.DataType is DAE.Schema.ITableType) { IServerCursor cursor = LPlan.Open(null); try { rowCount = ResultsFromCursor(cursor, LResult); LResult.Append("\r\n"); } finally { LPlan.Close(cursor); } } else { IDataValue value = LPlan.Evaluate(null); rowCount = -1; // row count not applicable if ((value == null) || value.IsNil) { LResult.Append(Strings.Get("NoValue")); } else if (LPlan.DataType is DAE.Schema.IRowType) { ResultsFromRow((IRow)value, LResult); } else if (LPlan.DataType is DAE.Schema.IListType) { ResultsFromList((ListValue)value, LResult); } else if (LPlan.DataType is DAE.Schema.IScalarType) { LResult.Append(((IScalar)value).AsDisplayString); } else { LResult.Append(String.Format("<Unknown Result Type: {0}>", LPlan.DataType.Name)); } LResult.Append("\r\n"); } return(rowCount); }
public int CompareTo(object obj) { // check for reference equality first if (object.ReferenceEquals(this, obj)) { return(CompareResult.Equal); } // check for null reference if (obj == null) { return(CompareResult.GreaterThan); } // handle comparison based on the IDataValue interface if (obj is IDataValue) { IDataValue dataValueObj = obj as IDataValue; // first check for the indeterminate state if (IsIndeterminate == true) { return(dataValueObj.IsIndeterminate ? CompareResult.Equal : CompareResult.LessThan); } else if (dataValueObj.IsIndeterminate) { return(CompareResult.GreaterThan); } // then check for the varies state if (IsVaries == true) { return(dataValueObj.IsVaries ? CompareResult.Equal : CompareResult.LessThan); } else if (dataValueObj.IsVaries) { return(CompareResult.GreaterThan); } } // the values are neither indeterminate or varies, // so let the subclas to compare the values return(compareValue(obj)); }
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 bool EvaluateCondition() { bool result = false; if (Condition != String.Empty) { DAE.Runtime.DataParams localParamsValue = BaseArgument.CollectArguments(this); DAE.IServerProcess process = HostNode.Session.DataSession.ServerSession.StartProcess(new DAE.ProcessInfo(HostNode.Session.DataSession.ServerSession.SessionInfo)); try { ErrorList errors = new ErrorList(); DAE.IServerScript script = process.PrepareScript(String.Format("select {0}", Condition)); try { DAE.IServerBatch batch = script.Batches[0]; DAE.IServerExpressionPlan plan = batch.PrepareExpression(localParamsValue); try { errors.AddRange(plan.Messages); using (IDataValue dataValue = plan.Evaluate(localParamsValue)) result = dataValue == null ? false : (bool)dataValue.AsNative; } finally { batch.UnprepareExpression(plan); } } finally { process.UnprepareScript(script); } HostNode.Session.ReportErrors(HostNode, errors); } finally { HostNode.Session.DataSession.ServerSession.StopProcess(process); } BaseArgument.ApplyArguments(this, localParamsValue); } return(result); }
public override object InternalExecute(Program program, object[] arguments) { IDataValue tempValue = arguments[0] as IDataValue; if (tempValue == null) { tempValue = DataValue.FromNative(program.ValueManager, arguments[0]); } if (tempValue.IsPhysicalStreaming) { using (Stream stream = tempValue.OpenStream()) { return((int)CRC32Utility.GetCRC32(stream)); } } else { byte[] physical = new byte[tempValue.GetPhysicalSize(true)]; tempValue.WriteToPhysical(physical, 0, true); return((int)CRC32Utility.GetCRC32(physical)); } }
private IDataValue _writeValue; // saves the row instantiated to write the compound value if this is a compound scalar public override int GetPhysicalSize(bool expandStreams) { int size = 1; // Scalar header if (!IsNil) { if (IsNative) { if (DataType.IsCompound) { _writeValue = DataValue.FromNative(Manager, DataType.CompoundRowType, Value); return(size + _writeValue.GetPhysicalSize(expandStreams)); } else { Streams.IConveyor conveyor = Manager.GetConveyor(DataType); if (conveyor.IsStreaming) { _writeStream = new MemoryStream(64); conveyor.Write(Value, _writeStream); return(size + (int)_writeStream.Length); } return(size + conveyor.GetSize(Value)); } } if (expandStreams) { _writeStream = Manager.StreamManager.Open(StreamID, LockMode.Exclusive); return(size + (int)_writeStream.Length); } return(size + StreamID.CSizeOf); } return(size); }
public byte[] Evaluate(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, ProcessCallInfo callInfo) { _process.ProcessCallInfo(callInfo); try { DataParams localParamsValue = _process.RemoteParamDataToDataParams(paramsValue); IDataValue tempValue = ServerExpressionPlan.Evaluate(localParamsValue); _process.DataParamsToRemoteParamData(localParamsValue, ref paramsValue); executeTime = ServerExpressionPlan.ProgramStatistics; if (tempValue == null) { return(null); } if (ServerExpressionPlan.DataType.Equivalent(tempValue.DataType)) { return(tempValue.AsPhysical); } return(tempValue.CopyAs(ServerExpressionPlan.DataType).AsPhysical); } catch (Exception E) { throw WrapException(E); } }
/// <summary> /// Writes <see cref="IDataValue" /> using the provided encoder <see cref="IBinaryEncoder" />. /// </summary> /// <param name="encoder">The encoder - an object implementing the <see cref="IBinaryEncoder" /> interface.</param> /// <param name="value">The value to be encoded.</param> public abstract void Write(IBinaryEncoder encoder, IDataValue value);
// Delete protected override void InternalExecuteDelete(Program program, IRow row, bool checkConcurrency, bool uncheckedValue) { base.InternalExecuteDelete(program, row, checkConcurrency, uncheckedValue); if (PropagateDelete) { PushRow(program, row); try { int columnIndex; for (int index = 1; index < Nodes.Count; index++) { Schema.TableVarColumn column = TableVar.Columns[_extendColumnOffset + index - 1]; if (column.ColumnType == Schema.TableVarColumnType.Stored) { columnIndex = row.DataType.Columns.IndexOfName(column.Column.Name); if (columnIndex >= 0) { TableNode tableNode = Nodes[index] as TableNode; if (tableNode == null) { ExtractRowNode extractRowNode = Nodes[index] as ExtractRowNode; if (extractRowNode != null) { tableNode = (TableNode)extractRowNode.Nodes[0]; } } if (tableNode == null) { throw new RuntimeException(RuntimeException.Codes.InternalError, "Could not determine update path for extend column."); } IDataValue oldValue = row.GetValue(columnIndex); if (!oldValue.IsNil) { IRow oldRowValue = oldValue as IRow; if (oldRowValue != null) { tableNode.Delete(program, oldRowValue, checkConcurrency, uncheckedValue); } else { TableValue oldTableValue = (TableValue)oldValue; using (ITable oldTableCursor = oldTableValue.OpenCursor()) { while (oldTableCursor.Next()) { using (IRow oldTableCursorRow = oldTableCursor.Select()) { tableNode.Delete(program, oldTableCursorRow, checkConcurrency, uncheckedValue); } } } } } } } } } finally { PopRow(program); } } }
// Insert protected override void InternalExecuteInsert(Program program, IRow oldRow, IRow newRow, BitArray valueFlags, bool uncheckedValue) { base.InternalExecuteInsert(program, oldRow, newRow, valueFlags, uncheckedValue); if (PropagateInsert != PropagateAction.False) { PushRow(program, newRow); try { int columnIndex; for (int index = 1; index < Nodes.Count; index++) { Schema.TableVarColumn column = TableVar.Columns[_extendColumnOffset + index - 1]; if (column.ColumnType == Schema.TableVarColumnType.Stored) { columnIndex = newRow.DataType.Columns.IndexOfName(column.Column.Name); if (columnIndex >= 0) { TableNode tableNode = Nodes[index] as TableNode; if (tableNode == null) { ExtractRowNode extractRowNode = Nodes[index] as ExtractRowNode; if (extractRowNode != null) { tableNode = (TableNode)extractRowNode.Nodes[0]; } } if (tableNode == null) { throw new RuntimeException(RuntimeException.Codes.InternalError, "Could not determine update path for extend column."); } IDataValue newValue = newRow.GetValue(columnIndex); if (!newValue.IsNil) { IRow newRowValue = newValue as IRow; if (newRowValue != null) { PerformInsert(program, tableNode, null, newRowValue, null, uncheckedValue); } else { TableValue newTableValue = (TableValue)newValue; using (ITable newTableCursor = newTableValue.OpenCursor()) { while (newTableCursor.Next()) { using (IRow newTableCursorRow = newTableCursor.Select()) { PerformInsert(program, tableNode, null, newTableCursorRow, null, uncheckedValue); } } } } } } } } } finally { PopRow(program); } } }
public void Write(IBinaryEncoder encoder, IDataValue value) { _encoder.Write(this, value); }
public string QuoteDataValue(IDataValue dataValue) { return dataValue.QuoteValue ? QuoteValue(dataValue.Value) : dataValue.Value.ToString(); }
public override void Write(IBinaryEncoder encoder, IDataValue value) { throw new NotImplementedException(); }
public DataKeyValuePair(IDataLiteral name, IDataValue value) { Key = name; Value = value; }