// read subfingerprints using the separate hashes table
        public IList <SubFingerprintData> ReadSubFingerprintDataByHashBucketsWithThresholdSeparateTable(int[] hashBins, int thresholdVotes, bool ignoreHashTableIndex)
        {
            // check IEnumerable<SubFingerprintData> ReadSubFingerprintDataByHashBucketsWithThreshold(long[] hashBins, int thresholdVotes)
            // https://github.com/AddictedCS/soundfingerprinting.mongodb/blob/release/2.3.x/src/SoundFingerprinting.MongoDb/HashBinDao.cs

            LiteDB.BsonExpression query = null;
            if (ignoreHashTableIndex)
            {
                query = GetQueryForHashBinsIgnoreIndex(hashBins, true);
            }
            else
            {
                query = GetQueryForHashBins(hashBins);
            }

            // Get hash collection
            var col = db.GetCollection <Hash>("hashes");

            // ensure indexes
            col.EnsureIndex(x => x.HashBin);
            col.EnsureIndex(x => x.HashTable);

            // find the subfingerprints that have more than the threshold number
            // of hashes that belong to that subfingerprint
            var hashes = col.Find(query)
                         .GroupBy(g => g.SubFingerprintId)
                         .Select(s => new
            {
                Key          = s.Key,
                MatchedCount = s.Count(),
                Hashes       = s.OrderBy(f => f.HashTable)
            })
                         .Where(e => e.MatchedCount >= thresholdVotes)
                         .OrderByDescending(o => o.MatchedCount)
                         .Select(s => new ModelReference <string>(s.Key))
                         .ToList();

            if (!hashes.Any())
            {
                return(Enumerable.Empty <SubFingerprintData>().ToList());
            }

            // get the SubFingerprintData for each of the hits
            return(ReadSubFingerprintDataByReference(hashes));
        }
Exemple #2
0
 /// <summary>
 /// Filters a sequence of documents based on a predicate expression
 /// </summary>
 public ILiteQueryable <T> Where(string predicate, params BsonValue[] args)
 {
     _query.Where.Add(BsonExpression.Create(predicate, args));
     return(this);
 }
Exemple #3
0
 internal static LiteException InvalidExpressionTypePredicate(BsonExpression expr)
 {
     return(new LiteException(INVALID_EXPRESSION_TYPE, "Expression '{0}' are not supported as predicate expression.", expr.Source));
 }
        /// <summary>
        /// Returns all values from array according index. If index are MaxValue, return all values
        /// </summary>
        public static IEnumerable <BsonValue> Array(IEnumerable <BsonValue> values, int index, BsonExpression expr, BsonDocument root)
        {
            foreach (var value in values)
            {
                if (value.IsArray)
                {
                    var arr = value.AsArray;

                    // [expression(Func<BsonValue, bool>)]
                    if (expr.Source != null)
                    {
                        foreach (var item in arr)
                        {
                            // execute for each child value and except a first bool value (returns if true)
                            var c = expr.Execute(root, item, true).First();

                            if (c.IsBoolean && c.AsBoolean == true)
                            {
                                yield return(item);
                            }
                        }
                    }
                    // [all]
                    else if (index == int.MaxValue)
                    {
                        foreach (var item in arr)
                        {
                            yield return(item);
                        }
                    }
                    // [fixed_index]
                    else
                    {
                        var idx = index < 0 ? arr.Count + index : index;

                        if (arr.Count > idx)
                        {
                            yield return(arr[idx]);
                        }
                    }
                }
            }
        }
Exemple #5
0
 /// <summary>
 /// Delete all documents based on predicate expression. Returns how many documents was deleted
 /// </summary>
 public Task <int> DeleteManyAsync(string predicate, params BsonValue[] args) => this.DeleteManyAsync(BsonExpression.Create(predicate, args));
        /// <summary>
        /// Returns all values from array according filter expression or all values (index = MaxValue)
        /// </summary>
        public static IEnumerable <BsonValue> ARRAY_FILTER(BsonValue value, int index, BsonExpression filterExpr, BsonDocument root, Collation collation, BsonDocument parameters)
        {
            if (!value.IsArray)
            {
                yield break;
            }

            var arr = value.AsArray;

            // [*] - index are all values
            if (index == int.MaxValue)
            {
                foreach (var item in arr)
                {
                    yield return(item);
                }
            }
            // [<expr>] - index are an expression
            else
            {
                // update parameters in expression
                parameters.CopyTo(filterExpr.Parameters);

                foreach (var item in arr)
                {
                    // execute for each child value and except a first bool value (returns if true)
                    var c = filterExpr.ExecuteScalar(new BsonDocument[] { root }, root, item, collation);

                    if (c.IsBoolean && c.AsBoolean == true)
                    {
                        yield return(item);
                    }
                }
            }
        }
