Share via


Procédures stockées

Azure Cosmos DB est une base de données multimodèle distribuée à l’échelle mondiale qui prend en charge les modèles de données de document, de graphique et de valeur clé. Le contenu de cette section est destiné à créer, interroger et gérer des ressources de document à l’aide de l’API SQL via REST.

Une procédure stockée est un élément de logique d'application écrit en code JavaScript, qui est enregistré et exécuté sur une collection en tant que transaction unique. Dans Azure Cosmos DB, JavaScript est hébergé dans le même espace mémoire que la base de données. Par conséquent, les demandes effectuées au sein de procédures stockées s'exécutent dans l'étendue d'une session de base de données. Ce processus permet à Azure Cosmos DB de garantir ACID pour toutes les opérations qui font partie d’une procédure stockée unique.

La ressource de procédure stockée est représentée par des sprocs dans le modèle de ressource Azure Cosmos DB.

La ressource de procédure stockée a un schéma fixe. La propriété body contient la logique d'application. L'exemple suivant illustre la construction JSON d'un procédure stockée :

{    
   "id":"SimpleStoredProc",  
   "body":"function (docToCreate, addedPropertyName, addedPropertyValue {getContext().getResponse().setBody('Hello World');}",  
   "_rid":"hLEEAI1YjgcBAAAAAAAAgA==",  
   "_ts":1408058682,  
   "_self":"dbs\/hLEEAA==\/colls\/hLEEAI1Yjgc=\/sprocs\/hLEEAI1YjgcBAAAAAAAAgA==\/",  
   "_etag":"00004100-0000-0000-0000-53ed453a0000"  
}  
  

Le simple fait d’avoir le mode d’accès Tous pour une procédure stockée particulière ne permet pas à l’utilisateur d’exécuter la procédure stockée. Au lieu de cela, l’utilisateur doit disposer du mode d’accès Tous au niveau de la collection pour exécuter une procédure stockée.

Propriété Description
id Obligatoire. Il s’agit d’une propriété settable par l’utilisateur. Nom unique utilisé pour identifier la procédure stockée. L’ID ne doit pas dépasser 255 caractères.
body Obligatoire. Il s’agit d’une propriété settable par l’utilisateur. Il s’agit du corps de la procédure stockée.
_Débarrasser Il s’agit d’une propriété générée par le système. L’ID de ressource (_rid) est un identificateur unique qui est également hiérarchique en fonction de la pile de ressources sur le modèle de ressource. Il est utilisé en interne pour le placement de la procédure stockée et la navigation vers celle-ci.
_Ts Il s’agit d’une propriété générée par le système. Elle spécifie l'horodateur de la dernière mise à jour de la ressource. La valeur est un horodateur.
_self Il s’agit d’une propriété générée par le système. Il s'agit de l'URI adressable unique pour la ressource.
_Etag Il s’agit d’une propriété générée par le système qui spécifie l’etag de ressource requis pour le contrôle d’accès concurrentiel optimiste.

Les procédures stockées peuvent utiliser le Kit de développement logiciel (SDK) côté serveur JavaScript Cosmos DB pour effectuer des opérations de base de données telles que la création, la lecture, la mise à jour, la suppression et l’interrogation de documents, ainsi que la lecture à partir du corps de la requête et l’écriture dans le corps de la réponse de la procédure stockée. Pour plus d’informations, consultez le didacticiel de programmation côté serveur Cosmos DB.

Par exemple, voici une procédure stockée pour « Hello World » :

var helloWorldStoredProc = {  
    id: "helloWorld",  
    body: function () {  
        var context = getContext();  
        var response = context.getResponse();  
  
        response.setBody("Hello, World");  
    }  
}  
  

L'exemple suivant crée un document à l'intérieur de la procédure stockée :

{  
    id: "createMyDocument",  
    body: function createMyDocument(documentToCreate) {  
        var context = getContext();  
        var collection = context.getCollection();  
  
        var accepted = collection.createDocument(collection.getSelfLink(),  
              documentToCreate,  
            function (err, documentCreated) {  
                if (err) throw new Error('Error' + err.message);  
                context.getResponse().setBody(documentCreated.id)  
            });  
        if (!accepted) return;  
    }  
}  
  

L'exemple suivant permute deux éléments à l'intérieur d'une procédure stockée :

// JavaScript source code  
var exchangeItemsSproc = {  
    name: "exchangeItems",  
    body: function (playerId1, playerId2) {  
        var context = getContext();  
        var collection = context.getCollection();  
        var response = context.getResponse();  
  
        var player1Document, player2Document;  
  
        // query for players  
        var filterQuery = 'SELECT * FROM Players p where p.id  = "' + playerId1 + '"';  
        var accept = collection.queryDocuments(collection.getSelfLink(), filterQuery, {},  
            function (err, documents, responseOptions) {  
                if (err) throw new Error("Error" + err.message);  
  
                if (documents.length != 1) throw "Unable to find both names";  
                player1Document = documents[0];  
  
                var filterQuery2 = 'SELECT * FROM Players p where p.id = "' + playerId2 + '"';  
                var accept2 = collection.queryDocuments(collection.getSelfLink(), filterQuery2, {},  
                    function (err2, documents2, responseOptions2) {  
                        if (err2) throw new Error("Error" + err2.message);  
                        if (documents2.length != 1) throw "Unable to find both names";  
                        player2Document = documents2[0];  
                        swapItems(player1Document, player2Document);  
                        return;  
                    });  
                if (!accept2) throw "Unable to read player details, abort ";  
            });  
  
        if (!accept) throw "Unable to read player details, abort ";  
  
        // swap the two players’ items  
        function swapItems(player1, player2) {  
            var player1ItemSave = player1.item;  
            player1.item = player2.item;  
            player2.item = player1ItemSave;  
  
            var accept = collection.replaceDocument(player1._self, player1,  
                function (err, docReplaced) {  
                    if (err) throw "Unable to update player 1, abort ";  
  
                    var accept2 = collection.replaceDocument(player2._self, player2,  
                        function (err2, docReplaced2) {  
                            if (err) throw "Unable to update player 2, abort"  
                        });  
  
                    if (!accept2) throw "Unable to update player 2, abort";  
                });  
  
            if (!accept) throw "Unable to update player 1, abort";  
        }  
    }  
}  
  

Tâches

Vous pouvez effectuer les opérations suivantes avec des procédures stockées :

Pour plus d’informations sur le fonctionnement des procédures stockées, notamment l’exécution d’une procédure stockée, consultez Programmation Azure Cosmos DB : Procédures stockées, déclencheurs et fonctions définies par l’utilisateur.

Voir aussi