Esercitazione su Node.js: usare l'API DocumentDB in Azure Cosmos DB per creare un'applicazione console Node.jsNode.js tutorial: Use the DocumentDB API in Azure Cosmos DB to create a Node.js console application

Esercitazione su Node.js per Azure Cosmos DB Node.js SDK.Welcome to the Node.js tutorial for the Azure Cosmos DB Node.js SDK! Dopo aver seguito questa esercitazione, si otterrà un'applicazione console che consente di creare e ridefinire le query delle risorse Azure Cosmos DB.After following this tutorial, you'll have a console application that creates and queries Azure Cosmos DB resources.

Tratteremo questo argomento:We'll cover:

  • Creazione e connessione a un account Azure Cosmos DBCreating and connecting to an Azure Cosmos DB account
  • Configurazione dell'applicazioneSetting up your application
  • Creazione di un database nodoCreating a node database
  • Creare una raccoltaCreating a collection
  • Creazione di documenti JSONCreating JSON documents
  • Esecuzione di query sulla raccoltaQuerying the collection
  • Sostituzione di un documentoReplacing a document
  • Eliminazione di un documentoDeleting a document
  • Eliminazione del database nodoDeleting the node database

Non si ha tempo?Don't have time? Nessun problema.Don't worry! La soluzione completa è disponibile in GitHub.The complete solution is available on GitHub. Per istruzioni rapide, vedere ottenere la soluzione completa .See Get the complete solution for quick instructions.

Dopo aver completato l'esercitazione su Node.js, usare i pulsanti di voto all'inizio e alla fine di questa pagina per fornire commenti e suggerimenti.After you've completed the Node.js tutorial, please use the voting buttons at the top and bottom of this page to give us feedback. Se si desidera contattarci, è possibile includere l'indirizzo di posta elettronica nel commento per il follow-up.If you'd like us to contact you directly, feel free to include your email address in your comments.

Ecco come procedere.Now let's get started!

Prerequisiti per l'esercitazione su Node.jsPrerequisites for the Node.js tutorial

Assicurarsi di disporre di quanto segue:Please make sure you have the following:

Passaggio 1: Creare un account di Azure Cosmos DBStep 1: Create an Azure Cosmos DB account