Exemple #7
0
 /// <summary>
 /// Find the first document using predicate expression. Returns null if not found
 /// </summary>
 public T FindOne(BsonExpression predicate, params BsonValue[] args) => this.FindOne(BsonExpression.Create(predicate, args));
Exemple #8
0
 /// <summary>
 /// Find the first document using predicate expression. Returns null if not found
 /// </summary>
 public T FindOne(BsonExpression predicate) => this.Find(predicate).FirstOrDefault();
        /// <summary>
        /// Returns all values from array according index. If index are MaxValue, return all values
        /// </summary>
        public static IEnumerable <BsonValue> Array(IEnumerable <BsonValue> values, int index, BsonExpression expr, BsonDocument root)
        {
            foreach (var value in values)
            {
                if (value.IsArray)
                {
                    var arr = value.AsArray;

                    // [<expr>] - index are an expression
                    if (expr.Source != null)
                    {
                        foreach (var item in arr)
                        {
                            // execute for each child value and except a first bool value (returns if true)
                            var c = expr.Execute(root, item, true).First();

                            if (c.IsBoolean && c.AsBoolean == true)
                            {
                                // fill destroy action to remove value from parent array
                                item.Destroy = () => arr.Remove(item);

                                yield return(item);
                            }
                        }
                    }
                    // [*] - index are all values
                    else if (index == int.MaxValue)
                    {
                        foreach (var item in arr)
                        {
                            // fill destroy action to remove value from parent array
                            item.Destroy = () => arr.Remove(item);

                            yield return(item);
                        }
                    }
                    // [n] - fixed index
                    else
                    {
                        var idx = index < 0 ? arr.Count + index : index;

                        if (arr.Count > idx)
                        {
                            var item = arr[idx];

                            // fill destroy action to remove value from parent array
                            item.Destroy = () => arr.Remove(item);

                            yield return(item);
                        }
                    }
                }
            }
        }
Exemple #10
0
 /// <summary>
 /// Delete all documents based on predicate expression. Returns how many documents was deleted
 /// </summary>
 public int DeleteMany(string predicate, params BsonValue[] args) => this.DeleteMany(BsonExpression.Create(predicate, args));
Exemple #11
0
 /// <summary>
 /// Delete all documents based on predicate expression. Returns how many documents was deleted
 /// </summary>
 public int DeleteMany(string predicate, BsonDocument parameters) => this.DeleteMany(BsonExpression.Create(predicate, parameters));
Exemple #12
0
 /// <summary>
 /// Execute Query[T].Where(predicate).SingleOrDefault();
 /// </summary>
 public T SingleOrDefault <T>(BsonExpression predicate, string collectionName = null)
 {
     return(this.Query <T>(collectionName)
            .Where(predicate)
            .SingleOrDefault());
 }
Exemple #13
0
 /// <summary>
 /// Execute Query[T].Where(predicate).First();
 /// </summary>
 public T First <T>(BsonExpression predicate, string collectionName = null)
 {
     return(this.Query <T>(collectionName)
            .Where(predicate)
            .First());
 }
Exemple #14
0
 /// <summary>
 /// Delete entity based on Query
 /// </summary>
 public int DeleteMany <T>(BsonExpression predicate, string collectionName = null)
 {
     return(_db.GetCollection <T>(collectionName).DeleteMany(predicate));
 }
 /// <summary>
 /// Create a new permanent index in all documents inside this collections if index not exists already. Returns true if index was created or false if already exits
 /// </summary>
 /// <param name="expression">Create a custom expression function to be indexed</param>
 /// <param name="unique">If is a unique index</param>
 /// <param name="collectionName">Collection Name</param>
 public bool EnsureIndex <T>(BsonExpression expression, bool unique = false, string collectionName = null)
 {
     return(_db.GetCollection <T>(collectionName).EnsureIndex(expression, unique));
 }
