public List <T> Scan <T>(ScanExpression <T> request, int limit)
        {
            var to = new List <T>();

            if (request.Limit == default(int))
            {
                request.Limit = limit;
            }

            ScanResponse response = null;

            do
            {
                if (response != null)
                {
                    request.ExclusiveStartKey = response.LastEvaluatedKey;
                }

                response = Exec(() => DynamoDb.Scan(request));
                var results = response.ConvertAll <T>();

                foreach (var result in results)
                {
                    to.Add(result);

                    if (to.Count >= limit)
                    {
                        break;
                    }
                }
            } while (!response.LastEvaluatedKey.IsEmpty() && to.Count < limit);

            return(to);
        }
        public ScanExpression <T> FromScan <T>(Expression <Func <T, bool> > filterExpression = null)
        {
            var q = new ScanExpression <T>(this)
            {
                Limit          = PagingLimit,
                ConsistentRead = !typeof(T).IsGlobalIndex() && this.ConsistentRead,
            };

            if (filterExpression != null)
            {
                q.Filter(filterExpression);
            }

            return(q);
        }
        public DynamoDbResult <T> ScanPage <T>(ScanExpression <T> request, int limit, Dictionary <string, AttributeValue> lastEvaluatedKey = null)
        {
            var result = new DynamoDbResult <T>();

            request.Limit = limit;
            ScanResponse response = null;

            if (lastEvaluatedKey != null)
            {
                request.ExclusiveStartKey = lastEvaluatedKey;
            }
            response = Exec(() => DynamoDb.Scan(request));
            var results = response.ConvertAll <T>();

            result.Data             = results;
            result.LastEvaluatedKey = response.LastEvaluatedKey;
            return(result);
        }
        public ScanExpression <T> FromScanIndex <T>(Expression <Func <T, bool> > filterExpression = null)
        {
            var table = typeof(T).GetIndexTable();
            var index = table.GetIndex(typeof(T));
            var q     = new ScanExpression <T>(this, table)
            {
                IndexName      = index.Name,
                Limit          = PagingLimit,
                ConsistentRead = !typeof(T).IsGlobalIndex() && this.ConsistentRead,
            };

            if (filterExpression != null)
            {
                q.Filter(filterExpression);
            }

            return(q);
        }
Example #5
0
        public virtual IEnumerable <T> GetResults(ScanExpression scanExpr, int?skip = null, int?take = null)
        {
            var results = db.Scan(scanExpr, r =>
            {
                if (total == null)
                {
                    total = r.Count;
                }
                return(r.ConvertAll <T>());
            });

            if (skip != null)
            {
                results = results.Skip(skip.Value);
            }

            if (take != null)
            {
                results = results.Take(take.Value);
            }

            return(results.ToList());
        }
 public IEnumerable <T> Scan <T>(ScanExpression <T> request)
 {
     return(Scan(request, r => r.ConvertAll <T>()));
 }
Example #7
0
 public static List <T> ScanInto <T>(this IPocoDynamo db, ScanExpression request, int limit)
 {
     return(db.Scan <T>(request.Projection <T>(), limit: limit));
 }
Example #8
0
 public static IEnumerable <T> ScanInto <T>(this IPocoDynamo db, ScanExpression request)
 {
     return(db.Scan <T>(request.Projection <T>()));
 }