Creare prima di tutto un account Azure Cosmos DB.Let's create an Azure Cosmos DB account. Se è già disponibile un account da usare, è possibile passare a Configurare l'applicazione Node.js.If you already have an account you want to use, you can skip ahead to Set up your Node.js application. Se si usa l'emulatore Azure Cosmos DB, seguire la procedura descritta nell'articolo Emulatore di Azure Cosmos DB per configurare l'emulatore e proseguire con il passaggio Configurare l'applicazione Node.js.If you are using the Azure Cosmos DB Emulator, please follow the steps at Azure Cosmos DB Emulator to setup the emulator and skip ahead to Set up your Node.js application.

  1. In una nuova finestra del browser accedere al portale di Azure.In a new browser window, sign in to the Azure portal.
  2. Fare clic su Nuovo > Database > Azure Cosmos DB.Click New > Databases > Azure Cosmos DB.

    Riquadro Database nel portale di Azure

  3. Nella pagina Nuovo account immettere le impostazioni per il nuovo account Azure Cosmos DB.In the New account page, enter the settings for the new Azure Cosmos DB account.

    ImpostazioneSetting Valore consigliatoSuggested value DescrizioneDescription
    IDID Immettere un nome univocoEnter a unique name Immettere un nome univoco per identificare l'account Azure Cosmos DB.Enter a unique name to identify this Azure Cosmos DB account. Poiché alI'ID fornito viene aggiunto documents.azure.com per creare l'URI, usare un ID univoco ma facilmente identificabile.Because documents.azure.com is appended to the ID that you provide to create your URI, use a unique but identifiable ID.

    L'ID può contenere solo lettere minuscole, numeri e il segno meno (-) e deve avere una lunghezza compresa tra 3 e 50 caratteri.The ID can contain only lowercase letters, numbers, and the hyphen (-) character, and it must contain 3 to 50 characters.
    APIAPI SQLSQL L'API determina il tipo di account da creare.The API determines the type of account to create. Azure Cosmos DB offre cinque API per soddisfare le esigenze dell'applicazione, ovvero SQL (database di documenti) Gremlin (grafo), MongoDB, SQL (database di documenti), Tabella di Azure e Cassandra, per ognuna delle quali è attualmente necessario un account separato.Azure Cosmos DB provides five APIs to suits the needs of your application: SQL (document database), Gremlin (graph database), MongoDB (document database), Azure Table, and Cassandra, each which currently require a separate account.

    Selezionare SQL perché in questo avvio rapido si sta creando un database di documenti su cui è possibile eseguire query tramite la sintassi SQL e a cui è possibile accedere tramite l'API DocumentDB.Select SQL because in this quickstart you are creating a document database that is queryable using SQL syntax and accessible with the DocumentDB API.

    Altre informazioni sull'API di DocumentDBLearn more about the DocumentDB API
    SottoscrizioneSubscription Sottoscrizione in usoYour subscription Selezionare la sottoscrizione di Azure da usare per l'account Azure Cosmos DB.Select Azure subscription that you want to use for this Azure Cosmos DB account.
    Gruppo di risorseResource Group Creare un nuovo gruppo di risorseCreate new

    Immettere quindi lo stesso nome univoco specificato sopra in IDThen enter the same unique name as provided above in ID
    Selezionare Crea nuovo, quindi immettere il nome di un nuovo gruppo di risorse per l'account.Select Create New, then enter a new resource-group name for your account. Per semplicità si può usare lo stesso nome usato come ID.For simplicity, you can use the same name as your ID.
    PercorsoLocation Selezionare l'area più vicina agli utentiSelect the region closest to your users Selezionare la posizione geografica in cui ospitare l'account Azure Cosmos DB.Select geographic location in which to host your Azure Cosmos DB account. Usare la località più vicina agli utenti per offrire loro la massima velocità di accesso ai dati.Use the location that's closest to your users to give them the fastest access to the data.
    Abilita ridondanza geograficaEnable geo-redundancy Lasciare vuotoLeave blank Consente di creare una versione replicata del database in una seconda area abbinata.This creates a replicated version of your database in a second (paired) region. Lasciare vuoto.Leave this blank.
    Aggiungi al dashboardPin to dashboard SelezionareSelect Selezionare questa casella per aggiungere il nuovo account di database al dashboard del portale e accedervi più facilmente.Select this box so that your new database account is added to your portal dashboard for easy access.

    Fare quindi clic su Crea.Then click Create.

    Pannello Nuovo account per Azure Cosmos DB

  4. La creazione dell'account richiede alcuni minuti,The account creation takes a few minutes. Durante la creazione dell'account il portale visualizza il riquadro Deploying Azure Cosmos DB (Distribuzione di Azure Cosmos DB) a destra, quindi potrebbe essere necessario scorrere a destra del dashboard per visualizzare il riquadro.During account creation the portal displays the Deploying Azure Cosmos DB tile on the right side, you may need to scroll right on your dashboard to see the tile. È presente anche un indicatore di stato nella parte superiore della schermata.There is also a progress bar displayed near the top of the screen. È possibile esaminare lo stato di avanzamento nelle due aree.You can watch either area for progress.

    Riquadro Notifiche del portale di Azure

    Al termine della creazione dell'account verrà visualizzata la pagina L'account Azure Cosmos DB è stato creato.Once the account is created, the Congratulations! Your Azure Cosmos DB account was created page is displayed.

Passaggio 2: Configurare l'applicazione Node.jsStep 2: Set up your Node.js application

  1. Aprire il terminale preferito.Open your favorite terminal.
  2. Individuare la cartella o la directory in cui si vuole salvare l'applicazione Node.js.Locate the folder or directory where you'd like to save your Node.js application.
  3. Creare due file JavaScript vuoti con i comandi seguenti:Create two empty JavaScript files with the following commands:
    • Windows:Windows:
      • fsutil file createnew app.js 0
      • fsutil file createnew config.js 0
    • Linux/OS X:Linux/OS X:
      • touch app.js
      • touch config.js
  4. Installare il modulo documentdb tramite npm.Install the documentdb module via npm. Usare il comando seguente:Use the following command:
    • npm install documentdb --save

