Esempio n. 1
0
        public int RemoveByIdAdvancedParam(ByteBuffer prefixBytes, uint prefixFieldCount,
                                           EnumerationOrder order,
                                           KeyProposition startKeyProposition, ByteBuffer startKeyBytes,
                                           KeyProposition endKeyProposition, ByteBuffer endKeyBytes)
        {
            using var enumerator = new RelationAdvancedEnumerator <T>(this, prefixBytes, prefixFieldCount,
                                                                      order, startKeyProposition, startKeyBytes, endKeyProposition, endKeyBytes, 0);
            var keysToDelete = new List <ByteBuffer>();

            while (enumerator.MoveNext())
            {
                keysToDelete.Add(enumerator.GetKeyBytes());
            }

            foreach (var key in keysToDelete)
            {
                RemoveById(key, true);
            }

            return(keysToDelete.Count);
        }
Esempio n. 2
0
        public long CountWithProposition(ByteBuffer prefixBytes,
                                         KeyProposition startKeyProposition, ByteBuffer startKeyBytes,
                                         KeyProposition endKeyProposition, ByteBuffer endKeyBytes)
        {
            var keyValueTrProtector = _transaction.TransactionProtector;

            if (endKeyProposition == KeyProposition.Included)
            {
                endKeyBytes = RelationAdvancedEnumerator <T> .FindLastKeyWithPrefix(prefixBytes, endKeyBytes, _kvtr, keyValueTrProtector);
            }

            keyValueTrProtector.Start();
            _kvtr.SetKeyPrefix(prefixBytes);

            long startIndex;
            long endIndex;

            if (endKeyProposition == KeyProposition.Ignored)
            {
                endIndex = _kvtr.GetKeyValueCount() - 1;
            }
            else
            {
                switch (_kvtr.Find(endKeyBytes))
                {
                case FindResult.Exact:
                    endIndex = _kvtr.GetKeyIndex();
                    if (endKeyProposition == KeyProposition.Excluded)
                    {
                        endIndex--;
                    }
                    break;

                case FindResult.Previous:
                    endIndex = _kvtr.GetKeyIndex();
                    break;

                case FindResult.Next:
                    endIndex = _kvtr.GetKeyIndex() - 1;
                    break;

                case FindResult.NotFound:
                    endIndex = -1;
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
            if (startKeyProposition == KeyProposition.Ignored)
            {
                startIndex = 0;
            }
            else
            {
                switch (_kvtr.Find(startKeyBytes))
                {
                case FindResult.Exact:
                    startIndex = _kvtr.GetKeyIndex();
                    if (startKeyProposition == KeyProposition.Excluded)
                    {
                        startIndex++;
                    }
                    break;

                case FindResult.Previous:
                    startIndex = _kvtr.GetKeyIndex() + 1;
                    break;

                case FindResult.Next:
                    startIndex = _kvtr.GetKeyIndex();
                    break;

                case FindResult.NotFound:
                    startIndex = 0;
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
            return(Math.Max(0, endIndex - startIndex + 1));
        }