Exemple #16
0
 /// <summary>
 /// Count documents matching a query. This method does not deserialize any documents. Needs indexes on query expression
 /// </summary>
 public long LongCount(string predicate, BsonDocument parameters) => this.LongCount(BsonExpression.Create(predicate, parameters));
Exemple #17
0
 /// <summary>
 /// Count documents matching a query. This method does not deserialize any documents. Needs indexes on query expression
 /// </summary>
 public long LongCount(string predicate, params BsonValue[] args) => this.LongCount(BsonExpression.Create(predicate, args));
Exemple #18
0
 /// <summary>
 /// Find all files that match with predicate expression.
 /// </summary>
 public IEnumerable <LiteFileInfo <TFileId> > Find(string predicate, BsonDocument parameters) => this.Find(BsonExpression.Create(predicate, parameters));
Exemple #19
0
 /// <summary>
 /// Find the first document using predicate expression. Returns null if not found
 /// </summary>
 public T FindOne(string predicate, BsonDocument parameters) => this.FindOne(BsonExpression.Create(predicate, parameters));
Exemple #20
0
 /// <summary>
 /// Find all files that match with predicate expression.
 /// </summary>
 public IEnumerable <LiteFileInfo <TFileId> > Find(string predicate, params BsonValue[] args) => this.Find(BsonExpression.Create(predicate, args));
Exemple #21
0
        /// <summary>
        /// Get an IEnumerable of values from a json-like path inside document. Use BsonExpression to parse this path
        /// </summary>
        public IEnumerable <BsonValue> Get(string path, bool includeNullIfEmpty = false)
        {
            var expr = new BsonExpression(new StringScanner(path), true, true);

            return(expr.Execute(this, includeNullIfEmpty));
        }
Exemple #22
0
        private const int MAX_SORT_PAGES = 5000; // ~ 20Mb?

        /// <summary>
        /// EXPERIMENTAL Find with sort operation - use memory or disk (temp file) to sort
        /// </summary>
        public List <BsonDocument> FindSort(string collection, Query query, string orderBy, int order = Query.Ascending, int skip = 0, int limit = int.MaxValue)
        {
            if (collection.IsNullOrWhiteSpace())
            {
                throw new ArgumentNullException(nameof(collection));
            }
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }

            _log.Write(Logger.COMMAND, "query-sort documents in '{0}' => {1}", collection, query);

            // evaluate orderBy path/expression
            var expr = new BsonExpression(orderBy);

            // lock database for read access
            using (_locker.Read())
            {
                var last         = order == Query.Ascending ? BsonValue.MaxValue : BsonValue.MinValue;
                var total        = limit == int.MaxValue ? int.MaxValue : skip + limit;
                var indexCounter = 0;
                var disk         = new TempDiskService();

                // create memory database
                using (var engine = new LiteEngine(disk))
                {
                    // get collection page
                    var col = this.GetCollectionPage(collection, false);

                    if (col == null)
                    {
                        return(new List <BsonDocument>());
                    }

                    // create a temp collection in new memory database
                    var tmp = engine._collections.Add("tmp");

                    // create index pointer
                    var index = engine._indexer.CreateIndex(tmp);

                    // get head/tail index node
                    var head = engine._indexer.GetNode(index.HeadNode);
                    var tail = engine._indexer.GetNode(index.TailNode);

                    // first lets works only with index in query
                    var nodes = query.Run(col, _indexer);

                    foreach (var node in nodes)
                    {
                        var buffer = _data.Read(node.DataBlock);
                        var doc    = _bsonReader.Deserialize(buffer).AsDocument;

                        // if needs use filter
                        if (query.UseFilter && query.FilterDocument(doc) == false)
                        {
                            continue;
                        }

                        // get key to be sorted
                        var key  = expr.Execute(doc, true).First();
                        var diff = key.CompareTo(last);

                        // add to list only if lower than last space
                        if ((order == Query.Ascending && diff < 1) ||
                            (order == Query.Descending && diff > -1))
                        {
                            var tmpNode = engine._indexer.AddNode(index, key, null);

                            tmpNode.DataBlock     = node.DataBlock;
                            tmpNode.CacheDocument = doc;

                            indexCounter++;

                            // exceeded limit
                            if (indexCounter > total)
                            {
                                var exceeded = (order == Query.Ascending) ? tail.Prev[0] : head.Next[0];

                                engine._indexer.Delete(index, exceeded);

                                var lnode = (order == Query.Ascending) ? tail.Prev[0] : head.Next[0];

                                last = engine._indexer.GetNode(lnode).Key;

                                indexCounter--;
                            }

                            // if memory pages excedded limit size, flush to disk
                            if (engine._cache.DirtyUsed > MAX_SORT_PAGES)
                            {
                                engine._trans.PersistDirtyPages();

                                engine._trans.CheckPoint();
                            }
                        }
                    }

                    var result = new List <BsonDocument>();

                    // if skip is lower than limit, take nodes from skip from begin
                    // if skip is higher than limit, take nodes from end and revert order (avoid lots of skip)
                    var find = skip < limit?
                               engine._indexer.FindAll(index, order).Skip(skip).Take(limit) :    // get from original order
                                   engine._indexer.FindAll(index, -order).Take(limit).Reverse(); // avoid long skips, take from end and revert

                    // --- foreach (var node in engine._indexer.FindAll(index, order).Skip(skip).Take(limit))
                    foreach (var node in find)
                    {
                        // if document are in cache, use it. if not, get from disk again
                        var doc = node.CacheDocument;

                        if (doc == null)
                        {
                            var buffer = _data.Read(node.DataBlock);
                            doc = _bsonReader.Deserialize(buffer).AsDocument;
                        }

                        result.Add(doc);
                    }

                    return(result);
                }
            }
        }
