public void Test12()
{
Order order1 = new Order { Customer = Hans, ID = 302, Freight = 2001.99m, OrderDate = DateTime.Now.AddMonths(-20) };
var assemblies = new Assembly[] { typeof(Order).Assembly, typeof(UnitTests).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
var resolver = new ExpressionSerializationTypeResolver(assemblies, new Type[] { typeof(Customer), typeof(Order), typeof(Product), typeof(Supplier), typeof(Shipper) });
ExpressionSerializer serializer = new ExpressionSerializer(resolver);
IEnumerable<Customer> customers = GetCustomers().ToArray();
Expression<Func<int, IEnumerable<Order[]>>> e12 =
n =>
from c in customers//instance == null : IEnumerable.Where/.Select
where c.ID < n
select c.Orders.ToArray();
e12 = ( Expression<Func<int, IEnumerable<Order[]>>>)ObjectServices.Evaluator.PartialEval(e12);
MethodCallExpression m1 = ((MethodCallExpression)e12.Body).Arguments[0] as MethodCallExpression;
ConstantExpression cx = ((ConstantExpression)m1.Arguments[0]);
LambdaExpression lambdaarg = ((LambdaExpression)m1.Arguments[1]);
//Expression arg1 = ((MethodCallExpression)e12.Body).Arguments[1];
XElement xml12 = serializer.Serialize(e12);
Expression result12 = serializer.Deserialize( xml12);
Assert.AreEqual( e12.ToString(), result12.ToString());
Console.WriteLine(((result12 as Expression<Func<int, IEnumerable<Order[]>>>).Compile())(5));
}
public void ComplexTypeTest()
{
Expression<Func<Customer, bool>> addExpr = (customer) => string.IsNullOrEmpty(customer.CustomerID);
var serializer = new ExpressionSerializer();
XElement addXml = serializer.Serialize(addExpr);
var addExpResult = serializer.Deserialize<Func<Customer, bool>>(addXml);
Func<Customer, bool> addExpResultFunc = addExpResult.Compile();
Assert.AreEqual(true, addExpResultFunc(new Customer() { CustomerID = "Allen" })); // evaluates to 2
}
public static XElement SerializeQuery(this IQueryable query)
{
var resolver = new TypeResolver(assemblies: null,knownTypes: new Type[] { query.ElementType });
ExpressionSerializer serializer = new ExpressionSerializer(resolver)
{
Converters = { new DLinqCustomExpressionXmlConverter(null, resolver)}
};
return serializer.Serialize(query.Expression);
}
public void PrimitiveTypeTest()
{
Expression<Func<int>> addExpr = () => 1 + 1;
var serializer = new ExpressionSerializer();
XElement addXml = serializer.Serialize(addExpr);
Expression<Func<int>> addExpResult = serializer.Deserialize<Func<int>>(addXml);
Func<int> addExpResultFunc = addExpResult.Compile();
Assert.AreEqual(2, addExpResultFunc()); // evaluates to 2
}
public RemoteProvider(WebHttpClient <IQueryService> client)
{
this.client = client;
visitor = new StripQuoteVisitor();
resolver = new TypeResolver(null, client.knownTypes ?? new Type[0]);
CustomExpressionXmlConverter queryconverter = new QueryExpressionXmlConverter(null, resolver);
CustomExpressionXmlConverter knowntypeconverter = new KnownTypeExpressionXmlConverter(resolver);
serializer = new ExpressionSerializer(resolver, new[] { queryconverter, knowntypeconverter });
}
public static XElement SerializeQuery(this IQueryable query)
{
var resolver = new TypeResolver(assemblies: null, knownTypes: new Type[] { query.ElementType });
ExpressionSerializer serializer = new ExpressionSerializer(resolver)
{
Converters = { new DLinqCustomExpressionXmlConverter(null, resolver) }
};
return(serializer.Serialize(query.Expression));
}
public static XElement SerializeQuery(this IQueryable query)
{
DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(null);
ExpressionSerializer serializer = new ExpressionSerializer(resolver)
{
Converters = { new DLinqCustomExpressionXmlConverter(null, resolver) }
};
return(serializer.Serialize(query.Expression));
}
//public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
public static IQueryable DeserializeQuery(this ObjectContext dc, XElement rootXml)
{
DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(dc);
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { customConverter } };
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
return customConverter.QueryKind.Provider.CreateQuery(queryExpr);
}
public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
{
var resolver = new TypeResolver(assemblies: null, knownTypes: GetKnownTypesFromTables(dc) );
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver, new List<CustomExpressionXmlConverter> { customConverter });
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
return customConverter.QueryKind.Provider.CreateQuery(queryExpr);
}
public List<Character> GetCharacters(XElement query)
{
var serializer = new ExpressionSerializer();
var expression = serializer.Deserialize<Func<Character, bool>>(query);
if (expression == null)
return null;
using (var db = new RevolutionEntities1())
{
return db.Characters.Where(expression).ToList();
}
}
static ExpressionSerializer CreateSerializer()
{
var assemblies = new Assembly[] { typeof(Customer).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
var resolver = new TypeResolver(assemblies, new Type[]
{
typeof(Customer), typeof(Order), typeof(Product),
typeof(Supplier), typeof(Shipper)
});
//var creator = new QueryCreator();
CustomExpressionXmlConverter queryconverter = new QueryExpressionXmlConverter(creator: null, resolver: resolver);
CustomExpressionXmlConverter knowntypeconverter = new KnownTypeExpressionXmlConverter(resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { queryconverter, knowntypeconverter });
return serializer;
//ExpressionSerializer serializer = new ExpressionSerializer()
}
public void TestGetCharacterByExpression()
{
// First, create the expression that we want the service to call. In this case, we want to get any character with a first name of "progress"
// Note: This expression MUST be of the type System.Linq.Expressions.Expression<Func<RevolutionDAL.Character, bool>> to succeed.
System.Linq.Expressions.Expression<Func<RevolutionDAL.Character, bool>> exp = (c) => c.FirstName == "progress";
// Next, create an ExpressionSerializer object
var serializer = new ExpressionSerializer();
// Now, serialize the expression...
var query = serializer.Serialize(exp);
// Now, we can send this to the DAL to be executed...
List<Character> characters = null;
Service<ICharacterService>.Use(client => characters = client.GetCharacters(query));
Assert.IsNotNull(characters);
Assert.IsNotEmpty(characters);
}
// Very simple serialization example
public static void BasicExpressionSerialization()
{
Console.WriteLine("BASIC SAMPLE - Serialize/Deserialize Simple Expression:");
Expression<Func<int, int, int>> addExpr = (x, y) => x + y;
ExpressionSerializer serializer = new ExpressionSerializer();
XElement addXml = serializer.Serialize(addExpr);
Expression<Func<int,int,int>> addExpResult = serializer.Deserialize<Func<int,int,int>>(addXml);
Func<int, int, int> addExpResultFunc = addExpResult.Compile();
int result = addExpResultFunc(1, 2); // evaluates to 3
Console.WriteLine("Deserialized Expression Tree:");
Console.WriteLine(" " + addExpResult.ToString());
Console.WriteLine();
}
public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
{
var resolver = new TypeResolver(assemblies: null, knownTypes: GetKnownTypesFromTables(dc));
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver, new List <CustomExpressionXmlConverter> {
customConverter
});
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
{
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
}
return(customConverter.QueryKind.Provider.CreateQuery(queryExpr));
}
//public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
public static IQueryable DeserializeQuery(this ObjectContext dc, XElement rootXml)
{
DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(dc);
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver)
{
Converters = { customConverter }
};
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
{
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
}
return(customConverter.QueryKind.Provider.CreateQuery(queryExpr));
}
private static ExpressionSerializer CreateSerializer(IEnumerable <Type> knownTypes = null)
{
if (knownTypes == null || !knownTypes.Any())
{
return(new ExpressionSerializer());
}
var assemblies = new List <Assembly> {
typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly
};
knownTypes.ToList().ForEach(type => assemblies.Add(type.Assembly));
var resolver = new TypeResolver(assemblies, knownTypes);
var knownTypeConverter = new KnownTypeExpressionXmlConverter(resolver);
var serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { knownTypeConverter });
return(serializer);
}
// Serializing an expression tree representing a query expression
public static void ComplexExpressionSerializationSamples()
{
Console.WriteLine("COMPLEX SAMPLE - Serialize/Deserialize In-Memory Query Expression:");
Expression<Func<IEnumerable<int>>> queryExp = () => from i in Enumerable.Range(1, 10)
where i % 2 == 0
select i * i;
ExpressionSerializer serializer = new ExpressionSerializer();
XElement queryXml = serializer.Serialize(queryExp);
Expression<Func<IEnumerable<int>>> queryExpResult = serializer.Deserialize<Func<IEnumerable<int>>>(queryXml);
// Print out the expression tree: "(x, y) => x + y"
Console.WriteLine("Deserialized Expression Tree:");
Console.WriteLine(" " + queryExpResult.ToString());
// Call it
Func<IEnumerable<int>> f = queryExpResult.Compile();
IEnumerable<int> result = f();
Console.WriteLine("\nResults: ");
result.ToList().ForEach(n => Console.WriteLine(" " + n));
Console.WriteLine();
}
public void TestExpresstion([FromBody] XElement s)
{
//XElement x = JsonConvert.DeserializeObject<XElement>(s);
var serializer = new ExpressionSerializer();
var newPredicate = serializer.Deserialize<Func<string, bool>>(s);
}
public void Tests1To11()
{
Order order1 = new Order { Customer = Hans, ID = 302, Freight = 2001.99m, OrderDate = DateTime.Now.AddMonths(-20) };
var assemblies = new Assembly[] { typeof(Order).Assembly, typeof(BaseTests).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
var resolver = new TypeResolver(assemblies, new Type[] { typeof(Customer), typeof(Order), typeof(Product), typeof(Supplier), typeof(Shipper) });
ExpressionSerializer serializer = new ExpressionSerializer(resolver);
Console.WriteLine("\nTEST - 2");
Expression<Func<int>> e2 = () => 1;
XElement xml2 = serializer.Serialize(e2.Body);
Expression result2 = serializer.Deserialize(xml2);
Assert.AreEqual(e2.Body.ToString(), result2.ToString());
Console.WriteLine("\nTEST - 3");
Expression<Func<ExpressionType>> e3 = () => ExpressionType.Add;
XElement xml3 = serializer.Serialize(e3.Body);
Expression result3 = serializer.Deserialize(xml3);
Assert.AreEqual(e3.Body.ToString(), result3.ToString());
Console.WriteLine("\nTEST - 4");
Expression<Func<bool>> e4 = () => true;
XElement xml4 = serializer.Serialize(e4.Body);
Expression result4 = serializer.Deserialize(xml4);
Assert.AreEqual(e4.Body.ToString(), result4.ToString());
Console.WriteLine("\nTEST - 5");
Expression<Func<decimal, decimal>> e5 = d => d + 1m;
XElement xml5 = serializer.Serialize(e5.Body);
Expression result5 = serializer.Deserialize(xml5);
Assert.AreEqual(e5.Body.ToString(), result5.ToString());
Console.WriteLine("\nTEST - 6");
Expression<Func<decimal, decimal>> e6 = d => d + 1m;
XElement xml6 = serializer.Serialize(e6);
Expression result6 = serializer.Deserialize(xml6);
Assert.AreEqual(e6.ToString(), result6.ToString());
Console.WriteLine(((result6 as Expression<Func<decimal, decimal>>).Compile())(3));
Console.WriteLine("\nTEST - 7");
Expression<Func<string, int>> e7 = s => int.Parse(s);
XElement xml7 = serializer.Serialize(e7);
Expression result7 = serializer.Deserialize(xml7);
Assert.AreEqual(e7.ToString(), result7.ToString());
Console.WriteLine(((result7 as Expression<Func<string, int>>).Compile())("1234"));
Console.WriteLine("\nTEST - 8");
Expression<Func<string, string>> e8 = s => s.PadLeft(4);
XElement xml8 = serializer.Serialize(e8);
Expression result8 = serializer.Deserialize(xml8);
Assert.AreEqual(e8.ToString(), result8.ToString());
Console.WriteLine(((result8 as Expression<Func<string, string>>).Compile())("1"));
Console.WriteLine("\nTEST - 9");
Expression<Func<string, int>> e9 = s => Foo<string, int>(s, 1);
XElement xml9 = serializer.Serialize(e9);
Expression result9 = serializer.Deserialize(xml9);
Assert.AreEqual(e9.ToString(), result9.ToString());
Console.WriteLine(((result9 as Expression<Func<string, int>>).Compile())("abcdac"));
Console.WriteLine("\nTEST - 10");
Expression<Func<string, char[]>> e10 = s => s.Where(c => c != 'a').ToArray();
XElement xml10 = serializer.Serialize(e10);
Expression result10 = serializer.Deserialize(xml10);
Assert.AreEqual(e10.ToString(), result10.ToString());
Console.WriteLine(((result10 as Expression<Func<string, char[]>>).Compile())("abcdac"));
Console.WriteLine("\nTEST - 11");
Expression<Func<string, char[]>> e11 =
s =>
(from c in s
where c != 'a'
select (char)(c + 1)).ToArray();
XElement xml11 = serializer.Serialize(e11);
Expression result11 = serializer.Deserialize(xml11);
Assert.AreEqual(e11.ToString(), result11.ToString());
Console.WriteLine(((result11 as Expression<Func<string, char[]>>).Compile())("abcdac"));
Console.WriteLine("\nTEST - 19");
Expression<Func<object, string>> e19 = o => o as string;
XElement xml19 = serializer.Serialize(e19);
Expression result19 = serializer.Deserialize(xml19);
Assert.AreEqual(e19.ToString(), result19.ToString());
Console.WriteLine(((result19 as Expression<Func<object, string>>).Compile())(7));
Console.WriteLine("\nTEST - 20");
Expression<Func<object, bool>> e20 = o => o is string;
XElement xml20 = serializer.Serialize(e20);
Expression result20 = serializer.Deserialize(xml20);
Assert.AreEqual(e20.ToString(), result20.ToString());
Console.WriteLine(((result20 as Expression<Func<object, bool>>).Compile())(7));
Console.WriteLine("\nTEST - 21");
Expression<Func<IEnumerable<string>>> e21 = () => from m in typeof(string).GetMethods()
where !m.IsStatic
group m by m.Name into g
select g.Key + g.Count().ToString();
XElement xml21 = serializer.Serialize(e21);
Expression result21 = serializer.Deserialize(xml21);
Assert.AreEqual(e21.ToString(), result21.ToString());
Console.WriteLine(((result21 as Expression<Func<IEnumerable<string>>>).Compile())());
Console.WriteLine("\nTEST - 22 (may take a while)");
Expression<Func<IEnumerable<int>>> e22 = () => from a in Enumerable.Range(1, 13)
join b in Enumerable.Range(1, 13) on 4 * a equals b
from c in Enumerable.Range(1, 13)
join d in Enumerable.Range(1, 13) on 5 * c equals d
from e in Enumerable.Range(1, 13)
join f in Enumerable.Range(1, 13) on 3 * e equals 2 * f
join g in Enumerable.Range(1, 13) on 2 * (c + d) equals 3 * g
from h in Enumerable.Range(1, 13)
join i in Enumerable.Range(1, 13) on 3 * h - 2 * (e + f) equals 3 * i
from j in Enumerable.Range(1, 13)
join k in Enumerable.Range(1, 13) on 3 * (a + b) + 2 * j - 2 * (g + c + d) equals k
from l in Enumerable.Range(1, 13)
join m in Enumerable.Range(1, 13) on (h + i + e + f) - l equals 4 * m
where (4 * (l + m + h + i + e + f) == 3 * (j + k + g + a + b + c + d))
select a + b + c + d + e + f + g + h + i + j + k + l + m;
XElement xml22 = serializer.Serialize(e22);
Expression result22 = serializer.Deserialize(xml22);
Assert.AreEqual(e22.ToString(), result22.ToString());
Console.WriteLine(((result22 as Expression<Func<IEnumerable<int>>>).Compile())().FirstOrDefault());
Console.WriteLine("\nTEST - 23");
Expression<Func<int, int>> e23 = n => ((Func<int, int>)(x => x + 1))(n);
XElement xml23 = serializer.Serialize(e23);
Expression result23 = serializer.Deserialize(xml23);
Assert.AreEqual(e23.ToString(), result23.ToString());
Console.WriteLine(((result23 as Expression<Func<int, int>>).Compile())(7));
Console.WriteLine("\nTEST - 24");
Expression<Func<IEnumerable<int>>> e24 = () => from x in Enumerable.Range(1, 10)
from y in Enumerable.Range(1, 10)
where x < y
select x * y;
XElement xml24 = serializer.Serialize(e24);
Expression result24 = serializer.Deserialize(xml24);
Assert.AreEqual(e24.ToString(), result24.ToString());
Console.WriteLine(((result24 as Expression<Func<IEnumerable<int>>>).Compile())());
Console.WriteLine("\nTEST - 25");
Expression<Func<DateTime>> e25 = () => new DateTime(10000);
XElement xml25 = serializer.Serialize(e25);
Expression result25 = serializer.Deserialize(xml25);
Assert.AreEqual(e25.ToString(), result25.ToString());
Console.WriteLine(((result25 as Expression<Func<DateTime>>).Compile())());
}
private void GetData(ExternalServiceClient client)
{
InvokeOnFormThread(() =>
{
this.chart2.Series.Clear();
var timeseries = this.chart2.Series.Add("timeseries");
timeseries.XValueType = ChartValueType.Date;
textBox2.Text = "Working...";
label4.Text = "Working...";
});
string query = textBox1.Text;
//object[] parameters = new object[] { textBox1.Text };
//Expression<Func<Mention, object[], bool>> query = (x,p) => true;
//if (!string.IsNullOrWhiteSpace(textBox1.Text))
//{
// query = (x, p) => x.Name.Contains((string)p[0]) || x.Description.Contains((string)p[0]);
//}
//var query2 = EvoQLBuilder.GetLambda(textBox1.Text);
//Expression<Func<IEnumerable<ThriftMention>, IEnumerable<ThriftDatapoint>>> mapreduce = mentions =>
// from mention in mentions
// from tag in mention.Tags
// group mention by new { mention.OccurredOn.Year, mention.OccurredOn.Month, mention.OccurredOn.Day, TagId = tag } into g
// select new ThriftDatapoint { Count = g.Count(), EntityId = g.Key.TagId, Value = g.Average(x => x.Sentiment), Timestamp = new DateTime(g.Key.Year, g.Key.Month, g.Key.Day).Ticks };
//Expression<Func<IEnumerable<Mention>, IEnumerable<Datapoint>>> mapreduce1 = collection =>
// from mention in collection
// from tag in mention.Tags
// from datasource in mention.Datasources
// group mention by new MentionGroup{ Timestamp = mention.OccurredOnTicks, Id = tag, Id2 = datasource } into g
// select new Datapoint { EntityId = g.Key.Id, EntityId2 = g.Key.Id2, Timestamp = g.Key.Timestamp };
//Expression<Func<IEnumerable<Mention>, IEnumerable<Datapoint>>> mapreduce = collection =>
// collection.SelectMany(m => m.Tags, (m, t) => new MentionMetadata { Mention = m, Id = t }).SelectMany(x => x.Mention.Datasources, (md, ds) => new MentionMetadata2 { Child = md, Id = ds }).GroupBy(md => new MentionGroup { Timestamp = md.Child.Mention.OccurredOnTicks, Id = md.Child.Id, Id2 = md.Id }).Select(x => new Datapoint { Timestamp = x.Key.Timestamp, EntityId = x.Key.Id, EntityId2 = x.Key.Id2 });
//Expression<Func<IEnumerable<Mention>, IEnumerable<Datapoint>>> mapreduce = x => x.GroupBy(y => y.OccurredOnDayTicks).Select(g => new Datapoint { Count = g.Count(), Timestamp = g.Key });
//Expression<Func<IEnumerable<Mention>, IEnumerable<Datapoint>>> mapreduce = x => x.GroupBy(y => new MentionGroup{ Timestamp = y.OccurredOnTicks - (y.OccurredOnTicks % 864000000000) }).Select(g => new Datapoint { Count = g.Count(), Value = g.Average(y => y.Sentiment), Timestamp = g.Key.Timestamp });
//Expression<Func<IEnumerable<Mention>, IEnumerable<Datapoint>>> mapreduce = null; // ReduceExpressionGeneration.MakeExpression(null, SelectedSelect, SelectedGroupBy, SelectedGroupBy2);
//Expression<Func<IEnumerable<Datapoint>, double>> merge = x => x.Sum(y => y.Value);
//if (SelectedSelect == SelectTypes.Count) merge = x => x.Sum(y => (double)y.Count);
var mapreduce = textBox9.Text;
//Expression<Func<IEnumerable<Mention>, IEnumerable<Mention>>> paging = c => c.OrderByDescending(x => x.OccurredOnTicks).Take(25);
ExpressionSerializer serializer = new ExpressionSerializer();
//InvokeOnFormThread(() =>
//{
// //ExpressionSerializer serializer = new ExpressionSerializer();
// //textBox6.Text = serializer.Serialize(mapreduce).ToString();
//});
var domain = textBox3.Text;
//var minDate = dateTimePicker1.Value;
//var maxDate = dateTimePicker2.Value;
string command = textBox7.Text;
Stopwatch sw = new Stopwatch();
sw.Start();
var result = client.GetData(domain, "__ql__" + query, "__ql__" + mapreduce, "__default__", null, command);
sw.Stop();
result.Metadata.OperationTime = sw.Elapsed;
InvokeOnFormThread(() =>
{
var area = chart2.ChartAreas.First();
var oldseries = chart2.Series.ToArray();
string separator = "\r\n################################################################################################################################\r\n";
HardcodedBermudaDatapoint[] datapoints = new HardcodedBermudaDatapoint[0];
string jsonError = null;
if (result.Data != null)
{
try
{
datapoints = new JavaScriptSerializer().Deserialize<HardcodedBermudaDatapoint[]>(result.Data);
label4.Text = "Retrieved " + datapoints.Count() + "\r\nin " + sw.Elapsed;
}
catch (Exception ex)
{
jsonError = ex.ToString() + separator;
}
}
else
{
datapoints = new HardcodedBermudaDatapoint[0];
}
StringBuilder sb = new StringBuilder();
if (result.Metadata != null) ConvertStatsToString(sb, result.Metadata);
textBox2.Text = result.CacheKey + separator + jsonError + result.Error + separator + sb.ToString() + separator + result.Data;
var groups = datapoints.GroupBy(x => new { x.Id, x.Text } );
chart2.SuspendLayout();
foreach (var s in chart2.Series.Skip(1).ToArray())
{
chart2.Series.Remove(s);
}
int i = 0;
foreach (var g in groups)
{
string name = g.Key.Text ?? g.Key.Id.ToString();
var timeseries = i == 0 ? chart2.Series.FirstOrDefault() : chart2.Series.Add(name);
timeseries.Points.Clear();
timeseries.Name = name;
timeseries.XValueType = g.Any(p => new DateTime(p.Id2).Year > 2000) ? ChartValueType.Date : ChartValueType.Int64;
foreach (var d in g)
{
timeseries.Points.Add(timeseries.XValueType == ChartValueType.Date ? new DataPoint(new DateTime(d.Id2).ToOADate(), d.Value) : new DataPoint(d.Id2, d.Value));
}
i++;
}
chart2.ResumeLayout(true);
//textBox2.Text = sb.ToString().Trim() + separator + string.Join("\r\n", datapoints.Datapoints.Select(x => x.Id.ToString().PadLeft(32) + x.Id2.ToString().PadLeft(32) + ((int)x.Value).ToString().PadLeft(16) + x.Count.ToString().PadLeft(16) ));
//var sb2 = new StringBuilder();
//ConvertStatsToString(sb2, mentions.Metadata);
//textBox5.Text = sb2.ToString().Trim() + separator + string.Join(separator, mentions.Mentions.Select(x => DateTime.FromBinary( x.OccurredOnTicks ) + " :: " + x.Name + "\r\n" + x.Description));
//label4.Text = "Received " + (datapoints.Datapoints.Count()) + " datapoints\r\nin " + sw.Elapsed;
});
//return datapoints.Datapoints;
}
private static object GetMergeFunc(string str, string mapreduce, Type itemType)
{
if (str == null) return null;
object result = null;
//if (mergeFuncCache.TryGetValue(str, out result)) return result;
//if (str == DefaultToken)
//{
// Expression<Func<IEnumerable<Datapoint>, double>> merge = x => x.Sum(y => y.Value);
// result = merge.Compile();
//}
//else if (str == "__average__")
//{
// Expression<Func<IEnumerable<Datapoint>, double>> merge = x => x.Sum(y => y.Value * (double)y.Count) / x.Sum(y => y.Count);
// result = merge.Compile();
//}
if (str == DefaultToken)
{
if (!mapreduce.StartsWith(QlHeader)) throw new Exception("QL based mapreduce expression must be used with __default__ merge specification");
var expr = EvoQLBuilder.GetMergeExpression(mapreduce.Substring(QlHeader.Length), itemType);
var type = expr == null ? null : expr.GetType();
var compileMethod = expr == null ? null : type.GetMethods().FirstOrDefault(x => x.Name == "Compile" && x.GetParameters().Length == 0);
result = compileMethod.Invoke(expr, new object[0]);
}
else
{
var serializer = new ExpressionSerializer(new TypeResolver(new Assembly[] { Assembly.GetAssembly(typeof(Entities.Thrift.ThriftMention)) }));
var expr = serializer.Deserialize<Func<IEnumerable<Datapoint>, double>>(XElement.Parse(str));
result = expr.Compile();
}
mergeFuncCache[str] = result;
return result;
}
private static object GetMapReduceFunc(string str, Type itemType, out Type resultType)
{
if (str == null)
{
resultType = null;
return null;
}
object result = null;
//if (reduceFuncCache.TryGetValue(str, out result)) return result;
if (str.StartsWith(QlHeader))
{
var expr = EvoQLBuilder.GetReduceExpression(str.Substring(QlHeader.Length), itemType);
var type = expr == null ? null : expr.GetType();
resultType = expr == null ? itemType : ReduceExpressionGeneration.GetTypeOfEnumerable( type.GetProperty("ReturnType").GetValue(expr, null) as Type );
var compileMethod = expr == null ? null : type.GetMethods().FirstOrDefault(x => x.Name == "Compile" && x.GetParameters().Length == 0);
result = compileMethod.Invoke(expr, new object[0]);
}
else
{
var serializer = new ExpressionSerializer(new TypeResolver(new Assembly[] { Assembly.GetAssembly(typeof(Mention)) }));
var expr = serializer.Deserialize<Func<IEnumerable<Mention>, IEnumerable<Datapoint>>>(XElement.Parse(str));
resultType = typeof(Datapoint);
result = expr.Compile();
}
reduceFuncCache[str] = result;
return result;
}
public void BasicExpressionSerialization()
{
Type funcT1T2T3 = typeof(Func<>).Assembly.GetType("System.Func`3");
Debug.WriteLine("BASIC SAMPLE - Serialize/Deserialize Simple Expression:");
XElement addXml;
Expression<Func<int, int, int>> addExpr = (x, y) => x + y;
ExpressionSerializer serializer = new ExpressionSerializer();
Expression simplifiedAddExpr = Evaluator.PartialEval(addExpr);
//addXml = serializer.Serialize(simplifiedAddExpr); //does not seem necessary
addXml = serializer.Serialize(addExpr);
Expression<Func<int, int, int>> addExpResult = serializer.Deserialize<Func<int, int, int>>(addXml);
Func<int, int, int> addExpResultFunc = addExpResult.Compile();
int result = addExpResultFunc(1, 2); // evaluates to 3
Debug.WriteLine("Deserialized Expression Tree:");
Debug.WriteLine(" " + addExpResult.ToString());
}
protected System.Tuple<Expression, Type> DeserializeExpression(XElement rootXml)
{
//move to ctor
BoxSerializationTypeResolver resolver = new BoxSerializationTypeResolver(this);
BoxCustomExpressionXmlConverter customConverter = new BoxCustomExpressionXmlConverter(resolver, RepoFinder.Mappings);
ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { customConverter } };
return new System.Tuple<Expression, Type>(serializer.Deserialize(rootXml), customConverter.QueryKind.ElementType);
}
private static ExpressionSerializer GetSerializer()
{
var tr = new TypeResolver(new Assembly[] { Assembly.GetAssembly(typeof(ExpressionSerializationTest)) },
new Type[] { typeof(DTO), typeof(Entity), typeof(BaseClass) });
var serializer = new ExpressionSerializer(tr, new List<CustomExpressionXmlConverter>());
return serializer;
}
private static object GetFilterFunc(string str, Type itemType)
{
if (str == null) return null;
object result = null;
if (filterFuncCache.TryGetValue(str, out result)) return result;
if (str.StartsWith(QlHeader))
{
var expr = EvoQLBuilder.GetWhereExpression(str.Substring(QlHeader.Length), itemType);
var type = expr == null ? null : expr.GetType();
var compileMethod = expr == null ? null : type.GetMethods().FirstOrDefault(x => x.Name == "Compile" && x.GetParameters().Length == 0);
result = compileMethod.Invoke(expr, new object[0]);
}
else
{
var serializer = new ExpressionSerializer(new TypeResolver(new Assembly[] { Assembly.GetAssembly(typeof(Mention)) }));
var expr = serializer.Deserialize<Func<Mention, object[], bool>>(XElement.Parse(str));
result = expr.Compile();
}
filterFuncCache[str] = result;
return result;
}
public static XElement SerializeQuery(this IQueryable query)
{
DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(null);
ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { new DLinqCustomExpressionXmlConverter(null, resolver) } };
return serializer.Serialize(query.Expression);
}