private static void AddQueryNotEqual(QueryHandle queryHandle, string columnName, object value)
{
var columnIndex = NativeQuery.get_column_index((QueryHandle)queryHandle, columnName, (IntPtr)columnName.Length);
var valueType = value.GetType();
if (value.GetType() == typeof(string))
{
string valueStr = (string)value;
NativeQuery.string_not_equal((QueryHandle)queryHandle, columnIndex, valueStr, (IntPtr)valueStr.Length);
}
else if (valueType == typeof(bool))
{
NativeQuery.bool_not_equal((QueryHandle)queryHandle, columnIndex, MarshalHelpers.BoolToIntPtr((bool)value));
}
else if (valueType == typeof(int))
{
NativeQuery.int_not_equal((QueryHandle)queryHandle, columnIndex, (IntPtr)((int)value));
}
else if (valueType == typeof(long))
{
NativeQuery.long_not_equal((QueryHandle)queryHandle, columnIndex, (long)value);
}
else if (valueType == typeof(float))
{
NativeQuery.float_not_equal((QueryHandle)queryHandle, columnIndex, (float)value);
}
else if (valueType == typeof(double))
{
NativeQuery.double_not_equal((QueryHandle)queryHandle, columnIndex, (double)value);
}
else if (valueType == typeof(DateTimeOffset))
{
NativeQuery.timestamp_milliseconds_not_equal(queryHandle, columnIndex, ((DateTimeOffset)value).ToRealmUnixTimeMilliseconds());
}
else if (valueType == typeof(byte[]))
{
var buffer = (byte[])value;
if (buffer.Length == 0)
{
// see RealmObject.SetByteArrayValue
NativeQuery.binary_not_equal(queryHandle, columnIndex, (IntPtr)0x1, IntPtr.Zero);
return;
}
unsafe
{
fixed(byte *bufferPtr = (byte[])value)
{
NativeQuery.binary_not_equal(queryHandle, columnIndex, (IntPtr)bufferPtr, (IntPtr)buffer.LongLength);
}
}
}
else
{
throw new NotImplementedException();
}
}
public long?GetNullableInt64(IntPtr propertyIndex)
{
NativeException nativeException;
long value;
var hasValue = MarshalHelpers.IntPtrToBool(NativeMethods.get_nullable_int64(this, propertyIndex, out value, out nativeException));
nativeException.ThrowIfNecessary();
return(hasValue ? value : (long?)null);
}
public double?GetNullableDouble(IntPtr propertyIndex)
{
NativeException nativeException;
double value;
var hasValue = MarshalHelpers.IntPtrToBool(NativeMethods.get_nullable_double(this, propertyIndex, out value, out nativeException));
nativeException.ThrowIfNecessary();
return(hasValue ? value : (double?)null);
}
public static double?GetNullableDouble(TableHandle tableHandle, IntPtr columnIndex, IntPtr rowIndex)
{
NativeException nativeException;
double value;
var hasValue = MarshalHelpers.IntPtrToBool(NativeTable.get_nullable_double(tableHandle, columnIndex, rowIndex, out value, out nativeException));
nativeException.ThrowIfNecessary();
return(hasValue ? value : (double?)null);
}
public static bool?GetNullableBoolean(TableHandle tableHandle, IntPtr columnIndex, IntPtr rowIndex)
{
NativeException nativeException;
IntPtr value;
var hasValue = MarshalHelpers.IntPtrToBool(NativeTable.get_nullable_bool(tableHandle, columnIndex, rowIndex, out value, out nativeException));
nativeException.ThrowIfNecessary();
return(hasValue ? MarshalHelpers.IntPtrToBool(value) : (bool?)null);
}
public DateTimeOffset?GetNullableDateTimeOffset(IntPtr propertyIndex)
{
NativeException nativeException;
long ticks;
var hasValue = MarshalHelpers.IntPtrToBool(NativeMethods.get_nullable_timestamp_ticks(this, propertyIndex, out ticks, out nativeException));
nativeException.ThrowIfNecessary();
return(hasValue ? new DateTimeOffset(ticks, TimeSpan.Zero) : (DateTimeOffset?)null);
}
public bool?GetNullableBoolean(IntPtr propertyIndex)
{
NativeException nativeException;
IntPtr value;
var hasValue = MarshalHelpers.IntPtrToBool(NativeMethods.get_nullable_bool(this, propertyIndex, out value, out nativeException));
nativeException.ThrowIfNecessary();
return(hasValue ? MarshalHelpers.IntPtrToBool(value) : (bool?)null);
}
public static DateTimeOffset?GetNullableDateTimeOffset(TableHandle tableHandle, IntPtr columnIndex,
IntPtr rowIndex)
{
NativeException nativeException;
long ticks;
var hasValue = MarshalHelpers.IntPtrToBool(NativeTable.get_nullable_timestamp_ticks(tableHandle, columnIndex, rowIndex, out ticks, out nativeException));
nativeException.ThrowIfNecessary();
return(hasValue ? new DateTimeOffset(ticks, TimeSpan.Zero) : (DateTimeOffset?)null);
}
protected DateTimeOffset?GetNullableDateTimeOffsetValue(string propertyName)
{
Debug.Assert(_realm != null, "Object is not managed, but managed access was attempted");
var rowIndex = _rowHandle.RowIndex;
long unixTimeSeconds = 0;
var hasValue = MarshalHelpers.IntPtrToBool(NativeTable.get_nullable_datetime_seconds(_metadata.Table, _metadata.ColumnIndices[propertyName], (IntPtr)rowIndex, ref unixTimeSeconds));
return(hasValue ? DateTimeOffsetExtensions.FromUnixTimeSeconds(unixTimeSeconds) : (DateTimeOffset?)null);
}
protected bool?GetNullableBooleanValue(string propertyName)
{
Debug.Assert(_realm != null, "Object is not managed, but managed access was attempted");
var rowIndex = _rowHandle.RowIndex;
var retVal = IntPtr.Zero;
var hasValue = MarshalHelpers.IntPtrToBool(NativeTable.get_nullable_bool(_metadata.Table, _metadata.ColumnIndices[propertyName], (IntPtr)rowIndex, ref retVal));
return(hasValue ? MarshalHelpers.IntPtrToBool(retVal) : (bool?)null);
}
protected double?GetNullableDoubleValue(string propertyName)
{
Debug.Assert(_realm != null, "Object is not managed, but managed access was attempted");
var rowIndex = _rowHandle.RowIndex;
var retVal = 0.0d;
var hasValue = MarshalHelpers.IntPtrToBool(NativeTable.get_nullable_double(_metadata.Table, _metadata.ColumnIndices[propertyName], (IntPtr)rowIndex, ref retVal));
return(hasValue ? retVal : (double?)null);
}
public unsafe int Find(byte[] value)
{
var result = IntPtr.Zero;
MarshalHelpers.SetByteArray(value, (IntPtr buffer, IntPtr bufferSize, bool hasValue, out NativeException ex) =>
{
result = NativeMethods.find_binary(this, buffer, bufferSize, hasValue, out ex);
});
return((int)result);
}
private static IntPtr GenerateObjectSchema(Type objectClass)
{
IntPtr objectSchemaPtr = IntPtr.Zero;
if (ObjectSchemaCache.TryGetValue(objectClass, out objectSchemaPtr))
{
return(objectSchemaPtr); // use cached schema
}
objectSchemaPtr = NativeObjectSchema.create(objectClass.Name);
ObjectSchemaCache[objectClass] = objectSchemaPtr; // save for later lookup
var propertiesToMap = objectClass.GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public)
.Where(p =>
{
return(p.GetCustomAttributes(false).OfType <WovenPropertyAttribute>().Any());
});
foreach (var p in propertiesToMap)
{
var mapToAttribute = p.GetCustomAttributes(false).FirstOrDefault(a => a is MapToAttribute) as MapToAttribute;
var propertyName = mapToAttribute != null ? mapToAttribute.Mapping : p.Name;
var objectIdAttribute = p.GetCustomAttributes(false).FirstOrDefault(a => a is ObjectIdAttribute);
var isObjectId = objectIdAttribute != null;
var indexedAttribute = p.GetCustomAttributes(false).FirstOrDefault(a => a is IndexedAttribute);
var isIndexed = indexedAttribute != null;
var isNullable = !(p.PropertyType.IsValueType ||
p.PropertyType.Name == "RealmList`1") ||
// IGNORING IList FOR NOW p.PropertyType.Name == "IList`1") ||
Nullable.GetUnderlyingType(p.PropertyType) != null;
var objectType = "";
if (!p.PropertyType.IsValueType && p.PropertyType.Name != "String")
{
if (p.PropertyType.Name == "RealmList`1") // IGNORING IList FOR NOW || p.PropertyType.Name == "IList`1")
{
objectType = p.PropertyType.GetGenericArguments()[0].Name;
}
else
{
if (p.PropertyType.BaseType.Name == "RealmObject")
{
objectType = p.PropertyType.Name;
}
}
}
var columnType = p.PropertyType;
NativeObjectSchema.add_property(objectSchemaPtr, propertyName, MarshalHelpers.RealmColType(columnType), objectType,
MarshalHelpers.BoolToIntPtr(isObjectId), MarshalHelpers.BoolToIntPtr(isIndexed), MarshalHelpers.BoolToIntPtr(isNullable));
}
return(objectSchemaPtr);
}
public unsafe void SetByteArray(IntPtr propertyIndex, byte[] value)
{
MarshalHelpers.SetByteArray(value, (IntPtr buffer, IntPtr bufferSize, bool hasValue, out NativeException ex) =>
{
if (hasValue)
{
NativeMethods.set_binary(this, propertyIndex, buffer, bufferSize, out ex);
}
else
{
NativeMethods.set_null(this, propertyIndex, out ex);
}
});
}
public static void SetNullableBoolean(TableHandle tableHandle, IntPtr columnIndex, IntPtr rowIndex, bool?value)
{
NativeException nativeException;
if (value.HasValue)
{
set_bool(tableHandle, columnIndex, rowIndex, MarshalHelpers.BoolToIntPtr(value.Value), out nativeException);
}
else
{
set_null(tableHandle, columnIndex, rowIndex, out nativeException);
}
nativeException.ThrowIfNecessary();
}
public void SetNullableBoolean(IntPtr propertyIndex, bool?value)
{
NativeException nativeException;
if (value.HasValue)
{
NativeMethods.set_bool(this, propertyIndex, MarshalHelpers.BoolToIntPtr(value.Value), out nativeException);
}
else
{
NativeMethods.set_null(this, propertyIndex, out nativeException);
}
nativeException.ThrowIfNecessary();
}
private static void AddQueryNotEqual(QueryHandle queryHandle, string columnName, object value)
{
var columnIndex = NativeQuery.get_column_index((QueryHandle)queryHandle, columnName, (IntPtr)columnName.Length);
var valueType = value.GetType();
if (value.GetType() == typeof(string))
{
string valueStr = (string)value;
NativeQuery.string_not_equal((QueryHandle)queryHandle, columnIndex, valueStr, (IntPtr)valueStr.Length);
}
else if (valueType == typeof(bool))
{
NativeQuery.bool_not_equal((QueryHandle)queryHandle, columnIndex, MarshalHelpers.BoolToIntPtr((bool)value));
}
else if (valueType == typeof(int))
{
NativeQuery.int_not_equal((QueryHandle)queryHandle, columnIndex, (IntPtr)((int)value));
}
else if (valueType == typeof(float))
{
NativeQuery.float_not_equal((QueryHandle)queryHandle, columnIndex, (float)value);
}
else if (valueType == typeof(double))
{
NativeQuery.double_not_equal((QueryHandle)queryHandle, columnIndex, (double)value);
}
else if (valueType == typeof(DateTimeOffset))
{
NativeQuery.datetime_seconds_not_equal(queryHandle, columnIndex, ((DateTimeOffset)value).ToUnixTimeSeconds());
}
else
{
throw new NotImplementedException();
}
}
public unsafe void Add(byte[] value)
{
MarshalHelpers.SetByteArray(value, (IntPtr buffer, IntPtr bufferSize, bool hasValue, out NativeException ex) =>
NativeMethods.add_binary(this, buffer, bufferSize, hasValue, out ex));
}
public override byte[] GetByteArrayAtIndex(int index)
{
return(MarshalHelpers.GetByteArray((IntPtr buffer, IntPtr bufferLength, out bool isNull, out NativeException ex) =>
NativeMethods.get_binary(this, (IntPtr)index, buffer, bufferLength, out isNull, out ex)));
}
public override string GetStringAtIndex(int index)
{
return(MarshalHelpers.GetString((IntPtr buffer, IntPtr length, out bool isNull, out NativeException ex) =>
NativeMethods.get_string(this, (IntPtr)index, buffer, length, out isNull, out ex)));
}
public void BoolNotEqual(IntPtr columnIndex, bool value)
{
NativeMethods.bool_not_equal(this, columnIndex, MarshalHelpers.BoolToIntPtr(value), out var nativeException);
nativeException.ThrowIfNecessary();
}
/// <summary>
/// Update a Realm and outstanding objects to point to the most recent data for this Realm.
/// This is only necessary when you have a Realm on a non-runloop thread that needs manual refreshing.
/// </summary>
/// <returns>
/// Whether the realm had any updates. Note that this may return true even if no data has actually changed.
/// </returns>
public bool Refresh()
{
return(MarshalHelpers.IntPtrToBool(NativeSharedRealm.refresh(SharedRealmHandle)));
}
public string GetString(IntPtr propertyIndex)
{
return(MarshalHelpers.GetString((IntPtr buffer, IntPtr length, out bool isNull, out NativeException ex) => NativeMethods.get_string(this, propertyIndex, buffer, length, out isNull, out ex)));
}
public static Realm GetInstance(RealmConfiguration config = null)
{
config = config ?? RealmConfiguration.DefaultConfiguration;
// TODO cache these initializers but note complications with ObjectClasses
var schemaInitializer = new SchemaInitializerHandle();
if (config.ObjectClasses == null)
{
foreach (var realmObjectClass in RealmObjectClasses)
{
var objectSchemaHandle = GenerateObjectSchema(realmObjectClass);
NativeSchema.initializer_add_object_schema(schemaInitializer, objectSchemaHandle);
}
}
else
{
foreach (var selectedRealmObjectClass in config.ObjectClasses)
{
if (selectedRealmObjectClass.BaseType != typeof(RealmObject))
{
throw new ArgumentException($"The class {selectedRealmObjectClass.FullName} must descend directly from RealmObject");
}
Debug.Assert(RealmObjectClasses.Contains(selectedRealmObjectClass)); // user-specified class must have been picked up by our static ctor
var objectSchemaHandle = GenerateObjectSchema(selectedRealmObjectClass);
NativeSchema.initializer_add_object_schema(schemaInitializer, objectSchemaHandle);
}
}
var schemaHandle = new SchemaHandle(schemaInitializer);
var srHandle = new SharedRealmHandle();
var readOnly = MarshalHelpers.BoolToIntPtr(config.ReadOnly);
var durability = MarshalHelpers.BoolToIntPtr(false);
var databasePath = config.DatabasePath;
IntPtr srPtr = IntPtr.Zero;
try {
srPtr = NativeSharedRealm.open(schemaHandle,
databasePath, (IntPtr)databasePath.Length,
readOnly, durability,
config.EncryptionKey,
config.SchemaVersion);
} catch (RealmMigrationNeededException) {
if (config.ShouldDeleteIfMigrationNeeded)
{
DeleteRealm(config);
}
else
{
throw; // rethrow te exception
//TODO when have Migration but also consider programmer control over auto migration
//MigrateRealm(configuration);
}
// create after deleting old reopen after migrating
srPtr = NativeSharedRealm.open(schemaHandle,
databasePath, (IntPtr)databasePath.Length,
readOnly, durability,
config.EncryptionKey,
config.SchemaVersion);
}
RuntimeHelpers.PrepareConstrainedRegions();
try { /* Retain handle in a constrained execution region */ }
finally
{
srHandle.SetHandle(srPtr);
}
return(new Realm(srHandle, config));
}
protected void SetNullableBooleanValue(string propertyName, bool?value)
{
Debug.Assert(_realm != null, "Object is not managed, but managed access was attempted");
if (!_realm.IsInTransaction)
{
throw new RealmOutsideTransactionException("Cannot set values outside transaction");
}
var rowIndex = _rowHandle.RowIndex;
if (value.HasValue)
{
NativeTable.set_bool(_metadata.Table, _metadata.ColumnIndices[propertyName], (IntPtr)rowIndex, MarshalHelpers.BoolToIntPtr(value.Value));
}
else
{
NativeTable.set_null(_metadata.Table, _metadata.ColumnIndices[propertyName], (IntPtr)rowIndex);
}
}
public byte[] GetByteArray(IntPtr propertyIndex)
{
return(MarshalHelpers.GetByteArray((IntPtr buffer, IntPtr bufferLength, out bool isNull, out NativeException ex) =>
NativeMethods.get_binary(this, propertyIndex, buffer, bufferLength, out isNull, out ex)));
}
public unsafe void Insert(int targetIndex, byte[] value)
{
MarshalHelpers.SetByteArray(value, (IntPtr buffer, IntPtr bufferSize, bool hasValue, out NativeException ex) =>
NativeMethods.insert_binary(this, (IntPtr)targetIndex, buffer, bufferSize, hasValue, out ex));
}
/// <summary>
/// Determines whether this instance is the same core instance as the specified rhs.
/// </summary>
/// <remarks>
/// You can, and should, have multiple instances open on different threads which have the same path and open the same Realm.
/// </remarks>
/// <returns><c>true</c> if this instance is the same core instance the specified rhs; otherwise, <c>false</c>.</returns>
/// <param name="rhs">The Realm to compare with the current Realm.</param>
public bool IsSameInstance(Realm rhs)
{
return(MarshalHelpers.IntPtrToBool(NativeSharedRealm.is_same_instance(SharedRealmHandle, rhs.SharedRealmHandle)));
}
public void BoolEqual(ColumnKey columnKey, bool value)
{
NativeMethods.bool_equal(this, columnKey, MarshalHelpers.BoolToIntPtr(value), out var nativeException);
nativeException.ThrowIfNecessary();
}
public void SetBoolean(IntPtr propertyIndex, bool value)
{
NativeMethods.set_bool(this, propertyIndex, MarshalHelpers.BoolToIntPtr(value), out var nativeException);
nativeException.ThrowIfNecessary();
}