Exemple #23
0
 /// <summary>
 /// Delete all documents based on predicate expression. Returns how many documents was deleted
 /// </summary>
 public Task <int> DeleteManyAsync(string predicate, BsonDocument parameters) => this.DeleteManyAsync(BsonExpression.Create(predicate, parameters));
Exemple #24
0
        /// <summary>
        /// [ EXPLAIN ]
        ///    SELECT {selectExpr}
        ///    [ INTO {newcollection|$function} [ : {autoId} ] ]
        ///    [ FROM {collection|$function} ]
        /// [ INCLUDE {pathExpr0} [, {pathExprN} ]
        ///   [ WHERE {filterExpr} ]
        ///   [ GROUP BY {groupByExpr} ]
        ///  [ HAVING {filterExpr} ]
        ///   [ ORDER BY {orderByExpr} [ ASC | DESC ] ]
        ///   [ LIMIT {number} ]
        ///  [ OFFSET {number} ]
        ///     [ FOR UPDATE ]
        /// </summary>
        private IBsonDataReader ParseSelect()
        {
            // initialize query definition
            var query = new Query();

            var token = _tokenizer.ReadToken();

            query.ExplainPlan = token.Is("EXPLAIN");

            if (query.ExplainPlan)
            {
                token = _tokenizer.ReadToken();
            }

            token.Expect("SELECT");

            // read required SELECT <expr> and convert into single expression
            query.Select = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.SelectDocument, _parameters);

            // read FROM|INTO
            var from = _tokenizer.ReadToken();

            if (from.Type == TokenType.EOF || from.Type == TokenType.SemiColon)
            {
                // select with no FROM - just run expression (avoid DUAL table, Mr. Oracle)
                //TODO: i think will be better add all sql into engine
                var result = query.Select.Execute(_collation.Value);

                var defaultName = "expr";

                return(new BsonDataReader(result.Select(x => x.IsDocument ? x.AsDocument : new BsonDocument {
                    [defaultName] = x
                }), null));
            }
            else if (from.Is("INTO"))
            {
                query.Into       = ParseCollection(_tokenizer);
                query.IntoAutoId = this.ParseWithAutoId();

                _tokenizer.ReadToken().Expect("FROM");
            }
            else
            {
                from.Expect("FROM");
            }

            // read FROM <name>
            var collection = ParseCollection(_tokenizer);

            var ahead = _tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);

            if (ahead.Is("INCLUDE"))
            {
                // read first INCLUDE (before)
                _tokenizer.ReadToken();

                foreach (var path in this.ParseListOfExpressions())
                {
                    query.Includes.Add(path);
                }
            }

            ahead = _tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);

            if (ahead.Is("WHERE"))
            {
                // read WHERE keyword
                _tokenizer.ReadToken();

                var where = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);

                query.Where.Add(where);
            }

            ahead = _tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);

            if (ahead.Is("GROUP"))
            {
                // read GROUP BY keyword
                _tokenizer.ReadToken();
                _tokenizer.ReadToken().Expect("BY");

                var groupBy = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);

                query.GroupBy = groupBy;

                ahead = _tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);

                if (ahead.Is("HAVING"))
                {
                    // read HAVING keyword
                    _tokenizer.ReadToken();

                    var having = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);

                    query.Having = having;
                }
            }

            ahead = _tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);

            if (ahead.Is("ORDER"))
            {
                // read ORDER BY keyword
                _tokenizer.ReadToken();
                _tokenizer.ReadToken().Expect("BY");

                var orderBy = BsonExpression.Create(_tokenizer, BsonExpressionParserMode.Full, _parameters);

                var orderByOrder = Query.Ascending;
                var orderByToken = _tokenizer.LookAhead();

                if (orderByToken.Is("ASC") || orderByToken.Is("DESC"))
                {
                    orderByOrder = _tokenizer.ReadToken().Is("ASC") ? Query.Ascending : Query.Descending;
                }

                query.OrderBy = orderBy;
                query.Order   = orderByOrder;
            }

            ahead = _tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);

            if (ahead.Is("LIMIT"))
            {
                // read LIMIT keyword
                _tokenizer.ReadToken();
                var limit = _tokenizer.ReadToken().Expect(TokenType.Int).Value;

                query.Limit = Convert.ToInt32(limit);
            }

            ahead = _tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);

            if (ahead.Is("OFFSET"))
            {
                // read OFFSET keyword
                _tokenizer.ReadToken();
                var offset = _tokenizer.ReadToken().Expect(TokenType.Int).Value;

                query.Offset = Convert.ToInt32(offset);
            }

            ahead = _tokenizer.LookAhead().Expect(TokenType.Word, TokenType.EOF, TokenType.SemiColon);

            if (ahead.Is("FOR"))
            {
                // read FOR keyword
                _tokenizer.ReadToken();
                _tokenizer.ReadToken().Expect("UPDATE");

                query.ForUpdate = true;
            }

            // read eof/;
            _tokenizer.ReadToken().Expect(TokenType.EOF, TokenType.SemiColon);

            return(_engine.Query(collection, query));
        }
