Wie erhalte ich die Anzahl der Artikel von DynamoDB?

Ich möchte die Anzahl der Elemente bei der DynamoDB-Abfrage wissen.

Ich kann nach DynamoDB fragen, möchte aber nur die Gesamtzahl der Elemente wissen.

Zum Beispiel 'SELECT COUNT (*) FROM ... WHERE ...' in MySQL

$result = $aws->query(array(
 'TableName' => 'game_table',
 'IndexName' => 'week-point-index',
 'KeyConditions' => array(
    'week' => array(
        'ComparisonOperator' => 'EQ',
        'AttributeValueList' => array(
            array(Type::STRING => $week)
        )
    ),
    'point' => array(
        'ComparisonOperator' => 'GE',
        'AttributeValueList' => array(
            array(Type::NUMBER => $my_point)
        )
    )
 ),
));
echo Count($result['Items']);

Dieser Code bringt die Daten aller Benutzer höher als mein Punkt.

Wenn die Anzahl von $ result 100.000 beträgt, ist $ result zu groß. Und es würde die Grenzen der Abfragegröße überschreiten.

Ich brauche Hilfe.

Sie können den SelectParameter verwenden undCOUNT in der Anfrage verwenden. Es "gibt die Anzahl der übereinstimmenden Elemente zurück und nicht die übereinstimmenden Elemente selbst". Wichtig , wie von Saumitra R. Bhave in einem Kommentar angesprochen : "Wenn die Größe der Abfrage-Ergebnismenge größer als 1 MB ist, stellen ScannedCount und Count nur einen Teil der Gesamtzahl der Elemente dar. Sie müssen mehrere ausführen Abfragevorgänge, um alle Ergebnisse abzurufen " .

Ich bin nicht mit PHP vertraut, aber hier ist, wie Sie es mit Java verwenden können. Und anstatt Count(was ich vermute, ist eine Funktion in PHP) auf dem zu verwenden 'Items', können Sie den CountWert aus der Antwort verwenden - $result['Count']:

final String week = "whatever";
final Integer myPoint = 1337;
Condition weekCondition = new Condition()
        .withComparisonOperator(ComparisonOperator.EQ)
        .withAttributeValueList(new AttributeValue().withS(week));
Condition myPointCondition = new Condition()
        .withComparisonOperator(ComparisonOperator.GE)
        .withAttributeValueList(new AttributeValue().withN(myPoint.toString()))

Map<String, Condition> keyConditions = new HashMap<>();
keyConditions.put("week", weekCondition);
keyConditions.put("point", myPointCondition);

QueryRequest request = new QueryRequest("game_table");
request.setIndexName("week-point-index");
request.setSelect(Select.COUNT);
request.setKeyConditions(keyConditions);

QueryResult result = dynamoDBClient.query(request);
Integer count = result.getCount();

Wenn Sie die WHEREKlausel nicht emulieren müssen , können Sie eine DescribeTableAnforderung verwenden und die resultierende Elementanzahl verwenden, um eine Schätzung zu erhalten.

Die Anzahl der Elemente in der angegebenen Tabelle. DynamoDB aktualisiert diesen Wert ungefähr alle sechs Stunden. Letzte Änderungen werden möglicherweise nicht in diesem Wert berücksichtigt.

Ein wichtiger Hinweis aus der Dokumentation, wie er von Saumitra R. Bhave in den Kommentaren zu dieser Antwort erwähnt wurde:

Wenn die Größe der QueryErgebnismenge größer als 1 MB ist ScannedCountund Countnur einen Teil der Gesamtzahl der Elemente darstellt. Sie müssen mehrere QueryVorgänge ausführen , um alle Ergebnisse abzurufen (siehe Paginieren von Tabellenabfrageergebnissen ).

Mit dem aws dynamodb cli können Sie es wie folgt per Scan erhalten :

aws dynamodb scan --table-name <TABLE_NAME> --select "COUNT"

Die Antwort sieht ungefähr so ​​aus:

{
    "Count": 123,
    "ScannedCount": 123,
    "ConsumedCapacity": null
}

Beachten Sie, dass diese Informationen im Gegensatz zur API für die Beschreibungstabelle in Echtzeit vorliegen

Kann auch von der Benutzeroberfläche aus gesehen werden. Gehen Sie zur Registerkarte Übersicht in der Tabelle, Sie sehen die Anzahl der Artikel. Hoffe es hilft jemandem.

Wenn Sie zufällig hierher gelangen und mit C # arbeiten, finden Sie hier den Code:

var cancellationToken = new CancellationToken();

var request = new ScanRequest("TableName") {Select = Select.COUNT};

var result = context.Client.ScanAsync(request, cancellationToken).Result;

totalCount = result.Count;

Ersetzen Sie den Tabellennamen und verwenden Sie die folgende Abfrage, um die Daten in Ihrer lokalen Umgebung abzurufen:

