private static bool ProcessSetOpOverEmptySet(
RuleProcessingContext context,
System.Data.Entity.Core.Query.InternalTrees.Node setOpNode,
out System.Data.Entity.Core.Query.InternalTrees.Node newNode)
{
bool flag1 = context.Command.GetExtendedNodeInfo(setOpNode.Child0).MaxRows == RowCount.Zero;
bool flag2 = context.Command.GetExtendedNodeInfo(setOpNode.Child1).MaxRows == RowCount.Zero;
if (!flag1 && !flag2)
{
newNode = setOpNode;
return(false);
}
SetOp op = (SetOp)setOpNode.Op;
int index = !flag2 && op.OpType == OpType.UnionAll || !flag1 && op.OpType == OpType.Intersect ? 1 : 0;
newNode = setOpNode.Children[index];
TransformationRulesContext transformationRulesContext = (TransformationRulesContext)context;
foreach (KeyValuePair <Var, Var> keyValuePair in (Dictionary <Var, Var>)op.VarMap[index])
{
transformationRulesContext.AddVarMapping(keyValuePair.Key, keyValuePair.Value);
}
return(true);
}
protected override void VisitSetOp(SetOp op, System.Data.Entity.Core.Query.InternalTrees.Node n)
{
foreach (Dictionary <Var, Var> var in op.VarMap)
{
foreach (KeyValuePair <Var, Var> keyValuePair in var)
{
if (TypeUtils.IsStructuredType(keyValuePair.Key.Type))
{
PropertyRefList propertyRefList = this.GetPropertyRefList(keyValuePair.Key);
PropertyRefList propertyRefs;
if (op.OpType == OpType.Intersect || op.OpType == OpType.Except)
{
propertyRefs = PropertyRefList.All;
this.AddPropertyRefs(keyValuePair.Key, propertyRefs);
}
else
{
propertyRefs = propertyRefList.Clone();
}
this.AddPropertyRefs(keyValuePair.Value, propertyRefs);
}
}
}
this.VisitChildren(n);
}
/// <summary>
/// SetOp handling
/// UnionAllOp handling
/// IntersectOp handling
/// ExceptOp handling
///
/// Visitor for a SetOp. Pushes desired properties to the corresponding
/// Vars of the input
/// </summary>
/// <param name="op">the setop</param>
/// <param name="n"></param>
protected override void VisitSetOp(SetOp op, Node n)
{
foreach (VarMap varMap in op.VarMap)
{
foreach (KeyValuePair <Var, Var> kv in varMap)
{
if (TypeUtils.IsStructuredType(kv.Key.Type))
{
// Get the set of expected properties for the unionVar, and
// push it down to the inputvars
// For Intersect and ExceptOps, we need all properties
// from the input
// We call GetPropertyRefList() always to initialize
// the map, even though we may not use it
//
PropertyRefList myProps = GetPropertyRefList(kv.Key);
if (op.OpType == OpType.Intersect || op.OpType == OpType.Except)
{
myProps = PropertyRefList.All;
// We "want" all properties even on the output of the setop
AddPropertyRefs(kv.Key, myProps);
}
else
{
myProps = myProps.Clone();
}
AddPropertyRefs(kv.Value, myProps);
}
}
}
VisitChildren(n);
}
/// <summary>
/// Returns intersection of two sets.
/// </summary>
/// <remarks>Intersection contains elements present in both sets.</remarks>
public static Set Intersection(Set a, Set b)
{
a.CheckComparer(b);
Set result = new Set(a.Comparer);
SetOp.Inersection(a, b, a.Comparer, new Inserter(result));
return(result);
}
/// <summary>
/// Returns symmetric difference of two sets.
/// </summary>
/// <remarks>
/// Symmetric difference contains elements present in one of the sets, but not in both
/// </remarks>
public static Set SymmetricDifference(Set a, Set b)
{
a.CheckComparer(b);
Set result = new Set(a.Comparer);
SetOp.SymmetricDifference(a, b, a.Comparer, new Inserter(result));
return(result);
}
// <summary>
// Does the list of outputs of the given SetOp contain a var
// from the given VarVec defined by the SetOp's child with the given index
// </summary>
private static bool HasVarReferences(SetOp op, VarVec vars, int index)
{
foreach (var var in op.VarMap[index].Values)
{
if (vars.IsSet(var))
{
return(true);
}
}
return(false);
}
public SetOpNode(RelNode left, SetOp setop, RelNode right)
{
_setop = setop;
_left = left;
_right = right;
Heading = left.Heading;
_othermap = Heading.CreateMap(right.Heading);
if (_othermap.Length != Heading.Degree ||
_othermap.Any(x => x < 0))
{
throw Error.Fatal(setop.ToString(), "headings do not match");
}
}
// <summary>
// The var that needs to be remapped may be produced by a set op,
// in which case the varmaps need to be updated too.
// </summary>
protected override void VisitSetOp(SetOp op, Node n)
{
base.VisitSetOp(op, n);
if (op.Outputs.IsSet(m_oldVar))
{
Var newVar = m_command.CreateSetOpVar(m_oldVar.Type);
op.Outputs.Clear(m_oldVar);
op.Outputs.Set(newVar);
RemapVarMapKey(op.VarMap[0], newVar);
RemapVarMapKey(op.VarMap[1], newVar);
AddMapping(m_oldVar, newVar);
}
}
protected override void VisitSetOp(SetOp op, System.Data.Entity.Core.Query.InternalTrees.Node n)
{
base.VisitSetOp(op, n);
if (!op.Outputs.IsSet(this.m_oldVar))
{
return;
}
Var setOpVar = (Var)this.m_command.CreateSetOpVar(this.m_oldVar.Type);
op.Outputs.Clear(this.m_oldVar);
op.Outputs.Set(setOpVar);
this.RemapVarMapKey(op.VarMap[0], setOpVar);
this.RemapVarMapKey(op.VarMap[1], setOpVar);
this.AddMapping(this.m_oldVar, setOpVar);
}
protected override System.Data.Entity.Core.Query.InternalTrees.Node VisitSetOp(
SetOp op,
System.Data.Entity.Core.Query.InternalTrees.Node n)
{
if (OpType.Intersect == op.OpType || OpType.Except == op.OpType)
{
this.AddReference((IEnumerable <Var>)op.Outputs);
}
this.PruneVarSet(op.Outputs);
foreach (VarMap var in op.VarMap)
{
this.PruneVarMap(var);
}
this.VisitChildren(n);
return(n);
}
public static List <HashSet <char> > GetGroups(SetOp op)
{
var inputfile = new List <string>(System.IO.File.ReadAllLines(@"./day06/input.txt"));
inputfile.Add("");
List <HashSet <char> > groups = new List <HashSet <char> >();
HashSet <char> group = null;
foreach (var line in inputfile)
{
if (string.IsNullOrEmpty(line))
{
if (group.Count > 0)
{
groups.Add(group);
}
group = null;
continue;
}
if (group == null)
{
group = new HashSet <char>(line);
}
else
{
switch (op)
{
case SetOp.Union:
group.UnionWith(new HashSet <char>(line));
break;
case SetOp.Intersect:
group.IntersectWith(new HashSet <char>(line));
break;
}
}
}
return(groups);
}
public void Should_Build_DtUpdateReq_Correctly()
{
var updateSetCommandBuilder = new UpdateSet.Builder(DefaultAdds, DefaultRemoves);
var q1 = new Quorum(1);
var q2 = new Quorum(2);
var q3 = new Quorum(3);
updateSetCommandBuilder
.WithBucketType(BucketType)
.WithBucket(Bucket)
.WithKey(Key)
.WithW(q3)
.WithPW(q1)
.WithDW(q2)
.WithReturnBody(true)
.WithIncludeContext(false)
.WithContext(Context)
.WithTimeout(TimeSpan.FromSeconds(20));
UpdateSet updateSetCommand = updateSetCommandBuilder.Build();
DtUpdateReq protobuf = (DtUpdateReq)updateSetCommand.ConstructPbRequest();
Assert.AreEqual(Encoding.UTF8.GetBytes(BucketType), protobuf.type);
Assert.AreEqual(Encoding.UTF8.GetBytes(Bucket), protobuf.bucket);
Assert.AreEqual(Encoding.UTF8.GetBytes(Key), protobuf.key);
Assert.AreEqual(q3, protobuf.w);
Assert.AreEqual(q1, protobuf.pw);
Assert.AreEqual(q2, protobuf.dw);
Assert.IsTrue(protobuf.return_body);
Assert.IsFalse(protobuf.include_context);
Assert.AreEqual(20000, protobuf.timeout);
SetOp setOpMsg = protobuf.op.set_op;
Assert.AreEqual(DefaultAdds, setOpMsg.adds);
Assert.AreEqual(DefaultRemoves, setOpMsg.removes);
}
/// <summary>
/// SetOps
///
/// Common handling for all SetOps. We first identify the "output" vars
/// that are referenced, and mark the corresponding "input" vars as referenced
/// We then remove all unreferenced output Vars from the "Outputs" varset
/// as well as from the Varmaps.
/// Finally, we visit the children
/// </summary>
/// <param name="op"></param>
/// <param name="n">current node</param>
/// <returns></returns>
protected override Node VisitSetOp(SetOp op, Node n)
{
// Prune the outputs varset, except for Intersect and Except, which require
// all their outputs to compare, so don't bother pruning them.
if (OpType.Intersect == op.OpType || OpType.Except == op.OpType)
{
AddReference(op.Outputs);
}
PruneVarSet(op.Outputs);
// Prune the varmaps. Identify which of the setOp vars have been
// referenced, and eliminate those entries that don't show up. Additionally
// mark all the other Vars as referenced
foreach (VarMap varMap in op.VarMap)
{
PruneVarMap(varMap);
}
// Now visit the children
VisitChildren(n);
return(n);
}
private static MapOp Populate(MapOperation mapOperation)
{
var mapOp = new MapOp();
if (mapOperation.HasRemoves)
{
foreach (var removeCounter in mapOperation.RemoveCounters)
{
RiakString counterName = removeCounter.Key;
var field = new MapField
{
name = counterName,
type = MapField.MapFieldType.COUNTER
};
mapOp.removes.Add(field);
}
foreach (var removeSet in mapOperation.RemoveSets)
{
RiakString setName = removeSet.Key;
var field = new MapField
{
name = setName,
type = MapField.MapFieldType.SET
};
mapOp.removes.Add(field);
}
foreach (var removeRegister in mapOperation.RemoveRegisters)
{
RiakString registerName = removeRegister.Key;
var field = new MapField
{
name = registerName,
type = MapField.MapFieldType.REGISTER
};
mapOp.removes.Add(field);
}
foreach (var removeFlag in mapOperation.RemoveFlags)
{
RiakString flagName = removeFlag.Key;
var field = new MapField
{
name = flagName,
type = MapField.MapFieldType.FLAG
};
mapOp.removes.Add(field);
}
foreach (var removeMap in mapOperation.RemoveMaps)
{
RiakString mapName = removeMap.Key;
var field = new MapField
{
name = mapName,
type = MapField.MapFieldType.MAP
};
mapOp.removes.Add(field);
}
}
foreach (var incrementCounter in mapOperation.IncrementCounters)
{
RiakString counterName = incrementCounter.Key;
long increment = incrementCounter.Value;
var field = new MapField
{
name = counterName,
type = MapField.MapFieldType.COUNTER
};
var counterOp = new CounterOp
{
increment = increment
};
var update = new MapUpdate
{
field = field,
counter_op = counterOp
};
mapOp.updates.Add(update);
}
foreach (var addToSet in mapOperation.AddToSets)
{
RiakString setName = addToSet.Key;
IList <RiakString> setAdds = addToSet.Value;
var field = new MapField
{
name = setName,
type = MapField.MapFieldType.SET
};
var setOp = new SetOp();
setOp.adds.AddRange(setAdds.Select(v => (byte[])v));
var update = new MapUpdate
{
field = field,
set_op = setOp
};
mapOp.updates.Add(update);
}
foreach (var removeFromSet in mapOperation.RemoveFromSets)
{
RiakString setName = removeFromSet.Key;
IList <RiakString> setRemoves = removeFromSet.Value;
var field = new MapField
{
name = setName,
type = MapField.MapFieldType.SET
};
var setOp = new SetOp();
setOp.removes.AddRange(setRemoves.Select(v => (byte[])v));
var update = new MapUpdate
{
field = field,
set_op = setOp
};
mapOp.updates.Add(update);
}
foreach (var registerToSet in mapOperation.RegistersToSet)
{
RiakString registerName = registerToSet.Key;
RiakString registerValue = registerToSet.Value;
var field = new MapField
{
name = registerName,
type = MapField.MapFieldType.REGISTER
};
var update = new MapUpdate
{
field = field,
register_op = registerValue
};
mapOp.updates.Add(update);
}
foreach (var flagToSet in mapOperation.FlagsToSet)
{
RiakString flagName = flagToSet.Key;
bool flagValue = flagToSet.Value;
var field = new MapField
{
name = flagName,
type = MapField.MapFieldType.FLAG
};
var update = new MapUpdate
{
field = field,
flag_op = flagValue ? MapUpdate.FlagOp.ENABLE : MapUpdate.FlagOp.DISABLE
};
mapOp.updates.Add(update);
}
foreach (var map in mapOperation.Maps)
{
RiakString mapName = map.Key;
MapOperation innerMapOperation = map.Value;
var field = new MapField
{
name = mapName,
type = MapField.MapFieldType.MAP
};
MapOp innerMapOp = Populate(innerMapOperation);
var update = new MapUpdate
{
field = field,
map_op = innerMapOp
};
mapOp.updates.Add(update);
}
return(mapOp);
}
protected override void VisitSetOp(SetOp op, System.Data.Entity.Core.Query.InternalTrees.Node n)
{
this.VisitRelOpDefault((RelOp)op, n);
this.Map(op.VarMap[0]);
this.Map(op.VarMap[1]);
}
// <summary>
// The number of outputs is same as for any of the inputs
// </summary>
protected override int VisitSetOp(SetOp op, Node n)
{
return(op.Outputs.Count);
}
protected override void VisitSetOp(SetOp op, Node n)
{
VisitRelOpDefault(op, n);
Map(op.VarMap[0]);
Map(op.VarMap[1]);
}
protected override int VisitSetOp(SetOp op, System.Data.Entity.Core.Query.InternalTrees.Node n)
{
return(op.Outputs.Count);
}