Exemple #25
0
        /// <summary>
        /// Internal implementation of insert a document
        /// </summary>
        private void InsertDocument(CollectionPage col, BsonDocument doc, BsonType autoId)
        {
            // collection Sequence was created after release current datafile version.
            // In this case, Sequence will be 0 but already has documents. Let's fix this
            // ** this code can be removed when datafile change from 7 (HeaderPage.FILE_VERSION) **
            if (col.Sequence == 0 && col.DocumentCount > 0)
            {
                var max = this.Max(col.CollectionName, "_id");

                // if max value is a number, convert to Sequence last value
                // if not, just set sequence as document count
                col.Sequence = (max.IsInt32 || max.IsInt64 || max.IsDouble || max.IsDecimal) ?
                               Convert.ToInt64(max.RawValue) :
                               Convert.ToInt64(col.DocumentCount);
            }

            // increase collection sequence _id
            col.Sequence++;

            _pager.SetDirty(col);

            // if no _id, add one
            if (!doc.RawValue.TryGetValue("_id", out var id))
            {
                doc["_id"] = id =
                    autoId == BsonType.ObjectId ? new BsonValue(ObjectId.NewObjectId()) :
                    autoId == BsonType.Guid ? new BsonValue(Guid.NewGuid()) :
                    autoId == BsonType.DateTime ? new BsonValue(DateTime.Now) :
                    autoId == BsonType.Int32 ? new BsonValue((Int32)col.Sequence) :
                    autoId == BsonType.Int64 ? new BsonValue(col.Sequence) : BsonValue.Null;
            }
            // create bubble in sequence number if _id is bigger than current sequence
            else if (autoId == BsonType.Int32 || autoId == BsonType.Int64)
            {
                var current = id.AsInt64;

                // if current id is bigger than sequence, jump sequence to this number. Other was, do not increse sequnce
                col.Sequence = current >= col.Sequence ? current : col.Sequence - 1;
            }

            // test if _id is a valid type
            if (id.IsNull || id.IsMinValue || id.IsMaxValue)
            {
                throw LiteException.InvalidDataType("_id", id);
            }

            _log.Write(Logger.COMMAND, "insert document on '{0}' :: _id = {1}", col.CollectionName, id.RawValue);

            // serialize object
            var bytes = _bsonWriter.Serialize(doc);

            // storage in data pages - returns dataBlock address
            var dataBlock = _data.Insert(col, bytes);

            // store id in a PK index [0 array]
            var pk = _indexer.AddNode(col.PK, id, null);

            // do link between index <-> data block
            pk.DataBlock = dataBlock.Position;

            // for each index, insert new IndexNode
            foreach (var index in col.GetIndexes(false))
            {
                // for each index, get all keys (support now multi-key) - gets distinct values only
                // if index are unique, get single key only
                var expr = new BsonExpression(index.Expression);
                var keys = expr.Execute(doc, true);

                // do a loop with all keys (multi-key supported)
                foreach (var key in keys)
                {
                    // insert node
                    var node = _indexer.AddNode(index, key, pk);

                    // link my index node to data block address
                    node.DataBlock = dataBlock.Position;
                }
            }
        }