L'installazione è riuscita.Great! Dopo avere completato l'installazione, è possibile iniziare a scrivere il codice.Now that you've finished setting up, let's start writing some code.

Passaggio 3: Impostare le configurazioni dell'appStep 3: Set your app's configurations

Aprire il file config.js in un editor di testo.Open config.js in your favorite text editor.

Quindi, copiare e incollare il frammento di codice riportato di seguito e impostare le proprietà config.endpoint e config.primaryKey sull'URI dell'endpoint Azure Cosmos DB e la chiave primaria.Then, copy and paste the code snippet below and set properties config.endpoint and config.primaryKey to your Azure Cosmos DB endpoint uri and primary key. Entrambe le configurazioni sono disponibili nel portale di Azure.Both these configurations can be found in the Azure portal.

Esercitazione su Node.js: screenshot del portale di Azure che mostra un account Azure Cosmos DB con l'hub ATTIVO evidenziato, il pulsante CHIAVI evidenziato nel pannello dell'account Azure Cosmos DB e i valori di URI, CHIAVE PRIMARIA e CHIAVE SECONDARIA evidenziati nel pannello Chiavi, database nodo

// ADD THIS PART TO YOUR CODE
var config = {}

config.endpoint = "~your Azure Cosmos DB endpoint uri here~";
config.primaryKey = "~your primary key here~";

Copiare e incollare database id, collection id e JSON documents nell'oggetto config seguente in cui sono impostate le proprietà config.endpoint e config.primaryKey.Copy and paste the database id, collection id, and JSON documents to your config object below where you set your config.endpoint and config.primaryKey properties. Se sono già disponibili dati da archiviare nel database, è possibile usare lo strumento di migrazione dati di Azure Cosmos DB invece di aggiungere le definizioni dei documenti.If you already have data you'd like to store in your database, you can use Azure Cosmos DB's Data Migration tool rather than adding the document definitions.

config.endpoint = "~your Azure Cosmos DB endpoint uri here~";
config.primaryKey = "~your primary key here~";

// ADD THIS PART TO YOUR CODE
config.database = {
    "id": "FamilyDB"
};

config.collection = {
    "id": "FamilyColl"
};

config.documents = {
    "Andersen": {
        "id": "Anderson.1",
        "lastName": "Andersen",
        "parents": [{
            "firstName": "Thomas"
        }, {
                "firstName": "Mary Kay"
            }],
        "children": [{
            "firstName": "Henriette Thaulow",
            "gender": "female",
            "grade": 5,
            "pets": [{
                "givenName": "Fluffy"
            }]
        }],
        "address": {
            "state": "WA",
            "county": "King",
            "city": "Seattle"
        }
    },
    "Wakefield": {
        "id": "Wakefield.7",
        "parents": [{
            "familyName": "Wakefield",
            "firstName": "Robin"
        }, {
                "familyName": "Miller",
                "firstName": "Ben"
            }],
        "children": [{
            "familyName": "Merriam",
            "firstName": "Jesse",
            "gender": "female",
            "grade": 8,
            "pets": [{
                "givenName": "Goofy"
            }, {
                    "givenName": "Shadow"
                }]
        }, {
                "familyName": "Miller",
                "firstName": "Lisa",
                "gender": "female",
                "grade": 1
            }],
        "address": {
            "state": "NY",
            "county": "Manhattan",
            "city": "NY"
        },
        "isRegistered": false
    }
};

Le definizioni del database, della raccolta e del documento verranno usate come database id, collection id e dati dei documenti di Azure Cosmos DB.The database, collection, and document definitions will act as your Azure Cosmos DB database id, collection id, and documents' data.

Esportare infine l'oggetto config per farvi riferimento nel file app.js.Finally, export your config object, so that you can reference it within the app.js file.

        },
        "isRegistered": false
    }
};

// ADD THIS PART TO YOUR CODE
module.exports = config;

Passaggio 4: Connettersi a un account Azure Cosmos DBStep 4: Connect to an Azure Cosmos DB account

