|
public GetColumnIndex ( string columnName ) : |
||
| columnName | string | |
| return | ||
private static void AddQueryNotEqual(QueryHandle queryHandle, string columnName, object value, Type columnType)
{
var columnIndex = queryHandle.GetColumnIndex(columnName);
switch (value)
{
case null:
queryHandle.NullNotEqual(columnIndex);
break;
case string stringValue:
queryHandle.StringNotEqual(columnIndex, stringValue, caseSensitive: true);
break;
case bool boolValue:
queryHandle.BoolNotEqual(columnIndex, boolValue);
break;
case DateTimeOffset date:
queryHandle.TimestampTicksNotEqual(columnIndex, date);
break;
case byte[] buffer:
if (buffer.Length == 0)
{
// see RealmObject.SetByteArrayValue
queryHandle.BinaryNotEqual(columnIndex, (IntPtr)0x1, IntPtr.Zero);
return;
}
unsafe
{
fixed(byte *bufferPtr = (byte[])value)
{
queryHandle.BinaryNotEqual(columnIndex, (IntPtr)bufferPtr, (IntPtr)buffer.LongCount());
}
}
break;
case RealmObject obj:
queryHandle.Not();
queryHandle.ObjectEqual(columnIndex, obj.ObjectHandle);
break;
default:
// The other types aren't handled by the switch because of potential compiler applied conversions
AddQueryForConvertibleTypes(columnIndex, value, columnType, queryHandle.NumericNotEqualMethods);
break;
}
}
private static void AddQueryGreaterThanOrEqual(QueryHandle queryHandle, string columnName, object value, Type columnType)
{
var columnIndex = queryHandle.GetColumnIndex(columnName);
switch (value)
{
case DateTimeOffset date:
queryHandle.TimestampTicksGreaterEqual(columnIndex, date);
break;
case string _:
case bool _:
throw new Exception($"Unsupported type {value.GetType().Name}");
default:
// The other types aren't handled by the switch because of potential compiler applied conversions
AddQueryForConvertibleTypes(columnIndex, value, columnType, queryHandle.NumericGreaterEqualMethods);
break;
}
}
private static void AddQueryGreaterThanOrEqual(QueryHandle queryHandle, string columnName, object value)
{
var columnIndex = queryHandle.GetColumnIndex(columnName);
if (value is char)
{
queryHandle.IntGreaterEqual(columnIndex, (int)value);
}
else if (value is int)
{
queryHandle.IntGreaterEqual(columnIndex, (int)value);
}
else if (value is long)
{
queryHandle.LongGreaterEqual(columnIndex, (long)value);
}
else if (value is float)
{
queryHandle.FloatGreaterEqual(columnIndex, (float)value);
}
else if (value is double)
{
queryHandle.DoubleGreaterEqual(columnIndex, (double)value);
}
else if (value is DateTimeOffset)
{
queryHandle.TimestampTicksGreaterEqual(columnIndex, (DateTimeOffset)value);
}
else if (value is string || value is bool)
{
throw new Exception($"Unsupported type {value.GetType().Name}");
}
else
{
throw new NotImplementedException();
}
}
private static void AddQueryNotEqual(QueryHandle queryHandle, string columnName, object value)
{
var columnIndex = queryHandle.GetColumnIndex(columnName);
if (value == null)
{
queryHandle.NullNotEqual(columnIndex);
}
else if (value is string)
{
queryHandle.StringNotEqual(columnIndex, (string)value, caseSensitive: true);
}
else if (value is bool)
{
queryHandle.BoolNotEqual(columnIndex, (bool)value);
}
else if (value is char)
{
queryHandle.IntNotEqual(columnIndex, (int)value);
}
else if (value is int)
{
queryHandle.IntNotEqual(columnIndex, (int)value);
}
else if (value is long)
{
queryHandle.LongNotEqual(columnIndex, (long)value);
}
else if (value is float)
{
queryHandle.FloatNotEqual(columnIndex, (float)value);
}
else if (value is double)
{
queryHandle.DoubleNotEqual(columnIndex, (double)value);
}
else if (value is DateTimeOffset)
{
queryHandle.TimestampTicksNotEqual(columnIndex, (DateTimeOffset)value);
}
else if (value is byte[])
{
var buffer = (byte[])value;
if (buffer.Length == 0)
{
// see RealmObject.SetByteArrayValue
queryHandle.BinaryNotEqual(columnIndex, (IntPtr)0x1, IntPtr.Zero);
return;
}
unsafe
{
fixed(byte *bufferPtr = (byte[])value)
{
queryHandle.BinaryNotEqual(columnIndex, (IntPtr)bufferPtr, (IntPtr)buffer.LongCount());
}
}
}
else if (value is RealmObject)
{
queryHandle.Not();
queryHandle.ObjectEqual(columnIndex, ((RealmObject)value).ObjectHandle);
}
else
{
throw new NotImplementedException();
}
}
internal override Expression VisitMethodCall(MethodCallExpression m)
{
if (m.Method.DeclaringType == typeof(Queryable))
{
if (m.Method.Name == nameof(Queryable.Where))
{
Visit(m.Arguments[0]);
var lambda = (LambdaExpression)StripQuotes(m.Arguments[1]);
Visit(lambda.Body);
return(m);
}
if (m.Method.Name == nameof(Queryable.OrderBy))
{
Visit(m.Arguments[0]);
AddSort((LambdaExpression)StripQuotes(m.Arguments[1]), true, true);
return(m);
}
if (m.Method.Name == nameof(Queryable.OrderByDescending))
{
Visit(m.Arguments[0]);
AddSort((LambdaExpression)StripQuotes(m.Arguments[1]), true, false);
return(m);
}
if (m.Method.Name == nameof(Queryable.ThenBy))
{
Visit(m.Arguments[0]);
AddSort((LambdaExpression)StripQuotes(m.Arguments[1]), false, true);
return(m);
}
if (m.Method.Name == nameof(Queryable.ThenByDescending))
{
Visit(m.Arguments[0]);
AddSort((LambdaExpression)StripQuotes(m.Arguments[1]), false, false);
return(m);
}
if (m.Method.Name == nameof(Queryable.Count))
{
RecurseToWhereOrRunLambda(m);
var foundCount = CoreQueryHandle.Count();
return(Expression.Constant(foundCount));
}
if (m.Method.Name == nameof(Queryable.Any))
{
RecurseToWhereOrRunLambda(m);
var foundAny = CoreQueryHandle.FindDirect(_realm.SharedRealmHandle) != IntPtr.Zero;
return(Expression.Constant(foundAny));
}
if (m.Method.Name.StartsWith(nameof(Queryable.First)))
{
RecurseToWhereOrRunLambda(m);
var firstObjectPtr = IntPtr.Zero;
if (OptionalSortDescriptorBuilder == null)
{
firstObjectPtr = CoreQueryHandle.FindDirect(_realm.SharedRealmHandle);
}
else
{
using (ResultsHandle rh = _realm.MakeResultsForQuery(CoreQueryHandle, OptionalSortDescriptorBuilder))
{
firstObjectPtr = rh.GetObjectAtIndex(0);
}
}
if (firstObjectPtr != IntPtr.Zero)
{
return(Expression.Constant(_realm.MakeObject(_metadata, firstObjectPtr)));
}
if (m.Method.Name == nameof(Queryable.First))
{
throw new InvalidOperationException("Sequence contains no matching element");
}
Debug.Assert(m.Method.Name == nameof(Queryable.FirstOrDefault), $"The method {m.Method.Name} is not supported. We expected {nameof(Queryable.FirstOrDefault)}.");
return(Expression.Constant(null));
}
/*
* // FIXME: See discussion in the test DefaultIfEmptyReturnsDefault
* // kept because it shows part of what might be a viable implementation if can work out architectural issues
*
* if (m.Method.Name == nameof(Queryable.DefaultIfEmpty))
* {
* RecurseToWhereOrRunLambda(m);
* IntPtr firstObjectPtr = _coreQueryHandle.FindDirect(IntPtr.Zero);
* if (firstObjectPtr != IntPtr.Zero)
* return m; // as if just a "Where"
* var innerType = m.Type.GetGenericArguments()[0];
* var listType = typeof(List<>).MakeGenericType(innerType);
* var singleNullItemList = Activator.CreateInstance(listType);
* ((IList)singleNullItemList).Add(null);
* return Expression.Constant(singleNullItemList);
* }
*/
if (m.Method.Name.StartsWith(nameof(Queryable.Single))) // same as unsorted First with extra checks
{
RecurseToWhereOrRunLambda(m);
var firstObjectPtr = CoreQueryHandle.FindDirect(_realm.SharedRealmHandle);
if (firstObjectPtr == IntPtr.Zero)
{
if (m.Method.Name == nameof(Queryable.Single))
{
throw new InvalidOperationException("Sequence contains no matching element");
}
Debug.Assert(m.Method.Name == nameof(Queryable.SingleOrDefault), $"The method {m.Method.Name} is not supported. We expected {nameof(Queryable.SingleOrDefault)}.");
return(Expression.Constant(null));
}
var firstObject = Realm.CreateObjectHandle(firstObjectPtr, _realm.SharedRealmHandle);
var nextObjectPtr = CoreQueryHandle.FindNext(firstObject);
if (nextObjectPtr != IntPtr.Zero)
{
throw new InvalidOperationException("Sequence contains more than one matching element");
}
return(Expression.Constant(_realm.MakeObject(_metadata, firstObject)));
}
if (m.Method.Name.StartsWith(nameof(Queryable.Last)))
{
RecurseToWhereOrRunLambda(m);
var lastObjectPtr = IntPtr.Zero;
using (ResultsHandle rh = _realm.MakeResultsForQuery(CoreQueryHandle, OptionalSortDescriptorBuilder))
{
var lastIndex = rh.Count() - 1;
if (lastIndex >= 0)
{
lastObjectPtr = rh.GetObjectAtIndex(lastIndex);
}
}
if (lastObjectPtr != IntPtr.Zero)
{
return(Expression.Constant(_realm.MakeObject(_metadata, lastObjectPtr)));
}
if (m.Method.Name == nameof(Queryable.Last))
{
throw new InvalidOperationException("Sequence contains no matching element");
}
Debug.Assert(m.Method.Name == nameof(Queryable.LastOrDefault), $"The method {m.Method.Name} is not supported. We expected {nameof(Queryable.LastOrDefault)}.");
return(Expression.Constant(null));
}
if (m.Method.Name.StartsWith(nameof(Queryable.ElementAt)))
{
Visit(m.Arguments.First());
object argument;
if (!TryExtractConstantValue(m.Arguments.Last(), out argument) || argument.GetType() != typeof(int))
{
throw new NotSupportedException($"The method '{m.Method}' has to be invoked with a single integer constant argument or closure variable");
}
IntPtr objectPtr;
var index = (int)argument;
if (OptionalSortDescriptorBuilder == null)
{
objectPtr = CoreQueryHandle.FindDirect(_realm.SharedRealmHandle, (IntPtr)index);
}
else
{
using (var rh = _realm.MakeResultsForQuery(CoreQueryHandle, OptionalSortDescriptorBuilder))
{
objectPtr = rh.GetObjectAtIndex(index);
}
}
if (objectPtr != IntPtr.Zero)
{
var objectHandle = Realm.CreateObjectHandle(objectPtr, _realm.SharedRealmHandle);
return(Expression.Constant(_realm.MakeObject(_metadata, objectHandle)));
}
if (m.Method.Name == nameof(Queryable.ElementAt))
{
throw new ArgumentOutOfRangeException();
}
Debug.Assert(m.Method.Name == nameof(Queryable.ElementAtOrDefault), $"The method {m.Method.Name} is not supported. We expected {nameof(Queryable.ElementAtOrDefault)}.");
return(Expression.Constant(null));
}
}
if (m.Method.DeclaringType == typeof(string) ||
m.Method.DeclaringType == typeof(StringExtensions))
{
QueryHandle.Operation <string> queryMethod = null;
// For extension methods, member should be m.Arguments[0] as MemberExpression;
MemberExpression member = null;
// For extension methods, that should be 1
var stringArgumentIndex = 0;
if (m.Method == Methods.String.Contains.Value)
{
queryMethod = (q, c, v) => q.StringContains(c, v, caseSensitive: true);
}
else if (m.Method == Methods.String.ContainsStringComparison.Value)
{
member = m.Arguments[0] as MemberExpression;
stringArgumentIndex = 1;
queryMethod = (q, c, v) => q.StringContains(c, v, GetComparisonCaseSensitive(m));
}
else if (m.Method == Methods.String.StartsWith.Value)
{
queryMethod = (q, c, v) => q.StringStartsWith(c, v, caseSensitive: true);
}
else if (m.Method == Methods.String.StartsWithStringComparison.Value)
{
queryMethod = (q, c, v) => q.StringStartsWith(c, v, GetComparisonCaseSensitive(m));
}
else if (m.Method == Methods.String.EndsWith.Value)
{
queryMethod = (q, c, v) => q.StringEndsWith(c, v, caseSensitive: true);
}
else if (m.Method == Methods.String.EndsWithStringComparison.Value)
{
queryMethod = (q, c, v) => q.StringEndsWith(c, v, GetComparisonCaseSensitive(m));
}
else if (m.Method == Methods.String.IsNullOrEmpty.Value)
{
member = m.Arguments.SingleOrDefault() as MemberExpression;
if (member == null)
{
throw new NotSupportedException($"The method '{m.Method}' has to be invoked with a RealmObject member");
}
var columnIndex = CoreQueryHandle.GetColumnIndex(member.Member.Name);
CoreQueryHandle.GroupBegin();
CoreQueryHandle.NullEqual(columnIndex);
CoreQueryHandle.Or();
CoreQueryHandle.StringEqual(columnIndex, string.Empty, caseSensitive: true);
CoreQueryHandle.GroupEnd();
return(m);
}
else if (m.Method == Methods.String.EqualsMethod.Value)
{
queryMethod = (q, c, v) => q.StringEqual(c, v, caseSensitive: true);
}
else if (m.Method == Methods.String.EqualsStringComparison.Value)
{
queryMethod = (q, c, v) => q.StringEqual(c, v, GetComparisonCaseSensitive(m));
}
else if (m.Method == Methods.String.Like.Value)
{
member = m.Arguments[0] as MemberExpression;
stringArgumentIndex = 1;
object caseSensitive;
if (!TryExtractConstantValue(m.Arguments.Last(), out caseSensitive) || !(caseSensitive is bool))
{
throw new NotSupportedException($"The method '{m.Method}' has to be invoked with a string and boolean constant arguments.");
}
queryMethod = (q, c, v) => q.StringLike(c, v, (bool)caseSensitive);
}
if (queryMethod != null)
{
member = member ?? m.Object as MemberExpression;
if (member == null)
{
throw new NotSupportedException($"The method '{m.Method}' has to be invoked on a RealmObject member");
}
var columnIndex = CoreQueryHandle.GetColumnIndex(member.Member.Name);
object argument;
if (!TryExtractConstantValue(m.Arguments[stringArgumentIndex], out argument) ||
(argument != null && argument.GetType() != typeof(string)))
{
throw new NotSupportedException($"The method '{m.Method}' has to be invoked with a single string constant argument or closure variable");
}
queryMethod(CoreQueryHandle, columnIndex, (string)argument);
return(m);
}
}
throw new NotSupportedException($"The method '{m.Method.Name}' is not supported");
}
private static void AddQueryEqual(QueryHandle queryHandle, string columnName, object value)
{
var columnIndex = queryHandle.GetColumnIndex(columnName);
if (value == null)
{
queryHandle.NullEqual(columnIndex);
}
else if (value is string)
{
queryHandle.StringEqual(columnIndex, (string)value);
}
else if (value is bool)
{
queryHandle.BoolEqual(columnIndex, (bool)value);
}
else if (value is char)
{
queryHandle.IntEqual(columnIndex, (int)value);
}
else if (value is int)
{
queryHandle.IntEqual(columnIndex, (int)value);
}
else if (value is long)
{
queryHandle.LongEqual(columnIndex, (long)value);
}
else if (value is float)
{
queryHandle.FloatEqual(columnIndex, (float)value);
}
else if (value is double)
{
queryHandle.DoubleEqual(columnIndex, (double)value);
}
else if (value is DateTimeOffset)
{
queryHandle.TimestampTicksEqual(columnIndex, (DateTimeOffset)value);
}
else if (value.GetType() == typeof(byte[]))
{
var buffer = (byte[])value;
if (buffer.Length == 0)
{
// see RealmObject.SetByteArrayValue
queryHandle.BinaryEqual(columnIndex, (IntPtr)0x1, IntPtr.Zero);
return;
}
unsafe
{
fixed(byte *bufferPtr = (byte[])value)
{
queryHandle.BinaryEqual(columnIndex, (IntPtr)bufferPtr, (IntPtr)buffer.LongLength);
}
}
}
else
{
throw new NotImplementedException();
}
}
internal override Expression VisitMethodCall(MethodCallExpression m)
{
if (m.Method.DeclaringType == typeof(Queryable))
{
if (m.Method.Name == nameof(Queryable.Where))
{
this.Visit(m.Arguments[0]);
LambdaExpression lambda = (LambdaExpression)StripQuotes(m.Arguments[1]);
this.Visit(lambda.Body);
return(m);
}
if (m.Method.Name == nameof(Queryable.OrderBy))
{
this.Visit(m.Arguments[0]);
AddSort((LambdaExpression)StripQuotes(m.Arguments[1]), true, true);
return(m);
}
if (m.Method.Name == nameof(Queryable.OrderByDescending))
{
this.Visit(m.Arguments[0]);
AddSort((LambdaExpression)StripQuotes(m.Arguments[1]), true, false);
return(m);
}
if (m.Method.Name == nameof(Queryable.ThenBy))
{
this.Visit(m.Arguments[0]);
AddSort((LambdaExpression)StripQuotes(m.Arguments[1]), false, true);
return(m);
}
if (m.Method.Name == nameof(Queryable.ThenByDescending))
{
this.Visit(m.Arguments[0]);
AddSort((LambdaExpression)StripQuotes(m.Arguments[1]), false, false);
return(m);
}
if (m.Method.Name == nameof(Queryable.Count))
{
RecurseToWhereOrRunLambda(m);
var foundCount = _coreQueryHandle.Count();
return(Expression.Constant(foundCount));
}
if (m.Method.Name == nameof(Queryable.Any))
{
RecurseToWhereOrRunLambda(m);
bool foundAny = _coreQueryHandle.FindDirect(IntPtr.Zero) != IntPtr.Zero;
return(Expression.Constant(foundAny));
}
if (m.Method.Name.StartsWith(nameof(Queryable.First)))
{
RecurseToWhereOrRunLambda(m);
IntPtr firstRowPtr = IntPtr.Zero;
if (OptionalSortDescriptorBuilder == null)
{
firstRowPtr = _coreQueryHandle.FindDirect(IntPtr.Zero);
}
else
{
using (ResultsHandle rh = _realm.MakeResultsForQuery(_coreQueryHandle, OptionalSortDescriptorBuilder))
{
firstRowPtr = rh.GetRow(0);
}
}
if (firstRowPtr != IntPtr.Zero)
{
return(Expression.Constant(_realm.MakeObjectForRow(_metadata, firstRowPtr)));
}
if (m.Method.Name == nameof(Queryable.First))
{
throw new InvalidOperationException("Sequence contains no matching element");
}
Debug.Assert(m.Method.Name == nameof(Queryable.FirstOrDefault));
return(Expression.Constant(null));
}
/*
* // FIXME: See discussion in the test DefaultIfEmptyReturnsDefault
* // kept because it shows part of what might be a viable implementation if can work out architectural issues
*
* if (m.Method.Name == nameof(Queryable.DefaultIfEmpty))
* {
* RecurseToWhereOrRunLambda(m);
* IntPtr firstRowPtr = _coreQueryHandle.FindDirect(IntPtr.Zero);
* if (firstRowPtr != IntPtr.Zero)
* return m; // as if just a "Where"
* var innerType = m.Type.GetGenericArguments()[0];
* var listType = typeof(List<>).MakeGenericType(innerType);
* var singleNullItemList = Activator.CreateInstance(listType);
* ((IList)singleNullItemList).Add(null);
* return Expression.Constant(singleNullItemList);
* }
*/
if (m.Method.Name.StartsWith(nameof(Queryable.Single))) // same as unsorted First with extra checks
{
RecurseToWhereOrRunLambda(m);
var firstRowPtr = _coreQueryHandle.FindDirect(IntPtr.Zero);
if (firstRowPtr == IntPtr.Zero)
{
if (m.Method.Name == nameof(Queryable.Single))
{
throw new InvalidOperationException("Sequence contains no matching element");
}
Debug.Assert(m.Method.Name == nameof(Queryable.SingleOrDefault));
return(Expression.Constant(null));
}
var firstRow = Realm.CreateRowHandle(firstRowPtr, _realm.SharedRealmHandle);
IntPtr nextIndex = (IntPtr)(firstRow.RowIndex + 1);
var nextRowPtr = _coreQueryHandle.FindDirect(nextIndex);
if (nextRowPtr != IntPtr.Zero)
{
throw new InvalidOperationException("Sequence contains more than one matching element");
}
return(Expression.Constant(_realm.MakeObjectForRow(_metadata, firstRow)));
}
if (m.Method.Name.StartsWith(nameof(Queryable.Last)))
{
RecurseToWhereOrRunLambda(m);
var lastRowPtr = IntPtr.Zero;
using (ResultsHandle rh = _realm.MakeResultsForQuery(_coreQueryHandle, OptionalSortDescriptorBuilder))
{
var lastIndex = rh.Count() - 1;
if (lastIndex >= 0)
{
lastRowPtr = rh.GetRow(lastIndex);
}
}
if (lastRowPtr != IntPtr.Zero)
{
return(Expression.Constant(_realm.MakeObjectForRow(_metadata, lastRowPtr)));
}
if (m.Method.Name == nameof(Queryable.Last))
{
throw new InvalidOperationException("Sequence contains no matching element");
}
Debug.Assert(m.Method.Name == nameof(Queryable.LastOrDefault));
return(Expression.Constant(null));
}
if (m.Method.Name.StartsWith(nameof(Queryable.ElementAt)))
{
var row = VisitElementAt(m);
if (row == null || row.IsInvalid)
{
if (m.Method.Name == nameof(Queryable.ElementAt))
{
throw new ArgumentOutOfRangeException();
}
Debug.Assert(m.Method.Name == nameof(Queryable.ElementAtOrDefault));
return(Expression.Constant(null));
}
return(Expression.Constant(_realm.MakeObjectForRow(_metadata, row)));
}
}
if (m.Method.DeclaringType == typeof(string))
{
QueryHandle.Operation <string> queryMethod = null;
if (m.Method == Methods.String.Contains.Value)
{
queryMethod = (q, c, v) => q.StringContains(c, v);
}
else if (m.Method == Methods.String.StartsWith.Value)
{
queryMethod = (q, c, v) => q.StringStartsWith(c, v);
}
else if (m.Method == Methods.String.EndsWith.Value)
{
queryMethod = (q, c, v) => q.StringEndsWith(c, v);
}
else if (m.Method == Methods.String.IsNullOrEmpty.Value)
{
var member = m.Arguments.SingleOrDefault() as MemberExpression;
if (member == null)
{
throw new NotSupportedException($"The method '{m.Method}' has to be invoked with a RealmObject member");
}
var columnIndex = _coreQueryHandle.GetColumnIndex(member.Member.Name);
_coreQueryHandle.GroupBegin();
_coreQueryHandle.NullEqual(columnIndex);
_coreQueryHandle.Or();
_coreQueryHandle.StringEqual(columnIndex, string.Empty);
_coreQueryHandle.GroupEnd();
return(m);
}
if (queryMethod != null)
{
var member = m.Object as MemberExpression;
if (member == null)
{
throw new NotSupportedException($"The method '{m.Method}' has to be invoked on a RealmObject member");
}
var columnIndex = _coreQueryHandle.GetColumnIndex(member.Member.Name);
object argument;
if (!TryExtractConstantValue(m.Arguments.SingleOrDefault(), out argument) || argument.GetType() != typeof(string))
{
throw new NotSupportedException($"The method '{m.Method}' has to be invoked with a single string constant argument or closure variable");
}
queryMethod(_coreQueryHandle, columnIndex, (string)argument);
return(m);
}
}
throw new NotSupportedException($"The method '{m.Method.Name}' is not supported");
}
private static void AddQueryGreaterThan(QueryHandle queryHandle, string columnName, object value)
{
var columnIndex = queryHandle.GetColumnIndex(columnName);
switch (value)
{
case char charValue:
queryHandle.IntGreater(columnIndex, charValue);
break;
case byte byteValue:
queryHandle.IntGreater(columnIndex, byteValue);
break;
case short shortValue:
queryHandle.IntGreater(columnIndex, shortValue);
break;
case int intValue:
queryHandle.IntGreater(columnIndex, intValue);
break;
case long longValue:
queryHandle.LongGreater(columnIndex, longValue);
break;
case float floatValue:
queryHandle.FloatGreater(columnIndex, floatValue);
break;
case double doubleValue:
queryHandle.DoubleGreater(columnIndex, doubleValue);
break;
case DateTimeOffset date:
queryHandle.TimestampTicksGreater(columnIndex, date);
break;
case string _:
case bool _:
throw new Exception($"Unsupported type {value.GetType().Name}");
case RealmInteger <byte> byteValue:
queryHandle.IntGreater(columnIndex, byteValue);
break;
case RealmInteger <short> shortValue:
queryHandle.IntGreater(columnIndex, shortValue);
break;
case RealmInteger <int> intValue:
queryHandle.IntGreater(columnIndex, intValue);
break;
case RealmInteger <long> longValue:
queryHandle.LongGreater(columnIndex, longValue);
break;
default:
throw new NotImplementedException();
}
}
private static void AddQueryNotEqual(QueryHandle queryHandle, string columnName, object value)
{
var columnIndex = queryHandle.GetColumnIndex(columnName);
switch (value)
{
case null:
queryHandle.NullNotEqual(columnIndex);
break;
case string stringValue:
queryHandle.StringNotEqual(columnIndex, stringValue, caseSensitive: true);
break;
case bool boolValue:
queryHandle.BoolNotEqual(columnIndex, boolValue);
break;
case char charValue:
queryHandle.IntNotEqual(columnIndex, charValue);
break;
case byte byteValue:
queryHandle.IntNotEqual(columnIndex, byteValue);
break;
case short shortValue:
queryHandle.IntNotEqual(columnIndex, shortValue);
break;
case int intValue:
queryHandle.IntNotEqual(columnIndex, intValue);
break;
case long longValue:
queryHandle.LongNotEqual(columnIndex, longValue);
break;
case float floatValue:
queryHandle.FloatNotEqual(columnIndex, floatValue);
break;
case double doubleValue:
queryHandle.DoubleNotEqual(columnIndex, doubleValue);
break;
case DateTimeOffset date:
queryHandle.TimestampTicksNotEqual(columnIndex, date);
break;
case byte[] buffer:
if (buffer.Length == 0)
{
// see RealmObject.SetByteArrayValue
queryHandle.BinaryNotEqual(columnIndex, (IntPtr)0x1, IntPtr.Zero);
return;
}
unsafe
{
fixed(byte *bufferPtr = (byte[])value)
{
queryHandle.BinaryNotEqual(columnIndex, (IntPtr)bufferPtr, (IntPtr)buffer.LongCount());
}
}
break;
case RealmObject obj:
queryHandle.Not();
queryHandle.ObjectEqual(columnIndex, obj.ObjectHandle);
break;
case RealmInteger <byte> byteValue:
queryHandle.IntNotEqual(columnIndex, byteValue);
break;
case RealmInteger <short> shortValue:
queryHandle.IntNotEqual(columnIndex, shortValue);
break;
case RealmInteger <int> intValue:
queryHandle.IntNotEqual(columnIndex, intValue);
break;
case RealmInteger <long> longValue:
queryHandle.LongNotEqual(columnIndex, longValue);
break;
default:
throw new NotImplementedException();
}
}
