public void TestTakeSkipLevelInFromExpression()
{
var q = new QueriableDummy <dummyntup>();
var c1 = from evt in q.Where(x => x.run > 10).Take(5).SelectMany(x => x.valC1D)
where evt > 50
select evt;
var c = c1.Count();
Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!");
var res = DummyQueryExectuor.FinalResult;
Console.WriteLine(DummyQueryExectuor.LastQueryModel.ToString());
res.DumpCodeToConsole();
Assert.AreEqual(1, res.DumpCode().Where(l => l.Contains("static int")).Count());
}
public void LocalBashCmdLineLoadExtraClassFiles()
{
var rootFile = TestUtils.CreateFileOfInt(20);
// Setup an extra file to be loaded.
string fnamebase = "TestLoadingCommonFilesObj";
var f = TTreeQueryExecutorTest.CreateCommonObject(fnamebase, new DirectoryInfo("."));
ntuple._gObjectFiles = new[] { f.FullName };
// Get a simple query we can "play" with
var q = new QueriableDummy <TestNtupe>();
var dude = q.Where(r => LocalBashCmdLineLoadExtraClassFilesHelpers.DoObjectLookup() > 0).Count();
var query = DummyQueryExectuor.LastQueryModel;
// Ok, now we can actually see if we can make it "go".
var exe = new TTreeQueryExecutor(new[] { rootFile.AsLocalBashUri() }, "dude", typeof(ntuple), typeof(TestNtupe));
int result = exe.ExecuteScalar <int>(query);
Assert.AreEqual(20, result);
}
public void TestWhereQuery()
{
int numberOfIter = 10;
var rootFile = TestUtils.CreateFileOfInt(numberOfIter);
var q = new QueriableDummy <TestNtupe>();
var dude = q.Where(v => v.run > 0).Count();
var query = DummyQueryExectuor.LastQueryModel;
var exe = new TTreeQueryExecutor(new Uri[] { rootFile }, "dude", typeof(ntuple), typeof(TestNtupe));
var result = exe.ExecuteScalarAsFuture <int>(query);
Assert.IsNotNull(result, "future should exist!");
Assert.IsFalse(result.HasValue, "future shoudl not have executed by now!");
var val = result.Value;
Assert.AreEqual(numberOfIter, val, "incorrect result came back.");
Assert.IsTrue(result.HasValue, "value should be marked by now!");
}
public void QMWith2ConcatsAndTwoEarlyTakesAndTests()
{
var q1 = new QueriableDummy <ntup>();
var q2 = new QueriableDummy <ntup>();
var s1 = q1.Where(x => x.run > 10).Take(500);
var s2 = q2.Where(x => x.run > 20).Take(100);
try
{
var r1 = s1.Concat(s2).Count();
} catch (InvalidOperationException e) when(e.Message.Contains("can't translate"))
{
}
var qm = DummyQueryExectuor.LastQueryModel;
var qmList = ConcatSplitterQueryVisitor.Split(qm)
.DumpToConsole();
Assert.AreEqual(2, qmList.Length);
CheckForQuery(() => q1.Where(x => x.run > 10).Take(500).Count(), qmList, 1, useDummy: true);
CheckForQuery(() => q1.Where(x => x.run > 20).Take(100).Count(), qmList, 1, useDummy: true);
// Dump the code
var code1 = qmList[0].GenerateCode <int>();
var code2 = qmList[1].GenerateCode <int>();
Console.WriteLine();
Console.WriteLine();
code1.DumpCodeToConsole();
Console.WriteLine();
Console.WriteLine();
code2.DumpCodeToConsole();
// Next, produce code to make sure that we have a static definition.
Assert.IsTrue(code1.DumpCode().Where(l => l.Contains("static int")).Any());
Assert.IsTrue(code1.DumpCode().Where(l => l.Contains("static int")).Any());
}
public void TestTakeSkipLevelBurreidTwice()
{
var q = new QueriableDummy<dummyntup>();
var c = q.Where(x => x.run > 10).Select(x => Tuple.Create(x.run, x.vals)).Select(x => x.Item2).SelectMany(x => x).Select(x => x + 1).Where(x => x > 10).Where(x => x > 5).Take(5).Count();
Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!");
var res = DummyQueryExectuor.FinalResult;
res.DumpCodeToConsole();
Assert.AreEqual(1, res.DumpCode().Where(l => l.Contains("static int")).Count());
}
public void TestTakeSkipLevelInFromExpression()
{
var q = new QueriableDummy<dummyntup>();
var c1 = from evt in q.Where(x => x.run > 10).Take(5).SelectMany(x => x.valC1D)
where evt > 50
select evt;
var c = c1.Count();
Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!");
var res = DummyQueryExectuor.FinalResult;
Console.WriteLine(DummyQueryExectuor.LastQueryModel.ToString());
res.DumpCodeToConsole();
Assert.AreEqual(1, res.DumpCode().Where(l => l.Contains("static int")).Count());
}
public void TestTakeSkipAtTopLevelBurreidTwice()
{
var q = new QueriableDummy<ntup>();
var c = q.Where(x => x.run > 10).Where(x => x.run > 20).Take(5).Count();
Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!");
var res = DummyQueryExectuor.FinalResult;
res.DumpCodeToConsole();
Assert.AreEqual(1, res.DumpCode().Where(l => l.Contains("static int")).Count());
}
public void TestDualQueryOnSameQueriable()
{
var rootFile = TestUtils.CreateFileOfInt(5);
///
/// Generate a proxy .h file that we can use
///
var proxyFile = TestUtils.GenerateROOTProxy(rootFile, "dude");
///
/// Get a simple query we can "play" with
///
var q = new QueriableDummy<TestNtupe>();
var dude = q.Count();
var query = DummyQueryExectuor.LastQueryModel;
///
/// Ok, now we can actually see if we can make it "go".
///
ntuple._gProxyFile = proxyFile.FullName;
var exe = new TTreeQueryExecutor(new[] { rootFile }, "dude", typeof(ntuple), typeof(TestNtupe));
int result = exe.ExecuteScalar<int>(query);
///
/// Run the second one now
///
var dude1 = q.Where(e => e.run > 10).Count();
query = DummyQueryExectuor.LastQueryModel;
result = exe.ExecuteScalar<int>(query);
}
