示例#1
0
        public async Task Checkout(string id)
        {
            var table = Table.LoadTable(dbClient, "carts_id_cid");

            var filter = new QueryFilter();

            filter.AddCondition("id", QueryOperator.Equal, id);

            var queryConfig = new QueryOperationConfig
            {
                Filter = filter,
                Limit  = 1
            };

            var result = table.Query(queryConfig);

            if (result.IsDone)
            {
                throw new ArgumentException("id");
            }
            else
            {
                var querySet = await result.GetNextSetAsync();

                var document = querySet.First();

                document["status"] = "DONE";

                await table.UpdateItemAsync(document);
            }
        }
示例#2
0
            public async Task <IEnumerable <TEntity> > ExecuteAsync()
            {
                var query = new QueryOperationConfig();

                foreach (var filterAction in this.collection)
                {
                    filterAction(query.Filter);
                }

                if (this.limit != null)
                {
                    query.Limit = this.limit.Value;
                }

                if (this.indexName != null)
                {
                    query.IndexName = this.indexName;
                }

                if (this.propertiesToGet != null)
                {
                    query.AttributesToGet = this.propertiesToGet.ToList();
                    query.Select          = SelectValues.SpecificAttributes;
                }

                var search = this.context.FromQueryAsync <TEntity>(query);

                return(await search.GetRemainingAsync());
            }
        private QueryOperationConfig GetQueryOperationConfig(List <QueryFilterCondition> QueryFilterConditions, bool consistentRead = true, List <string> attributesToGet = null)
        {
            QueryFilter queryFilter = new QueryFilter();

            foreach (var queryFilterCondition in QueryFilterConditions)
            {
                if (queryFilterCondition.Type == QueryFilterConditionType.one)
                {
                    queryFilter.AddCondition(queryFilterCondition.AttributeName, queryFilterCondition.Condition);
                }
                if (queryFilterCondition.Type == QueryFilterConditionType.two)
                {
                    queryFilter.AddCondition(queryFilterCondition.AttributeName, queryFilterCondition.QueryOperator, queryFilterCondition.AttributeValues);
                }
                if (queryFilterCondition.Type == QueryFilterConditionType.three)
                {
                    queryFilter.AddCondition(queryFilterCondition.AttributeName, queryFilterCondition.QueryOperator, queryFilterCondition.DynamoDBEntry);
                }
            }

            QueryOperationConfig queryOperationConfig = new QueryOperationConfig()
            {
                ConsistentRead = consistentRead,
                Filter         = queryFilter
            };

            if (attributesToGet != null)
            {
                queryOperationConfig.AttributesToGet = attributesToGet;
            }

            return(queryOperationConfig);
        }
示例#4
0
        public async Task DeleteItem(string id, string item_id)
        {
            var table = Table.LoadTable(dbClient, "carts_id_cid");

            var filter = new QueryFilter();

            filter.AddCondition("id", QueryOperator.Equal, id);

            var queryConfig = new QueryOperationConfig
            {
                Filter = filter,
                Limit  = 1
            };

            var result = table.Query(queryConfig);

            if (result.IsDone)
            {
                throw new ArgumentException("id");
            }
            else
            {
                var querySet = await result.GetNextSetAsync();

                var document = querySet.First();

                var items = JsonConvert.DeserializeObject <List <CartItem> >(document["items"].AsString());
                var item  = items.FirstOrDefault(x => x.id.ToString() == item_id);
                items.Remove(item);

                await table.UpdateItemAsync(document);
            }
        }
        public async Task <(object Snapshot, long Index)> GetSnapshotAsync(string actorName)
        {
            var config = new QueryOperationConfig {
                ConsistentRead = true, BackwardSearch = true, Limit = 1
            };

            config.Filter.AddCondition(_options.SnapshotsTableHashKey, QueryOperator.Equal, actorName);
            var query   = _snapshotsTable.Query(config);
            var results = await query.GetNextSetAsync();

            var doc = results.FirstOrDefault();

            if (doc == null)
            {
                return(null, 0);
            }

            var snapshotIndexE = doc.GetValueOrThrow(_options.SnapshotsTableSortKey);
            var dataTypeE      = doc.GetValueOrThrow(_options.SnapshotsTableDataTypeKey);
            var dataE          = doc.GetValueOrThrow(_options.SnapshotsTableDataKey);

            var dataType = Type.GetType(dataTypeE.AsString());
            var data     = _dynamoDBContext.FromDocumentDynamic(dataE.AsDocument(), dataType);

            return(data, snapshotIndexE.AsLong());
        }
        protected virtual async Task <T[]> GetByIndex(string index, string key, string value, int limit = int.MaxValue)
        {
            Table table = GetTable(TableName);

            QueryFilter filter = new QueryFilter(key, QueryOperator.Equal, value);

            QueryOperationConfig config = new QueryOperationConfig();

            config.Filter = filter;

            config.IndexName = index;

            config.Limit = limit;

            Search search = table.Query(config);

            List <Document> documents = new List <Document>();

            do
            {
                documents.AddRange(await search.GetNextSetAsync());
            } while (!search.IsDone);

            return(!documents.Any() ? new T[0] : documents.Select(ConvertDocumentToObject).ToArray());
        }
