Puis - je faire une requête texte avec le pilote mongodb c#

y a-t-il un moyen de soumettre une requête qui est exprimée dans la syntaxe de requête de l'interpréteur de commandes au pilote C# de mongo

Par exemple quelque Chose comme

Coll.find { "myrecs","$query : { x : 3, y : "abc" }, $orderby : { x : 1 } } ");

Pour prendre un exemple de la coquille guide

24
demandé sur jack.the.ripper 2011-05-25 10:52:47

5 réponses

il n'y a pas exactement la même fonctionnalité que vous voulez.

mais vous pouvez créer BsonDocument à partir de JSON pour la requête:

var jsonQuery = "{ x : 3, y : 'abc' }";
BsonDocument doc = MongoDB.Bson.Serialization
                   .BsonSerializer.Deserialize<BsonDocument>(jsonQuery);

Et après que vous pouvez créer une requête à partir de BsonDocument:

var query = new QueryComplete(doc); // or probably Query.Wrap(doc);

La même chose que vous pouvez faire pour l'expression de tri:

var jsonOrder = "{ x : 1 }";
BsonDocument orderDoc = BsonSerializer.Deserialize<BsonDocument>(jsonQuery);

var sortExpr = new SortByWrapper(orderDoc);

vous pouvez aussi créer la méthode extension pour la MongoCollection comme ceci:

public static List<T> GetItems<T>(this MongoCollection collection, string queryString, string orderString) where T : class 
{
    var queryDoc = BsonSerializer.Deserialize<BsonDocument>(queryString);
    var orderDoc = BsonSerializer.Deserialize<BsonDocument>(orderString);

    //as of version 1.8 you should use MongoDB.Driver.QueryDocument instead (thanks to @Erik Hunter)
    var query = new QueryComplete(queryDoc);
    var order = new SortByWrapper(orderDoc);

    var cursor = collection.FindAs<T>(query);
    cursor.SetSortOrder(order);

    return cursor.ToList();
}

Je n'ai pas testé le code ci-dessus. Allons le faire plus tard si besoin.

mise à Jour:

vient de tester le code ci-dessus, il fonctionne!

Vous pouvez l'utiliser comme ceci:

var server = MongoServer.Create("mongodb://localhost:27020");
var collection= server.GetDatabase("examples").GetCollection("SO");

var items = collection.GetItems<DocType>("{ x : 3, y : 'abc' }", "{ x : 1 }");
33
répondu Andrew Orsich 2017-04-03 07:15:40

la classe QueryComplete semble avoir été dépréciée. Utilisez MongoDB.Driver.QueryDocument à la place. Comme ci-dessous:

BsonDocument document = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{ name : value }");
QueryDocument queryDoc = new QueryDocument(document);
MongoCursor toReturn = collection.Find(queryDoc);
14
répondu Erik Hunter 2017-04-03 07:17:16

Voici une fonction de service web que j'ai écrite que vous pouvez envoyer dans une requête de filtre, limite, et sauter pour la pagination et une requête de tri pour n'importe quelle collection que vous voulez! Elle est générique et rapide.

    /// <summary>
    /// This method returns data from a collection specified by data type
    /// </summary>
    /// <param name="dataType"></param>
    /// <param name="filter">filter is a json specified filter. one or more separated by commas.  example: { "value":"23" }  example: { "enabled":true, "startdate":"2015-10-10"}</param>
    /// <param name="limit">limit and skip are for pagination, limit is the number of results per page</param>
    /// <param name="skip">skip is is the page size * page. so limit of 100 should use skip 0,100,200,300,400, etc. which represent page 1,2,3,4,5, etc</param>
    /// <param name="sort">specify which fields to sort and direction example:  { "value":1 }  for ascending, {"value:-1} for descending</param>
    /// <returns></returns>
    [WebMethod]
    public string GetData(string dataType, string filter, int limit, int skip, string sort) {
        //example: limit of 100 and skip of 0 returns the first 100 records

        //get bsondocument from a collection dynamically identified by datatype
        try {
            MongoCollection<BsonDocument> col = MongoDb.GetConnection("qis").GetCollection<BsonDocument>(dataType);
            if (col == null) {
                return "Error: Collection Not Found";
            }

            MongoCursor cursor = null;
            SortByWrapper sortExpr = null;

            //calc sort order
            try {
                BsonDocument orderDoc = BsonSerializer.Deserialize<BsonDocument>(sort);
                sortExpr = new SortByWrapper(orderDoc);
            } catch { }

            //create a query from the filter if one is specified
            try {
                if (filter != "") {
                    //sample filter: "{tags:'dog'},{enabled:true}"
                    BsonDocument query = BsonSerializer.Deserialize<BsonDocument>(filter);
                    QueryDocument queryDoc = new QueryDocument(query);
                    cursor = col.Find(queryDoc).SetSkip(skip).SetLimit(limit);

                    if (sortExpr != null) {
                        cursor.SetSortOrder(sortExpr);
                    }

                    return cursor.ToJson();
                }
            } catch{}


            //if no filter specified or the filter failed just return all
            cursor = col.FindAll().SetSkip(skip).SetLimit(limit);

            if (sortExpr != null) {
                cursor.SetSortOrder(sortExpr);
            }

            return cursor.ToJson();
        } catch(Exception ex) {
            return "Exception: " + ex.Message;
        }
    }

