private InstrumentationToken(RequestType type, ExecutionFlags executionFlags, string cql) { Id = Guid.NewGuid(); Type = type; ExecutionFlags = executionFlags; Cql = cql; }
private InstrumentationToken(RequestType type, ExecutionFlags executionFlags, string cql) { Id = Guid.NewGuid(); Type = type; ExecutionFlags = executionFlags; Cql = cql ?? string.Empty; }
internal static IObservable<object> CreatePrepareQuery(IConnection connection, string cql, ExecutionFlags executionFlags) { Action<IFrameWriter> writer = fw => WritePrepareRequest(fw, cql); Func<IFrameReader, IEnumerable<object>> reader = ReadPreparedQuery; InstrumentationToken token = InstrumentationToken.Create(RequestType.Prepare, executionFlags, cql); Query query = new Query(writer, reader, token, connection); return query; }
internal static IObservable<object> CreateQuery(IConnection connection, string cql, ConsistencyLevel cl, IDataMapperFactory factory, ExecutionFlags executionFlags) { Action<IFrameWriter> writer = fw => WriteQueryRequest(fw, cql, cl, MessageOpcodes.Query); Func<IFrameReader, IEnumerable<object>> reader = fr => ReadRowSet(fr, factory); InstrumentationToken token = InstrumentationToken.Create(RequestType.Query, executionFlags, cql); Query query = new Query(writer, reader, token, connection); return query; }
internal static IObservable<object> CreateExecuteQuery(IConnection connection, byte[] id, IColumnSpec[] columnSpecs, ConsistencyLevel cl, ExecutionFlags executionFlags, string cql, IDataMapperFactory factory) { Action<IFrameWriter> writer = fw => WriteExecuteRequest(fw, id, columnSpecs, cl, factory); Func<IFrameReader, IEnumerable<object>> reader = fr => ReadRowSet(fr, factory); InstrumentationToken token = InstrumentationToken.Create(RequestType.Prepare, executionFlags, cql); Query query = new Query(writer, reader, token, connection); return query; }
public BatchQuery(IConnection connection, ConsistencyLevel consistencyLevel, ExecutionFlags executionFlags, string cql, byte[] id, IColumnSpec[] columnSpecs, object dataSource, IDataMapper mapperIn, IDataMapper mapperOut) : base(connection, consistencyLevel, executionFlags, cql, mapperOut) { _id = id; _columnSpecs = columnSpecs; _mapperIn = mapperIn; _dataSource = dataSource; }
public override void Execute() { ExecutionFlags executionFlags = ExecutionFlags.None; if (CommandContext.Tracing) { executionFlags |= ExecutionFlags.Tracing; } var cmd = CommandContext.Cluster.CreatePropertyBagCommand() .WithConsistencyLevel(CommandContext.CL) .WithExecutionFlags(executionFlags); var res = cmd.Execute(_statement).AsFuture(); CommandContext.ResultWriter.Write(CommandContext.TextWriter, res.Result); }
public IQuery <T> Execute <T>(string cql, object dataSource, PartitionKey partitionKey) { if (null != dataSource) { throw new ArgumentException("Binary protocol v2 is not implemented"); } // grab a connection BigInteger? token = partitionKey == null ? null : _cluster.Partitioner.ComputeToken(partitionKey); IConnection connection = _cluster.GetConnection(token); // define execution context ConsistencyLevel cl = _consistencyLevel ?? connection.DefaultConsistencyLevel; ExecutionFlags executionFlags = _executionFlags ?? connection.DefaultExecutionFlags; // out to spit out results IDataMapper factoryOut = _factoryOut.Create <T>(); IQuery <T> query = new CqlQuery <T>(connection, cl, executionFlags, cql, factoryOut); return(query); }
public static IPreparedQuery PrepareNonQuery(this ICluster cluster, string cql, ExecutionFlags executionFlags = ExecutionFlags.None) { var cmd = cluster.CreatePropertyBagCommand(); IPreparedQuery preparedQuery = cmd.Prepare(cql, executionFlags); return preparedQuery; }
public static Task ExecuteNonQuery(this ICluster cluster, string cql, ConsistencyLevel cl = ConsistencyLevel.QUORUM, ExecutionFlags executionFlags = ExecutionFlags.None) { var cmd = cluster.CreatePropertyBagCommand(); return cmd.Execute(cql, cl, executionFlags); }
public static IPreparedQuery<IDictionary<string, object>> Prepare(this ICluster cluster, string cql, ExecutionFlags executionFlags = ExecutionFlags.None) { var cmd = cluster.CreatePropertyBagCommand(); IPreparedQuery<IDictionary<string, object>> preparedQuery = cmd.Prepare<IDictionary<string, object>>(cql, executionFlags); return preparedQuery; }
public IPropertyBagCommand WithExecutionFlags(ExecutionFlags executionFlags) { _command.WithExecutionFlags(executionFlags); return this; }
public static Task<IEnumerable<IDictionary<string, object>>> Execute(this ICluster cluster, string cql, ConsistencyLevel cl = ConsistencyLevel.QUORUM, ExecutionFlags executionFlags = ExecutionFlags.None) { var cmd = cluster.CreatePropertyBagCommand(); return cmd.Execute<IDictionary<string, object>>(cql, cl, executionFlags); }
public ICqlCommand WithExecutionFlags(ExecutionFlags executionFlags) { _executionFlags = executionFlags; return(this); }
private void WriteNextFrame(Action<IFrameWriter> writer, byte streamId, ExecutionFlags executionFlags) { try { InstrumentationToken token = _queryInfos[streamId].InstrumentationToken; _instrumentation.ClientTrace(token, EventType.BeginWrite); bool tracing = 0 != (executionFlags & ExecutionFlags.Tracing); // acquire the global lock to write the request _logger.Debug("Starting writing frame for stream {0}@{1}", streamId, Endpoint); lock (_globalLock) { using (BufferingFrameWriter bufferingFrameWriter = new BufferingFrameWriter(_socket, streamId, tracing)) { writer(bufferingFrameWriter); bufferingFrameWriter.SendFrame(); } } _logger.Debug("Done writing frame for stream {0}@{1}", streamId, Endpoint); _instrumentation.ClientTrace(token, EventType.EndWrite); } catch (Exception ex) { _queryInfos[streamId].Exception = ex; _queryInfos[streamId].ReadTask.RunSynchronously(); } }
public PrepareQuery(IConnection connection, ConsistencyLevel consistencyLevel, ExecutionFlags executionFlags, string cql) : base(connection, consistencyLevel, executionFlags, cql, null) { }
internal static InstrumentationToken Create(RequestType requestType, ExecutionFlags executionFlags, string cql = null) { return(new InstrumentationToken(requestType, executionFlags, cql)); }
public IPropertyBagCommand WithExecutionFlags(ExecutionFlags executionFlags) { _command.WithExecutionFlags(executionFlags); return(this); }
public CQLPreparedQueryHelpers(ICluster cluster, string cql, ExecutionFlags executionFlags) { _cluster = cluster; _cql = cql; _executionFlags = executionFlags; }
public PreparedNonQuery(ICluster cluster, IDataMapper dataMapper, string cql, ExecutionFlags executionFlags) { _dataMapper = dataMapper; _helpers = new CQLPreparedQueryHelpers(cluster, cql, executionFlags); }
public CqlQuery(IConnection connection, ConsistencyLevel consistencyLevel, ExecutionFlags executionFlags, string cql, IDataMapper mapperOut) : base(connection, consistencyLevel, executionFlags) { CQL = cql; _mapperOut = mapperOut; }
public ReadyQuery(IConnection connection, ConsistencyLevel consistencyLevel, ExecutionFlags executionFlags, string cqlVersion) : base(connection, consistencyLevel, executionFlags) { _cqlVersion = cqlVersion; }
/// <summary> /// <para>Compiles an operator into an object that can be dispatched to the GPU.</para> /// </summary> /// <remarks> /// <para> /// A compiled operator represents the efficient, baked form of an operator suitable for /// execution on the GPU. A compiled operator holds state (such as shaders and other objects) /// required for execution. Because a compiled operator implements the /// <see cref="IDMLPageable"/> interface, you're able to evict one from GPU memory if you wish. /// </para> /// <para> /// See Microsoft Docs: /// <see href="https://docs.microsoft.com/en-us/windows/win32/api/directml/nf-directml-idmldevice-compileoperator"/> /// </para> /// </remarks> /// <param name="operator"></param> /// <param name="executionFlags"></param> /// <returns></returns> public IDMLCompiledOperator CompileOperator(IDMLOperator @operator, ExecutionFlags executionFlags) { CompileOperator(@operator, executionFlags, typeof(IDMLCompiledOperator).GUID, out IntPtr nativePtr).CheckError(); return(new IDMLCompiledOperator(nativePtr)); }
public Task<IEnumerable<object>> Execute(Action<IFrameWriter> writer, Func<IFrameReader, IEnumerable<object>> reader, ExecutionFlags executionFlags, InstrumentationToken instrumentationToken) { _instrumentation.ClientQuery(instrumentationToken); Task<IEnumerable<object>> taskRead; byte streamId; lock (_globalLock) { while (0 == _availableStreamIds.Count) { _logger.Debug("Waiting for available stream id for {0}", Endpoint); _cancellation.Token.ThrowIfCancellationRequested(); Monitor.Wait(_globalLock); } _cancellation.Token.ThrowIfCancellationRequested(); // get the stream id and initialize async reader context streamId = _availableStreamIds.Pop(); // promise to stream results taskRead = new Task<IEnumerable<object>>(() => ReadResultStream(streamId, reader)); _queryInfos[streamId].InstrumentationToken = instrumentationToken; _queryInfos[streamId].ReadTask = taskRead; _instrumentation.ClientConnectionInfo(instrumentationToken, Endpoint, streamId); } _logger.Debug("Using stream {0}@{1}", streamId, Endpoint); // write the request asynchronously StartWriteNextFrame(writer, streamId, executionFlags); return taskRead; }
protected Query(IConnection connection, ConsistencyLevel consistencyLevel, ExecutionFlags executionFlags) { _connection = connection; ConsistencyLevel = consistencyLevel; ExecutionFlags = executionFlags; }
private void StartWriteNextFrame(Action<IFrameWriter> writer, byte streamId, ExecutionFlags executionFlags) { Task.Factory.StartNew(() => WriteNextFrame(writer, streamId), _cancellation.Token); }
/// <summary> /// Compiles a graph of DirectML operators into an object that can be dispatched to the GPU. /// </summary> /// <remarks> /// <para> /// See Microsoft Docs: /// <see href="https://docs.microsoft.com/en-us/windows/win32/api/directml/nf-directml-idmldevice1-compilegraph"/> /// </para> /// </remarks> /// <param name="graphDescription">A description of the graph to compile.</param> /// <param name="executionFlags">Any flags to control the execution of this operator.</param> /// <returns></returns> public IDMLCompiledOperator CompileGraph(GraphDescription graphDescription, ExecutionFlags executionFlags) { CompileGraph(ref graphDescription, executionFlags, typeof(IDMLCompiledOperator).GUID, out IntPtr nativePtr).CheckError(); return(new IDMLCompiledOperator(nativePtr)); }
internal static InstrumentationToken Create(RequestType requestType, ExecutionFlags executionFlags, string cql = null) { return new InstrumentationToken(requestType, executionFlags, cql); }
public AuthenticateQuery(IConnection connection, ConsistencyLevel consistencyLevel, ExecutionFlags executionFlags, string user, string password) : base(connection, consistencyLevel, executionFlags) { _user = user; _password = password; }
public CreateOptionsQuery(IConnection connection, ConsistencyLevel consistencyLevel, ExecutionFlags executionFlags) : base(connection, consistencyLevel, executionFlags) { }