public async Task <IQueryResults> ExecuteQueryAsync(Query query, IDictionary <string, object> parameters)
{
var contentItemQuery = query as Services.ContentItemQuery;
var sqlQueryResults = new SQLQueryResults();
// var templateContext = new TemplateContext();
//templateContext.SetValue("Query", contentItemQuery);
// await templateContext.ContextualizeAsync(_serviceProvider);
// if (parameters != null)
// {
// foreach (var parameter in parameters)
// {
// templateContext.SetValue(parameter.Key, parameter.Value);
// }
// }
var queryResults = await _contentItemService.GetResults(contentItemQuery);
// var results = new List<JObject>();
var results = new List <ContentItem>();
foreach (var contentItem in queryResults)
{
results.Add(contentItem);
// results.Add(JObject.FromObject(document));
}
sqlQueryResults.Items = results;
return(sqlQueryResults);
}
public async Task <IQueryResults> ExecuteQueryAsync(Query query, IDictionary <string, object> parameters)
{
var elasticQuery = query as ElasticQuery;
var elasticQueryResults = new SQLQueryResults();
object result = null;
await _elasticIndexProvider.SearchAsync(elasticQuery.Index, async() =>
{
//var templateContext = new TemplateContext();
var templateContext = _liquidTemplateManager.Context;
// await templateContext.ContextualizeAsync(_serviceProvider);
if (parameters != null)
{
foreach (var parameter in parameters)
{
templateContext.SetValue(parameter.Key, parameter.Value);
}
}
var tokenizedContent = await _liquidTemplateManager.RenderAsync(elasticQuery.Template, System.Text.Encodings.Web.JavaScriptEncoder.Default, templateContext);
var parameterizedQuery = JObject.Parse(tokenizedContent);
//var analyzer = _luceneAnalyzerManager.CreateAnalyzer(LuceneSettings.StandardAnalyzer);
//var context = new ElasticQueryContext(searcher, LuceneSettings.DefaultVersion, analyzer);
var context = new ElasticQueryContext(elasticQuery.Index);
var docs = await _queryService.SearchAsync(context, parameterizedQuery);
if (elasticQuery.ReturnContentItems)
{
/*todo
* // Load corresponding content item versions
* var contentItemVersionIds = docs.Results.Select(x => doc.Get("Content.ContentItem.ContentItemVersionId")).ToArray();
* var contentItems = await _session.Query<ContentItem, ContentItemIndex>(x => x.ContentItemVersionId.IsIn(contentItemVersionIds)).ListAsync();
*
* // Reorder the result to preserve the one from the lucene query
* var indexed = contentItems.ToDictionary(x => x.ContentItemVersionId, x => x);
* result = contentItemVersionIds.Select(x => indexed[x]).ToArray();
*/
}
else
{
var results = new List <JObject>();
foreach (var document in docs.Results.Select(hit => hit))
{
//todo
// results.Add(new JObject(document.Select(x => new JProperty(x.Name, x.GetStringValue()))));
}
result = results;
}
});
elasticQueryResults.Items = new object[] { result }; //result; // new object[results];
return(elasticQueryResults);
}
public Task <IQueryResults> ExecuteQueryAsync(Query query, IDictionary <string, object> parameters)
{
object results;
var jsonDocQuery = query as ExcelQuery;
var objectQueryResults = new SQLQueryResults();
// var templateContext = new TemplateContext();
// templateContext.SetValue("Query",jsonDocQuery);
// await templateContext.ContextualizeAsync(_serviceProvider);
// if (parameters != null)
// {
// foreach (var parameter in parameters)
// {
// templateContext.SetValue(parameter.Key, parameter.Value);
// }
// }
//change to SourceDocument
//Template - for adding jsonpath query
// var tokenizedQuery = await _liquidTemplateManager.RenderAsync(jsonDocQuery.Template, templateContext);
// IEnumerable<dynamic> queryResults;
// dynamic queryResults;
if (String.IsNullOrEmpty(jsonDocQuery.Template))
{
results = jsonDocQuery.Document;
}
else
{
//perform a jsonpath query using template
// dynamic queryResults;
// results = JObject.FromObject<jsonDocQuery.Document>;
results = jsonDocQuery.Document;
var jArrObject = JArray.Parse(jsonDocQuery.Document);
var items = jArrObject.SelectTokens(jsonDocQuery.Template);
results = JsonConvert.SerializeObject(items);
}
objectQueryResults.Items = new object[] { results }; // new object[results];
return(Task.FromResult <IQueryResults>(objectQueryResults));
}
public async Task <IQueryResults> ExecuteQueryAsync(Query query, IDictionary <string, object> parameters)
{
var sqlQuery = query as SqlQuery;
var sqlQueryResults = new SQLQueryResults();
var tokenizedQuery = await _liquidTemplateManager.RenderStringAsync(sqlQuery.Template, NullEncoder.Default,
parameters.Select(x => new KeyValuePair <string, FluidValue>(x.Key, FluidValue.Create(x.Value, _templateOptions))));
var connection = _dbConnectionAccessor.CreateConnection();
var dialect = _session.Store.Configuration.SqlDialect;
if (!SqlParser.TryParse(tokenizedQuery, dialect, _session.Store.Configuration.TablePrefix, parameters, out var rawQuery, out var messages))
{
sqlQueryResults.Items = new object[0];
connection.Dispose();
return(sqlQueryResults);
}
if (sqlQuery.ReturnDocuments)
{
IEnumerable <int> documentIds;
using (connection)
{
await connection.OpenAsync();
using (var transaction = connection.BeginTransaction(_session.Store.Configuration.IsolationLevel))
{
documentIds = await connection.QueryAsync <int>(rawQuery, parameters, transaction);
}
}
sqlQueryResults.Items = await _session.GetAsync <ContentItem>(documentIds.ToArray());
return(sqlQueryResults);
}
else
{
IEnumerable <dynamic> queryResults;
using (connection)
{
await connection.OpenAsync();
using (var transaction = connection.BeginTransaction(_session.Store.Configuration.IsolationLevel))
{
queryResults = await connection.QueryAsync(rawQuery, parameters, transaction);
}
}
var results = new List <JObject>();
foreach (var document in queryResults)
{
results.Add(JObject.FromObject(document));
}
sqlQueryResults.Items = results;
return(sqlQueryResults);
}
}
public async Task <IQueryResults> ExecuteQueryAsync(Query query, IDictionary <string, object> parameters)
{
var sqlQuery = query as SqlParserQuery;
var sqlQueryResults = new SQLQueryResults();
// var templateContext = new TemplateContext();
var templateContext = _liquidTemplateManager.Context;
templateContext.SetValue("Query", sqlQuery);
// await templateContext.ContextualizeAsync(_serviceProvider);
if (parameters != null)
{
foreach (var parameter in parameters)
{
templateContext.SetValue(parameter.Key, parameter.Value);
}
}
var tokenizedQuery = await _liquidTemplateManager.RenderAsync(sqlQuery.Template, NullEncoder.Default, templateContext);
var connection = _store.Configuration.ConnectionFactory.CreateConnection();
var dialect = _store.Configuration.SqlDialect;
if (!SqlParser.TryParse(tokenizedQuery, dialect, _store.Configuration.TablePrefix, parameters,
out var rawQuery, out var messages))
{
sqlQueryResults.Items = new object[0];
return(sqlQueryResults);
}
if (sqlQuery.ReturnDocuments)
{
IEnumerable <int> documentIds;
using (connection)
{
connection.Open();
documentIds = await connection.QueryAsync <int>(rawQuery, parameters);
}
sqlQueryResults.Items = await _session.GetAsync <object>(documentIds.ToArray());
return(sqlQueryResults);
// return await _session.GetAsync<object>(documentIds.ToArray());
}
else
{
IEnumerable <dynamic> queryResults;
using (connection)
{
connection.Open();
queryResults = await connection.QueryAsync(rawQuery);
}
var results = new List <JObject>();
foreach (var document in queryResults)
{
results.Add(JObject.FromObject(document));
}
sqlQueryResults.Items = results;
return(sqlQueryResults);
// return results;
}
}