示例#7
0
    public async Task <List <Coffee> > GetAll()
    {
        var query  = new QueryOperationConfig();
        var result = this._context.FromQueryAsync <Coffee>(query);

        return(await result.GetRemainingAsync());
    }
示例#8
0
        /// <summary>
        /// Returns messages that have yet to be dispatched
        /// </summary>
        /// <param name="millSecondsSinceSent">How long ago as the message sent?</param>
        /// <param name="pageSize">How many messages to return at once?</param>
        /// <param name="pageNumber">Which page number of messages</param>
        /// <returns>A list of messages that are outstanding for dispatch</returns>
        public IEnumerable <Message> OutstandingMessages(
            double millisecondsDispatchedSince,
            int pageSize   = 100,
            int pageNumber = 1,
            Dictionary <string, object> args = null)
        {
            if (args == null)
            {
                throw new ArgumentException("Missing required argument", nameof(args));
            }

            var sinceTime = DateTime.UtcNow.Subtract(TimeSpan.FromMilliseconds(millisecondsDispatchedSince));
            var topic     = (string)args["Topic"];

            // We get all the messages for topic, added within a time range
            // There should be few enough of those that we can efficiently filter for those
            // that don't have a delivery date.
            var queryConfig = new QueryOperationConfig
            {
                IndexName        = _configuration.OutstandingIndexName,
                KeyExpression    = new KeyTopicCreatedTimeExpression().Generate(topic, sinceTime),
                FilterExpression = new NoDispatchTimeExpression().Generate(),
                ConsistentRead   = false
            };

            //block async to make this sync
            var messages = PageAllMessagesAsync(queryConfig).Result.ToList();

            return(messages.Select(msg => msg.ConvertToMessage()));
        }
示例#9
0
        private async Task <List <string> > QueryTable(string userId, string dataId)
        {
            var config = new QueryOperationConfig();

            if (string.IsNullOrWhiteSpace(dataId))
            {
                config.KeyExpression = new Expression
                {
                    ExpressionStatement       = $"UserId = :{nameof(userId)}",
                    ExpressionAttributeValues = new Dictionary <string, DynamoDBEntry>
                    {
                        { $":{nameof(userId)}", userId }
                    }
                };
            }
            else
            {
                config.KeyExpression = new Expression
                {
                    ExpressionStatement       = $"UserId = :{nameof(userId)} and DataId = :{nameof(dataId)}",
                    ExpressionAttributeValues = new Dictionary <string, DynamoDBEntry>
                    {
                        { $":{nameof(userId)}", userId },
                        { $":{nameof(dataId)}", dataId }
                    }
                };
            }

            var dataDocuments = await _dataDynamoDbTable.Query(config).GetRemainingAsync();

            var values = dataDocuments.Select(dataDocument => dataDocument["DataAsJson"]?.AsString()).ToList();

            return(values);
        }
