Exemplo n.º 1
0
        public void setup()
        {
            _mongo = MongoTestHelper.create_new_database_connection();
            _provider = new MongoQueryProvider(_mongo);

            _mongo.Database.DropCollection(typeof (Book).Name);
        }
 public void TestConstructorWithOneArgument()
 {
     var provider = new MongoQueryProvider(_collection);
     var iqueryable = (IQueryable)new MongoQueryable<C>(provider);
     Assert.AreSame(typeof(C), iqueryable.ElementType);
     Assert.AreSame(provider, iqueryable.Provider);
 }
 /// <summary>
 /// Translate a MongoDB LINQ query.
 /// </summary>
 /// <param name="provider">The MongoDB query provider.</param>
 /// <param name="expression">The LINQ query expression.</param>
 /// <returns>A TranslatedQuery.</returns>
 public static TranslatedQuery Translate(MongoQueryProvider provider, Expression expression)
 {
     expression = PartialEvaluator.Evaluate(expression, provider.CanBeEvaluatedLocally);
     // assume for now it's a SelectQuery
     var documentType = GetDocumentType(expression);
     var selectQuery = new SelectQuery(provider.Collection, documentType);
     selectQuery.Translate(expression);
     return selectQuery;
 }
 public void TestCreateQueryNonGeneric()
 {
     var expression = collection.AsQueryable<C>().Expression;
     var provider = new MongoQueryProvider(collection);
     var query = provider.CreateQuery(expression);
     Assert.AreSame(typeof(C), query.ElementType);
     Assert.AreSame(provider, query.Provider);
     Assert.AreSame(expression, query.Expression);
 }
Exemplo n.º 5
0
        public void ConfigureQuerying()
        {
            var mongoQueryProvider = new MongoQueryProvider(_queryConfiguration.DatabaseName,
                _queryConfiguration.Server,
                _queryConfiguration.ServerPort,
                _queryConfiguration.Options);

            ObjectFactory.Configure(configure =>
                {
                    configure.For<IMongoQueryProvider>().Use(mongoQueryProvider);
                    configure.For<IMongoDatabase>().Use(mongoQueryProvider.Db);
                });
        }
 public void TestConstructor()
 {
     var provider = new MongoQueryProvider(collection);
 }
Exemplo n.º 7
0
        public static ExecutableQuery <TDocument, TResult> TranslateScalar <TDocument, TResult>(MongoQueryProvider <TDocument> provider, Expression expression)
        {
            expression = PartialEvaluator.EvaluatePartially(expression);

            var context = TranslationContext.Create(expression, provider.CollectionDocumentSerializer);
            var methodCallExpression = (MethodCallExpression)expression;

            switch (methodCallExpression.Method.Name)
            {
            case "All":
                return(AllMethodToExecutableQueryTranslator.Translate(provider, context, methodCallExpression).AsExecutableQuery <TDocument, TResult>());

            case "Any":
            case "AnyAsync":
                return(AnyMethodToExecutableQueryTranslator.Translate(provider, context, methodCallExpression).AsExecutableQuery <TDocument, TResult>());

            case "Average":
            case "AverageAsync":
                return(AverageMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));

            case "Contains":
                return(ContainsMethodToExecutableQueryTranslator.Translate(provider, context, methodCallExpression).AsExecutableQuery <TDocument, TResult>());;

            case "Count":
            case "CountAsync":
                return(CountMethodToExecutableQueryTranslator.Translate(provider, context, methodCallExpression).AsExecutableQuery <TDocument, TResult>());

            case "ElementAt":
                return(ElementAtMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));

            case "First":
            case "FirstAsync":
            case "FirstOrDefault":
            case "FirstOrDefaultAsync":
                return(FirstMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));

            case "Last":
            case "LastOrDefault":
                return(LastMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));

            case "LongCount":
            case "LongCountAsync":
                return(LongCountMethodToExecutableQueryTranslator.Translate(provider, context, methodCallExpression).AsExecutableQuery <TDocument, TResult>());

            case "Max":
            case "MaxAsync":
                return(MaxMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));

            case "Min":
            case "MinAsync":
                return(MinMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));

            case "Single":
            case "SingleAsync":
            case "SingleOrDefault":
            case "SingleOrDefaultAsync":
                return(SingleMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));

            case "StandardDeviationPopulation":
            case "StandardDeviationPopulationAsync":
            case "StandardDeviationSample":
            case "StandardDeviationSampleAsync":
                return(StandardDeviationMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));

            case "Sum":
            case "SumAsync":
                return(SumMethodToExecutableQueryTranslator <TResult> .Translate(provider, context, methodCallExpression));
            }

            throw new ExpressionNotSupportedException(expression);
        }
Exemplo n.º 8
0
        // public static methods
        public static ExecutableQuery <TDocument, IAsyncCursor <TOutput> > Translate <TDocument, TOutput>(MongoQueryProvider <TDocument> provider, Expression expression)
        {
            expression = PartialEvaluator.EvaluatePartially(expression);

            var context  = TranslationContext.Create(expression, provider.CollectionDocumentSerializer);
            var pipeline = ExpressionToPipelineTranslator.Translate(context, expression);

            return(ExecutableQuery.Create(
                       provider.Collection,
                       provider.Options,
                       pipeline,
                       IdentityFinalizer <TOutput> .Instance));
        }
Exemplo n.º 9
0
 public void TestConstructor()
 {
     var provider = new MongoQueryProvider(_collection);
 }
Exemplo n.º 10
0
        /// <summary>
        /// The main.
        /// </summary>
        /// <param name="args">
        /// The args.
        /// </param>
        private static void Main( string[] args )
        {
            var mongo = new Mongo( "myorders", "localhost", "27017", string.Empty );
            // For Linq to work, collection name must match Class name.
            MongoCollection< Order > collection = mongo.GetCollection< Order >( "Order" );

            var provider = new MongoQueryProvider(mongo);
            var orderQueryable = new MongoQuery< Order >( provider );

            DeleteAllDocumentsFromCollection( collection );
            CreateAndInsertSingleDocumentIntoCollection( collection );
            CreateAndInsertMultipleDocumentIntoCollection( collection );
            UpdateDocument( collection );
            UpdateUsingAtomicIncrement(collection);
            QueryFromCollection( collection );
            QueryUsingLinq( orderQueryable );
            QueryAllDocuments(orderQueryable);

            QueryConditionalOperators( collection );
            QueryConditionalOperatorsUsingLinq(orderQueryable);

            Console.WriteLine( "\n Press Enter to Exit." );
            Console.ReadLine();
        }
Exemplo n.º 11
0
 /// <summary>
 /// This is the LINQ Hook, call me and you'll be querying MongoDB via LINQ. w00t!
 /// </summary>
 /// <returns></returns>
 public IQueryable <T> AsQueryable()
 {
     return(new MongoQuery <T>(MongoQueryProvider.Create(this._db, this._collectionName)));
 }