aws dynamodb scan --table-name <TABLE_NAME> --select "COUNT" --endpoint-url http://localhost:8000

Ersetzen Sie den Tabellennamen und entfernen Sie die Endpunkt-URL, um die Daten in der Produktionsumgebung abzurufen

aws dynamodb scan --table-name <TABLE_NAME> --select "COUNT"

Ähnlich wie bei Java in PHP nur Select PARAMETER mit dem Wert 'COUNT' setzen.

$result = $aws->query(array(
 'TableName' => 'game_table',
 'IndexName' => 'week-point-index',
 'KeyConditions' => array(
    'week' => array(
        'ComparisonOperator' => 'EQ',
        'AttributeValueList' => array(
            array(Type::STRING => $week)
        )
    ),
    'point' => array(
        'ComparisonOperator' => 'GE',
        'AttributeValueList' => array(
            array(Type::NUMBER => $my_point)
        )
    )
 ),
 'Select' => 'COUNT'
));

und greift einfach so zu:

echo $ result ['Count'];

aber wie Saumitra oben erwähnt seien Sie vorsichtig mit Result largers als 1 MB, in diesem Fall der Verwendung LastEvaluatedKey bis es null zurückgibt die letzte aktualisierte Zählwert zu erhalten.

Sie können die Dynamodb-Mapper-Abfrage verwenden.

PaginatedQueryList<YourModel> list = DymamoDBMapper.query(YourModel.class, queryExpression);
int count = list.size();

Es ruft auf, loadAllResults()dass das nächste verfügbare Ergebnis träge geladen wird, bis allResultsLoaded.

Ref: https://docs.amazonaws.cn/en_us/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html#DynamoDBMapper.Methods.query

len(response['Items'])

gibt Ihnen die Anzahl der gefilterten Zeilen

wo,

fe = Key('entity').eq('tesla')
response = table.scan(FilterExpression=fe)

Ich poste diese Antwort für alle, die C # verwenden und eine voll funktionsfähige, gut getestete Antwort wünschen, die die Verwendung von Abfragen anstelle von Scans demonstriert. Diese Antwort behandelt insbesondere mehr als 1 MB Größe der zu zählenden Elemente.

        public async Task<int> GetAvailableCount(string pool_type, string pool_key)
    {
        var queryRequest = new QueryRequest
        {
            TableName = PoolsDb.TableName,
            ConsistentRead = true,
            Select = Select.COUNT,
            KeyConditionExpression = "pool_type_plus_pool_key = :type_plus_key",
            ExpressionAttributeValues = new Dictionary<string, AttributeValue> {
                {":type_plus_key", new AttributeValue { S =  pool_type + pool_key }}
            },
        };
        var t0 = DateTime.UtcNow;
        var result = await Client.QueryAsync(queryRequest);
        var count = result.Count;
        var iter = 0;
        while ( result.LastEvaluatedKey != null && result.LastEvaluatedKey.Values.Count > 0) 
        {
            iter++;
            var lastkey = result.LastEvaluatedKey.Values.ToList()[0].S;
            _logger.LogDebug($"GetAvailableCount {pool_type}-{pool_key} iteration {iter} instance key {lastkey}");
            queryRequest.ExclusiveStartKey = result.LastEvaluatedKey;
            result = await Client.QueryAsync(queryRequest);
            count += result.Count;
        }
        _logger.LogDebug($"GetAvailableCount {pool_type}-{pool_key} returned {count} after {iter} iterations in {(DateTime.UtcNow - t0).TotalMilliseconds} ms.");
        return count;
    }
}

In Scala:

import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder
import com.amazonaws.services.dynamodbv2.document.DynamoDB
val client = AmazonDynamoDBClientBuilder.standard().build()

val dynamoDB = new DynamoDB(client)
val tableDescription = dynamoDB.getTable("table name").describe().getItemCount()

Ich habe Scan verwendet, um die Gesamtzahl des erforderlichen Tabellennamens zu ermitteln. Das Folgende ist ein Java-Code-Snippet für denselben

Long totalItemCount = 0;
do{
    ScanRequest req = new ScanRequest();
    req.setTableName(tableName);

    if(result != null){
        req.setExclusiveStartKey(result.getLastEvaluatedKey());
    }

    result = client.scan(req);

    totalItemCount += result.getItems().size();

} while(result.getLastEvaluatedKey() != null);

System.out.println("Result size: " + totalItemCount);

Dies ist eine Lösung für AWS JavaScript SDK-Benutzer, die für andere Sprachen fast identisch ist.

Result.data.Count gibt Ihnen, wonach Sie suchen

 apigClient.getitemPost({}, body, {})

    .then(function(result){

        var dataoutput = result.data.Items[0];

        console.log(result.data.Count);
  }).catch( function(result){

});