en supposant que j'ai ces enregistrements dans ma collection appelé "mytest2":

[{ "_id" : ObjectId("54ff7b1e5cc61604f0bc3016"), "timestamp" : "2015-01-10 10:10:10", "value" : "23" }, 
 { "_id" : ObjectId("54ff7b415cc61604f0bc3017"), "timestamp" : "2015-01-10 10:10:11", "value" : "24" }, 
 { "_id" : ObjectId("54ff7b485cc61604f0bc3018"), "timestamp" : "2015-01-10 10:10:12", "value" : "25" }, 
 { "_id" : ObjectId("54ff7b4f5cc61604f0bc3019"), "timestamp" : "2015-01-10 10:10:13", "value" : "26" }]

je pourrais faire l'appel de service web avec les paramètres suivants pour retourner 100 enregistrements à partir de la première page où valeur > = 23 et valeur <= 26, en décroissant 

dataType: mytest2
filter: { value: {$gte: 23}, value: {$lte: 26} }
limit: 100
skip: 0
sort: { "value": -1 }

Profitez-en!

5
répondu JJ_Coder4Hire 2015-03-11 01:02:33

voici quelques routines que j'utilise pour convertir les objets string et from .net en requêtes BSON (ceci fait partie de l'enveloppeur d'objet d'affaires, donc quelques références à cette classe):

    public QueryDocument GetQueryFromString(string jsonQuery)
    {
        return new QueryDocument(BsonSerializer.Deserialize<BsonDocument>(jsonQuery));
    }

    public IEnumerable<T> QueryFromString<T>(string jsonQuery, string collectionName = null)
    {
        if (string.IsNullOrEmpty(collectionName))
            collectionName = this.CollectionName;

        var query = GetQueryFromString(jsonQuery);            
        var items = Database.GetCollection<T>(collectionName).Find(query);

        return items as IEnumerable<T>;
    }


    public IEnumerable<T> QueryFromObject<T>(object queryObject, string collectionName = null)
    {
        if (string.IsNullOrEmpty(collectionName))
            collectionName = this.CollectionName;

        var query = new QueryDocument(queryObject.ToBsonDocument());
        var items = Database.GetCollection<T>(collectionName).Find(query);

        return items as IEnumerable<T>;
    }

en utilisant ceux-ci, il est assez facile de faire des requêtes via des parmes de chaîne ou d'objet:

var questionBus = new busQuestion();           
var json = "{ QuestionText: /elimination/, GroupName: \"Elimination\" }";
var questions = questionBus.QueryFromString<Question>(json);

foreach(var question in questions) { ... }

ou à l'aide de l'objet de la syntaxe:

var questionBus = new busQuestion();            
var query = new {QuestionText = new BsonRegularExpression("/elimination/"), 
                 GroupName = "Elimination"};
var questions = questionBus.QueryFromObject<Question>(query);

foreach(var question in questions) { ... }

j'aime la syntaxe de l'objet tout simplement parce qu'il est un peu plus facile d'écrire en code C que de traiter avec des guillemets inclus dans des chaînes JSON s'ils sont handcoded.

4
répondu Rick Strahl 2014-01-27 22:47:48

officiel C# pilote, vous feriez quelque chose comme ceci:

var server = MongoServer.Create("mongodb://localhost:27017");
var db = server.GetDatabase("mydb");
var col = db.GetCollection("col");

var query = Query.And(Query.EQ("x", 3), Query.EQ("y", "abc"));
var resultsCursor = col.Find(query).SetSortOrder("x");
var results = resultsCursor.ToList();

la requête équivalente du shell serait:

col.find({ x: 3, y: "abc" }).sort({ x: 1 })
0
répondu Chris Fulstow 2011-05-25 11:30:56