Aprire il file app.js vuoto nell'editor di testo.Open your empty app.js file in the text editor. Copiare e incollare il codice seguente per importare il modulo documentdb e il modulo config appena creato.Copy and paste the code below to import the documentdb module and your newly created config module.

// ADD THIS PART TO YOUR CODE
"use strict";

var documentClient = require("documentdb").DocumentClient;
var config = require("./config");
var url = require('url');

Copiare e incollare il codice per usare gli oggetti config.endpoint e config.primaryKey salvati in precedenza per creare un nuovo DocumentClient.Copy and paste the code to use the previously saved config.endpoint and config.primaryKey to create a new DocumentClient.

var config = require("./config");
var url = require('url');

// ADD THIS PART TO YOUR CODE
var client = new documentClient(config.endpoint, { "masterKey": config.primaryKey });

Ora che è disponibile il codice per inizializzare il client Azure Cosmos DB, è possibile esaminare l'uso delle risorse di Azure Cosmos DB.Now that you have the code to initialize the Azure Cosmos DB client, let's take a look at working with Azure Cosmos DB resources.

Passaggio 5: Creare un database di NodeStep 5: Create a Node database

Copiare e incollare il codice seguente per impostare lo stato HTTP per l'URL della raccolta, l'URL di database e Non trovato.Copy and paste the code below to set the HTTP status for Not Found, the database url, and the collection url. Tali URL definiscono il modo in cui il client Azure Cosmos DB trova il database e la raccolta corretti.These urls are how the Azure Cosmos DB client will find the right database and collection.

var client = new documentClient(config.endpoint, { "masterKey": config.primaryKey });

// ADD THIS PART TO YOUR CODE
var HttpStatusCodes = { NOTFOUND: 404 };
var databaseUrl = `dbs/${config.database.id}`;
var collectionUrl = `${databaseUrl}/colls/${config.collection.id}`;

È possibile creare un database con la funzione createDatabase della classe DocumentClient.A database can be created by using the createDatabase function of the DocumentClient class. Un database è un contenitore logico di archiviazione documenti partizionato nelle raccolte.A database is the logical container of document storage partitioned across collections.

Copiare e incollare la funzione getDatabase per la creazione del nuovo database nel file app.js con l'id specificato nell'oggetto config.Copy and paste the getDatabase function for creating your new database in the app.js file with the id specified in the config object. La funzione controlla se esiste già un database con lo stesso ID FamilyRegistry .The function will check if the database with the same FamilyRegistry id does not already exist. Se esiste, verrà restituito il database esistente, invece di procedere con la creazione di un nuovo database.If it does exist, we'll return that database instead of creating a new one.

var collectionUrl = `${databaseUrl}/colls/${config.collection.id}`;

// ADD THIS PART TO YOUR CODE
function getDatabase() {
    console.log(`Getting database:\n${config.database.id}\n`);

    return new Promise((resolve, reject) => {
        client.readDatabase(databaseUrl, (err, result) => {
            if (err) {
                if (err.code == HttpStatusCodes.NOTFOUND) {
                    client.createDatabase(config.database, (err, created) => {
                        if (err) reject(err)
                        else resolve(created);
                    });
                } else {
                    reject(err);
                }
            } else {
                resolve(result);
            }
        });
    });
}

Copiare e incollare il codice seguente in cui viene impostata la funzione getDatabase per aggiungere la funzione di supporto exit, che stampa il messaggio di uscita e la chiamata alla funzione getDatabase.Copy and paste the code below where you set the getDatabase function to add the helper function exit that will print the exit message and the call to getDatabase function.

            } else {
                resolve(result);
            }
        });
    });
}

// ADD THIS PART TO YOUR CODE
function exit(message) {
    console.log(message);
    console.log('Press any key to exit');
    process.stdin.setRawMode(true);
    process.stdin.resume();
    process.stdin.on('data', process.exit.bind(process, 0));
}

getDatabase()
.then(() => { exit(`Completed successfully`); })
.catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });

Nel terminale trovare il file app.js ed eseguire il comando node app.js.In your terminal, locate your app.js file and run the command: node app.js

