public TabModel ToTabModel()
{
FilterQuery filter;
try
{
filter = QueryCompiler.Compile(Query);
}
catch (FilterQueryException ex)
{
BackstageModel.RegisterEvent(new QueryCorruptionEvent(Name, ex));
filter = null;
}
var model = new TabModel
{
Name = Name,
FilterQuery = filter,
BindingHashtags = this.BindingHashtags,
NotifyNewArrivals = this.NotifyNewArrivals,
NotifySoundSource = this.NotifySoundSource,
ShowUnreadCounts = this.ShowUnreadCounts
};
this.BindingAccountIds.ForEach(model.BindingAccounts.Add);
return(model);
}
public void CopyTab()
{
try
{
var model = new TabModel
{
Name = Name,
FilterQuery = Model.FilterQuery != null
? QueryCompiler.Compile(Model.FilterQuery.ToQuery())
: null,
RawQueryString = Model.RawQueryString,
BindingHashtags = Model.BindingHashtags.ToArray(),
NotifyNewArrivals = Model.NotifyNewArrivals,
ShowUnreadCounts = Model.ShowUnreadCounts,
NotifySoundSource = Model.NotifySoundSource
};
Model.BindingAccounts.ForEach(id => model.BindingAccounts.Add(id));
Parent.Model.CreateTab(model);
}
catch (FilterQueryException fqex)
{
BackstageModel.RegisterEvent(
new OperationFailedEvent(QueryCompilerResources.QueryCompileFailed, fqex));
}
}
public void QueryCompilerCompileDeleteTest()
{
var part = new DelegateQueryPart(OperationType.Delete, () => "Table");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "DELETE FROM Table");
}
public void QueryCompilerCompileAndTest()
{
var part = new DelegateQueryPart(OperationType.And, () => "Field = 1");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "\r\n AND Field = 1");
}
public void QueryCompilerCompileCountTest()
{
var part = new QueryPart(OperationType.None);
part.Add(new FieldQueryPart("Name", "Alias", operation: OperationType.Count));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " COUNT(Name) AS Alias");
}
public void QueryCompilerCompileFieldTest()
{
var part = new QueryPart(OperationType.None);
part.Add(new FieldQueryPart("Name", null));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " Name");
}
public void QueryCompiler_Compile_UnOrdered()
{
var container = new ComponentContainer()
.Add(new QueryComponent(SyntaxComponent.Keyword, "FROM"))
.Add(new QueryComponent(SyntaxComponent.Keytable, "Item"))
.Add(new QueryComponent(SyntaxComponent.FieldList, "ID, Name"))
.Add(new QueryComponent(SyntaxComponent.Command, "SELECT"));
var compiler = new QueryCompiler();
var query = compiler.Compile(container);
Assert.AreEqual("SELECT ID, Name FROM Item", query.Query);
}
public void CompileQueryTest()
{
// setup
var parts = new Mock<IQueryPartsContainer>();
//parts.Setup(p => p.Compile()).Returns(new CompiledQuery());
// Act
var compiler = new QueryCompiler();
var query = compiler.Compile(parts.Object, new InterceptorCollection());
Assert.IsNotNull(query);
//parts.Verify(p => p.Compile(), Times.Once);
}
public static EnumerateFactory <T> GetEnumerateFactory <T>(ISchema schema, IDataRecord header)
{
ColumnCacheKey cacheKey = GetCacheKey(schema, QueryType.List, header);
return((EnumerateFactory <T>)enumerateMap.GetOrAdd(cacheKey, k =>
{
EnumerateParser parser = new EnumerateParser(schema);
EnumerateResult result = parser.Parse(k.Header);
QueryCompiler compiler = new QueryCompiler();
return compiler.Compile <T>(result);
}));
}
public static AggregateFactory GetAggregateFactory(ISchema schema, IEnumerable <AggregateAttribute> header)
{
AggregateCacheKey cacheKey = new AggregateCacheKey(schema, QueryType.Aggregate, header.ToList());
return((AggregateFactory)aggregateMap.GetOrAdd(cacheKey, k =>
{
AggregateParser parser = new AggregateParser(k.Schema);
AggregateResult result = parser.Parse(k.Header);
QueryCompiler compiler = new QueryCompiler();
return compiler.Compile(result);
}));
}
public void SqlServer_QueryCompiler_Compile_AddColumnMissingNUllableTest()
{
var part = new ValueCollectionQueryPart(OperationType.AddColumn);
part.AddValue(KeyValuePart.MemberName, "ColumnName");
part.AddValue(KeyValuePart.MemberType, "int");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "ADD ColumnName int");
}
private async void OnTextChanged(string value)
{
if (value != null && value.StartsWith("?"))
{
IsQueryMode = true;
IsSearchOptionAvailable = false;
IsSearchResultAvailable = false;
ErrorText = SearchFlipResources.SearchFlipQueryCompiling;
try
{
if (value == "?")
{
ErrorText = SearchFlipResources.SearchFlipQueryEmpty;
IsSearchResultAvailable = false;
return;
}
await Task.Run(() =>
{
var result = QueryCompiler.Compile(value.Substring(1));
result.GetEvaluator(); // check evaluator
});
ErrorText = null;
}
catch (FilterQueryException fex)
{
ErrorText = fex.Message;
}
}
else
{
IsQueryMode = false;
IsSearchOptionAvailable = true;
ErrorText = null;
if (String.IsNullOrEmpty(value))
{
IsSearchResultAvailable = false;
IsSearchOptionAvailable = false;
}
else
{
IsSearchResultAvailable = SearchMode == SearchMode.CurrentTab;
if (IsSearchResultAvailable)
{
CommitSearch();
}
CanBeUserScreenName = _userScreenNameRegex.IsMatch(value);
}
}
}
public void SqliteQueryCompilerCompileAddColumnNullableTest()
{
var part = new ValueCollectionQueryPart(OperationType.AddColumn);
part.AddValue(KeyValuePart.MemberName, "ColumnName");
part.AddValue(KeyValuePart.MemberType, "int");
part.AddValue(KeyValuePart.Nullable, true.ToString());
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "ADD COLUMN ColumnName int");
}
public void CopyTab()
{
var model = new TabModel
{
Name = this.Name,
FilterQuery = this.Model.FilterQuery != null?QueryCompiler.Compile(this.Model.FilterQuery.ToQuery()) : null,
BindingHashtags = this.Model.BindingHashtags.ToArray(),
NotifyNewArrivals = this.Model.NotifyNewArrivals,
ShowUnreadCounts = this.Model.ShowUnreadCounts,
NotifySoundSource = this.Model.NotifySoundSource
};
this.Model.BindingAccounts.ForEach(id => model.BindingAccounts.Add(id));
this.Parent.Model.CreateTab(model);
}
static HierarchyList <CallTreeNodeViewModel> LoadWorker(ProfilingDataProvider provider, QueryCompiler compiler, int rangeStart, int rangeEnd)
{
try {
if (compiler.Compile())
{
var data = compiler.ExecuteQuery(provider, rangeStart, rangeEnd);
var nodes = data.Select(i => new CallTreeNodeViewModel(i, null)).ToList();
return(new HierarchyList <CallTreeNodeViewModel>(nodes));
}
} catch (ObjectDisposedException) {
return(null);
}
return(null);
}
public static ListFactory GetListFactory(ISchema schema, QueryType queryType, IDataRecord header)
{
ColumnCacheKey cacheKey = GetCacheKey(schema, queryType, header);
return(listMap.GetOrAdd(cacheKey, k =>
{
BufferCache buffer = GetBuffer(k.Schema);
ListParser parser = new ListParser(buffer, queryType);
ListResult result = parser.Parse(k.Header);
QueryCompiler compiler = new QueryCompiler();
return compiler.Compile(result);
}));
}
/// <summary>
/// Create new tab model
/// </summary>
/// <param name="name">tab name</param>
/// <param name="query">tab query(KQ)</param>
/// <returns>tab model</returns>
public static TabModel Create(string name, string query)
{
var model = new TabModel
{
Name = name,
FilterQuery = query != null?QueryCompiler.Compile(query) : null,
RawQueryString = query,
ShowUnreadCounts = true,
NotifyNewArrivals = false,
};
var cf = TabManager.CurrentFocusTab;
cf?.BindingAccounts.ForEach(model.BindingAccounts.Add);
return(model);
}
public void TestQueryCache()
{
int iterations = 1000;
var cache = new QueryCache(10);
var notCached = RunTimedTest(iterations, i =>
{
var results = db.OrderDetails.Where(d => d.OrderID > i).Take(n).ToList();
System.Diagnostics.Debug.Assert(results.Count == n);
});
this.provider.Cache = cache;
var autoCached = RunTimedTest(iterations, i =>
{
var results = db.OrderDetails.Where(d => d.OrderID > i).Take(n).ToList();
System.Diagnostics.Debug.Assert(results.Count == n);
});
this.provider.Cache = null;
var check = RunTimedTest(iterations, i =>
{
var query = db.OrderDetails.Where(d => d.OrderID > i).Take(n);
var isCached = cache.Contains(query);
});
var cached = RunTimedTest(iterations, i =>
{
var query = db.OrderDetails.Where(d => d.OrderID > i).Take(n);
var results = cache.Execute(query).ToList();
System.Diagnostics.Debug.Assert(results.Count == n);
});
System.Diagnostics.Debug.Assert(cache.Count == 1);
var cq = QueryCompiler.Compile((Northwind nw, int i) => nw.OrderDetails.Where(d => d.OrderID > i).Take(n));
var compiled = RunTimedTest(iterations, i =>
{
var results = cq(db, i).ToList();
System.Diagnostics.Debug.Assert(results.Count == n);
});
Console.WriteLine("compiled : {0} sec", compiled);
Console.WriteLine("check cache: {0}", check);
Console.WriteLine("cached : {0} {1:#.##}x vs compiled", cached, cached / compiled);
Console.WriteLine("auto cached: {0} {1:#.##}x vs compiled", autoCached, autoCached / compiled);
Console.WriteLine("not cached : {0} {1:#.##}x vs compiled", notCached, notCached / compiled);
}
public void TestCompiledQuery()
{
int n = 50;
int iterations = 100;
var query = QueryCompiler.Compile((Northwind nw, int i) => nw.OrderDetails.Where(d => d.OrderID > i).Take(n));
var result = query(db, 0).ToList();
var compiledTime = RunTimedTest(iterations, i =>
{
var list = query(db, i).ToList();
});
var adoTime = RunTimedTest(iterations, i =>
{
var cmd = this.GetProvider().Connection.CreateCommand();
cmd.CommandText = "SELECT TOP (@p0) OrderID, ProductID FROM [Order Details] WHERE OrderID > @p1";
//cmd.CommandText = "PARAMETERS p1 int; SELECT TOP 50 OrderID, ProductID FROM [Order Details] WHERE OrderID > p1";
var p0 = cmd.CreateParameter();
p0.ParameterName = "p0";
p0.Value = n;
cmd.Parameters.Add(p0);
var p1 = cmd.CreateParameter();
p1.ParameterName = "p1";
p1.Value = i;
cmd.Parameters.Add(p1);
var reader = cmd.ExecuteReader();
var list = new List <object>();
while (reader.Read())
{
var orderId = reader.IsDBNull(0) ? default(int) : reader.GetInt32(0);
var productId = reader.IsDBNull(1) ? default(int) : reader.GetInt32(1);
list.Add(new OrderDetail {
OrderID = orderId, ProductID = productId
});
}
reader.Close();
});
Console.WriteLine("Direct ADO : {0}", adoTime);
Console.WriteLine("Compiled IQ: {0} {1:#.##}x vs ADO", compiledTime, compiledTime / adoTime);
}
private async void CheckCompile(string source)
{
try
{
var newFilter = await Task.Run(() => QueryCompiler.Compile(source));
newFilter.GetEvaluator(); // validate types
_filterQuery = newFilter;
FoundError = false;
}
catch (Exception ex)
{
FoundError = true;
ExceptionMessage = ex.Message;
}
}
static HierarchyList <CallTreeNodeViewModel> LoadWorker(ProfilingDataProvider provider, QueryCompiler compiler, int rangeStart, int rangeEnd)
{
try {
if (compiler.Compile())
{
IEnumerable <CallTreeNode> data = compiler.ExecuteQuery(provider, rangeStart, rangeEnd);
#if DEBUG
data = data.WithQueryLog(Console.Out);
#endif
var nodes = data.Select(i => new CallTreeNodeViewModel(i, null)).ToList();
return(new HierarchyList <CallTreeNodeViewModel>(nodes));
}
} catch (ObjectDisposedException) {
return(null);
}
return(null);
}
private async Task <bool> CheckCompile(string source)
{
try
{
var newFilter = await Task.Run(() => QueryCompiler.Compile(source));
newFilter.GetEvaluator(); // validate types
_lastValidFilterQuery = newFilter;
_lastValidFilterQueryString = source;
FoundError = false;
return(true);
}
catch (Exception ex)
{
FoundError = true;
ExceptionMessage = ex.Message;
return(false);
}
}
private void ProcessDumpEvents()
{
string error;
List <string> files = null;
if (!FileUtilities.ValidateAndEnumerate(inputFiles, ref files, ".etl", out error))
{
Console.WriteLine(error);
return;
}
if (queries == null || queries.Length == 0)
{
Logger.Log("Dumping Raw Events");
string fileName = Path.Combine(SupportFiles.SupportFileDir, "AllEvents.linq");
QueryCompiler.Compile(inputFiles,
fileName,
Console.Out,
this.LogWriter,
ManifestCompiler.GetKnowntypesforPlayback());
}
else
{
Logger.Log("Dumping events using query.");
List <string> queryFiles = null;
FileUtilities.ValidateAndEnumerate(inputFiles, ref queryFiles, ".linq", out error);
if (!FileUtilities.ValidateAndEnumerate(queries, ref queryFiles, ".linq", out error))
{
Console.WriteLine(error);
return;
}
foreach (var item in queryFiles)
{
EtlViewer.QueryFx.QueryCompiler.Compile(inputFiles,
item,
Console.Out,
this.LogWriter,
ManifestCompiler.GetKnowntypesforPlayback());
}
}
}
public string GetQueryString()
{
// check raw query string is equals to filter query
try
{
if (RawQueryString != null)
{
if (!this._isQueryStringValid &&
QueryCompiler.Compile(this.RawQueryString).ToQuery() == this.FilterQuery.ToQuery())
{
this._isQueryStringValid = true;
}
return(RawQueryString);
}
}
catch { }
RawQueryString = this.FilterQuery != null?this.FilterQuery.ToQuery() : String.Empty;
this._isQueryStringValid = true;
return(RawQueryString);
}
public void QueryCompilerCompileSelectTest()
{
var parts = new QueryPartsContainer();
parts.Add(new QueryPart(OperationType.Select, null));
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "SELECT");
}
public void QueryCompilerCompileOrderByTest()
{
var part = new DelegateQueryPart(OperationType.OrderBy, () => "Field");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " \r\nORDER BY Field ASC");
}
public void SqlServer_QueryCompiler_Compile_MultipleParameterOutputTest()
{
var part = new QueryPart(OperationType.None);
part.Add(new DelegateQueryPart(OperationType.OutputParameter, () => "Param1=value1"));
part.Add(new DelegateQueryPart(OperationType.OutputParameter, () => "Param2=value2"));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "Param1=value1 OUTPUT, Param2=value2 OUTPUT");
}
/// <summary>
/// Compiles the current queryable type.
/// </summary>
/// <typeparam name="T">The source type within the collection.</typeparam>
/// <param name="source">The current IQueryable type.</param>
/// <returns>The enumrable function type.</returns>
public static Nequeo.Threading.FunctionHandler <IEnumerable <T> > Compile <T>(this IQueryable <T> source)
{
return(QueryCompiler.Compile <IEnumerable <T> >(
Expression.Lambda <Nequeo.Threading.FunctionHandler <IEnumerable <T> > >(((IQueryable)source).Expression)));
}
public void QueryCompilerCompileValuesTest()
{
var part = new QueryPart(OperationType.Values, null);
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " VALUES ()");
}
public void QueryCompilerCompileUpdateValueWithValueCollectionTest()
{
var part = new ValueCollectionQueryPart(OperationType.UpdateValue);
part.AddValue(KeyValuePart.MemberName, "Member");
part.AddValue(KeyValuePart.Value, "Value");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "Member = Value");
}
public void QueryCompilerCompileSelectWithIncludeTest()
{
var select = new QueryPart(OperationType.Select);
select.Add(new FieldQueryPart("Name", "Alias") { OperationType = OperationType.Include });
var parts = new QueryPartsContainer();
parts.Add(select);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "SELECT Name AS Alias");
}
public void SqlServer_QueryCompiler_Compile_ColumnMultipleTest()
{
var part = new QueryPart(OperationType.None);
var part1 = new ValueCollectionQueryPart(OperationType.Column);
part1.AddValue(KeyValuePart.MemberName, "ColumnName1");
part1.AddValue(KeyValuePart.MemberType, "int");
part1.AddValue(KeyValuePart.Nullable, false.ToString());
part.Add(part1);
var part2 = new ValueCollectionQueryPart(OperationType.Column);
part2.AddValue(KeyValuePart.MemberName, "ColumnName2");
part2.AddValue(KeyValuePart.MemberType, "VARCHAR(20)");
part2.AddValue(KeyValuePart.Nullable, true.ToString());
part.Add(part2);
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "ColumnName1 int NOT NULL, ColumnName2 VARCHAR(20)");
}
public void SqlServer_QueryCompiler_Compile_AlterTableTest()
{
var part = new DelegateQueryPart(OperationType.AlterTable, () => "Table");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "ALTER TABLE Table ");
}
public void SqlServer_QueryCompiler_Compile_SelectWithOutputParameterSelectTest()
{
var part = new QueryPart(OperationType.Select);
part.Add(new DelegateQueryPart(OperationType.OutParameterSelect, () => "Param1"));
part.Add(new DelegateQueryPart(OperationType.OutParameterSelect, () => "Param2"));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "SELECT @Param1 AS Param1, @Param2 AS Param2");
}
public void QueryCompilerCompileFieldWithAliasAndTableAndTableAliasDefinitionTest()
{
var part = new QueryPart(OperationType.None);
part.Add(new FieldQueryPart("Name", "Alias", entity: "Entity", entityalias: "EntityAlias"));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " EntityAlias.Name AS Alias");
}
public void SqlServer_QueryCompiler_Compile_ParameterTest()
{
var part = new QueryPart(OperationType.None, null);
part.Add(new DelegateQueryPart(OperationType.Parameter, () => "Param=value"));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "Param=value");
}
public void SqlServer_QueryCompiler_Compile_OutputParameterSetTest()
{
var part = new DelegateQueryPart(OperationType.OutParameterSet, () => "ParamName=1");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "SET @ParamName=1\r\n");
}
public void QueryCompilerCompileSimpleJoinTest()
{
var part = new DelegateQueryPart(OperationType.Join, () => "Table");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " \r\nJOIN Table");
}
public void QueryCompilerCompileFromTest()
{
var part = new EntityPart(OperationType.From, entity: "Table");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " \r\nFROM Table");
}
public void QueryCompilerCompileThenByDescTest()
{
var part = new DelegateQueryPart(OperationType.ThenByDesc, () => "Field");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, ", Field DESC");
}
public void QueryCompilerCompileIgnoreTest()
{
var select = new QueryPart(OperationType.IgnoreColumn);
var parts = new QueryPartsContainer();
parts.Add(select);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, string.Empty);
}
public void QueryCompilerCompileUpdateWithUpdateValueTest()
{
var part = new DelegateQueryPart(OperationType.Update, () => "Table");
part.Add(new DelegateQueryPart(OperationType.UpdateValue, () => "Field1=Value1, "));
part.Add(new DelegateQueryPart(OperationType.UpdateValue, () => "Field2=Value2"));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "UPDATE Table SET Field1=Value1, Field2=Value2");
}
public void QueryCompilerCompileInsertWithInsertMemberTest()
{
var part = new DelegateQueryPart(OperationType.Insert, () => "TableName");
part.Add(new DelegateQueryPart(OperationType.InsertMember, () => "Field1"));
part.Add(new DelegateQueryPart(OperationType.InsertMember, () => "Field2"));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "INSERT INTO TableName (Field1, Field2)");
}
public void QueryCompilerCompileValuesWithInsertValuesTest()
{
var part = new QueryPart(OperationType.Values);
part.Add(new DelegateQueryPart(OperationType.InsertValue, () => "Field1"));
part.Add(new DelegateQueryPart(OperationType.InsertValue, () => "Field2"));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " VALUES (Field1, Field2)");
}
public void QueryCompilerCompileJoinithAliasTest()
{
var part = new EntityPart(OperationType.Join, entity: "Table", entityAlias: "Alias");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, " \r\nJOIN Table Alias");
}
public void SqlServer_QueryCompiler_Compile_PrimaryKeyWithMultipleColumnsTest()
{
var part = new QueryPart(OperationType.PrimaryKey);
part.Add(new DelegateQueryPart(OperationType.Column, () => "Column1"));
part.Add(new DelegateQueryPart(OperationType.Column, () => "Column2"));
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "PRIMARY KEY (Column1, Column2)");
}
public void SqlServer_QueryCompiler_Compile_ForeignKeyTest()
{
var part = new ValueCollectionQueryPart(OperationType.ForeignKey);
part.AddValue(KeyValuePart.MemberName, "ColumnName");
part.AddValue(KeyValuePart.ReferenceTable, "RefTable");
part.AddValue(KeyValuePart.ReferenceMember, "RefColumn");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "FOREIGN KEY(ColumnName) REFERENCES RefTable(RefColumn)");
}
private void PrepareFilter()
{
var disposable = new CompositeDisposable();
var prev = Interlocked.Exchange(ref _previousFilterListener, disposable);
if (prev != null)
{
prev.Dispose();
}
switch (this._option)
{
case SearchOption.Web:
this._filterFunc = FilterExpressionBase.Tautology;
break;
case SearchOption.Query:
try
{
var fq = QueryCompiler.Compile(this._query);
_filterQuery = fq;
fq.Activate();
disposable.Add(Disposable.Create(fq.Deactivate));
disposable.Add(Observable.FromEvent(
h => fq.InvalidateRequired += h,
h => fq.InvalidateRequired -= h)
.Subscribe(r => this.QueueInvalidateTimeline()));
}
catch
{
_filterQuery = null;
this._filterFunc = FilterExpressionBase.Contradiction;
this._filterSql = FilterExpressionBase.ContradictionSql;
}
break;
default:
var splitted = this._query.Split(new[] { " ", "\t", " " },
StringSplitOptions.RemoveEmptyEntries)
.Distinct().ToArray();
var positive = splitted.Where(s => !s.StartsWith("-")).ToArray();
var negative = splitted.Where(s => s.StartsWith("-")).Select(s => s.Substring(1)).ToArray();
var filter = new Func <TwitterStatus, bool>(
status =>
positive.Any(s => status.GetEntityAidedText(EntityDisplayMode.LinkUri)
.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) >= 0) &&
!negative.Any(s => status.GetEntityAidedText(EntityDisplayMode.LinkUri)
.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) >= 0));
var psql = positive.Select(s => "LOWER(EntityAidedText) like LOWER('%" + s + "%')").JoinString(" OR ");
var nsql = negative.Select(s => "LOWER(EntityAidedText) not like LOWER('%" + s + "%')").JoinString(" AND ");
var sql = psql.SqlConcatAnd(nsql);
var ctab = TabManager.CurrentFocusTab;
var ctf = ctab != null ? ctab.FilterQuery : null;
if (_option == SearchOption.CurrentTab && ctf != null)
{
// add current tab filter
this._filterSql = sql.SqlConcatAnd(ctf.GetSqlQuery());
var func = ctf.GetEvaluator();
this._filterFunc = s => func(s) && filter(s);
}
else
{
this._filterSql = sql;
this._filterFunc = filter;
}
break;
}
}
public void SqlServer_QueryCompiler_Compile_ProcedureTest()
{
var part = new DelegateQueryPart(OperationType.Procedure, () => "ProcName");
var parts = new QueryPartsContainer();
parts.Add(part);
var compiler = new QueryCompiler();
var query = compiler.Compile(parts, new InterceptorCollection());
Assert.AreEqual(query.QueryString, "EXEC ProcName ");
}