示例#10
0
        private async Task <List <string> > GetPatientData(string patientIdentifier)
        {
            var config = new QueryOperationConfig
            {
                KeyExpression = new Expression
                {
                    ExpressionStatement       = $"{nameof(DataModel.PatientId)} = :{nameof(patientIdentifier)}",
                    ExpressionAttributeValues = new Dictionary <string, DynamoDBEntry> {
                        { $":{nameof(patientIdentifier)}", patientIdentifier }
                    }
                },
                Select          = SelectValues.SpecificAttributes,
                AttributesToGet = new List <string> {
                    nameof(DataModel.DataAsJson)
                }
            };

            var dataDocuments = await _dataDynamoDbTable.Query(config).GetRemainingAsync();

            if (dataDocuments == null || !dataDocuments.Any())
            {
                throw new DataNotFoundException(patientIdentifier);
            }

            var values = dataDocuments.Select(dataDocument => GetValue(dataDocument[nameof(DataModel.DataAsJson)])).ToList();

            return(values);
        }
示例#11
0
        private static void FindRepliesPostedWithinTimePeriod(Table table, string forumName, string threadSubject)
        {
            DateTime startDate = DateTime.UtcNow.Subtract(new TimeSpan(21, 0, 0, 0));
            DateTime endDate = DateTime.UtcNow.Subtract(new TimeSpan(1, 0, 0, 0));

            QueryFilter filter = new QueryFilter("Id", QueryOperator.Equal, forumName + "#" + threadSubject);
            filter.AddCondition("ReplyDateTime", QueryOperator.Between, startDate, endDate);

            QueryOperationConfig config = new QueryOperationConfig()
            {
                Limit = 2, // 2 items/page.
                Select = SelectValues.SpecificAttributes,
                AttributesToGet = new List<string> { "Message",
                                 "ReplyDateTime",
                                 "PostedBy" },
                ConsistentRead = true,
                Filter = filter
            };

            Search search = table.Query(config);

            List<Document> documentList = new List<Document>();

            do
            {
                documentList = search.GetNextSet();
                Console.WriteLine("\nFindRepliesPostedWithinTimePeriod: printing replies posted within dates: {0} and {1} ............", startDate, endDate);
                foreach (var document in documentList)
                {
                    PrintDocument(document);
                }
            } while (!search.IsDone);
        }
示例#12
0
        private static void FindRepliesInLast15DaysWithConfig(Table table, string forumName, string threadName)
        {
            DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);
            QueryFilter filter = new QueryFilter("Id", QueryOperator.Equal, forumName + "#" + threadName);
            filter.AddCondition("ReplyDateTime", QueryOperator.GreaterThan, twoWeeksAgoDate);
            // You are specifying optional parameters so use QueryOperationConfig.
            QueryOperationConfig config = new QueryOperationConfig()
            {
                Filter = filter,
                // Optional parameters.
                Select = SelectValues.SpecificAttributes,
                AttributesToGet = new List<string> { "Message", "ReplyDateTime",
                                 "PostedBy" },
                ConsistentRead = true
            };

            Search search = table.Query(config);

            List<Document> documentSet = new List<Document>();
            do
            {
                documentSet = search.GetNextSet();
                Console.WriteLine("\nFindRepliesInLast15DaysWithConfig: printing ............");
                foreach (var document in documentSet)
                    PrintDocument(document);
            } while (!search.IsDone);
        }
示例#13
0
        /// <summary>
        /// Returns messages that have been successfully dispatched. Eventually consistent.
        /// </summary>
        /// <param name="millisecondsDispatchedSince">How long ago was the message dispatched?</param>
        /// <param name="pageSize">How many messages returned at once?</param>
        /// <param name="pageNumber">Which page of the dispatched messages to return?</param>
        /// <param name="outboxTimeout"></param>
        /// <param name="args">Used to pass through the topic we are searching for messages in. Use Key: "Topic"</param>
        /// <returns>A list of dispatched messages</returns>
        public IEnumerable <Message> DispatchedMessages(
            double millisecondsDispatchedSince,
            int pageSize      = 100,
            int pageNumber    = 1,
            int outboxTimeout = -1,
            Dictionary <string, object> args = null)
        {
            if (args == null)
            {
                throw new ArgumentException("Missing required argument", nameof(args));
            }

            var sinceTime = DateTime.UtcNow.Subtract(TimeSpan.FromMilliseconds(millisecondsDispatchedSince));
            var topic     = (string)args["Topic"];

            //in theory this is all values on that index that have a Delivered data (sparse index)
            //we just need to filter for ones in the right date range
            //As it is a GSI it can't use a consistent read
            var queryConfig = new QueryOperationConfig
            {
                IndexName      = _configuration.DeliveredIndexName,
                KeyExpression  = new KeyTopicDeliveredTimeExpression().Generate(topic, sinceTime),
                ConsistentRead = false
            };

            //block async to make this sync
            var messages = PageAllMessagesAsync(queryConfig).Result.ToList();

            return(messages.Select(msg => msg.ConvertToMessage()));
        }
