public static IEnumerable <TResult> Execute <TResult, CompareWith>(this ICassandraQueryable <TResult, CompareWith> source)
            where CompareWith : CassandraType
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            return(source.Provider.ExecuteQuery(source));
        }
        public static IDictionary <BytesType, int> MultiCount <TResult, CompareWith>(this ICassandraQueryable <TResult, CompareWith> source)
            where CompareWith : CassandraType
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            source = source.Provider.CreateQuery(source.Setup, Expression.Call(null, ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(new Type[] { typeof(TResult), typeof(CompareWith) }), new Expression[] { source.Expression }));
            return(source.Provider.Execute <IDictionary <BytesType, int> >(source, (x, slice) => new MultiGetColumnCount(x.Keys, x.SuperColumnName, slice)));
        }
        private static TOperation BuildOperation <TOperation>(this ICassandraQueryable source, Func <CassandraQuerySetup, CassandraSlicePredicate, TOperation> createOp)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            var calls = BuildCallDictionary(new Dictionary <string, object>(), source.Expression);

            var predicate = BuildPredicateFromExpression(calls);
            var operation = createOp(source.Setup, predicate);

            return(operation);
        }
 public static IEnumerable <dynamic> ExecuteDynamic <TResult, CompareWith>(this ICassandraQueryable <TResult, CompareWith> source)
     where CompareWith : CassandraType
 {
     return(Execute(source).Cast <dynamic>());
 }
        public static ICassandraQueryable <TResult, CompareWith> Reverse <TResult, CompareWith>(this ICassandraQueryable <TResult, CompareWith> source)
            where CompareWith : CassandraType
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            return(source.Provider.CreateQuery(source.Setup, Expression.Call(null, ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(new Type[] { typeof(TResult), typeof(CompareWith) }), new Expression[] { source.Expression })));
        }
 public static ColumnFamilyOperation <TResult> BuildOperation <TResult>(this ICassandraQueryable source, Func <CassandraQuerySetup, CassandraSlicePredicate, ColumnFamilyOperation <TResult> > createOp)
 {
     return(BuildOperation <ColumnFamilyOperation <TResult> >(source, createOp));
 }
 public static QueryableColumnFamilyOperation <TResult> BuildQueryableOperation <TResult, CompareWith>(this ICassandraQueryable <TResult, CompareWith> source)
     where CompareWith : CassandraType
 {
     return(BuildOperation <QueryableColumnFamilyOperation <TResult> >(source, source.Setup.CreateQueryOperation));
 }
        TResult ICassandraQueryProvider.Execute <TResult>(ICassandraQueryable query, Func <CassandraQuerySetup, CassandraSlicePredicate, ColumnFamilyOperation <TResult> > createOp)
        {
            var op = query.BuildOperation <TResult>(createOp);

            return(ExecuteOperation(op, true));
        }
        IEnumerable <TResult> ICassandraQueryProvider.ExecuteQuery <TResult, CompareWith>(ICassandraQueryable <TResult, CompareWith> query)
        {
            var op = query.BuildQueryableOperation();

            return(ExecuteOperation(op, true));
        }