public override Task Init(IWorkerGrain self, PredicateBase predicate, IPrincipalGrain principalGrain)
{
base.Init(self, predicate, principalGrain);
joinFieldIndex = ((HashJoinPredicate)predicate).JoinFieldIndex;
TableID = ((HashJoinPredicate)predicate).TableID;
return(Task.CompletedTask);
}
protected BinaryChain(
PredicateBase <TArg> leftPredicate,
PredicateBase <TArg> rightPredicate)
{
_leftPredicate = leftPredicate;
_rightPredicate = rightPredicate;
}
internal JoinedTableSource(TableSourceBase left, TableSourceBase right, PredicateBase on, JoinType type)
{
Left = Argument.NotNull(left, "left");
Right = Argument.NotNull(right, "right");
On = Argument.NotNull(on, "on");
Type = type;
}
internal PredicateDisjunction Add(PredicateBase predicate)
{
Argument.NotNull(predicate, "predicate");
var result = new PredicateDisjunction(InternalPredicates.Add(predicate));
return(result);
}
public override Task Init(IWorkerGrain self, PredicateBase predicate, IPrincipalGrain principalGrain)
{
base.Init(self, predicate, principalGrain);
ulong filesize = ((ScanPredicate)predicate).FileSize;
tableId = ((ScanPredicate)predicate).TableID;
separator = ((ScanPredicate)predicate).Separator;
string extensionKey = "";
Guid key = this.GetPrimaryKey(out extensionKey);
ulong i = UInt64.Parse(extensionKey);
ulong num_grains = (ulong)((ScanPredicate)predicate).NumberOfGrains;
ulong partition = filesize / num_grains;
ulong start_byte = i * partition;
ulong end_byte = num_grains - 1 == i?filesize:(i + 1) * partition;
reader = new ScanStreamReader(((ScanPredicate)predicate).File);
if (!reader.GetFile(start_byte))
{
return(Task.FromException(new Exception("unable to get file")));
}
start = start_byte;
end = end_byte;
if (start != 0)
{
start += reader.TrySkipFirst();
}
Console.WriteLine("Init: start byte: " + start.ToString() + " end byte: " + end.ToString());
return(Task.CompletedTask);
}
public OrChain(
PredicateBase <TArg> leftPredicate,
PredicateBase <TArg> rightPredicate) : base(
leftPredicate,
rightPredicate)
{
}
public override Task Init(IWorkerGrain self, PredicateBase predicate, IPrincipalGrain principalGrain)
{
base.Init(self, predicate, principalGrain);
searchIndex = ((KeywordPredicate)predicate).SearchIndex;
keyword = ((KeywordPredicate)predicate).Query;
return(Task.CompletedTask);
}
protected ISinglePredicateState InitialPredicateState(PredicateBase predicate, bool negate)
{
if (negate)
{
predicate = Predicate.Not(predicate);
}
return(new SinglePredicateState(predicate));
}
public override Task Init(IWorkerGrain self, PredicateBase predicate, IPrincipalGrain principalGrain)
{
base.Init(self, predicate, principalGrain);
groupByIndex = ((GroupByPredicate)predicate).GroupByIndex;
aggregationFunc = ((GroupByPredicate)predicate).AggregationFunction;
aggregationIndex = ((GroupByPredicate)predicate).AggregationIndex;
return(Task.CompletedTask);
}
public static PredicateDisjunction AppendOrCreateDisjunction(PredicateBase left, PredicateBase right)
{
var disjunction = left as PredicateDisjunction;
if (disjunction != null)
{
return(disjunction.Add(right));
}
return(Predicate.Or(left, right));
}
protected PredicateDisjunctionState PredicateDisjunctionState(PredicateBase nextPredicate, bool negate = false)
{
if (negate)
{
nextPredicate = Builder.Predicate.Predicate.Not(nextPredicate);
}
var disjunction = PredicateHelper.AppendOrCreateDisjunction(Predicate, nextPredicate);
return(new PredicateDisjunctionState(disjunction));
}
public static PredicateConjuction AppendOrCreateConjuction(PredicateBase left, PredicateBase right)
{
var conjuction = left as PredicateConjuction;
if (conjuction != null)
{
return(conjuction.Add(right));
}
return(Predicate.And(left, right));
}
public override Task Init(IWorkerGrain self, PredicateBase predicate, IPrincipalGrain principalGrain)
{
base.Init(self, predicate, principalGrain);
if (typeof(T) != typeof(string) && (ParseInfo == null || !typeof(T).IsAssignableFrom(ParseInfo.ReturnType)))
{
throw new InvalidOperationException("Invalid type, must contain public static T Parse(string)");
}
type = ((FilterPredicate)predicate).Type;
filterIndex = ((FilterPredicate)predicate).FilterIndex;
threshold = Parse(((FilterPredicate)predicate).Threshold);
return(Task.CompletedTask);
}
public static Query JoinLastTableSource(this Query query, TableSourceBase joinTableSource, PredicateBase on, JoinType joinType)
{
Argument.NotNull(query, "query");
Argument.NotNull(joinTableSource, "joinTableSource");
var lastTableSource = query.From.InternalNodes.LastOrDefault();
if (lastTableSource == null)
{
throw new InvalidOperationException("Query's table source list is empty.");
}
var newTableSource = new JoinedTableSource(lastTableSource, joinTableSource, on, joinType);
return(new Query(query.Select, query.From.ReplaceLast(newTableSource), query.Where));
}
/// <summary>
/// Adds a predicate to the stub
/// </summary>
/// <param name="predicate">The predicate object designating what the stub will match on</param>
/// <returns>The stub that the predicate was added to</returns>
public HttpStub On(PredicateBase predicate)
{
Predicates.Add(predicate);
return(this);
}
public IPredicateConjuctionState And(PredicateBase predicate)
{
Argument.NotNull(predicate, "predicate");
return(PredicateConjuctionState(predicate));
}
protected PredicateState(PredicateBase predicate)
{
Predicate = Argument.NotNull(predicate, "predicate");
}
public AndState(PredicateBase predicate, bool negate)
: base(predicate)
{
_negate = negate;
}
public static PredicateBase Not(PredicateBase predicate)
{
Argument.NotNull(predicate, "predicate");
return(new NotPredicate(predicate));
}
public IPredicateDisjunctionState Or(PredicateBase predicate)
{
Argument.NotNull(predicate, "predicate");
return(PredicateDisjunctionState(predicate));
}
internal PredicateJunction(PredicateBase first, PredicateBase second)
{
Argument.NotNull(first, "first");
Argument.NotNull(second, "second");
InternalPredicates = ImmutableList <PredicateBase> .Empty.Add(first).Add(second);
}
public OrExpressionState(PredicateBase predicate, string expression)
: this(predicate, expression, false)
{
}
public OrExpressionState(PredicateBase predicate, string expression, bool negate)
: base(predicate, expression)
{
_negate = negate;
}
internal PredicateDisjunction(PredicateBase first, PredicateBase second)
: base(first, second)
{
}
public static PredicateDisjunction Or(PredicateBase left, PredicateBase right)
{
Argument.NotNull(left, "left");
Argument.NotNull(right, "right");
return(new PredicateDisjunction(left, right));
}
protected PredicateExpressionStateBase(PredicateBase predicate, string expression)
: base(predicate)
{
Expression = Argument.NotWhiteSpace(expression, "expression");
}
public static PredicateConjuction And(PredicateBase left, PredicateBase right)
{
Argument.NotNull(left, "left");
Argument.NotNull(right, "right");
return(new PredicateConjuction(left, right));
}
public ParameterMetadata(
PredicateBase <TArg> predicate)
{
Predicate = predicate;
}
public AndState(PredicateBase predicate)
: this(predicate, false)
{
}
public SinglePredicateState(PredicateBase predicate)
: base(predicate)
{
}
