Lagrade procedurer

  • Artikel

Azure Cosmos DB är en globalt distribuerad databas med flera modeller som stöder datamodeller för dokument, diagram och nyckelvärden. Innehållet i det här avsnittet handlar om att skapa, fråga och hantera dokumentresurser med hjälp av SQL-API :et via REST.

En lagrad procedur är en programlogik som skrivits i JavaScript och som registreras och körs mot en samling som en enda transaktion. I Azure Cosmos DB finns JavaScript i samma minnesutrymme som databasen. Begäranden som görs i lagrade procedurer körs därför inom samma omfång för en databassession. Den här processen gör det möjligt för Azure Cosmos DB att garantera ACID för alla åtgärder som ingår i en enda lagrad procedur.

Resursen för lagrad procedur representeras av sprocs i Azure Cosmos DB-resursmodellen.

Den lagrade procedurresursen har ett fast schema. Egenskapen body innehåller programlogik. I följande exempel visas JSON-konstruktionen för en lagrad procedur.

{    
   "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"  
}

Att bara ha alla åtkomstlägen för en viss lagrad procedur tillåter inte att användaren kör den lagrade proceduren. I stället måste användaren ha alla åtkomstlägen på samlingsnivå för att kunna köra en lagrad procedur.

Egenskap Beskrivning
id Krävs. Det är en användaruppsättningsbar egenskap. Det är det unika namn som används för att identifiera den lagrade proceduren. ID:t får inte överstiga 255 tecken.
Kroppen Krävs. Det är en användaruppsättningsbar egenskap. Det är brödtexten i den lagrade proceduren.
_Bli Det är en systemgenererad egenskap. Resurs-ID :t (_rid) är en unik identifierare som också är hierarkisk per resursstacken i resursmodellen. Den används internt för placering och navigering av resursen för lagrad procedur.
_Ts Det är en systemgenererad egenskap. Den anger den senast uppdaterade tidsstämpeln för resursen. Värdet är en tidsstämpel.
_Själv Det är en systemgenererad egenskap. Det är den unika adresserbara URI:n för resursen.
_Etag Det är en systemgenererad egenskap som anger resursetaggen som krävs för optimistisk samtidighetskontroll.

Lagrade procedurer kan använda Cosmos DB JavaScript SDK på serversidan för att göra databasåtgärder som att skapa, läsa, uppdatera, ta bort och fråga dokument, samt läsa från begärandetexten och skriva till svarstexten i den lagrade proceduren. Mer information finns i programmeringsguiden för Cosmos DB-serversidan.

Här är till exempel en lagrad procedur för "Hello World":

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

I följande exempel skapas ett dokument i den lagrade proceduren:

{  
    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;  
    }  
}

I följande exempel växlas två objekt inuti en lagrad procedur:

// 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";  
        }  
    }  
}

Aktiviteter

Du kan utföra följande åtgärder med lagrade procedurer:

Information om hur lagrade procedurer fungerar, inklusive körning av en lagrad procedur, finns i Azure Cosmos DB-programmering: Lagrade procedurer, utlösare och UDF:er.

Se även