Congratulazioni.Congratulations! La creazione di un database di Azure Cosmos DB è stata completata.You have successfully created an Azure Cosmos DB database.

Passaggio 6: Creare una raccoltaStep 6: Create a collection

Avviso

createCollection crea una nuova raccolta, che ha implicazioni in termini di prezzi.createCollection will create a new collection, which has pricing implications. Per altre informazioni, visitare la pagina relativa ai prezzi.For more details, please visit our pricing page.

È possibile creare una raccolta con la funzione createCollection della classe DocumentClient.A collection can be created by using the createCollection function of the DocumentClient class. Una raccolta è un contenitore di documenti JSON e di logica dell'applicazione JavaScript associata.A collection is a container of JSON documents and associated JavaScript application logic.

Copiare e incollare la funzione getCollection sotto la funzione getDatabase nel file app.js per creare la nuova raccolta con il valore id specificato nell'oggetto config.Copy and paste the getCollection function underneath the getDatabase function in the app.js file to create your new collection with the id specified in the config object. Anche in questo caso è necessario assicurarsi che non esista già una raccolta con lo stesso ID FamilyCollection .Again, we'll check to make sure a collection with the same FamilyCollection id does not already exist. Se esiste, verrà restituita la raccolta esistente, invece di procedere con la creazione di una nuova raccolta.If it does exist, we'll return that collection instead of creating a new one.

            } else {
                resolve(result);
            }
        });
    });
}

// ADD THIS PART TO YOUR CODE
function getCollection() {
    console.log(`Getting collection:\n${config.collection.id}\n`);

    return new Promise((resolve, reject) => {
        client.readCollection(collectionUrl, (err, result) => {
            if (err) {
                if (err.code == HttpStatusCodes.NOTFOUND) {
                    client.createCollection(databaseUrl, config.collection, { offerThroughput: 400 }, (err, created) => {
                        if (err) reject(err)
                        else resolve(created);
                    });
                } else {
                    reject(err);
                }
            } else {
                resolve(result);
            }
        });
    });
}

Copiare e incollare il codice sotto la chiamata a getDatabase per eseguire la funzione getCollection.Copy and paste the code below the call to getDatabase to execute the getCollection function.

getDatabase()

// ADD THIS PART TO YOUR CODE
.then(() => getCollection())
// ENDS HERE

.then(() => { exit(`Completed successfully`); })
.catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });

Nel terminale trovare il file app.js ed eseguire il comando node app.js.In your terminal, locate your app.js file and run the command: node app.js

Congratulazioni.Congratulations! La creazione di una raccolta di Azure Cosmos DB è stata completata.You have successfully created an Azure Cosmos DB collection.

Passaggio 7: Creare un documentoStep 7: Create a document

È possibile creare un documento con la funzione createDocument della classe DocumentClient.A document can be created by using the createDocument function of the DocumentClient class. I documenti sono contenuto JSON definito dall'utente (arbitrario).Documents are user defined (arbitrary) JSON content. È ora possibile inserire un documento in Azure Cosmos DB.You can now insert a document into Azure Cosmos DB.

Copiare e incollare la funzione getFamilyDocument sotto la funzione getCollection per la creazione di documenti che contengono i dati JSON salvati nell'oggetto config.Copy and paste the getFamilyDocument function underneath the getCollection function for creating the documents containing the JSON data saved in the config object. Anche in questo caso è necessario assicurarsi che non esista già un documento con lo stesso ID.Again, we'll check to make sure a document with the same id does not already exist.

            } else {
                resolve(result);
            }
        });
    });
}

// ADD THIS PART TO YOUR CODE
function getFamilyDocument(document) {
    let documentUrl = `${collectionUrl}/docs/${document.id}`;
    console.log(`Getting document:\n${document.id}\n`);

    return new Promise((resolve, reject) => {
        client.readDocument(documentUrl, { partitionKey: document.district }, (err, result) => {
            if (err) {
                if (err.code == HttpStatusCodes.NOTFOUND) {
                    client.createDocument(collectionUrl, document, (err, created) => {
                        if (err) reject(err)
                        else resolve(created);
                    });
                } else {
                    reject(err);
                }
            } else {
                resolve(result);
            }
        });
    });
};