示例#14
0
        /// <summary>
        /// Fetch the specified metadata field from the metadata DynamoDB table
        /// </summary>
        /// <param name="searchkey"></param>
        /// <returns></returns>
        public string FetchMetadata(string searchkey)
        {
            QueryFilter filter = new QueryFilter();

            filter.AddCondition(Constants.KEY, QueryOperator.Equal, searchkey);

            QueryOperationConfig config = new QueryOperationConfig();

            config.Select = SelectValues.AllAttributes;
            config.Filter = filter;

            Search          searchRes   = metadataTable.Query(config);
            List <Document> documentSet = new List <Document>();

            do
            {
                try
                {
                    // We can assume there is only one entry per key.
                    // Hence, we are fetching the first item as required
                    documentSet = searchRes.GetNextSetAsync().Result;
                    Console.WriteLine("\nFindRepliesInLast15DaysWithConfig: printing ............");
                    return(documentSet[0][Constants.VALUE]);
                }
                catch (Exception ex)
                {
                    Logger.AddLog(ex.ToString());
                }
            } while (!searchRes.IsDone);

            return(String.Empty);
        }
示例#15
0
        public async Task <IList <T> > Get <T>(string tableName, QueryFilter queryFilter, string paginationToken = null, bool consistentRead = true, CancellationToken cancellationToken = default) where T : class
        {
            var table   = Table.LoadTable(AmazonDynamoDBClient, tableName);
            var scanOps = new ScanOperationConfig();

            if (!string.IsNullOrEmpty(paginationToken))
            {
                scanOps.PaginationToken = paginationToken;
            }

            QueryOperationConfig config = new QueryOperationConfig()
            {
                Filter          = queryFilter,
                Select          = SelectValues.SpecificAttributes,
                AttributesToGet = new List <string> {
                    AttributeValue
                },
                ConsistentRead = consistentRead
            };

            var             results = table.Query(config);
            List <Document> data    = await results.GetNextSetAsync(cancellationToken).ConfigureAwait(false);

            return(TransformData <T>(data));
        }
        public async Task <double?> GetTotalCashFlowForAccountAsync(string accountId)
        {
            var table = Table.LoadTable(_dynamoDb, "AccountBalances");
            var query = new QueryOperationConfig();

            query.IndexName     = "CFAccountId-Date-index";
            query.KeyExpression = new Expression();
            query.KeyExpression.ExpressionStatement = "CFAccountId = :v_accountId";
            query.KeyExpression.ExpressionAttributeValues[":v_accountId"] = accountId;
            query.AttributesToGet = new List <string> {
                "CF"
            };
            query.Select = SelectValues.SpecificAttributes;
            double?result = null;

            var search = table.Query(query);

            do
            {
                var list = await search.GetNextSetAsync();

                foreach (var doc in list)
                {
                    if (doc != null && !doc.ContainsKey("CF") && doc["CF"] != null)
                    {
                        result = result.HasValue
                            ? result + doc["CF"].AsDouble()
                            : doc["CF"].AsDouble();
                    }
                }
            } while (!search.IsDone);
            return(result);
        }
示例#17
0
        private Search ConvertFromQuery <T>(QueryOperationConfig queryConfig, DynamoDBOperationConfig operationConfig)
        {
            Table  table  = GetTargetTableInternal <T>(operationConfig);
            Search search = table.Query(queryConfig);

            return(search);
        }
