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;
}