Exemple #26
0
        /// <summary>
        /// Implement internal update document
        /// </summary>
        private bool UpdateDocument(CollectionPage col, BsonDocument doc)
        {
            // normalize id before find
            var id = doc["_id"];

            // validate id for null, min/max values
            if (id.IsNull || id.IsMinValue || id.IsMaxValue)
            {
                throw LiteException.InvalidDataType("_id", id);
            }

            _log.Write(Logger.COMMAND, "update document on '{0}' :: _id = {1}", col.CollectionName, id.RawValue);

            // find indexNode from pk index
            var pkNode = _indexer.Find(col.PK, id, false, Query.Ascending);

            // if not found document, no updates
            if (pkNode == null)
            {
                return(false);
            }

            // serialize document in bytes
            var bytes = _bsonWriter.Serialize(doc);

            // update data storage
            var dataBlock = _data.Update(col, pkNode.DataBlock, bytes);

            // get all non-pk index nodes from this data block
            var allNodes = _indexer.GetNodeList(pkNode, false).ToArray();

            // delete/insert indexes - do not touch on PK
            foreach (var index in col.GetIndexes(false))
            {
                var expr = new BsonExpression(index.Expression);

                // getting all keys do check
                var keys = expr.Execute(doc).ToArray();

                // get a list of to delete nodes (using ToArray to resolve now)
                var toDelete = allNodes
                               .Where(x => x.Slot == index.Slot && !keys.Any(k => k == x.Key))
                               .ToArray();

                // get a list of to insert nodes (using ToArray to resolve now)
                var toInsert = keys
                               .Where(x => !allNodes.Any(k => k.Slot == index.Slot && k.Key == x))
                               .ToArray();

                // delete changed index nodes
                foreach (var node in toDelete)
                {
                    _indexer.Delete(index, node.Position);
                }

                // insert new nodes
                foreach (var key in toInsert)
                {
                    // and add a new one
                    var node = _indexer.AddNode(index, key, pkNode);

                    // link my node to data block
                    node.DataBlock = dataBlock.Position;
                }
            }

            return(true);
        }
Exemple #27
0
 internal static LiteException InvalidExpressionType(BsonExpression expr, BsonExpressionType type)
 {
     return(new LiteException(INVALID_EXPRESSION_TYPE, "Expression '{0}' must be a {1} type.", expr.Source, type));
 }
Exemple #28
0
 /// <summary>
 /// Returns true if query returns any document. This method does not deserialize any document. Needs indexes on query expression
 /// </summary>
 public bool Exists(string predicate, BsonDocument parameters) => this.Exists(BsonExpression.Create(predicate, parameters));
Exemple #29
0
 /// <summary>
 /// Returns true if query returns any document. This method does not deserialize any document. Needs indexes on query expression
 /// </summary>
 public bool Exists(string predicate, params BsonValue[] args) => this.Exists(BsonExpression.Create(predicate, args));
Exemple #30
0
 /// <summary>
 /// Filters a sequence of documents based on a predicate expression
 /// </summary>
 public ILiteQueryable <T> Where(string predicate, BsonDocument parameters)
 {
     _query.Where.Add(BsonExpression.Create(predicate, parameters));
     return(this);
 }