示例#18
0
        private ContextSearch ConvertQueryHelper <T>(DynamoDBFlatConfig currentConfig, ItemStorageConfig storageConfig, QueryFilter filter, List <string> indexNames)
        {
            Table  table       = GetTargetTable(storageConfig, currentConfig);
            string indexName   = GetQueryIndexName(currentConfig, indexNames);
            var    queryConfig = new QueryOperationConfig
            {
                Filter              = filter,
                ConsistentRead      = currentConfig.ConsistentRead.Value,
                BackwardSearch      = currentConfig.BackwardQuery.Value,
                IndexName           = indexName,
                ConditionalOperator = currentConfig.ConditionalOperator
            };

            if (string.IsNullOrEmpty(indexName))
            {
                queryConfig.Select = SelectValues.SpecificAttributes;
                List <string> attributesToGet = storageConfig.AttributesToGet;
                queryConfig.AttributesToGet = attributesToGet;
            }
            else
            {
                queryConfig.Select = SelectValues.AllProjectedAttributes;
            }
            Search query = table.Query(queryConfig);

            return(new ContextSearch(query, currentConfig));
        }
        public IEnumerable <LeaderBoardEntry> GetLeaderBoard(string match, int duration)
        {
            DynamoDBContext context = new DynamoDBContext(_client);

            QueryFilter filter = new QueryFilter();

            filter.AddCondition("Match", QueryOperator.Equal, match);
            filter.AddCondition("TimeStamp", QueryOperator.GreaterThanOrEqual, DateTime.Now.AddHours(-duration));

            QueryOperationConfig queryOperationConfig = new QueryOperationConfig {
                Filter = filter, IndexName = "LeaderBoardIndex"
            };

            var playerStats = context.FromQueryAsync <PlayerStat>(queryOperationConfig).GetNextSetAsync().GetAwaiter().GetResult();

            playerStats.Sort((x, y) => { return(y.Score.CompareTo(x.Score)); });

            List <LeaderBoardEntry> leaderBoardEntries = new List <LeaderBoardEntry>();

            foreach (var playerStat in playerStats)
            {
                if (leaderBoardEntries.Find(item => item.UserName == playerStat.UserName) == null)
                {
                    leaderBoardEntries.Add(new LeaderBoardEntry
                    {
                        Kills    = playerStat.Kills,
                        Score    = playerStat.Score,
                        UserName = playerStat.UserName,
                        Rank     = leaderBoardEntries.FindAll(item => item.Score > playerStat.Score).Count + 1
                    });
                }
            }

            return(leaderBoardEntries);
        }
        public static async Task <PagedResult <TEntity> > GetPagedQueryResultsAsync <TEntity>(
            this IDynamoDBContext dynamoDbContext, QueryOperationConfig queryConfig) where TEntity : class
        {
            var dbResults = new List <TEntity>();
            var table     = dynamoDbContext.GetTargetTable <TEntity>();

            var search     = table.Query(queryConfig);
            var resultsSet = await search.GetNextSetAsync().ConfigureAwait(false);

            var paginationToken = search.PaginationToken;

            if (resultsSet.Any())
            {
                dbResults.AddRange(dynamoDbContext.FromDocuments <TEntity>(resultsSet));

                // Look ahead for any more, but only if we have a token
                if (!string.IsNullOrEmpty(PaginationDetails.EncodeToken(paginationToken)))
                {
                    queryConfig.PaginationToken = paginationToken;
                    queryConfig.Limit           = 1;
                    search     = table.Query(queryConfig);
                    resultsSet = await search.GetNextSetAsync().ConfigureAwait(false);

                    if (!resultsSet.Any())
                    {
                        paginationToken = null;
                    }
                }
            }

            return(new PagedResult <TEntity>(dbResults, new PaginationDetails(paginationToken)));
        }
示例#21
0
        /// <summary>
        /// Executes a Query operation against DynamoDB, finding items
        /// that match the specified conditions.
        /// </summary>
        /// <typeparam name="T">Type of object.</typeparam>
        /// <param name="queryConfig">Query request object.</param>
        /// <param name="operationConfig">Config object which can be used to override the table used.</param>
        /// <returns>Lazy-loaded collection of results.</returns>
        public IEnumerable<T> FromQuery<T>(QueryOperationConfig queryConfig, DynamoDBOperationConfig operationConfig)
        {
            if (queryConfig == null) throw new ArgumentNullException("queryConfig");

            var search = ConvertFromQuery<T>(queryConfig, operationConfig);
            return FromSearch<T>(search);
        }
