public void Date_FracSecond_offset(string dateStr, DateTimeKind expectedOffsetKind,
int expectedOffsetValue, string expectedStr)
{
var timestamp = Timestamp.Parse(dateStr);
var expected = Timestamp.Parse(expectedStr);
using (var memStream = new MemoryStream())
{
var binWriter = IonBinaryWriterBuilder.Build(memStream);
binWriter.WriteTimestamp(timestamp);
binWriter.Finish();
var bytes = memStream.ToArray();
var datagram = IonLoader.Default.Load(bytes);
foreach (var ionValue in datagram)
{
Assert.IsTrue(ionValue is IonTimestamp);
var ionTimestamp = ionValue.TimestampValue;
Assert.AreEqual(expected.FractionalSecond, ionTimestamp.FractionalSecond);
Assert.AreEqual(expectedOffsetValue, ionTimestamp.LocalOffset);
Assert.AreEqual(expected.TimestampPrecision, ionTimestamp.TimestampPrecision);
Assert.AreEqual(expectedOffsetKind, ionTimestamp.DateTimeValue.Kind);
Assert.IsTrue(expected.Equals(ionTimestamp));
}
}
}
private byte[] GetBytes(IonType type, dynamic value, bool isNull)
{
if (isNull)
{
byte typeCode = (byte)type;
return(new byte[] { (byte)(typeCode << 4 | 0x0F) });
}
else if (type == IonType.Float && value == 0 && BitConverter.DoubleToInt64Bits(value) >= 0)
{
// value is 0.0, not -0.0
return(new byte[] { 0x40 });
}
else
{
using (MemoryStream stream = new MemoryStream())
{
using (IIonWriter writer = IonBinaryWriterBuilder.Build(stream, forceFloat64: true))
{
Serializers(type, value, writer);
writer.Finish();
}
return(stream.ToArray().Skip(4).ToArray());
}
}
}
public void Float_zeros()
{
var file = DirStructure.IonTestFile("good/float_zeros.ion");
var reader = ReaderFromFile(file, InputStyle.FileStream);
while (reader.MoveNext() != IonType.None)
{
Assert.AreEqual(IonType.Float, reader.CurrentType);
Assert.AreEqual(0d, reader.DoubleValue());
using (var memoryStream = new MemoryStream())
{
using (var writer = IonBinaryWriterBuilder.Build(memoryStream, forceFloat64: true))
{
writer.WriteFloat(reader.DoubleValue());
writer.Finish();
}
// Confirm the reader's and writer's byte presentations are the same
var readerByte = BitConverter.GetBytes(reader.DoubleValue());
Array.Reverse(readerByte);
// Get byte reprsentation of value from the stream
var writerByte = memoryStream.ToArray().Skip(5).ToArray();
Assert.IsTrue(Enumerable.SequenceEqual(writerByte, readerByte));
}
}
}
public void ContainerTypesInWriter(string value, IonType expectedType)
{
var reader = IonReaderBuilder.Build(value);
reader.MoveNext();
MemoryStream memoryStream = new MemoryStream();
var writer = IonBinaryWriterBuilder.Build(memoryStream);
writer.StepIn(IonType.Struct);
writer.SetFieldName("fieldName");
writer.WriteValue(reader);
writer.StepOut();
writer.Finish();
memoryStream.Flush();
var bytes = memoryStream.ToArray();
reader = IonReaderBuilder.Build(bytes);
reader.MoveNext();
reader.StepIn();
var actualType = reader.MoveNext();
Assert.AreEqual(expectedType, actualType);
}
internal override IIonReader GetIonReader(IIonValue ionValue)
{
MemoryStream ms = new MemoryStream();
IIonWriter writer = IonBinaryWriterBuilder.Build(ms);
ionValue.WriteTo(writer);
writer.Flush();
return(IonReaderBuilder.Build(ms.ToArray()));
}
public void WriteSymbolWithSymbolTableOutOfRange()
{
var datagram = SymTabUtils.DatagramWithOutOfRangeSymbolsInSymbolTable();
var memStream = new MemoryStream();
var binaryWriter = IonBinaryWriterBuilder.Build(memStream);
// Should throw exception as sid 12 in datagram exceeds the max ID of the symbol table currently in scope
datagram.WriteTo(binaryWriter);
binaryWriter.Finish();
}
/// <summary>
/// Send an asynchronous execute request with parameters to QLDB.
/// </summary>
///
/// <param name="txnId">The unique ID of the transaction to execute.</param>
/// <param name="statement">The PartiQL statement to execute.</param>
/// <param name="parameters">The parameters to use with the PartiQL statement for execution.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>
/// The result of the execution, which contains a <see cref="Page"/> representing the first data chunk.
/// </returns>
internal virtual async Task <ExecuteStatementResult> ExecuteStatementAsync(
string txnId, string statement, List <IIonValue> parameters, CancellationToken cancellationToken)
{
List <ValueHolder> valueHolders = null;
try
{
valueHolders = parameters.ConvertAll(ionValue =>
{
MemoryStream stream = new MemoryStream();
using (var writer = IonBinaryWriterBuilder.Build(stream))
{
ionValue.WriteTo(writer);
writer.Finish();
}
var valueHolder = new ValueHolder
{
IonBinary = stream,
};
return(valueHolder);
});
var executeStatementRequest = new ExecuteStatementRequest
{
TransactionId = txnId,
Statement = statement,
Parameters = valueHolders,
};
var request = new SendCommandRequest
{
ExecuteStatement = executeStatementRequest,
};
var response = await this.SendCommand(request, cancellationToken);
return(response.ExecuteStatement);
}
catch (IOException e)
{
throw new QldbDriverException(ExceptionMessages.FailedToSerializeParameter + e.Message, e);
}
finally
{
if (valueHolders != null)
{
valueHolders.ForEach(valueHolder =>
{
valueHolder.IonBinary.Dispose();
});
}
}
}
/// <inheritdoc/>
public IIonWriter Create(IonSerializationOptions options, Stream stream)
{
return(options.Format switch
{
BINARY => IonBinaryWriterBuilder.Build(stream),
TEXT => IonTextWriterBuilder.Build(new StreamWriter(stream)),
PRETTY_TEXT => IonTextWriterBuilder.Build(
new StreamWriter(stream),
new IonTextOptions {
PrettyPrint = true
}),
_ => throw new InvalidOperationException($"Format {options.Format} not supported"),
});
public void TestUnresolvedSid()
{
// unresolved SIDs (such as SID 10 here) should result in an exception
SymbolToken symbolUnresolvedSid = new SymbolToken(null, 10);
using (MemoryStream memoryStream = new MemoryStream())
{
IIonHashWriter writer = IonHashWriterBuilder
.Standard()
.WithHasherProvider(new IdentityIonHasherProvider())
.WithWriter(IonBinaryWriterBuilder.Build(memoryStream))
.Build();
Assert.ThrowsException <UnknownSymbolException>(() => writer.WriteSymbolToken(symbolUnresolvedSid));
}
}
public void Date_FragSecond(string dateStr)
{
var ts = Timestamp.Parse(dateStr);
using (var memStream = new MemoryStream())
{
var binWriter = IonBinaryWriterBuilder.Build(memStream);
binWriter.WriteTimestamp(ts);
binWriter.Finish();
var bytes = memStream.ToArray();
var dg = IonLoader.Default.Load(bytes);
Assert.IsTrue(dg[0] is IonTimestamp);
var ionTimestamp = (IonTimestamp)dg[0];
Assert.AreEqual(0.123 * TimeSpan.TicksPerSecond, ionTimestamp.Value.DateTimeValue.Ticks % TimeSpan.TicksPerSecond);
}
}
private static void RoundTrip_AssertBinary(IIonValue datagram, ISymbolTable readerTable)
{
using (var ms = new MemoryStream())
{
using (var writer = IonBinaryWriterBuilder.Build(ms, readerTable.GetImportedTables()))
{
datagram.WriteTo(writer);
writer.Finish();
var bin = ms.ToArray();
var catalog = Symbols.GetReaderCatalog(readerTable);
var datagram2 = IonLoader.WithReaderOptions(new ReaderOptions {
Catalog = catalog, Format = ReaderFormat.Binary
}).Load(bin);
AssertDatagramEquivalent(datagram, datagram2);
}
}
}
/// <summary>
/// Send an execute request with parameters to QLDB.
/// </summary>
///
/// <param name="txnId">The unique ID of the transaction to execute.</param>
/// <param name="statement">The PartiQL statement to execute.</param>
/// <param name="parameters">The parameters to use with the PartiQL statement for execution.</param>
///
/// <returns>The result of the execution, which contains a <see cref="Page"/> representing the first data chunk.</returns>
internal virtual ExecuteStatementResult ExecuteStatement(string txnId, string statement, List <IIonValue> parameters)
{
List <ValueHolder> valueHolders = null;
try
{
valueHolders = parameters.ConvertAll(ionValue =>
{
MemoryStream stream = new MemoryStream();
using (var writer = IonBinaryWriterBuilder.Build(stream))
{
ionValue.WriteTo(writer);
writer.Finish();
}
var valueHolder = new ValueHolder
{
IonBinary = stream,
};
return(valueHolder);
});
var executeStatementRequest = new ExecuteStatementRequest
{
TransactionId = txnId,
Statement = statement,
Parameters = valueHolders,
};
var request = new SendCommandRequest
{
ExecuteStatement = executeStatementRequest,
};
var response = this.SendCommand(request);
return(response.ExecuteStatement);
}
finally
{
if (valueHolders != null)
{
valueHolders.ForEach(valueHolder =>
{
valueHolder.IonBinary.Dispose();
});
}
}
}
public static ValueHolder CreateValueHolder(IIonValue ionValue)
{
MemoryStream stream = new MemoryStream();
using (var writer = IonBinaryWriterBuilder.Build(stream))
{
ionValue.WriteTo(writer);
writer.Finish();
}
var valueHolder = new ValueHolder
{
IonBinary = new MemoryStream(stream.GetWrittenBuffer())
};
return(valueHolder);
}
public void RespectBinarySerializationFormat()
{
var serializer = new IonSerializer(new IonSerializationOptions {
Format = IonSerializationFormat.BINARY
});
MemoryStream testStream = (MemoryStream)serializer.Serialize(TestObjects.John);
IIonValue ionValue = IonLoader.Default.Load(TestObjects.JohnIonText).GetElementAt(0);
MemoryStream expectedStream = new MemoryStream();
using (var writer = IonBinaryWriterBuilder.Build(expectedStream))
{
ionValue.WriteTo(writer);
writer.Finish();
}
Assert.IsTrue(expectedStream.ToArray().SequenceEqual(testStream.ToArray()));
}
public void Blob_PartialRead(int size, int step)
{
var blob = new byte[size];
for (var i = 0; i < size; i++)
{
blob[i] = (byte)i;
}
var memStream = new MemoryStream();
using (var writer = IonBinaryWriterBuilder.Build(memStream))
{
writer.WriteBlob(blob);
writer.Finish();
}
var output = memStream.ToArray();
var reader = IonReaderBuilder.Build(new MemoryStream(output));
ReaderTestCommon.Blob_PartialRead(size, step, reader);
}
public void WriteValuesWithAnnotation()
{
var ionValues = new List <IIonValue>();
var valueFactory = new ValueFactory();
ionValues.Add(valueFactory.NewBool(true));
ionValues.Add(valueFactory.NewString("string"));
ionValues.Add(valueFactory.NewFloat(22.22f));
ionValues.Add(valueFactory.NewDecimal(3.4m));
ionValues.Add(valueFactory.NewInt(3));
ionValues.Add(valueFactory.NewNull());
ionValues.Add(valueFactory.NewSymbol("symbol"));
ionValues.Add(valueFactory.NewTimestamp(new Timestamp(DateTime.Now)));
var arrayOfbytes = Enumerable.Repeat <byte>(1, 10).ToArray();
ReadOnlySpan <byte> bytes = new ReadOnlySpan <byte>(arrayOfbytes);
ionValues.Add(valueFactory.NewClob(bytes));
ionValues.Add(valueFactory.NewBlob(bytes));
foreach (var ionValue in ionValues)
{
ionValue.AddTypeAnnotation("annotation");
}
var ms = new MemoryStream();
var writer = IonBinaryWriterBuilder.Build(ms);
using (writer)
{
foreach (var ionValue in ionValues)
{
ionValue.WriteTo(writer);
}
writer.Finish();
}
var reader = new UserBinaryReader(new MemoryStream(ms.GetWrittenBuffer()));
while (reader.MoveNext() != IonType.None)
{
var annotation = reader.GetTypeAnnotations();
Assert.AreEqual("annotation", annotation[0]);
}
}
private byte[] ExerciseWriter(IIonReader reader, bool useHashWriter, Action <IIonReader, IIonWriter> lambda)
{
using (MemoryStream memoryStream = new MemoryStream())
{
IIonWriter writer = IonBinaryWriterBuilder.Build(memoryStream);
if (useHashWriter)
{
writer = IonHashWriterBuilder
.Standard()
.WithHasherProvider(new IdentityIonHasherProvider())
.WithWriter(writer)
.Build();
}
lambda(reader, writer);
writer.Finish();
return(memoryStream.ToArray());
}
}
private void AssertNoFieldnameInCurrentHash(string value, byte[] expectedBytes)
{
var reader = IonReaderBuilder.Build(value);
reader.MoveNext();
MemoryStream memoryStream = new MemoryStream();
var writer = IonBinaryWriterBuilder.Build(memoryStream);
writer.StepIn(IonType.Struct);
IIonHashWriter ihw = IonHashWriterBuilder
.Standard()
.WithHasherProvider(new IdentityIonHasherProvider())
.WithWriter(writer)
.Build();
ihw.SetFieldName("field_name");
ihw.WriteValue(reader);
byte[] actual = ihw.Digest();
TestUtil.AssertEquals(expectedBytes, actual, "Digest arrays mismatch");
writer.StepOut();
ihw.Finish();
writer.Finish();
memoryStream.Flush();
byte[] bytes = memoryStream.ToArray();
memoryStream.Close();
reader = IonReaderBuilder.Build(bytes);
reader.MoveNext();
reader.StepIn();
IIonHashReader ihr = IonHashReaderBuilder
.Standard()
.WithHasherProvider(new IdentityIonHasherProvider())
.WithReader(reader)
.Build();
ihr.MoveNext(); //List
ihr.MoveNext(); //none
actual = ihr.Digest();
TestUtil.AssertEquals(expectedBytes, actual, "Digest arrays mismatch");
}
public IonSystemLite(IonTextWriterBuilder textWriterBuilder, PrivateIonBinaryWriterBuilder binaryWriterBuilder,
IonReaderBuilder readerBuilder)
{
_readerBuilder = readerBuilder;
var catalog = textWriterBuilder.Catalog;
//make sure we're on the same catalog here
Debug.Assert(catalog == binaryWriterBuilder.Catalog);
Debug.Assert(catalog == readerBuilder.Catalog);
Context = new ContainerlessContext(this);
Catalog = catalog;
_systemSymbolTable = binaryWriterBuilder.InitialSymbolTable;
Debug.Assert(_systemSymbolTable.IsSystem);
binaryWriterBuilder.SymtabValueFactory = this;
_textWriterBuilder = textWriterBuilder.Immutable();
_binaryWriterBuilder = binaryWriterBuilder.Immutable();
}
public void FieldNameAsymmetry()
{
var memoryStream = new MemoryStream();
var writer = IonBinaryWriterBuilder.Build(memoryStream);
IIonHashWriter ihw = IonHashWriterBuilder
.Standard()
.WithHasherProvider(new IdentityIonHasherProvider())
.WithWriter(writer)
.Build();
// A nested struct: {a:{b:1}}
writer.StepIn(IonType.Struct);
writer.SetFieldName("a");
ihw.StepIn(IonType.Struct);
ihw.SetFieldName("b");
ihw.WriteInt(1);
ihw.StepOut();
byte[] writeHash = ihw.Digest();
ihw.Flush();
writer.StepOut();
writer.Flush();
var loader = IonLoader.Default;
var ionValue = loader.Load(memoryStream.ToArray()) //Datagram
.GetElementAt(0) //first struct
.GetField("a"); //inner struct
IIonReader reader = IonReaderBuilder.Build(ionValue);
IIonHashReader ihr = IonHashReaderBuilder
.Standard()
.WithReader(reader)
.WithHasherProvider(new IdentityIonHasherProvider())
.Build();
ihr.MoveNext(); // struct
ihr.MoveNext(); // none
TestUtil.AssertEquals(writeHash, ihr.Digest(), "Digest arrays mismatch");
}
/// <summary>
/// Apply the same writing logic to binary and text writers and assert the accuracy
/// </summary>
protected void AssertReaderWriter(Action <IIonReader> assertReader, Action <IIonWriter> writerFunc)
{
//bin
using (var s = new MemoryStream())
{
var binWriter = IonBinaryWriterBuilder.Build(s);
writerFunc(binWriter);
s.Seek(0, SeekOrigin.Begin);
var binReader = IonReaderBuilder.Build(s);
assertReader(binReader);
}
//text
var sw = new StringWriter();
var textWriter = IonTextWriterBuilder.Build(sw);
writerFunc(textWriter);
var str = sw.ToString();
var textReader = IonReaderBuilder.Build(str);
assertReader(textReader);
}
/// <summary>
/// Send an asynchronous execute request with parameters to QLDB.
/// </summary>
///
/// <param name="txnId">The unique ID of the transaction to execute.</param>
/// <param name="statement">The PartiQL statement to execute.</param>
/// <param name="parameters">The parameters to use with the PartiQL statement for execution.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>
/// The result of the execution, which contains a <see cref="Page"/> representing the first data chunk.
/// </returns>
internal virtual async Task <ExecuteStatementResult> ExecuteStatementAsync(
string txnId, string statement, List <IIonValue> parameters, CancellationToken cancellationToken)
{
List <ValueHolder> valueHolders = null;
valueHolders = parameters.ConvertAll(ionValue =>
{
MemoryStream stream = new MemoryStream();
using (var writer = IonBinaryWriterBuilder.Build(stream))
{
ionValue.WriteTo(writer);
writer.Finish();
}
var valueHolder = new ValueHolder
{
IonBinary = stream,
};
return(valueHolder);
});
return(await this.ExecuteStatementAsync(txnId, statement, valueHolders.ToArray(), cancellationToken));
}
public void MultipleClobs()
{
IIonReader binReader;
using (var ms = new MemoryStream())
{
ReadOnlySpan <byte> firstClob = new ReadOnlySpan <byte>(new byte[] { 97, 98, 99, 32, 100, 101 });
ReadOnlySpan <byte> secondClob = new ReadOnlySpan <byte>(new byte[] { 65, 32, 66, 32, 67 });
ReadOnlySpan <byte> thirdClob = new ReadOnlySpan <byte>(new byte[] { 50, 51, 32, 54, 55 });
var binWriter = IonBinaryWriterBuilder.Build(ms);
binWriter.WriteClob(firstClob); // {{ "abc de" }}
binWriter.WriteClob(secondClob); // {{ "A B\tC" }}
binWriter.WriteClob(thirdClob); // {{ "23 56" }}
binWriter.Finish();
ms.Seek(0, SeekOrigin.Begin);
binReader = IonReaderBuilder.Build(ms);
var type = binReader.MoveNext();
var buffer = binReader.NewByteArray();
Assert.AreEqual(IonType.Clob, type);
Assert.AreEqual("abc de", Encoding.ASCII.GetString(buffer));
type = binReader.MoveNext();
buffer = binReader.NewByteArray();
Assert.AreEqual(IonType.Clob, type);
Assert.AreEqual("A B C", Encoding.ASCII.GetString(buffer));
type = binReader.MoveNext();
buffer = binReader.NewByteArray();
Assert.AreEqual(IonType.Clob, type);
Assert.AreEqual("23 67", Encoding.ASCII.GetString(buffer));
}
}
public void MultipleBlobs()
{
IIonReader binReader;
using (var ms = new MemoryStream())
{
ReadOnlySpan <byte> firstBlob = new ReadOnlySpan <byte>(new byte[] { 68, 65, 72, 72, 75 });
ReadOnlySpan <byte> secondBlob = new ReadOnlySpan <byte>(new byte[] { 68, 69 });
ReadOnlySpan <byte> thirdBlob = new ReadOnlySpan <byte>(new byte[] { 68, 65, 85 });
var binWriter = IonBinaryWriterBuilder.Build(ms);
binWriter.WriteBlob(firstBlob);
binWriter.WriteBlob(secondBlob);
binWriter.WriteBlob(thirdBlob);
binWriter.Finish();
ms.Seek(0, SeekOrigin.Begin);
binReader = IonReaderBuilder.Build(ms);
var type = binReader.MoveNext();
var buffer = binReader.NewByteArray();
Assert.AreEqual(IonType.Blob, type);
Assert.AreEqual("68 65 72 72 75 ", BytesToHex(buffer));
type = binReader.MoveNext();
buffer = binReader.NewByteArray();
Assert.AreEqual(IonType.Blob, type);
Assert.AreEqual("68 69 ", BytesToHex(buffer));
type = binReader.MoveNext();
buffer = binReader.NewByteArray();
Assert.AreEqual(IonType.Blob, type);
Assert.AreEqual("68 65 85 ", BytesToHex(buffer));
}
}
public PrivateIonBinaryWriterBuilder(IonBinaryWriterBuilder that) : base(that)
{
}
