private bool CheckIfPersonAlreadyExists(TransactionExecutor transactionExecutor, string govId)
{
IIonValue ionGovId = this.valueFactory.NewString(govId);
IEnumerable <IIonValue> selectResult = transactionExecutor.Execute("SELECT GovId FROM Person AS p WHERE p.GovId = ?", ionGovId);
return(selectResult.Any(x => x.GetField("GovId").StringValue == govId));
}
public override bool IsEquivalentTo(IIonValue other)
{
if (!base.IsEquivalentTo(other))
{
return(false);
}
var otherDec = (IonDecimal)other;
if (this.NullFlagOn())
{
return(otherDec.IsNull);
}
if (other.IsNull)
{
return(false);
}
if (this.BigDecimalValue.IsNegativeZero ^ otherDec.BigDecimalValue.IsNegativeZero)
{
return(false);
}
if (otherDec.BigDecimalValue.Scale > 0 || this.BigDecimalValue.Scale > 0)
{
// precision matters, make sure that this has the same precision
return(this.BigDecimalValue.Scale == otherDec.BigDecimalValue.Scale &&
this.BigDecimalValue.IntVal == otherDec.BigDecimalValue.IntVal);
}
// this only compares values
return(this.BigDecimalValue == otherDec.BigDecimalValue);
}
public MultisetField(SymbolToken name, IIonValue value)
{
Debug.Assert(name != null, "name is null");
this.name = name;
this.value = value;
this.Count = 0;
}
public Entity(Stream stream, int id, int type, ISymbolTable symbolTable, IonLoader loader)
{
using var reader = new BinaryReader(stream, Encoding.UTF8, true);
Signature = Encoding.ASCII.GetString(reader.ReadBytes(4));
if (Signature != EntitySignature)
{
throw new Exception("Invalid signature");
}
Version = reader.ReadUInt16();
if (!_allowedVersions.Contains(Version))
{
throw new Exception($"Version not supported ({Version})");
}
Length = reader.ReadUInt32();
if (Length < MinHeaderLength)
{
throw new Exception("Header too short");
}
// Duplicated in KfxContainer
// 10 = number of bytes read so far
var containerInfoData = new MemoryStream(stream.ReadBytes((int)Length - 10));
var entityInfo = loader.LoadSingle <IonStruct>(containerInfoData);
if (entityInfo == null)
{
throw new Exception("Bad container or something");
}
var compressionType = entityInfo.GetField(KfxSymbols.BcComprType).IntValue;
if (compressionType != KfxContainer.DefaultCompressionType)
{
throw new Exception($"Unexpected bcComprType ({compressionType})");
}
var drmScheme = entityInfo.GetField(KfxSymbols.BcDrmScheme).IntValue;
if (drmScheme != KfxContainer.DefaultDrmScheme)
{
throw new Exception($"Unexpected bcDRMScheme ({drmScheme})");
}
FragmentId = symbolTable.FindKnownSymbol(id);
FragmentType = symbolTable.FindKnownSymbol(type);
Value = RawFragmentTypes.Contains(FragmentType)
? new IonBlob(new ReadOnlySpan <byte>(stream.ReadToEnd()))
: ((IonDatagram)loader.Load(stream.ReadToEnd())).Single();
// Skipping annotation handling for now
//if ftype == fid and ftype in ROOT_FRAGMENT_TYPES and not self.pure:
//fid = "$348"
//return YJFragment(fid = fid if fid != "$348" else None, ftype = ftype, value = self.value)
}
private object DeserializeObject(Type type, IIonValue ionValue)
{
Object obj;
// Get type's attributes
IList <PropertyInfo> properties = new List <PropertyInfo>(type.GetProperties());
// Array to hold parameters to create object
object[] paramArray = new object[properties.Count];
int count = 0;
foreach (PropertyInfo property in properties)
{
Type propertyType = property.PropertyType;
if (Type.GetTypeCode(propertyType) == TypeCode.Object)
{
obj = DeserializeObject(propertyType, ionValue.GetField(property.Name));
}
else
{
obj = DeserializingMappers(propertyType, ionValue.GetField(property.Name));
}
paramArray[count] = obj;
count++;
}
// Create object by passing in array of parameters into constructor
obj = Activator.CreateInstance(type, args: paramArray);
return(obj);
}
public void RespectPrettyTextSerializationFormat()
{
var serializer =
new IonSerializer(new IonSerializationOptions {
Format = IonSerializationFormat.PRETTY_TEXT
});
MemoryStream testStream = (MemoryStream)serializer.Serialize(TestObjects.John);
string testString = System.Text.Encoding.UTF8.GetString(testStream.ToArray());
IIonValue ionValue = IonLoader.Default.Load(TestObjects.JohnIonText).GetElementAt(0);
StringWriter expectedStringWriter = new StringWriter();
using (var writer =
IonTextWriterBuilder.Build(expectedStringWriter, new IonTextOptions {
PrettyPrint = true
}))
{
ionValue.WriteTo(writer);
writer.Finish();
}
string expectedString = expectedStringWriter.ToString();
Assert.AreEqual(expectedString, testString);
}
private void RunTest(
string testName,
IIonValue testCase,
IIonValue expectedHashLog,
TestIonHasherProvider hasherProvider,
IonHashTester testObject
)
{
if (expectedHashLog == null)
{
return;
}
IIonValue ionValue = testCase.GetField("ion");
IIonValue ionBinary = testCase.GetField("10n");
if (ionValue != null && ionBinary != null)
{
throw new Exception("Test must not define both 'ion' and '10n' fields");
}
var reader = ionValue == null
? testObject.GetIonReader(ContainerToBytes(ionBinary))
: testObject.GetIonReader(ionValue);
testObject.Traverse(reader, hasherProvider);
IIonValue actualHashLog = testObject.GetHashLog();
IIonValue actualHashLogFiltered = FilterHashLog(actualHashLog, expectedHashLog);
Assert.AreEqual(HashLogToString(expectedHashLog), HashLogToString(actualHashLogFiltered));
}
private async Task <bool> CheckIndexExistsAsync(string tableName, string field)
{
return(await Task.Run(async() =>
{
Amazon.QLDB.Driver.IAsyncResult result = await qldbDriver.Execute(async transactionExecutor =>
{
IIonValue ionTableName = this.valueFactory.NewString(tableName);
return await transactionExecutor.Execute($"SELECT * FROM information_schema.user_tables WHERE name = ?", ionTableName);
});
List <IIonValue> ionValues = await result.ToListAsync();
if (ionValues.Any())
{
IIonList indexes = ionValues.First().GetField("indexes");
foreach (IIonValue index in indexes)
{
string expr = index.GetField("expr").StringValue;
if (expr.Contains(field))
{
return true;
}
}
}
return false;
}));
}
public async Task ExecuteAsync_InsertDocumentWithMultipleFields_DocumentIsInserted()
{
// Given.
// Create Ion struct to insert.
IIonValue ionStruct = GetSingleValueIonStruct(IonString);
ionStruct.SetField(Constants.SecondColumnName, ValueFactory.NewString(Constants.SingleDocumentValue));
// When.
var insertQuery = $"INSERT INTO {Constants.TableName} ?";
Assert.AreEqual(1, await ExecuteWithParamAndReturnRowCount(insertQuery, ionStruct));
// Then.
var searchQuery = $@"SELECT {Constants.ColumnName}, {Constants.SecondColumnName} FROM {Constants.TableName}
WHERE {Constants.ColumnName} = '{Constants.SingleDocumentValue}'
AND {Constants.SecondColumnName} = '{Constants.SingleDocumentValue}'";
IIonValue value = await ExecuteAndReturnIonValue(searchQuery);
var ionReader = IonReaderBuilder.Build(value);
ionReader.MoveNext();
ionReader.StepIn();
ionReader.MoveNext();
Assert.AreEqual(Constants.ColumnName, ionReader.CurrentFieldName);
Assert.AreEqual(Constants.SingleDocumentValue, ionReader.StringValue());
ionReader.MoveNext();
Assert.AreEqual(Constants.SecondColumnName, ionReader.CurrentFieldName);
Assert.AreEqual(Constants.SingleDocumentValue, ionReader.StringValue());
}
public void TestMapper()
{
IIonValue ionStruct = IonLoader.Default
.Load("{name: \"John\", age: 22, address: {city: \"cityName\", street: \"streetName\", isApartment: false}}");
var lossyIonMapper = IonMapper.LOSSY();
Person person = lossyIonMapper.FromIon <Person>(ionStruct);
Console.WriteLine(person.ToString());
IIonValue ionValue = lossyIonMapper.ToIon <Person>(person);
Console.WriteLine(ionValue.ToPrettyString());
Console.WriteLine("\n \n ==== Now with a customized mapper === \n");
Func <IIonString, string> specialIonStringMapper = ionValue => (ionValue.StringValue).ToUpper();
Func <IIonInt, int> specialIonIntMapper = ionValue => (ionValue.IntValue) * 3;
Func <IIonBool, bool> specialIonBoolMapper = ionValue => !(ionValue.BoolValue);
var customizedMapper = new CustomIonMapper(MapperTypes.LOSSY)
.WithMapperFromIonTo <string>(specialIonStringMapper)
.WithMapperFromIonTo <int>(specialIonIntMapper)
.WithMapperFromIonTo <bool>(specialIonBoolMapper)
.Build();
person = customizedMapper.FromIon <Person>(ionStruct);
Console.WriteLine(person.ToString());
ionValue = customizedMapper.ToIon <Person>(person);
Console.WriteLine(ionValue.ToPrettyString());
}
public override bool IsEquivalentTo(IIonValue other)
{
if (!base.IsEquivalentTo(other))
{
return(false);
}
var oFloat = (IonFloat)other;
if (this.NullFlagOn())
{
return(oFloat.IsNull);
}
if (oFloat.IsNull)
{
return(false);
}
if (PrivateHelper.IsNegativeZero(this.d) ^ PrivateHelper.IsNegativeZero(oFloat.d))
{
return(false);
}
return(EqualityComparer <double> .Default.Equals(oFloat.DoubleValue, this.DoubleValue));
}
private bool CheckIfVinAlreadyExists(TransactionExecutor transactionExecutor, string vin)
{
IIonValue ionVin = this.valueFactory.NewString(vin);
IResult selectResult = transactionExecutor.Execute("SELECT VIN FROM VehicleRegistration AS v WHERE v.VIN = ?", ionVin);
return(selectResult.Any(x => x.GetField("VIN").StringValue == vin));
}
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
Vehicle vehicle = JsonConvert.DeserializeObject <Vehicle>(request.Body);
return(this.qldbDriver.Execute(transactionExecutor =>
{
context.Logger.Log($"Checking vehicle already exists for VIN {vehicle.Vin}.");
if (CheckIfVinAlreadyExists(transactionExecutor, vehicle.Vin))
{
context.Logger.Log($"Vehicle does exist for VIN {vehicle.Vin}, returning not modified.");
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.NotModified
};
}
else
{
context.Logger.Log($"Inserting vehicle for VIN {vehicle.Vin}.");
IIonValue ionVehicle = ConvertObjectToIonValue(vehicle);
transactionExecutor.Execute($"INSERT INTO Vehicle ?", ionVehicle);
context.Logger.Log($"Inserted ionVehicle for VIN {vehicle.Vin}, returning OK.");
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK
};
}
}));
}
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
string govId = request.QueryStringParameters["GovId"];
IResult selectResult = this.qldbDriver.Execute(transactionExecutor =>
{
string personDocumentId = this.tableMetadataService.GetDocumentId(transactionExecutor, PersonTableName, "GovId", govId);
context.Logger.Log($"Searching for vehicles where primary owner ID is {personDocumentId}.");
IIonValue ionPersonDocumentId = this.valueFactory.NewString(personDocumentId);
IResult result = transactionExecutor.Execute("SELECT v FROM Vehicle AS v INNER JOIN VehicleRegistration AS r "
+ "ON v.VIN = r.VIN WHERE r.Owners.PrimaryOwner.PersonId = ?", ionPersonDocumentId);
return(result);
});
IEnumerable <Vehicle> vehicles = selectResult.Select(x =>
{
var ionVehicle = x.GetField("v");
return(new Vehicle
{
Vin = ionVehicle.GetField("VIN").StringValue,
Type = ionVehicle.GetField("Type").StringValue,
Year = ionVehicle.GetField("Year").IntValue,
Make = ionVehicle.GetField("Make").StringValue,
Model = ionVehicle.GetField("Model").StringValue,
Color = ionVehicle.GetField("Color").StringValue
});
});
return(new APIGatewayProxyResponse
{
StatusCode = vehicles.Any() ? (int)HttpStatusCode.OK : (int)HttpStatusCode.NotFound,
Body = JsonConvert.SerializeObject(vehicles)
});
}
public object ConvertTo(IIonValue value, Type type)
{
var props = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
var instance = Activator.CreateInstance(type);
var members = type.GetMembers(BindingFlags.Public | BindingFlags.Instance)
.Where(m => (m.MemberType == MemberTypes.Field || m.MemberType == MemberTypes.Property));
foreach (MemberInfo member in members)
{
var field = value.GetField(member.Name);
var memberType = member.GetUnderlyingType();
var fieldHandler = FieldHandlers.GetHandler(memberType);
if (field != null)
{
var fieldValue = fieldHandler.ConvertTo(field, memberType);
if (member.MemberType == MemberTypes.Field)
{
type.GetField(member.Name).SetValue(instance, fieldValue);
continue;
}
if (member.MemberType == MemberTypes.Property)
{
if (((PropertyInfo)member).CanWrite)
{
type.GetProperty(member.Name).SetValue(instance, fieldValue);
}
}
}
}
return(instance);
}
public IIonValue ConvertFrom(object value)
{
IIonValue root = Factory.NewEmptyStruct();
BuildChildren(root, value);
return(root);
}
public MultisetField(SymbolToken name, IIonValue value)
{
Debug.Assert(name != null);
_name = name;
_value = value;
Count = 0;
}
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
Person person = JsonConvert.DeserializeObject <Person>(request.Body, new JsonSerializerSettings {
DateFormatString = "yyyy-MM-dd"
});
return(this.qldbDriver.Execute(transactionExecutor =>
{
context.Logger.Log($"Checking person already exists for GovId {person.GovId}.");
if (CheckIfPersonAlreadyExists(transactionExecutor, person.GovId))
{
context.Logger.Log($"Person does exist for GovId {person.GovId}, returning not modified.");
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.NotModified
};
}
else
{
context.Logger.Log($"Inserting person for GovId {person.GovId}.");
IIonValue ionPerson = ConvertObjectToIonValue(person);
transactionExecutor.Execute($"INSERT INTO Person ?", ionPerson);
context.Logger.Log($"Inserted person for GovId {person.GovId}, returning OK.");
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK
};
}
}));
}
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
VehicleRegistration vehicleRegistration = JsonConvert.DeserializeObject <VehicleRegistration>(request.Body);
return(this.qldbDriver.Execute(transactionExecutor =>
{
context.Logger.Log($"Checking vehicle registration already exists for VIN {vehicleRegistration.Vin}.");
if (!CheckIfVinAlreadyExists(transactionExecutor, vehicleRegistration.Vin))
{
context.Logger.Log($"Vehicle registration does not exist for VIN {vehicleRegistration.Vin}, returning not found.");
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.NotFound
};
}
context.Logger.Log($"Vehicle registration already exists, checking what's changed between current value and request.");
IEnumerable <string> existingSecondaryOwners = GetSecondaryOwners(transactionExecutor, vehicleRegistration.Vin);
IEnumerable <string> newSecondaryOwnersGovIds = vehicleRegistration.Owners.SecondaryOwners
.Select(x => x.PersonId)
.Except(existingSecondaryOwners);
if (!newSecondaryOwnersGovIds.Any())
{
context.Logger.Log($"Nothing changed, returning not modified.");
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.NotModified
};
}
string secondaryOwnerPersonDocumentId = this.tableMetadataService.GetDocumentId(transactionExecutor, PersonTableName, "GovId", newSecondaryOwnersGovIds.First());
if (!CheckIfSecondaryOwnerExists(existingSecondaryOwners, secondaryOwnerPersonDocumentId))
{
context.Logger.Log($"Secondary owner does not exists with document ID {secondaryOwnerPersonDocumentId}, adding secondary owner.");
IIonValue ionVin = this.valueFactory.NewString(vehicleRegistration.Vin);
IIonValue ionSecondaryOwner = ConvertOwnerToIonValue(new Owner {
PersonId = secondaryOwnerPersonDocumentId
});
IResult result = transactionExecutor.Execute($"FROM VehicleRegistration AS v WHERE v.VIN = ? " +
"INSERT INTO v.Owners.SecondaryOwners VALUE ?", ionVin, ionSecondaryOwner);
context.Logger.Log($"Secondary owner added with document ID {secondaryOwnerPersonDocumentId}, returning OK.");
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.OK
};
}
else
{
context.Logger.Log($"Secondary owner already exists, returning not modified.");
return new APIGatewayProxyResponse
{
StatusCode = (int)HttpStatusCode.NotModified
};
}
}));
}
public IIonValue ConvertFrom(object value)
{
IIonValue list = Factory.NewEmptyList();
var enumerableValue = (IEnumerable)value;
BuildIonList(list, enumerableValue);
return(list);
}
public Field(IIonValue ionValue, bool strict)
{
_name = ionValue.FieldNameSymbol.Text ??
$"{UnknownSymbolTextPrefix}{ionValue.FieldNameSymbol.Sid}";
_ionValue = ionValue;
_strict = strict;
Count = 0;
}
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
string vin = request.QueryStringParameters["VIN"];
IEnumerable <IIonValue> selectResult = this.qldbDriver.Execute(transactionExecutor =>
{
string vehicleRegistrationDocumentId = this.tableMetadataService.GetDocumentId(transactionExecutor, VehicleRegistrationTableName, "VIN", vin);
context.Logger.Log($"Getting history for vehicle registration where document ID is {vehicleRegistrationDocumentId}.");
IIonValue ionVehicleRegistrationDocumentId = this.valueFactory.NewString(vehicleRegistrationDocumentId);
IResult result = transactionExecutor.Execute("SELECT data, data.Owners.PrimaryOwner AS PrimaryOwner, data.Owners.SecondaryOwners AS SecondaryOwners, metadata.version "
+ $"FROM history(VehicleRegistration) "
+ "AS history WHERE history.metadata.id = ?", ionVehicleRegistrationDocumentId);
return(result);
});
IEnumerable <VehicleRegistrationHistory> vehicles = selectResult.Select(x =>
{
IIonValue ionData = x.GetField("data");
IIonValue ionVersion = x.GetField("version");
Owners owners = new Owners
{
PrimaryOwner = new Owner {
PersonId = x.GetField("PrimaryOwner").GetField("PersonId").StringValue
}
};
var ionSecondaryOwners = x.GetField("SecondaryOwners") as IIonList;
foreach (var secondaryOwner in ionSecondaryOwners)
{
owners.SecondaryOwners.Add(new Owner {
PersonId = secondaryOwner.GetField("PersonId").StringValue
});
}
return(new VehicleRegistrationHistory
{
Version = ionVersion.IntValue,
VehicleRegistration = new VehicleRegistration
{
Vin = ionData.GetField("VIN").StringValue,
LicensePlateNumber = ionData.GetField("LicensePlateNumber").StringValue,
State = ionData.GetField("State").StringValue,
PendingPenaltyTicketAmount = Convert.ToDouble(ionData.GetField("PendingPenaltyTicketAmount").DecimalValue),
ValidFromDate = DateTime.Parse(ionData.GetField("ValidFromDate").StringValue),
ValidToDate = DateTime.Parse(ionData.GetField("ValidToDate").StringValue),
Owners = owners
}
});
});
return(new APIGatewayProxyResponse
{
StatusCode = vehicles.Any() ? (int)HttpStatusCode.OK : (int)HttpStatusCode.NotFound,
Body = JsonConvert.SerializeObject(vehicles, Formatting.Indented)
});
}
private static bool AssertDatagramEquivalent(IIonValue d1, IIonValue d2)
{
IonValue[] values1 = GetIonValues(d1);
IonValue[] values2 = GetIonValues(d2);
var eq = values1.SequenceEqual(values2, IonValueComparer);
return(eq);
}
public IIonValue ConvertFrom(object value)
{
IIonValue dict = Factory.NewEmptyStruct();
var enumerableValue = (IDictionary)value;
BuildDictionary(dict, enumerableValue);
return(dict);
}
public void RunWriterTest(
string testName,
IIonValue testCase,
IIonValue expectedHashLog,
TestIonHasherProvider hasherProvider
)
{
RunTest(testName, testCase, expectedHashLog, hasherProvider, new WriterTest());
}
public T MapFromIonBoolTo <T>(IIonValue ionValue)
{
if (IIonBoolTo != null)
{
return((T)IIonBoolTo(ionValue));
}
return(Mapper.MapFromIonBoolTo <T>(ionValue));
}
public virtual void Add(IIonValue item)
{
if (!(item is IonValueLite ionValueLite))
{
throw new InvalidOperationException();
}
AddChild(ChildCount, ionValueLite);
}
public void StepOut()
{
if (_top < 1)
{
throw new IonException("Cannot stepOut any further, already at top level.");
}
Pop();
_current = null;
}
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 HasAnnotation_AssertUnknownSymbolException()
{
string input = "$ion_symbol_table::{ imports:[{ name: \"abc\", version: 1, max_id: 1}],symbols: [\"foo\"]}$10::$11::\"value\"";
IIonValue data = IonLoader.Default.Load(input);
UserTreeReader reader = new UserTreeReader(data);
ReaderTestCommon.HasAnnotation_AssertUnknownSymbolException(reader);
}
