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)
{
}