Copiare e incollare il codice sotto la chiamata a getCollection per eseguire la funzione getFamilyDocument.Copy and paste the code below the call to getCollection to execute the getFamilyDocument function.

getDatabase()
.then(() => getCollection())

// ADD THIS PART TO YOUR CODE
.then(() => getFamilyDocument(config.documents.Andersen))
.then(() => getFamilyDocument(config.documents.Wakefield))
// ENDS HERE

.then(() => { exit(`Completed successfully`); })
.catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });

Nel terminale trovare il file app.js ed eseguire il comando node app.js.In your terminal, locate your app.js file and run the command: node app.js

Congratulazioni.Congratulations! La creazione di un documento di Azure Cosmos DB è stata completata.You have successfully created an Azure Cosmos DB document.

Esercitazione su Node.js - Diagramma che illustra la relazione gerarchica tra l'account, il database, la raccolta e i documenti - Database nodo

Passaggio 8: Eseguire query sulle risorse di Azure Cosmos DBStep 8: Query Azure Cosmos DB resources

Azure Cosmos DB supporta query complesse sui documenti JSON archiviati in ogni raccolta.Azure Cosmos DB supports rich queries against JSON documents stored in each collection. L'esempio di codice seguente illustra una query eseguibile nei documenti della raccolta.The following sample code shows a query that you can run against the documents in your collection.

Copiare e incollare la funzione queryCollection sotto la funzione getFamilyDocument nel file app.js.Copy and paste the queryCollection function underneath the getFamilyDocument function in the app.js file. Azure Cosmos DB supporta query simili a SQL, come illustrato di seguito.Azure Cosmos DB supports SQL-like queries as shown below. Per altre informazioni sulla creazione di query complesse, vedere la pagina Query Playground e la documentazione sulle query.For more information on building complex queries, check out the Query Playground and the query documentation.

            } else {
                resolve(result);
            }
        });
    });
}

// ADD THIS PART TO YOUR CODE
function queryCollection() {
    console.log(`Querying collection through index:\n${config.collection.id}`);

    return new Promise((resolve, reject) => {
        client.queryDocuments(
            collectionUrl,
            'SELECT VALUE r.children FROM root r WHERE r.lastName = "Andersen"'
        ).toArray((err, results) => {
            if (err) reject(err)
            else {
                for (var queryResult of results) {
                    let resultString = JSON.stringify(queryResult);
                    console.log(`\tQuery returned ${resultString}`);
                }
                console.log();
                resolve(results);
            }
        });
    });
};

Il diagramma seguente illustra il modo in cui la sintassi di query SQL di Azure Cosmos DB viene chiamata nella raccolta creata.The following diagram illustrates how the Azure Cosmos DB SQL query syntax is called against the collection you created.

Esercitazione su Node.js - Diagramma che illustra l'ambito e il significato della query - Database nodo

La parola chiave FROM è facoltativa nella query perché le query di Azure Cosmos DB sono già limitate a una singola raccolta.The FROM keyword is optional in the query because Azure Cosmos DB queries are already scoped to a single collection. Di conseguenza, "FROM Families f" può essere scambiata con "FROM root r" o con il nome di qualsiasi altra variabile scelta.Therefore, "FROM Families f" can be swapped with "FROM root r", or any other variable name you choose. Azure Cosmos DB dedurrà che Families, root o il nome della variabile scelta, si riferisce per impostazione predefinita alla raccolta attuale.Azure Cosmos DB will infer that Families, root, or the variable name you chose, reference the current collection by default.

Copiare e incollare il codice sotto la chiamata a getFamilyDocument per eseguire la funzione queryCollection.Copy and paste the code below the call to getFamilyDocument to execute the queryCollection function.

.then(() => getFamilyDocument(config.documents.Andersen))
.then(() => getFamilyDocument(config.documents.Wakefield))

// ADD THIS PART TO YOUR CODE
.then(() => queryCollection())
// ENDS HERE

.then(() => { exit(`Completed successfully`); })
.catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });

Nel terminale trovare il file app.js ed eseguire il comando node app.js.In your terminal, locate your app.js file and run the command: node app.js

