web-dev-qa-db-fra.com

Cosmos DB - Suppression d'un document

Comment supprimer un enregistrement individuel de Cosmos DB?

Je peux sélectionner en utilisant la syntaxe SQL:

SELECT *
FROM collection1
WHERE (collection1._ts > 0)

Et bien sûr, tous les documents (analogues aux lignes?) Sont retournés

Cependant, cela ne fonctionne pas lorsque j'essaie de supprimer

DELETE
FROM collection1
WHERE (collection1._ts > 0)

Comment puis-je y parvenir?

azureazure-cosmosdb
16
Ben Mayo

Le SQL de l'API DocumentDB est spécifiquement pour interrogation. Autrement dit, il ne fournit que SELECT, pas UPDATE ou DELETE.

Ces opérations sont entièrement prises en charge, mais nécessitent des appels REST (ou SDK). Par exemple, avec .net, vous appelez DeleteDocumentAsync() ou ReplaceDocumentAsync() , et dans node.js, ce serait un appel à deleteDocument() ou replaceDocument().

Dans votre scénario particulier, vous pouvez exécuter votre SELECT pour identifier les documents à supprimer, puis effectuer des appels "supprimer", un par document (ou, pour des raisons d'efficacité et de transactionnalité, transmettre un tableau de documents à supprimer, dans un fichier stocké procédure).

26
David Makogon

Une autre option à considérer est le temps de vivre (TTL). Vous pouvez l'activer pour une collection, puis définir une expiration pour les documents. Les documents seront nettoyés automatiquement à leur expiration.

5
Morrolan

Créez une procédure stockée avec le code suivant:

/**
 * A Cosmos DB stored procedure that bulk deletes documents for a given query.
 * Note: You may need to execute this stored procedure multiple times (depending whether the stored procedure is able to delete every document within the execution timeout limit).
 *
 * @function
 * @param {string} query - A query that provides the documents to be deleted (e.g. "SELECT c._self FROM c WHERE c.founded_year = 2008"). Note: For best performance, reduce the # of properties returned per document in the query to only what's required (e.g. prefer SELECT c._self over SELECT * )
 * @returns {Object.<number, boolean>} Returns an object with the two properties:
 *   deleted - contains a count of documents deleted
 *   continuation - a boolean whether you should execute the stored procedure again (true if there are more documents to delete; false otherwise).
 */
function bulkDeleteStoredProcedure(query) {
    var collection = getContext().getCollection();
    var collectionLink = collection.getSelfLink();
    var response = getContext().getResponse();
    var responseBody = {
        deleted: 0,
        continuation: true
    };

    // Validate input.
    if (!query) throw new Error("The query is undefined or null.");

    tryQueryAndDelete();

    // Recursively runs the query w/ support for continuation tokens.
    // Calls tryDelete(documents) as soon as the query returns documents.
    function tryQueryAndDelete(continuation) {
        var requestOptions = {continuation: continuation};

        var isAccepted = collection.queryDocuments(collectionLink, query, requestOptions, function (err, retrievedDocs, responseOptions) {
            if (err) throw err;

            if (retrievedDocs.length > 0) {
                // Begin deleting documents as soon as documents are returned form the query results.
                // tryDelete() resumes querying after deleting; no need to page through continuation tokens.
                //  - this is to prioritize writes over reads given timeout constraints.
                tryDelete(retrievedDocs);
            } else if (responseOptions.continuation) {
                // Else if the query came back empty, but with a continuation token; repeat the query w/ the token.
                tryQueryAndDelete(responseOptions.continuation);
            } else {
                // Else if there are no more documents and no continuation token - we are finished deleting documents.
                responseBody.continuation = false;
                response.setBody(responseBody);
            }
        });

        // If we hit execution bounds - return continuation: true.
        if (!isAccepted) {
            response.setBody(responseBody);
        }
    }

    // Recursively deletes documents passed in as an array argument.
    // Attempts to query for more on empty array.
    function tryDelete(documents) {
        if (documents.length > 0) {
            // Delete the first document in the array.
            var isAccepted = collection.deleteDocument(documents[0]._self, {}, function (err, responseOptions) {
                if (err) throw err;

                responseBody.deleted++;
                documents.shift();
                // Delete the next document in the array.
                tryDelete(documents);
            });

            // If we hit execution bounds - return continuation: true.
            if (!isAccepted) {
                response.setBody(responseBody);
            }
        } else {
            // If the document array is empty, query for more documents.
            tryQueryAndDelete();
        }
    }
}

Et exécutez-le en utilisant votre clé de partition (exemple: null) et une requête pour sélectionner les documents (exemple: SELECT c._self FROM c pour tout supprimer).

Basé sur Supprimer les documents de CosmosDB en fonction de la condition via l'explorateur de requêtes

0
Antón R. Yuste