public int ExecuteBatch(string configuration, string queryData)
{
try
{
var data = LinqServiceSerializer.DeserializeStringArray(queryData);
var queries = data.Select(LinqServiceSerializer.Deserialize).ToArray();
foreach (var query in queries)
{
ValidateQuery(query);
}
using (var db = CreateDataContext(configuration))
{
db.BeginTransaction();
foreach (var query in queries)
{
var obj = ((IDataContext)db).SetQuery(new QueryContext {
SqlQuery = query.Query, Parameters = query.Parameters
});
((IDataContext)db).ExecuteNonQuery(obj);
}
db.CommitTransaction();
return(queryData.Length);
}
}
catch (Exception exception)
{
HandleException(exception);
throw;
}
}
public int ExecuteNonQuery(string configuration, string queryData)
{
try
{
var query = LinqServiceSerializer.Deserialize(queryData);
ValidateQuery(query);
using (var db = CreateDataContext(configuration))
using (db.DataProvider.ExecuteScope())
{
return(DataConnection.QueryRunner.ExecuteNonQuery(db, new QueryContext
{
Statement = query.Statement,
Parameters = query.Parameters,
QueryHints = query.QueryHints
}));
}
}
catch (Exception exception)
{
HandleException(exception);
throw;
}
}
public int ExecuteNonQuery(string configuration, string queryData)
{
try
{
var query = LinqServiceSerializer.Deserialize(queryData);
ValidateQuery(query);
using (IDataContext db = CreateDataContext(configuration))
{
var obj = db.SetQuery(new QueryContext
{
SelectQuery = query.Query,
Parameters = query.Parameters,
QueryHints = query.QueryHints
});
return(db.ExecuteNonQuery(obj));
}
}
catch (Exception exception)
{
HandleException(exception);
throw;
}
}
public override object?ExecuteScalar()
{
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
string data;
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var sqlOptimizer = _dataContext.GetSqlOptimizer();
var q = sqlOptimizer.PrepareStatementForRemoting(queryContext.Statement, _dataContext.MappingSchema, queryContext.Aliases !, _evaluationContext);
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
_evaluationContext.ParameterValues, QueryHints);
_client = _dataContext.GetClient();
return(_client.ExecuteScalar(_dataContext.Configuration, data));
}
public override Task <int> ExecuteNonQueryAsync(CancellationToken cancellationToken)
{
string data;
lock (Query)
{
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().OptimizeStatement(queryContext.Statement, _dataContext.MappingSchema, _dataContext.InlineParameters, true);
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(),
QueryHints);
}
if (_dataContext._batchCounter > 0)
{
_dataContext._queryBatch !.Add(data);
return(TaskCache.MinusOne);
}
_client = _dataContext.GetClient();
return(_client.ExecuteNonQueryAsync(_dataContext.Configuration, data));
}
public int ExecuteBatch(string queryData)
{
var data = LinqServiceSerializer.DeserializeStringArray(queryData);
var queries = data.Select <string, LinqServiceQuery>(LinqServiceSerializer.Deserialize).ToArray();
foreach (var query in queries)
{
ValidateQuery(query);
}
using (var db = CreateDataContext())
{
if (db is DbManager)
{
((DbManager)db).BeginTransaction();
}
foreach (var query in queries)
{
var obj = db.SetQuery(new QueryContext {
SqlQuery = query.Query, Parameters = query.Parameters
});
db.ExecuteNonQuery(obj);
}
if (db is DbManager)
{
((DbManager)db).CommitTransaction();
}
return(queryData.Length);
}
}
public override Task <object?> ExecuteScalarAsync(CancellationToken cancellationToken)
{
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
string data;
lock (Query)
{
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().OptimizeStatement(queryContext.Statement, _dataContext.MappingSchema, _dataContext.InlineParameters, true);
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(), QueryHints);
}
_client = _dataContext.GetClient();
return(_client.ExecuteScalarAsync(_dataContext.Configuration, data));
}
public override IDataReader ExecuteReader()
{
_dataContext.ThrowOnDisposed();
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
string data;
lock (Query)
{
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().OptimizeStatement(queryContext.Statement, _dataContext.MappingSchema, _dataContext.InlineParameters);
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(),
QueryHints);
}
_client = _dataContext.GetClient();
var ret = _client.ExecuteReader(_dataContext.Configuration, data);
var result = LinqServiceSerializer.DeserializeResult(_dataContext.SerializationMappingSchema, ret);
return(new ServiceModelDataReader(_dataContext.SerializationMappingSchema, result));
}
public override Task <int> ExecuteNonQueryAsync(CancellationToken cancellationToken)
{
string data;
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().PrepareStatementForRemoting(queryContext.Statement, _dataContext.MappingSchema, _evaluationContext);
var currentParameters = q.CollectParameters();
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
currentParameters,
_evaluationContext.ParameterValues,
QueryHints);
if (_dataContext._batchCounter > 0)
{
_dataContext._queryBatch !.Add(data);
return(TaskCache.MinusOne);
}
_client = _dataContext.GetClient();
return(_client.ExecuteNonQueryAsync(_dataContext.Configuration, data));
}
public override DataReaderWrapper ExecuteReader()
{
_dataContext.ThrowOnDisposed();
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
SetCommand(false);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().PrepareStatementForRemoting(queryContext.Statement, _dataContext.MappingSchema, queryContext.Aliases !, _evaluationContext);
var data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
_evaluationContext.ParameterValues,
_dataContext.GetNextCommandHints(true));
_client = _dataContext.GetClient();
var ret = _client.ExecuteReader(_dataContext.Configuration, data);
var result = LinqServiceSerializer.DeserializeResult(_dataContext.SerializationMappingSchema, ret);
return(new DataReaderWrapper(new RemoteDataReader(_dataContext.SerializationMappingSchema, result)));
}
public override int ExecuteNonQuery()
{
string data;
// locks are bad, m'kay?
lock (Query)
{
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().OptimizeStatement(queryContext.Statement, _dataContext.MappingSchema, _dataContext.InlineParameters, true);
q.CollectParameters();
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
queryContext.GetParameters(),
QueryHints);
}
if (_dataContext._batchCounter > 0)
{
_dataContext._queryBatch !.Add(data);
return(-1);
}
_client = _dataContext.GetClient();
return(_client.ExecuteNonQuery(_dataContext.Configuration, data));
}
public void CommitBatch()
{
if (_batchCounter == 0)
{
throw new InvalidOperationException();
}
_batchCounter--;
if (_batchCounter == 0)
{
var client = GetClient();
try
{
var data = LinqServiceSerializer.Serialize(_queryBatch.ToArray());
client.ExecuteBatch(data);
}
finally
{
((IDisposable)client).Dispose();
_queryBatch = null;
}
}
}
public override IDataReader ExecuteReader()
{
_dataContext.ThrowOnDisposed();
SetCommand(true);
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
var queryContext = Query.Queries[QueryNumber];
_client = _dataContext.GetClient();
var q = queryContext.SelectQuery.ProcessParameters(_dataContext.MappingSchema);
var ret = _client.ExecuteReader(
_dataContext.Configuration,
LinqServiceSerializer.Serialize(
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(),
QueryHints));
var result = LinqServiceSerializer.DeserializeResult(ret);
return(new ServiceModelDataReader(_dataContext.MappingSchema, result));
}
public override IDataReader ExecuteReader()
{
_dataContext.ThrowOnDisposed();
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
string data;
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().PrepareStatementForRemoting(queryContext.Statement, _dataContext.MappingSchema, _evaluationContext);
var currentParameters = q.CollectParameters();
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
currentParameters,
_evaluationContext.ParameterValues,
QueryHints);
_client = _dataContext.GetClient();
var ret = _client.ExecuteReader(_dataContext.Configuration, data);
var result = LinqServiceSerializer.DeserializeResult(_dataContext.SerializationMappingSchema, ret);
return(new ServiceModelDataReader(_dataContext.SerializationMappingSchema, result));
}
public override async Task <IDataReaderAsync> ExecuteReaderAsync(CancellationToken cancellationToken)
{
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
_client = _dataContext.GetClient();
var q = _dataContext.GetSqlOptimizer().OptimizeStatement(queryContext.Statement, _dataContext.MappingSchema);
var ret = await _client.ExecuteReaderAsync(
_dataContext.Configuration,
LinqServiceSerializer.Serialize(
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(),
QueryHints));
var result = LinqServiceSerializer.DeserializeResult(ret);
var reader = new ServiceModelDataReader(_dataContext.MappingSchema, result);
return(new DataReaderAsync(reader));
}
public override async Task <IDataReaderAsync> ExecuteReaderAsync(CancellationToken cancellationToken)
{
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
string data;
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().PrepareStatementForRemoting(queryContext.Statement, _dataContext.MappingSchema, _evaluationContext);
var currentParameters = q.CollectParameters();
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
currentParameters,
_evaluationContext.ParameterValues,
QueryHints);
_client = _dataContext.GetClient();
var ret = await _client.ExecuteReaderAsync(_dataContext.Configuration, data).ConfigureAwait(Common.Configuration.ContinueOnCapturedContext);
var result = LinqServiceSerializer.DeserializeResult(_dataContext.SerializationMappingSchema, ret);
var reader = new ServiceModelDataReader(_dataContext.SerializationMappingSchema, result);
return(new DataReaderAsync(reader));
}
public override Task <object?> ExecuteScalarAsync(CancellationToken cancellationToken)
{
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
string data;
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().PrepareStatementForRemoting(queryContext.Statement, _dataContext.MappingSchema, _evaluationContext);
var currentParameters = q.CollectParameters();
data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
currentParameters,
_evaluationContext.ParameterValues,
QueryHints);
_client = _dataContext.GetClient();
return(_client.ExecuteScalarAsync(_dataContext.Configuration, data));
}
public override int ExecuteNonQuery()
{
SetCommand(false);
var queryContext = Query.Queries[QueryNumber];
var q = _dataContext.GetSqlOptimizer().PrepareStatementForRemoting(queryContext.Statement,
_dataContext.MappingSchema, queryContext.Aliases !, _evaluationContext);
var data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
_evaluationContext.ParameterValues,
_dataContext.GetNextCommandHints(true));
if (_dataContext._batchCounter > 0)
{
_dataContext._queryBatch !.Add(data);
return(-1);
}
_client = _dataContext.GetClient();
return(_client.ExecuteNonQuery(_dataContext.Configuration, data));
}
public int ExecuteNonQuery(string queryData)
{
var query = LinqServiceSerializer.Deserialize(queryData);
ValidateQuery(query);
using (var db = CreateDataContext())
{
var obj = db.SetQuery(new QueryContext {
SqlQuery = query.Query, Parameters = query.Parameters
});
return(db.ExecuteNonQuery(obj));
}
}
object IDataContext.ExecuteScalar(object query)
{
if (_batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
var ctx = (QueryContext)query;
ctx.Client = GetClient();
var q = ctx.Query.SqlQuery.ProcessParameters();
return(ctx.Client.ExecuteScalar(
LinqServiceSerializer.Serialize(q, q.IsParameterDependent ? q.Parameters.ToArray() : ctx.Query.GetParameters())));
}
int IDataContext.ExecuteNonQuery(object query)
{
var ctx = (QueryContext)query;
var q = ctx.Query.SqlQuery.ProcessParameters();
var data = LinqServiceSerializer.Serialize(q, q.IsParameterDependent ? q.Parameters.ToArray() : ctx.Query.GetParameters());
if (_batchCounter > 0)
{
_queryBatch.Add(data);
return(-1);
}
ctx.Client = GetClient();
return(ctx.Client.ExecuteNonQuery(data));
}
int IDataContext.ExecuteNonQuery(object query)
{
ThrowOnDisposed();
var ctx = (QueryContext)query;
var q = ctx.Query.SelectQuery.ProcessParameters(MappingSchema);
var data = LinqServiceSerializer.Serialize(q, q.IsParameterDependent ? q.Parameters.ToArray() : ctx.Query.GetParameters(), ctx.Query.QueryHints);
if (_batchCounter > 0)
{
_queryBatch.Add(data);
return(-1);
}
ctx.Client = GetClient();
return(ctx.Client.ExecuteNonQuery(Configuration, data));
}
IDataReader IDataContext.ExecuteReader(object query)
{
if (_batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
var ctx = (QueryContext)query;
ctx.Client = GetClient();
var q = ctx.Query.SqlQuery.ProcessParameters();
var ret = ctx.Client.ExecuteReader(
LinqServiceSerializer.Serialize(q, q.IsParameterDependent ? q.Parameters.ToArray() : ctx.Query.GetParameters()));
var result = LinqServiceSerializer.DeserializeResult(ret);
return(new ServiceModelDataReader(result));
}
object IDataContext.ExecuteScalar(object query)
{
ThrowOnDisposed();
if (_batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
var ctx = (QueryContext)query;
ctx.Client = GetClient();
var q = ctx.Query.SelectQuery.ProcessParameters(MappingSchema);
return(ctx.Client.ExecuteScalar(
Configuration,
LinqServiceSerializer.Serialize(q, q.IsParameterDependent ? q.Parameters.ToArray() : ctx.Query.GetParameters(), ctx.Query.QueryHints)));
}
public override async Task <object> ExecuteScalarAsync(CancellationToken cancellationToken)
{
SetCommand(true);
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
var queryContext = Query.Queries[QueryNumber];
_client = _dataContext.GetClient();
var q = queryContext.SelectQuery.ProcessParameters(_dataContext.MappingSchema);
return(await _client.ExecuteScalarAsync(
_dataContext.Configuration,
LinqServiceSerializer.Serialize(
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(), QueryHints)));
}
public override object ExecuteScalar()
{
SetCommand(true);
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
var queryContext = Query.Queries[QueryNumber];
_client = _dataContext.GetClient();
var q = _dataContext.GetSqlOptimizer().OptimizeStatement(queryContext.Statement, _dataContext.MappingSchema);
return(_client.ExecuteScalar(
_dataContext.Configuration,
LinqServiceSerializer.Serialize(
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(), QueryHints)));
}
public object ExecuteScalar(string queryData)
{
try
{
var query = LinqServiceSerializer.Deserialize(queryData);
ValidateQuery(query);
using (var db = CreateDataContext())
{
var obj = db.SetQuery(new QueryContext {
SqlQuery = query.Query, Parameters = query.Parameters
});
return(db.ExecuteScalar(obj));
}
}
catch (Exception exception)
{
HandleException(exception);
throw;
}
}
public override object?ExecuteScalar()
{
if (_dataContext._batchCounter > 0)
{
throw new LinqException("Incompatible batch operation.");
}
SetCommand(false);
var queryContext = Query.Queries[QueryNumber];
var sqlOptimizer = _dataContext.GetSqlOptimizer();
var q = sqlOptimizer.PrepareStatementForRemoting(queryContext.Statement, _dataContext.MappingSchema, queryContext.Aliases !, _evaluationContext);
var data = LinqServiceSerializer.Serialize(
_dataContext.SerializationMappingSchema,
q,
_evaluationContext.ParameterValues,
_dataContext.GetNextCommandHints(true));
_client = _dataContext.GetClient();
var ret = _client.ExecuteScalar(_dataContext.Configuration, data);
object?result = null;
if (ret != null)
{
var lsr = LinqServiceSerializer.DeserializeResult(_dataContext.SerializationMappingSchema, ret);
var value = lsr.Data[0][0];
if (!string.IsNullOrEmpty(value))
{
result = SerializationConverter.Deserialize(_dataContext.SerializationMappingSchema, lsr.FieldTypes[0], value);
}
}
return(result);
}
public override async Task <int> ExecuteNonQueryAsync(CancellationToken cancellationToken)
{
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = queryContext.SelectQuery.ProcessParameters(_dataContext.MappingSchema);
var data = LinqServiceSerializer.Serialize(
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(),
QueryHints);
if (_dataContext._batchCounter > 0)
{
_dataContext._queryBatch.Add(data);
return(-1);
}
_client = _dataContext.GetClient();
return(await _client.ExecuteNonQueryAsync(_dataContext.Configuration, data));
}
public override int ExecuteNonQuery()
{
SetCommand(true);
var queryContext = Query.Queries[QueryNumber];
var q = queryContext.Statement.ProcessParameters(_dataContext.MappingSchema);
var data = LinqServiceSerializer.Serialize(
q,
q.IsParameterDependent ? q.Parameters.ToArray() : queryContext.GetParameters(),
QueryHints);
if (_dataContext._batchCounter > 0)
{
_dataContext._queryBatch.Add(data);
return(-1);
}
_client = _dataContext.GetClient();
return(_client.ExecuteNonQuery(_dataContext.Configuration, data));
}