public override int ExecuteNonQuery()
{
if (_connection == null)
{
throw new Exception("You must set the Connection property before execution.");
}
if (string.IsNullOrEmpty(_commandText))
{
throw new Exception("Invalid query specified.");
}
ICollection <Common.Server.Engine.IParameter> _params = new List <Common.Server.Engine.IParameter>();
Alachisoft.NosDB.Common.Storage.Caching.QueryCache.QueryCache <IDqlObject> queryParser = new Alachisoft.NosDB.Common.Storage.Caching.QueryCache.QueryCache <IDqlObject>();
IDqlObject parsedQuery = queryParser.GetParsedQuery(_commandText);
foreach (IDataParameter idp in _parameters)
{
_params.Add(new Common.Server.Engine.Impl.Parameter(idp.ParameterName, idp.Value));
}
Client.Collection <JSONDocument> coll = ((NosDbConnection)_connection)._database.GetCollection(((IDmObject)parsedQuery).Collection);
long val = coll.ExecuteNonQuery(_commandText, _params);
//ICollectionReader value = _connection._database.ExecuteQuery(query);
return((int)val);
}
private void ExecuteQuery(string query)
{
QueryCache <IDqlObject> _reducedQueryCache = new QueryCache <IDqlObject>();
IDqlObject parsedObject = _reducedQueryCache.GetParsedQuery(query);
if (parsedObject is SelectObject)
{
if (_databaseContext)
{
Execute(query, QueryType.Reader);
}
else
{
throw new Exception("For Execution of Data Query you must be in context of database.");
}
}
else if (parsedObject is InsertObject || parsedObject is DeleteObject ||
parsedObject is UpdateObject)
{
if (_databaseContext)
{
Execute(query, QueryType.NonQuery);
}
else
{
throw new Exception("For Execution of Data Query you must be in context of database.");
}
}
else
{
Execute(query, QueryType.NonDataQuery);
}
}
private QueryCriteria AddQueryCriteria(IDqlObject query, IList <IParameter> parameters, IQueryStore queryStore)
{
var queryCriteria = new QueryCriteria {
Store = queryStore
};
if (query is SelectObject)
{
var selectQuery = query as SelectObject;
if (selectQuery.WherePredicate != null && parameters != null)
{
selectQuery.WherePredicate.AssignConstants(parameters);
selectQuery.WherePredicate.AssignScalarFunctions();
}
var functions = new List <Function>();
foreach (var projectionValue in selectQuery.Projections)
{
if (selectQuery.IsDistinct)
{
IEvaluable projValue = projectionValue as IEvaluable;
queryCriteria.AddDistinctField(projValue);
}
var evaluable = projectionValue as IEvaluable;
if (parameters != null && evaluable != null)
{
evaluable.AssignConstants(parameters);
}
if (evaluable != null)
{
if (projectionValue is AllEvaluable)
{
queryCriteria.GetAllFields = true;
}
else
{
queryCriteria.AddProjection(evaluable.ToString(), evaluable);
}
if (evaluable.Functions != null)
{
functions.AddRange(evaluable.Functions);
}
}
}
foreach (var function in functions)
{
if (!AssignAggregateFunction(function, queryCriteria))
{
if (!AssignScalarFunction(function))
{
throw new QuerySystemException(ErrorCodes.Query.INVALID_FUNCTION_NAME_SPECIFIED,
new[] { function.FunctionNameActual });
}
}
}
if (selectQuery.GroupValue != null)
{
foreach (var projectionValue in selectQuery.GroupValue)
{
queryCriteria.AddGroupByField(projectionValue);
}
}
if (queryCriteria.GroupByField == null && queryCriteria.ContainsAggregations &&
queryCriteria.Aggregations.Count > 0)
{
queryCriteria.GroupByField = new AllField(Field.FieldType.Grouped);
}
if (selectQuery.OrderValue != null)
{
foreach (var projectionValue in selectQuery.OrderValue)
{
var attribute = projectionValue;
if (attribute != null)
{
queryCriteria.AddOrderByField(attribute,
attribute is BinaryExpression?
((BinaryExpression)attribute).SortOrder: SortOrder.ASC);
}
}
}
long limit = -1;
if (selectQuery.Limit != null)
{
limit = long.Parse(selectQuery.Limit.InString);
}
if (limit > -1)
{
long skip = -1;
if (selectQuery.Skip != null)
{
skip = long.Parse(selectQuery.Skip.InString);
}
if (skip > 0)
{
limit += skip; //: Adding this to avoid bug at query router (while applying skip query)
}
queryCriteria.AddLimit(limit);
}
}
else if (query is UpdateObject)
{
var updateQuery = query as UpdateObject;
if (updateQuery.WherePredicate != null && parameters != null)
{
updateQuery.WherePredicate.AssignConstants(parameters);
}
updateQuery.Updator.AssignConstants(parameters);
foreach (IUpdation update in updateQuery.Updator.Updations)
{
foreach (var function in update.GetFunctions())
{
foreach (var argument in function.Arguments)
{
if (argument.EvaluationType != EvaluationType.Constant)
{
throw new QuerySystemException(ErrorCodes.Query.INVALID_CONSTANT_FUNCTION_SPECIFIED);
}
}
if (!AssignScalarFunction(function))
{
throw new QuerySystemException(ErrorCodes.Query.INVALID_FUNCTION_NAME_SPECIFIED,
new[] { function.FunctionNameActual });
}
}
}
queryCriteria.DocumentUpdate = updateQuery.Updator;
queryCriteria.UpdateOption = UpdateOption.Update;
}
else if (query is InsertObject)
{
var document = new JSONDocument();
foreach (KeyValuePair <Attribute, IEvaluable> pair in ((InsertObject)query).ValuesToInsert)
{
pair.Value.AssignConstants(parameters);
foreach (var function in pair.Value.Functions)
{
foreach (var argument in function.Arguments)
{
if (argument.EvaluationType != EvaluationType.Constant)
{
throw new QuerySystemException(ErrorCodes.Query.INVALID_CONSTANT_FUNCTION_SPECIFIED);
}
}
if (!AssignScalarFunction(function))
{
throw new QuerySystemException(ErrorCodes.Query.INVALID_FUNCTION_NAME_SPECIFIED,
new[] { function.FunctionNameActual });
}
}
IJsonValue jsonValue;
if (!pair.Value.Evaluate(out jsonValue, null))
{
throw new QuerySystemException(ErrorCodes.Query.INVALID_CONSTANT_BINARY_EXPRESSION_SPECIFIED);
}
document.Add(pair.Key.ToString(), jsonValue.Value);
}
queryCriteria.NewDocument = document;
queryCriteria.UpdateOption = UpdateOption.Insert;
}
else if (query is DeleteObject)
{
var deleteQuery = query as DeleteObject;
if (deleteQuery.WherePredicate != null && parameters != null)
{
deleteQuery.WherePredicate.AssignConstants(parameters);
}
queryCriteria.UpdateOption = UpdateOption.Delete;
}
return(queryCriteria);
}
protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
{
if (_connection == null)
{
throw new Exception("You must set the Connection property before execution.");
}
if (string.IsNullOrEmpty(_commandText))
{
throw new Exception("Invalid query specified.");
}
if (_connection.State != ConnectionState.Open)
{
throw new Exception("Connection must be open to execute the command.");
}
try
{
ArrayList al = new ArrayList();
ICollection <Common.Server.Engine.IParameter> _params = new List <Common.Server.Engine.IParameter>();
Alachisoft.NosDB.Common.Storage.Caching.QueryCache.QueryCache <IDqlObject> queryParser = new Alachisoft.NosDB.Common.Storage.Caching.QueryCache.QueryCache <IDqlObject>();
IDqlObject parsedQuery = queryParser.GetParsedQuery(_commandText);
if (parsedQuery != null && parsedQuery is SelectObject)
{
SelectObject select = parsedQuery as SelectObject;
if (select.Projections != null)
{
al = new ArrayList();
foreach (IEvaluable projection in select.Projections)
{
string prjct = "";
if (projection is BinaryExpression)
{
prjct = ((BinaryExpression)projection).Alias;
}
else
{
prjct = projection.CaseSensitiveInString.Replace("$", "");
}
if (!prjct.Contains('*'))
{
if (prjct.Contains('.')) // Incase of embedded, take the last one out.
{
string[] parts = prjct.Split('.');
prjct = parts[parts.Length - 1];
}
al.Add(prjct);
}
}
}
}
foreach (IDataParameter idp in _parameters)
{
_params.Add(new Common.Server.Engine.Impl.Parameter(idp.ParameterName, idp.Value));
}
Client.Collection <JSONDocument> coll = ((NosDbConnection)_connection)._database.GetCollection(((SelectObject)parsedQuery).Collection);
long val = 0;
ICollectionReader reader = null;
if (parsedQuery is SelectObject)
{
reader = coll.ExecuteReader(_commandText, _params);
}
else
{
val = ((NosDbConnection)_connection)._database.ExecuteNonQuery(_commandText, _params);
}
// reader = _connection._database.ExecuteQuery(query);
NosDataReader readerr = new NosDataReader(reader);
readerr.AttributesColumns = al;
readerr._rowsAffected = (int)val;
return(readerr);
}
finally
{
if (behavior == CommandBehavior.CloseConnection)
{
this._connection.Close();
}
}
}