示例#22
0
        public String[] Query(String tableName, String expression = null, String[] attributes = null)
        {
            var   results = new List <string>();
            Table table   = Table.LoadTable(client, tableName);


            QueryOperationConfig config = new QueryOperationConfig()
            {
                Select         = SelectValues.AllAttributes,
                ConsistentRead = true
            };

            if (attributes != null)
            {
                config.Select          = SelectValues.SpecificAttributes;
                config.AttributesToGet = new List <string> (attributes);
            }
            if (expression != null)
            {
                config.Filter = CreateFilter(expression);
            }

            Search tableResult = table.Query(config);
            var    docs        = tableResult.GetRemaining();

            foreach (Document doc in docs)
            {
                results.Add(doc.ToJson());
            }
            return(results.ToArray());
        }
        public async Task <Product> GetById(string id)
        {
            var table = Table.LoadTable(dbClient, "products_id_sku");

            var filter = new QueryFilter();

            filter.AddCondition("id", QueryOperator.Equal, id);

            var queryConfig = new QueryOperationConfig
            {
                Filter = filter,
                Limit  = 1
            };

            var result = table.Query(queryConfig);

            if (result.IsDone)
            {
                throw new ArgumentException("sku");
            }
            else
            {
                var querySet = await result.GetNextSetAsync();

                var document = querySet.First();

                Product product = ProductFromDocument(document);

                return(product);
            }
        }
示例#24
0
        private ContextSearch ConvertFromQuery <T>(QueryOperationConfig queryConfig, DynamoDBOperationConfig operationConfig)
        {
            DynamoDBFlatConfig flatConfig = new DynamoDBFlatConfig(operationConfig, Config);
            Table  table  = GetTargetTableInternal <T>(operationConfig);
            Search search = table.Query(queryConfig);

            return(new ContextSearch(search, flatConfig));
        }
        protected static QueryOperationConfig CreateQueryConfiguration(QueryFilter filter)
        {
            var queryOperationConfig = new QueryOperationConfig
            {
                Filter = filter
            };

            return(queryOperationConfig);
        }
    private void FindRepliesPostedWithinTimePeriod(Table table, string forumName, string threadSubject)
    {
        this.displayMessage += "\n***FindRepliesPostedWithinTimePeriod***\n";
        if (replyTable == null)
        {
            this.displayMessage += "\nLoad table before running query";
            return;
        }
        ThreadPool.QueueUserWorkItem((s) =>
        {
            try
            {
                this.displayMessage = "\nRunning on background thread";


                DateTime startDate = DateTime.UtcNow.Subtract(new TimeSpan(21, 0, 0, 0));
                DateTime endDate   = DateTime.UtcNow.Subtract(new TimeSpan(1, 0, 0, 0));

                QueryFilter filter = new QueryFilter("Id", QueryOperator.Equal, forumName + "#" + threadSubject);
                filter.AddCondition("ReplyDateTime", QueryOperator.Between, startDate, endDate);

                QueryOperationConfig config = new QueryOperationConfig()
                {
                    Limit           = 2, // 2 items/page.
                    Select          = SelectValues.SpecificAttributes,
                    AttributesToGet = new List <string> {
                        "Message",
                        "ReplyDateTime",
                        "PostedBy"
                    },
                    ConsistentRead = true,
                    Filter         = filter
                };

                Search search = table.Query(config);

                List <Document> documentList = new List <Document>();

                do
                {
                    documentList         = search.GetNextSet();
                    this.displayMessage += String.Format("\nFindRepliesPostedWithinTimePeriod: printing replies posted within dates: {0} and {1} ............", startDate, endDate);
                    foreach (var document in documentList)
                    {
                        PrintDocument(document);
                    }
                } while (!search.IsDone);
                this.displayMessage += "\nCompleted !\n";
            }
            catch (Exception ex)
            {
                this.displayMessage += "\nFindRepliesPostedWithinTimePeriod:" + ex.Message;
                Debug.LogException(ex);
            }
        });
    }
