private void AddSort(LambdaExpression lambda, bool isStarting, bool ascending)
        {
            var body = lambda.Body as MemberExpression;

            if (body == null)
            {
                throw new NotSupportedException($"The expression {lambda} cannot be used in an Order clause");
            }

            if (isStarting)
            {
                if (OptionalSortDescriptorBuilder == null)
                {
                    OptionalSortDescriptorBuilder = new SortDescriptorBuilder(_metadata.Table);
                }
                else
                {
                    var badCall = ascending ? "ThenBy" : "ThenByDescending";
                    throw new NotSupportedException($"You can only use one OrderBy or OrderByDescending clause, subsequent sort conditions should be {badCall}");
                }
            }

            var propertyChain = TraverseSort(body).Select(n =>
            {
                var metadata = _realm.Metadata[n.Item1.Name];
                return(metadata.PropertyIndices[n.Item2]);
            });

            OptionalSortDescriptorBuilder.AddClause(propertyChain, ascending);
        }
Пример #2
0
        private void AddSort(LambdaExpression lambda, bool isStarting, bool ascending)
        {
            var body = lambda.Body as MemberExpression;

            if (body == null)
            {
                throw new NotSupportedException($"The expression {lambda} cannot be used in an Order clause");
            }

            if (isStarting)
            {
                if (OptionalSortDescriptorBuilder == null)
                {
                    OptionalSortDescriptorBuilder = _realm.CreateSortDescriptorForTable(_metadata);
                }
                else
                {
                    var badCall = ascending ? "ThenBy" : "ThenByDescending";
                    throw new NotSupportedException($"You can only use one OrderBy or OrderByDescending clause, subsequent sort conditions should be {badCall}");
                }
            }

            var sortColName = body.Member.Name;

            OptionalSortDescriptorBuilder.AddClause(sortColName, ascending);
        }
Пример #3
0
        public IntPtr CreateSortedResults(SharedRealmHandle sharedRealmHandle, SortDescriptorBuilder sortDescriptorBuilder)
        {
            var marshaledValues = sortDescriptorBuilder.Flatten();
            var result          = NativeMethods.create_sorted_results(this, sharedRealmHandle, marshaledValues.Item2, (IntPtr)marshaledValues.Item2.Length, marshaledValues.Item1, out var nativeException);

            nativeException.ThrowIfNecessary();
            return(result);
        }
Пример #4
0
        internal ResultsHandle MakeResultsForQuery(QueryHandle builtQuery, SortDescriptorBuilder optionalSortDescriptorBuilder)
        {
            var resultsPtr = IntPtr.Zero;

            if (optionalSortDescriptorBuilder == null)
            {
                return(builtQuery.CreateResults(SharedRealmHandle));
            }

            return(builtQuery.CreateSortedResults(SharedRealmHandle, optionalSortDescriptorBuilder));
        }
Пример #5
0
        public static IntPtr CreateSortedResults(TableHandle tableHandle, SharedRealmHandle sharedRealmHandle, SortDescriptorBuilder sortDescriptorBuilder)
        {
            NativeException nativeException;
            var             marshaledValues = sortDescriptorBuilder.Flatten();
            var             result          = create_sorted_results(tableHandle, sharedRealmHandle, marshaledValues.Item2, (IntPtr)marshaledValues.Item2.Length, marshaledValues.Item1, out nativeException);

            nativeException.ThrowIfNecessary();
            return(result);
        }