Congratulazioni.Congratulations! L'esecuzione di query sui documenti di Azure Cosmos DB è stata completata.You have successfully queried Azure Cosmos DB documents.

Passaggio 9: Sostituire un documentoStep 9: Replace a document

Azure Cosmos DB supporta la sostituzione di documenti JSON.Azure Cosmos DB supports replacing JSON documents.

Copiare e incollare la funzione replaceFamilyDocument sotto la funzione queryCollection nel file app.js.Copy and paste the replaceFamilyDocument function underneath the queryCollection function in the app.js file.

                }
                console.log();
                resolve(result);
            }
        });
    });
}

// ADD THIS PART TO YOUR CODE
function replaceFamilyDocument(document) {
    let documentUrl = `${collectionUrl}/docs/${document.id}`;
    console.log(`Replacing document:\n${document.id}\n`);
    document.children[0].grade = 6;

    return new Promise((resolve, reject) => {
        client.replaceDocument(documentUrl, document, (err, result) => {
            if (err) reject(err);
            else {
                resolve(result);
            }
        });
    });
};

Copiare e incollare il codice sotto la chiamata a queryCollection per eseguire la funzione replaceDocument.Copy and paste the code below the call to queryCollection to execute the replaceDocument function. Aggiungere anche il codice per chiamare nuovamente queryCollection e verificare che il documento sia stato modificato correttamente.Also, add the code to call queryCollection again to verify that the document had successfully changed.

.then(() => getFamilyDocument(config.documents.Andersen))
.then(() => getFamilyDocument(config.documents.Wakefield))
.then(() => queryCollection())

// ADD THIS PART TO YOUR CODE
.then(() => replaceFamilyDocument(config.documents.Andersen))
.then(() => queryCollection())
// ENDS HERE

.then(() => { exit(`Completed successfully`); })
.catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });

Nel terminale trovare il file app.js ed eseguire il comando node app.js.In your terminal, locate your app.js file and run the command: node app.js

Congratulazioni.Congratulations! La sostituzione di un documento di Azure Cosmos DB è stata completata.You have successfully replaced an Azure Cosmos DB document.

Passaggio 10: Eliminare un documentoStep 10: Delete a document

Azure Cosmos DB supporta l'eliminazione di documenti JSON.Azure Cosmos DB supports deleting JSON documents.

Copiare e incollare la funzione deleteFamilyDocument sotto la funzione replaceFamilyDocument.Copy and paste the deleteFamilyDocument function underneath the replaceFamilyDocument function.

            else {
                resolve(result);
            }
        });
    });
};

// ADD THIS PART TO YOUR CODE
function deleteFamilyDocument(document) {
    let documentUrl = `${collectionUrl}/docs/${document.id}`;
    console.log(`Deleting document:\n${document.id}\n`);

    return new Promise((resolve, reject) => {
        client.deleteDocument(documentUrl, (err, result) => {
            if (err) reject(err);
            else {
                resolve(result);
            }
        });
    });
};

Copiare e incollare il codice sotto la chiamata alla seconda funzione queryCollection per eseguire la funzione deleteDocument.Copy and paste the code below the call to the second queryCollection to execute the deleteDocument function.

.then(() => queryCollection())
.then(() => replaceFamilyDocument(config.documents.Andersen))
.then(() => queryCollection())

// ADD THIS PART TO YOUR CODE
.then(() => deleteFamilyDocument(config.documents.Andersen))
// ENDS HERE

.then(() => { exit(`Completed successfully`); })
.catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });

Nel terminale trovare il file app.js ed eseguire il comando node app.js.In your terminal, locate your app.js file and run the command: node app.js

Congratulazioni.Congratulations! L'eliminazione di un documento di Azure Cosmos DB è stata completata.You have successfully deleted an Azure Cosmos DB document.

Passaggio 11: Eliminare il database NodeStep 11: Delete the Node database

Se si elimina il database creato, verrà rimosso il database e tutte le risorse figlio (raccolte, documenti e così via).Deleting the created database will remove the database and all children resources (collections, documents, etc.).