示例#27
0
        private void AddQueryFilterCondition(string name, QueryOperator operation, IEnumerable <object> values)
        {
            Primitive primitiveValue = null;

            DynamoDBEntry[] primitiveValues = null;
            if (values != null)
            {
                var valuesArray = values.ToArray();
                if (valuesArray.Length == 1)
                {
                    primitiveValue = converter.ToPrimative(valuesArray.First());
                }
                else
                {
                    primitiveValues = valuesArray.Select(v => (DynamoDBEntry)converter.ToPrimative(v)).ToArray();
                }
            }

            if (queryOperation == null)
            {
                if (!IsKeyField(name))
                {
                    throw new ApplicationException("The first Filter must be a key field");
                }
                queryOperation = new QueryOperationConfig();
                if (indexName != null)
                {
                    queryOperation.IndexName = indexName;
                    if (indexAttributes != null)
                    {
                        queryOperation.Select          = SelectValues.SpecificAttributes;
                        queryOperation.AttributesToGet = indexAttributes;
                    }
                }

                if (primitiveValue != null)
                {
                    queryOperation.Filter = new QueryFilter(name, operation, primitiveValue);
                }
                else if (primitiveValues != null)
                {
                    queryOperation.Filter = new QueryFilter(name, operation, primitiveValues);
                }
            }
            else
            {
                if (primitiveValue != null)
                {
                    queryOperation.Filter.AddCondition(name, operation, primitiveValue);
                }
                else if (primitiveValues != null)
                {
                    queryOperation.Filter.AddCondition(name, operation, primitiveValues);
                }
            }
        }
示例#28
0
        public Task <List <Match> > GetTeamSeasonAwayMatches(short year, byte season, int teamId)
        {
            var awayGamesQuery = new QueryOperationConfig
            {
                IndexName = "AwayTeamMatches",
                Filter    = new QueryFilter("AwayTeamIdYearSeason", QueryOperator.Equal, $"{teamId}#{year}#{season}")
            };

            return(Context.FromQueryAsync <Match>(awayGamesQuery).GetRemainingAsync());
        }
        private Search TryExecuteQuery(TranslationResult translationResult, Type entityType)
        {
            QueryFilter queryFilter;
            string      indexName;

            // if we failed to compose a query with table's keys and local secondary indexes
            if (!translationResult.TryGetQueryFilterForTable(this.TableDefinition, out queryFilter, out indexName))
            {
                // then trying to find a suitable Global Secondary Index
                var matchingIndex = this.TableDefinition
                                    .GlobalSecondaryIndexes.Values
                                    .FirstOrDefault
                                    (
                    index => translationResult.TryGetQueryFilterForGlobalSeconaryIndex(index, out queryFilter)
                                    );

                if (matchingIndex == null)
                {
                    return(null);
                }

                indexName = matchingIndex.IndexName;
            }

            var queryConfig = new QueryOperationConfig
            {
                Filter           = queryFilter,
                CollectResults   = false,
                ConsistentRead   = this._consistentRead,
                IndexName        = indexName,
                FilterExpression = translationResult.CustomizationHooks.CustomFilterExpression
            };

            // if a projection is specified - then getting only the required list of fields
            if (translationResult.AttributesToGet != null)
            {
                queryConfig.Select          = SelectValues.SpecificAttributes;
                queryConfig.AttributesToGet = translationResult.AttributesToGet;
            }

            translationResult.CustomizationHooks.ConfigureQueryOperationCallback?.Invoke(queryConfig);

            var searchResult = this.TableDefinition.Query(queryConfig);

            if (string.IsNullOrEmpty(queryConfig.IndexName))
            {
                this.Log("DynamoDb query: {0}", translationResult);
            }
            else
            {
                this.Log("DynamoDb index query: {0}. Index name: {1}", translationResult, queryConfig.IndexName);
            }

            return(searchResult);
        }
示例#30
0
        /// <summary>
        /// Configures an async Query operation against DynamoDB, finding items
        /// that match the specified conditions.
        /// </summary>
        /// <typeparam name="T">Type of object.</typeparam>
        /// <param name="queryConfig">Query request object.</param>
        /// <param name="operationConfig">Config object which can be used to override the table used.</param>
        /// <returns>AsyncSearch which can be used to retrieve DynamoDB data.</returns>
        public AsyncSearch <T> FromQueryAsync <T>(QueryOperationConfig queryConfig, DynamoDBOperationConfig operationConfig)
        {
            if (queryConfig == null)
            {
                throw new ArgumentNullException("queryConfig");
            }

            var query = ConvertFromQuery <T>(queryConfig, operationConfig);

            return(FromSearchAsync <T>(query));
        }