protected override Expression VisitChildren(ExpressionVisitor visitor) { var outerTable = visitor.VisitAndConvert(OuterTable, nameof(VisitChildren)); var innerTable = visitor.VisitAndConvert(InnerTable, nameof(VisitChildren)); var predicate = visitor.Visit(Predicate); if (outerTable != OuterTable || innerTable != InnerTable || predicate != Predicate) { if (outerTable != OuterTable) { var oldTables = OuterTable.Flatten().ToArray(); var newTables = outerTable.Flatten().ToArray(); var updater = new TableUpdatingExpressionVisitor(oldTables, newTables); innerTable = updater.VisitAndConvert(innerTable, nameof(VisitChildren)); predicate = updater.Visit(predicate); } if (innerTable != InnerTable) { var oldTables = InnerTable.Flatten().ToArray(); var newTables = innerTable.Flatten().ToArray(); var updater = new TableUpdatingExpressionVisitor(oldTables, newTables); predicate = updater.Visit(predicate); } return(Recreate(outerTable, innerTable, predicate, Type)); } return(this); }
public void Struct_Serialize_InnerNull() { OuterTable outer = new OuterTable { Struct = new OuterStruct(), }; outer.Struct.InnerB = null; byte[] data = new byte[1024]; data.AsSpan().Fill(123); int length = FlatBufferSerializer.Default.Serialize(outer, data); var parsed = FlatBufferSerializer.Default.Parse <OuterTable>(data); // Null overwrites buffer to 0 on serialize. Assert.Equal(0, parsed.Struct.InnerB.Item); Span <byte> expected = new byte[] { 4, 0, 0, 0, 220, 255, 255, 255, 1, 0, 0, 0, 123, 123, 123, 123, // padding bytes are not overwritten. 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // null InnerB struct is overwritten with 0. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 36, 0, 4, 0, }; Assert.True(expected.SequenceEqual(data.AsSpan().Slice(0, length))); }
/// <summary> /// <para type="description">Process record.</para> /// </summary> protected override void ProcessRecord() { Validators.ValidateTableName(OuterTable, "Outer table"); Validators.ValidateTableName(InnerTable, "Inner table"); if (JoinedTableName == null) { JoinedTableName = $"{OuterTable.TableName}_{InnerTable.TableName}"; } Result = new DataTable { TableName = JoinedTableName }; InsertColumns(); var joinResult = OuterTable.AsEnumerable().Join( InnerTable.AsEnumerable(), OuterKeySelector.Execute, InnerKeySelector.Execute, ResultSelector.Execute, new PSScriptResultComparer() ); foreach (var rowItemArray in joinResult) { var resultRow = Result.NewRow(); resultRow.ItemArray = rowItemArray.ToArray(); Result.Rows.Add(resultRow); } }
public override IEnumerable <AliasedTableExpression> Flatten() { foreach (var table in OuterTable.Flatten()) { yield return(table); } yield return(InnerTable); }
public void Struct_Serialize_InnerNull_2() { OuterTable outer = new OuterTable { Struct = new OuterStruct(), }; outer.Struct.InnerA = null; byte[] data = new byte[1024]; data.AsSpan().Fill(123); FlatBufferSerializer.Default.Serialize(outer, data); var parsed = FlatBufferSerializer.Default.Parse <OuterTable>(data); // Null overwrites buffer to 0 on serialize. Assert.Equal(0, parsed.Struct.InnerA.Item); }
public override ITable Evaluate(IRequest context) { // Evaluate the child branch, var result = Child.Evaluate(context); // Get the table of the complete mark name, var completeLeft = context.Query.GetCachedTable(MarkerName); // The rows in 'complete_left' that are outside (not in) the rows in the // left result. var outside = completeLeft.OuterJoin(result); // Create an OuterTable var outerTable = OuterTable.Create(result); outerTable.MergeIn(outside); // Return the outer table return(outerTable); }
public override ITable Evaluate(IQueryContext context) { // Evaluate the child branch, ITable result = Child.Evaluate(context); // Get the table of the complete mark name, ITable completeLeft = context.GetMarkedTable(completeMarkName); // The rows in 'complete_left' that are outside (not in) the rows in the // left result. ITable outside = completeLeft.Outer(result); // Create an OuterTable OuterTable outerTable = new OuterTable((Table)result); outerTable.MergeIn((Table)outside); // Return the outer table return(outerTable); }
public void ConstructorSerializationTests() { OuterTable outer = new OuterTable { Struct = new OuterStruct(), }; byte[] data = new byte[1024]; FlatBufferSerializer.Default.Serialize(outer, data); var parsed = FlatBufferSerializer.Default.Parse <OuterTable>(data); Assert.NotNull(parsed.Context); Assert.Null(outer.Context); Assert.Null(parsed.Struct.InnerA.Context); Assert.Null(outer.Struct.InnerA.Context); Assert.NotNull(parsed.Struct.InnerB.Context); Assert.Null(outer.Struct.InnerB.Context); }
protected override Expression VisitChildren(ExpressionVisitor visitor) { var outerTable = visitor.VisitAndConvert(OuterTable, nameof(VisitChildren)); var innerTable = visitor.VisitAndConvert(InnerTable, nameof(VisitChildren)); if (outerTable != OuterTable || innerTable != InnerTable) { if (outerTable != OuterTable) { var oldTables = OuterTable.Flatten().ToArray(); var newTables = outerTable.Flatten().ToArray(); var updater = new TableUpdatingExpressionVisitor(oldTables, newTables); innerTable = updater.VisitAndConvert(innerTable, nameof(VisitChildren)); } return(new OuterApplyTableExpression(outerTable, innerTable, Type)); } return(this); }
public void CopyConstructorsTest() { string schema = $@" namespace CopyConstructorTest; union Union {{ OuterTable, InnerTable, OuterStruct, InnerStruct }} // Optionally add more tables. table OuterTable ({MetadataKeys.SerializerKind}: ""Greedy"") {{ A:string; B:byte; C:ubyte; D:int16; E:uint16; F:int32; G:uint32; H:int64; I:uint64; IntVector_List:[int] ({MetadataKeys.VectorKind}:""IList""); IntVector_RoList:[int] ({MetadataKeys.VectorKind}:""IReadOnlyList""); IntVector_Array:[int] ({MetadataKeys.VectorKind}:""Array""); TableVector_List:[InnerTable] ({MetadataKeys.VectorKind}:""IList""); TableVector_RoList:[InnerTable] ({MetadataKeys.VectorKind}:""IReadOnlyList""); TableVector_Indexed:[InnerTable] ({MetadataKeys.VectorKind}:""IIndexedVector""); TableVector_Array:[InnerTable] ({MetadataKeys.VectorKindLegacy}:""Array""); ByteVector:[ubyte] ({MetadataKeys.VectorKind}:""Memory""); ByteVector_RO:[ubyte] ({MetadataKeys.VectorKind}:""ReadOnlyMemory""); Union:Union; }} struct OuterStruct {{ Value:int; InnerStruct:InnerStruct; }} struct InnerStruct {{ LongValue:int64; }} table InnerTable {{ Name:string ({MetadataKeys.Key}); OuterStruct:OuterStruct; }} "; OuterTable original = new OuterTable { A = "string", B = 1, C = 2, D = 3, E = 4, F = 5, G = 6, H = 7, I = 8, ByteVector = new byte[] { 1, 2, 3, }.AsMemory(), ByteVector_RO = new byte[] { 4, 5, 6, }.AsMemory(), IntVector_Array = new[] { 7, 8, 9, }, IntVector_List = new[] { 10, 11, 12, }.ToList(), IntVector_RoList = new[] { 13, 14, 15 }.ToList(), TableVector_Array = CreateInner("Rocket", "Molly", "Jingle"), TableVector_Indexed = new IndexedVector <string, InnerTable>(CreateInner("Pudge", "Sunshine", "Gypsy"), false), TableVector_List = CreateInner("Finnegan", "Daisy"), TableVector_RoList = CreateInner("Gordita", "Lunchbox"), Union = new FlatBufferUnion <OuterTable, InnerTable, OuterStruct, InnerStruct>(new OuterStruct()) }; byte[] data = new byte[FlatBufferSerializer.Default.GetMaxSize(original)]; int bytesWritten = FlatBufferSerializer.Default.Serialize(original, data); Assembly asm = FlatSharpCompiler.CompileAndLoadAssembly(schema, new()); Type outerTableType = asm.GetType("CopyConstructorTest.OuterTable"); dynamic serializer = outerTableType.GetProperty("Serializer", BindingFlags.Public | BindingFlags.Static).GetValue(null); object parsedObj = serializer.Parse(new ArrayInputBuffer(data)); dynamic parsed = parsedObj; dynamic copied = Activator.CreateInstance(outerTableType, (object)parsed); //dynamic copied = new CopyConstructorTest.OuterTable((CopyConstructorTest.OuterTable)parsedObj); // Strings can be copied by reference since they are immutable. Assert.AreEqual(original.A, copied.A); Assert.AreEqual(original.A, parsed.A); Assert.AreEqual(original.B, copied.B); Assert.AreEqual(original.C, copied.C); Assert.AreEqual(original.D, copied.D); Assert.AreEqual(original.E, copied.E); Assert.AreEqual(original.F, copied.F); Assert.AreEqual(original.G, copied.G); Assert.AreEqual(original.H, copied.H); Assert.AreEqual(original.I, copied.I); Assert.AreEqual((byte)3, original.Union.Discriminator); Assert.AreEqual((byte)3, parsed.Union.Discriminator); Assert.AreEqual((byte)3, copied.Union.Discriminator); Assert.AreEqual("CopyConstructorTest.OuterStruct", copied.Union.Item3.GetType().FullName); Assert.AreNotEqual("CopyConstructorTest.OuterStruct", parsed.Union.Item3.GetType().FullName); Assert.AreNotSame(parsed.Union, copied.Union); Assert.AreNotSame(parsed.Union.Item3, copied.Union.Item3); Memory <byte>?mem = copied.ByteVector; Memory <byte>?pMem = parsed.ByteVector; Assert.IsTrue(original.ByteVector.Value.Span.SequenceEqual(mem.Value.Span)); Assert.IsFalse(mem.Value.Span.Overlaps(pMem.Value.Span)); ReadOnlyMemory <byte>?roMem = copied.ByteVector_RO; ReadOnlyMemory <byte>?pRoMem = parsed.ByteVector_RO; Assert.IsTrue(original.ByteVector_RO.Value.Span.SequenceEqual(roMem.Value.Span)); Assert.IsFalse(roMem.Value.Span.Overlaps(pRoMem.Value.Span)); // array of table { int count = original.TableVector_Array.Length; Assert.AreNotSame(parsed.TableVector_Array, copied.TableVector_Array); for (int i = 0; i < count; ++i) { var p = parsed.TableVector_Array[i]; var c = copied.TableVector_Array[i]; DeepCompareInnerTable(original.TableVector_Array[i], p, c); } } // list of table. { Assert.IsFalse(object.ReferenceEquals(parsed.TableVector_List, copied.TableVector_List)); IEnumerable <object> parsedEnum = AsObjectEnumerable(parsed.TableVector_List); IEnumerable <object> copiedEnum = AsObjectEnumerable(copied.TableVector_List); foreach (var((p, c), o) in parsedEnum.Zip(copiedEnum).Zip(original.TableVector_List)) { DeepCompareInnerTable(o, p, c); } } // read only list of table. { Assert.IsFalse(object.ReferenceEquals(parsed.TableVector_RoList, copied.TableVector_RoList)); IEnumerable <object> parsedEnum = AsObjectEnumerable(parsed.TableVector_RoList); IEnumerable <object> copiedEnum = AsObjectEnumerable(copied.TableVector_RoList); foreach (var((p, c), o) in parsedEnum.Zip(copiedEnum).Zip(original.TableVector_RoList)) { DeepCompareInnerTable(o, p, c); } } // indexed vector of table. { Assert.IsFalse(object.ReferenceEquals(parsed.TableVector_Indexed, copied.TableVector_Indexed)); foreach (var kvp in original.TableVector_Indexed) { string key = kvp.Key; InnerTable?value = kvp.Value; var parsedValue = parsed.TableVector_Indexed[key]; var copiedValue = copied.TableVector_Indexed[key]; Assert.IsNotNull(parsedValue); Assert.IsNotNull(copiedValue); DeepCompareInnerTable(value, parsedValue, copiedValue); } } }
public override ITable Evaluate(IQueryContext context) { // Evaluate the child branch, ITable result = Child.Evaluate(context); // Get the table of the complete mark name, ITable completeLeft = context.GetMarkedTable(completeMarkName); // The rows in 'complete_left' that are outside (not in) the rows in the // left result. ITable outside = completeLeft.Outer(result); // Create an OuterTable OuterTable outerTable = new OuterTable((Table)result); outerTable.MergeIn((Table)outside); // Return the outer table return outerTable; }