Copiare e incollare la funzione cleanup sotto la funzione deleteFamilyDocument per rimuovere il database e tutte le risorse figlio.Copy and paste the cleanup function underneath the deleteFamilyDocument function to remove the database and all the children resources.

            else {
                resolve(result);
            }
        });
    });
};

// ADD THIS PART TO YOUR CODE
function cleanup() {
    console.log(`Cleaning up by deleting database ${config.database.id}`);

    return new Promise((resolve, reject) => {
        client.deleteDatabase(databaseUrl, (err) => {
            if (err) reject(err)
            else resolve(null);
        });
    });
}

Copiare e incollare il codice sotto la chiamata a deleteFamilyDocument per eseguire la funzione cleanup.Copy and paste the code below the call to deleteFamilyDocument to execute the cleanup function.

.then(() => deleteFamilyDocument(config.documents.Andersen))

// ADD THIS PART TO YOUR CODE
.then(() => cleanup())
// ENDS HERE

.then(() => { exit(`Completed successfully`); })
.catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });

Passaggio 12: Eseguire l'applicazione Node.jsStep 12: Run your Node.js application all together!

In generale, la sequenza per chiamare le funzioni dovrebbe avere un aspetto simile al seguente:Altogether, the sequence for calling your functions should look like this:

getDatabase()
.then(() => getCollection())
.then(() => getFamilyDocument(config.documents.Andersen))
.then(() => getFamilyDocument(config.documents.Wakefield))
.then(() => queryCollection())
.then(() => replaceFamilyDocument(config.documents.Andersen))
.then(() => queryCollection())
.then(() => deleteFamilyDocument(config.documents.Andersen))
.then(() => cleanup())
.then(() => { exit(`Completed successfully`); })
.catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });

Nel terminale trovare il file app.js ed eseguire il comando node app.js.In your terminal, locate your app.js file and run the command: node app.js

Verrà visualizzato l'output dell'app introduttiva.You should see the output of your get started app. L'output dovrebbe essere analogo al testo di esempio seguente.The output should match the example text below.

Getting database:
FamilyDB

Getting collection:
FamilyColl

Getting document:
Anderson.1

Getting document:
Wakefield.7

Querying collection through index:
FamilyColl
    Query returned [{"firstName":"Henriette Thaulow","gender":"female","grade":5,"pets":[{"givenName":"Fluffy"}]}]

Replacing document:
Anderson.1

Querying collection through index:
FamilyColl
    Query returned [{"firstName":"Henriette Thaulow","gender":"female","grade":6,"pets":[{"givenName":"Fluffy"}]}]

Deleting document:
Anderson.1

Cleaning up by deleting database FamilyDB
Completed successfully
Press any key to exit

Congratulazioni.Congratulations! È stata completata l'esercitazione su Node.js ed stata creata la prima applicazione console di Azure Cosmos DB.You've created you've completed the Node.js tutorial and have your first Azure Cosmos DB console application!

Ottenere la soluzione completa per l'esercitazione su Node.jsGet the complete Node.js tutorial solution

Se non si ha tempo per completare le procedure dell'esercitazione o se si vogliono solo scaricare gli esempi di codice, è possibile ottenerli da GitHub.If you didn't have time to complete the steps in this tutorial, or just want to download the code, you can get it from GitHub.

Per eseguire la soluzione GetStarted completa contenente tutti gli esempi riportati in questo articolo, è necessario avere:To run the GetStarted solution that contains all the samples in this article, you will need the following:

Installare il modulo documentdb tramite npm.Install the documentdb module via npm. Usare il comando seguente:Use the following command:

  • npm install documentdb --save

Nel file config.js aggiornare quindi i valori config.endpoint e config.primaryKey, come illustrato nel Passaggio 3: Impostare le configurazioni dell'app.Next, in the config.js file, update the config.endpoint and config.primaryKey values as described in Step 3: Set your app's configurations.

Nel terminale trovare quindi il file app.js ed eseguire il comando: node app.js.Then in your terminal, locate your app.js file and run the command: node app.js.

Per completare la procedura, è sufficiente procedere alla compilazione.That's it, build it and you're on your way!

Passaggi successiviNext steps