Jak používat službu Azure Table Storage a rozhraní Table API služby Azure Cosmos DB pomocí C++How to use Azure Table storage and Azure Cosmos DB Table API with C++

PLATÍ pro: rozhraní API pro tabulky

Tip

Obsah v tomto článku se vztahuje na službu Azure Table Storage a rozhraní Azure Cosmos DB Table API.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. Rozhraní Azure Cosmos DB Table API je nabídka služby Table Storage úrovně Premium, která nabízí tabulky optimalizované pro zvýšení propustnosti, globální distribuci a automatické sekundární indexy.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

Tato příručka popisuje běžné scénáře pomocí služby Azure Table Storage nebo Azure Cosmos DB rozhraní API pro tabulky.This guide shows you common scenarios by using the Azure Table storage service or Azure Cosmos DB Table API. Ukázky jsou napsané v C++ a využívají klientskou knihovnu služby Azure Storage pro C++.The samples are written in C++ and use the Azure Storage Client Library for C++. Tento článek se zabývá následujícími scénáři:This article covers the following scenarios:

  • Vytvoření a odstranění tabulkyCreate and delete a table
  • Práce s entitami tabulkyWork with table entities

Poznámka

Tato příručka je určená pro klientskou knihovnu služby Azure Storage pro C++ verze 1.0.0 nebo novější.This guide targets the Azure Storage Client Library for C++ version 1.0.0 and above. Doporučená verze je Klientská knihovna pro úložiště 2.2.0, která je k dispozici pomocí NuGet nebo GitHubu.The recommended version is Storage Client Library 2.2.0, which is available by using NuGet or GitHub.

Vytváření účtůCreate accounts

Vytvoření účtu služby AzureCreate an Azure service account

S tabulkami můžete pracovat pomocí služby Azure Table Storage nebo Azure Cosmos DB.You can work with tables using the Azure Table storage or the Azure Cosmos DB. Další informace o rozdílech mezi nabídkami tabulek v těchto dvou službách najdete v článku věnovaném nabídkám pro tabulky .To learn more about the differences between table offerings in these two services, see the Table offerings article. U služby, kterou budete používat, si budete muset vytvořit účet.You'll need to create an account for the service you're going to use. V následujících částech se dozvíte, jak vytvořit službu Azure Table Storage a účet Azure Cosmos DB, ale stačí použít jednu z nich.The following sections show how to create both Azure Table storage and the Azure Cosmos DB account, however you can just use one of them.

Vytvoření účtu úložiště AzureCreate an Azure storage account

Nejjednodušší způsob, jak vytvořit účet úložiště Azure, je použít Azure Portal.The easiest way to create an Azure storage account is by using the Azure portal. Další informace najdete v tématu Vytvoření účtu úložiště.To learn more, see Create a storage account.

Účet úložiště Azure můžete vytvořit také pomocí Azure PowerShellu nebo Azure CLI.You can also create an Azure storage account by using Azure PowerShell or Azure CLI.

Pokud nechcete v tomto okamžiku vytvořit účet úložiště, můžete také použít emulátor Azure Storage ke spuštění a otestování kódu v místním prostředí.If you prefer not to create a storage account at this time, you can also use the Azure Storage Emulator to run and test your code in a local environment. Další informace najdete v tématu použití emulátoru Azure Storage pro vývoj a testování.For more information, see Use the Azure Storage Emulator for development and testing.

Vytvoření účtu rozhraní Table API služby Azure Cosmos DBCreate an Azure Cosmos DB Table API account

Pokyny k vytvoření účtu Azure Cosmos DB rozhraní API pro tabulky najdete v tématu vytvoření databázového účtu.For instructions on creating an Azure Cosmos DB Table API account, see Create a database account.

Vytvoření aplikace C++Create a C++ application

V této příručce použijete funkce úložiště z aplikace C++.In this guide, you use storage features from a C++ application. Provedete to tak, že nainstalujete klientskou knihovnu Azure Storage pro C++.To do so, install the Azure Storage Client Library for C++.

Pro instalaci klientské knihovny Azure Storage pro jazyk C++ použijte následující metody:To install the Azure Storage Client Library for C++, use the following methods:

.\vcpkg.exe install azure-storage-cpp

Můžete najít průvodce pro sestavení zdrojového kódu a exportovat ho do NuGet v souboru Readme .You can find a guide for how to build the source code and export to Nuget in the README file.

Konfigurace přístupu ke klientské knihovně služby Table StorageConfigure access to the Table client library

Pokud chcete používat rozhraní API služby Azure Storage pro přístup k tabulkám, přidejte include do horní části souboru C++ následující příkazy:To use the Azure storage APIs to access tables, add the following include statements to the top of the C++ file:

#include <was/storage_account.h>
#include <was/table.h>

Klient Azure Storage nebo klient Cosmos DB používá připojovací řetězec k uložení koncových bodů a přihlašovacích údajů pro přístup ke službám správy dat.An Azure Storage client or Cosmos DB client uses a connection string to store endpoints and credentials to access data management services. Při spuštění klientské aplikace musíte zadat připojovací řetězec úložiště nebo připojovací řetězec Azure Cosmos DB v příslušném formátu.When you run a client application, you must provide the storage connection string or Azure Cosmos DB connection string in the appropriate format.

Nastavení připojovacího řetězce služby Azure StorageSet up an Azure Storage connection string

Tento příklad ukazuje, jak deklarovat statické pole pro uchování Azure Storage připojovacího řetězce:This example shows how to declare a static field to hold the Azure Storage connection string:

// Define the Storage connection string with your values.
const utility::string_t storage_connection_string(U("DefaultEndpointsProtocol=https;AccountName=<your_storage_account>;AccountKey=<your_storage_account_key>"));

Použijte název svého účtu úložiště pro <your_storage_account> .Use the name of your Storage account for <your_storage_account>. Pro <your_storage_account_key> použijte přístupový klíč pro účet úložiště uvedený v Azure Portal.For <your_storage_account_key>, use the access key for the Storage account listed in the Azure portal. Informace o účtech úložiště a přístupových klíčích najdete v tématu Vytvoření účtu úložiště.For information on Storage accounts and access keys, see Create a storage account.

Nastavení připojovacího řetězce služby Azure Cosmos DBSet up an Azure Cosmos DB connection string

Tento příklad ukazuje, jak deklarovat statické pole pro uchování Azure Cosmos DB připojovacího řetězce:This example shows how to declare a static field to hold the Azure Cosmos DB connection string:

// Define the Azure Cosmos DB connection string with your values.
const utility::string_t storage_connection_string(U("DefaultEndpointsProtocol=https;AccountName=<your_cosmos_db_account>;AccountKey=<your_cosmos_db_account_key>;TableEndpoint=<your_cosmos_db_endpoint>"));

Použijte název účtu Azure Cosmos DB pro <your_cosmos_db_account> .Use the name of your Azure Cosmos DB account for <your_cosmos_db_account>. Zadejte svůj primární klíč pro <your_cosmos_db_account_key> .Enter your primary key for <your_cosmos_db_account_key>. Zadejte koncový bod uvedený v Azure Portal pro <your_cosmos_db_endpoint> .Enter the endpoint listed in the Azure portal for <your_cosmos_db_endpoint>.

K otestování vaší aplikace v místním počítači se systémem Windows můžete použít emulátor Azure Storage, který je nainstalovaný se sadou Azure SDK.To test your application in your local Windows-based computer, you can use the Azure Storage Emulator that is installed with the Azure SDK. Emulátor úložiště je nástroj, který simuluje služby Azure Blob, Queue a Table, které jsou k dispozici na vašem místním vývojovém počítači.The Storage Emulator is a utility that simulates the Azure Blob, Queue, and Table services available on your local development machine. Následující příklad ukazuje, jak deklarovat statické pole pro uložení připojovacího řetězce do místního emulátoru úložiště:The following example shows how to declare a static field to hold the connection string to your local storage emulator:

// Define the connection string with Azure Storage Emulator.
const utility::string_t storage_connection_string(U("UseDevelopmentStorage=true;"));  

Chcete-li spustit emulátor Azure Storage, vyberte z plochy systému Windows tlačítko Start nebo klávesu Windows.To start the Azure Storage Emulator, from your Windows desktop, select the Start button or the Windows key. Zadejte a spusťte emulátor úložiště Microsoft Azure.Enter and run Microsoft Azure Storage Emulator. Další informace najdete v tématu použití emulátoru Azure Storage pro vývoj a testování.For more information, see Use the Azure Storage Emulator for development and testing.

Načtení připojovacího řetězceRetrieve your connection string

Třídu můžete použít cloud_storage_account k reprezentaci informací o svém účtu úložiště.You can use the cloud_storage_account class to represent your storage account information. K načtení informací o účtu úložiště z připojovacího řetězce úložiště použijte parse metodu.To retrieve your storage account information from the storage connection string, use the parse method.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

Potom Získejte odkaz na cloud_table_client třídu.Next, get a reference to a cloud_table_client class. Tato třída umožňuje získat referenční objekty pro tabulky a entity uložené ve službě Table Storage.This class lets you get reference objects for tables and entities stored within the Table storage service. Následující kód vytvoří cloud_table_client objekt pomocí objektu účtu úložiště, který jste dříve získali:The following code creates a cloud_table_client object by using the storage account object you retrieved previously:

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

Vytvoření a přidání entit do tabulkyCreate and add entities to a table

Vytvoření tabulkyCreate a table

cloud_table_clientObjekt umožňuje získat referenční objekty pro tabulky a entity.A cloud_table_client object lets you get reference objects for tables and entities. Následující kód vytvoří cloud_table_client objekt a použije ho k vytvoření nové tabulky.The following code creates a cloud_table_client object and uses it to create a new table.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);  

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Retrieve a reference to a table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Create the table if it doesn't exist.
table.create_if_not_exists();  

Přidání entity do tabulkyAdd an entity to a table

Chcete-li přidat entitu do tabulky, vytvořte nový table_entity objekt a předejte ho do table_operation::insert_entity .To add an entity to a table, create a new table_entity object and pass it to table_operation::insert_entity. Následující kód používá jméno zákazníka jako klíč řádku a jeho příjmení jako klíč oddílu.The following code uses the customer's first name as the row key and last name as the partition key. Společně pak klíč oddílu a řádku entity jednoznačně identifikují entitu v tabulce.Together, an entity's partition and row key uniquely identify the entity in the table. Na entity se stejným klíčem oddílu je možné zadávat dotazy rychleji než entity s různými klíči oddílů.Entities with the same partition key can be queried faster than entities with different partition keys. Použití různých klíčů oddílů umožňuje větší škálovatelnost paralelních operací.Using diverse partition keys allows for greater parallel operation scalability. Další informace najdete v tématu Kontrolní seznam výkonu a škálovatelnosti služby Microsoft Azure Storage.For more information, see Microsoft Azure storage performance and scalability checklist.

Následující kód vytvoří novou instanci table_entity s některými Zákaznickými daty k uložení.The following code creates a new instance of table_entity with some customer data to store. Kód při dalším volání table_operation::insert_entity k vytvoření table_operation objektu pro vložení entity do tabulky a přidruží k ní novou entitu tabulka.The code next calls table_operation::insert_entity to create a table_operation object to insert an entity into a table, and associates the new table entity with it. Nakonec kód volá execute metodu cloud_table objektu.Finally, the code calls the execute method on the cloud_table object. Nový table_operation pošle požadavek do Table Service, aby se do tabulky vložila nová entita zákazníka people .The new table_operation sends a request to the Table service to insert the new customer entity into the people table.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Retrieve a reference to a table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Create the table if it doesn't exist.
table.create_if_not_exists();

// Create a new customer entity.
azure::storage::table_entity customer1(U("Harp"), U("Walter"));

azure::storage::table_entity::properties_type& properties = customer1.properties();
properties.reserve(2);
properties[U("Email")] = azure::storage::entity_property(U("Walter@contoso.com"));

properties[U("Phone")] = azure::storage::entity_property(U("425-555-0101"));

// Create the table operation that inserts the customer entity.
azure::storage::table_operation insert_operation = azure::storage::table_operation::insert_entity(customer1);

// Execute the insert operation.
azure::storage::table_result insert_result = table.execute(insert_operation);

Vložení dávky entitInsert a batch of entities

V rámci jedné operace zápisu můžete do služby Table Storage vložit dávku entit.You can insert a batch of entities to the Table service in one write operation. Následující kód vytvoří table_batch_operation objekt a poté přidá do něj tři operace vložení.The following code creates a table_batch_operation object, and then adds three insert operations to it. Každá operace vložení je přidána vytvořením nového objektu entity, nastavením jeho hodnot a následným voláním insert metody table_batch_operation objektu k přidružení entity k nové operaci vložení.Each insert operation is added by creating a new entity object, setting its values, and then calling the insert method on the table_batch_operation object to associate the entity with a new insert operation. Potom kód volá cloud_table.execute ke spuštění operace.Then, the code calls cloud_table.execute to run the operation.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Define a batch operation.
azure::storage::table_batch_operation batch_operation;

// Create a customer entity and add it to the table.
azure::storage::table_entity customer1(U("Smith"), U("Jeff"));

azure::storage::table_entity::properties_type& properties1 = customer1.properties();
properties1.reserve(2);
properties1[U("Email")] = azure::storage::entity_property(U("Jeff@contoso.com"));
properties1[U("Phone")] = azure::storage::entity_property(U("425-555-0104"));

// Create another customer entity and add it to the table.
azure::storage::table_entity customer2(U("Smith"), U("Ben"));

azure::storage::table_entity::properties_type& properties2 = customer2.properties();
properties2.reserve(2);
properties2[U("Email")] = azure::storage::entity_property(U("Ben@contoso.com"));
properties2[U("Phone")] = azure::storage::entity_property(U("425-555-0102"));

// Create a third customer entity to add to the table.
azure::storage::table_entity customer3(U("Smith"), U("Denise"));

azure::storage::table_entity::properties_type& properties3 = customer3.properties();
properties3.reserve(2);
properties3[U("Email")] = azure::storage::entity_property(U("Denise@contoso.com"));
properties3[U("Phone")] = azure::storage::entity_property(U("425-555-0103"));

// Add customer entities to the batch insert operation.
batch_operation.insert_or_replace_entity(customer1);
batch_operation.insert_or_replace_entity(customer2);
batch_operation.insert_or_replace_entity(customer3);

// Execute the batch operation.
std::vector<azure::storage::table_result> results = table.execute_batch(batch_operation);

O dávkových operacích byste měli vědět několik věcí:Some things to note on batch operations:

  • V rámci jedné dávky můžete provádět operace až 100,,,, a insert delete merge replace insert-or-merge insert-or-replace v libovolné kombinaci.You can do up to 100 insert, delete, merge, replace, insert-or-merge, and insert-or-replace operations in any combination in a single batch.
  • Dávková operace může mít operaci načtení, pokud se jedná o jedinou operaci v dávce.A batch operation can have a retrieve operation, if it's the only operation in the batch.
  • Všechny entity v jedné dávkové operaci musí mít stejný klíč oddílu.All entities in a single batch operation must have the same partition key.
  • Velikost datové části dávkové operace je omezená na 4 MB.A batch operation is limited to a 4-MB data payload.

Dotazování a úpravy entitQuery and modify entities

Načtení všech entit v oddíluRetrieve all entities in a partition

Chcete-li zadat dotaz na tabulku pro všechny entity v oddílu, použijte table_query objekt.To query a table for all entities in a partition, use a table_query object. Následující příklad kódu určuje filtr entit, kde Smith je klíč oddílu.The following code example specifies a filter for entities where Smith is the partition key. Tento příklad zobrazí pole každé entity z výsledků dotazu z konzoly.This example prints the fields of each entity in the query results to the console.

Poznámka

Tyto metody se ve službě Azure Cosmos DB v současné době nepodporují pro C++.These methods are not currently supported for C++ in Azure Cosmos DB.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Construct the query operation for all customer entities where PartitionKey="Smith".
azure::storage::table_query query;

query.set_filter_string(azure::storage::table_query::generate_filter_condition(U("PartitionKey"), azure::storage::query_comparison_operator::equal, U("Smith")));

// Execute the query.
azure::storage::table_query_iterator it = table.execute_query(query);

// Print the fields for each customer.
azure::storage::table_query_iterator end_of_results;
for (; it != end_of_results; ++it)
{
    const azure::storage::table_entity::properties_type& properties = it->properties();

    std::wcout << U("PartitionKey: ") << it->partition_key() << U(", RowKey: ") << it->row_key()
        << U(", Property1: ") << properties.at(U("Email")).string_value()
        << U(", Property2: ") << properties.at(U("Phone")).string_value() << std::endl;
}  

Dotaz v tomto příkladu vrátí všechny entity, které odpovídají kritériím filtru.The query in this example returns all the entities that match the filter criteria. Pokud máte velké tabulky a potřebujete často stahovat entity tabulky, doporučujeme místo toho ukládat data v objektech blob v úložišti Azure.If you have large tables and need to download the table entities often, we recommend that you store your data in Azure storage blobs instead.

Načtení rozsahu entit v oddíluRetrieve a range of entities in a partition

Pokud nechcete zadávat dotazy na všechny entity v oddílu, můžete zadat rozsah.If you don't want to query all the entities in a partition, you can specify a range. Kombinovat filtr klíče oddílu s filtrem klíče řádku.Combine the partition key filter with a row key filter. Následující příklad kódu používá dva filtry k získání všech entit v oddílu, Smith kde klíč řádku (jméno) začíná písmenem starším než E abecedou a následně vypíše výsledky dotazu.The following code example uses two filters to get all entities in partition Smith where the row key (first name) starts with a letter earlier than E in the alphabet, and then prints the query results.

Poznámka

Tyto metody se ve službě Azure Cosmos DB v současné době nepodporují pro C++.These methods are not currently supported for C++ in Azure Cosmos DB.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Create the table query.
azure::storage::table_query query;

query.set_filter_string(azure::storage::table_query::combine_filter_conditions(
    azure::storage::table_query::generate_filter_condition(U("PartitionKey"),
    azure::storage::query_comparison_operator::equal, U("Smith")),
    azure::storage::query_logical_operator::op_and,
    azure::storage::table_query::generate_filter_condition(U("RowKey"), azure::storage::query_comparison_operator::less_than, U("E"))));

// Execute the query.
azure::storage::table_query_iterator it = table.execute_query(query);

// Loop through the results, displaying information about the entity.
azure::storage::table_query_iterator end_of_results;
for (; it != end_of_results; ++it)
{
    const azure::storage::table_entity::properties_type& properties = it->properties();

    std::wcout << U("PartitionKey: ") << it->partition_key() << U(", RowKey: ") << it->row_key()
        << U(", Property1: ") << properties.at(U("Email")).string_value()
        << U(", Property2: ") << properties.at(U("Phone")).string_value() << std::endl;
}  

Načtení jedné entityRetrieve a single entity

Můžete napsat dotaz pro načtení jedné konkrétní entity.You can write a query to retrieve a single, specific entity. Následující kód používá table_operation::retrieve_entity k určení zákazníka Jeff Smith .The following code uses table_operation::retrieve_entity to specify the customer Jeff Smith. Tato metoda vrátí pouze jednu entitu, nikoli kolekci, a vrácenou hodnotu je v table_result .This method returns just one entity, rather than a collection, and the returned value is in table_result. Určení jak klíčů oddílu, tak klíčů řádků v dotazu představuje nejrychlejší způsob, jak načíst jednu entitu ze služby Table service.Specifying both partition and row keys in a query is the fastest way to retrieve a single entity from the Table service.

azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Retrieve the entity with partition key of "Smith" and row key of "Jeff".
azure::storage::table_operation retrieve_operation = azure::storage::table_operation::retrieve_entity(U("Smith"), U("Jeff"));
azure::storage::table_result retrieve_result = table.execute(retrieve_operation);

// Output the entity.
azure::storage::table_entity entity = retrieve_result.entity();
const azure::storage::table_entity::properties_type& properties = entity.properties();

std::wcout << U("PartitionKey: ") << entity.partition_key() << U(", RowKey: ") << entity.row_key()
    << U(", Property1: ") << properties.at(U("Email")).string_value()
    << U(", Property2: ") << properties.at(U("Phone")).string_value() << std::endl;

Nahrazení entityReplace an entity

Pokud chcete entitu nahradit, načtěte ji ze služby Table Storage, upravte objekt entity a pak uložte změny zpět do služby Table Storage.To replace an entity, retrieve it from the Table service, modify the entity object, and then save the changes back to the Table service. Následující kód změní telefonní číslo a e-mailovou adresu stávajícího zákazníka.The following code changes an existing customer's phone number and email address. Místo volání table_operation::insert_entity , tento kód používá table_operation::replace_entity .Instead of calling table_operation::insert_entity, this code uses table_operation::replace_entity. Tento přístup způsobí, že entita se na serveru úplně nahradí, pokud se entita na serveru od načtení nezměnila.This approach causes the entity to be fully replaced on the server, unless the entity on the server has changed since it was retrieved. Pokud byl změněn, operace se nezdařila.If it has been changed, the operation fails. Tato chyba zabraňuje vaší aplikaci přepsat změnu provedenou mezi načítáním a aktualizací jiné součásti.This failure prevents your application from overwriting a change made between the retrieval and update by another component. Řádným zpracováním této chyby je znovu načíst entitu, provést změny, pokud je stále platná, a pak provést jinou table_operation::replace_entity operaci.The proper handling of this failure is to retrieve the entity again, make your changes, if still valid, and then do another table_operation::replace_entity operation.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Replace an entity.
azure::storage::table_entity entity_to_replace(U("Smith"), U("Jeff"));
azure::storage::table_entity::properties_type& properties_to_replace = entity_to_replace.properties();
properties_to_replace.reserve(2);

// Specify a new phone number.
properties_to_replace[U("Phone")] = azure::storage::entity_property(U("425-555-0106"));

// Specify a new email address.
properties_to_replace[U("Email")] = azure::storage::entity_property(U("JeffS@contoso.com"));

// Create an operation to replace the entity.
azure::storage::table_operation replace_operation = azure::storage::table_operation::replace_entity(entity_to_replace);

// Submit the operation to the Table service.
azure::storage::table_result replace_result = table.execute(replace_operation);

Vložení nebo nahrazení entityInsert or replace an entity

table_operation::replace_entity operace se nezdaří, pokud byla entita od načtení ze serveru změněna.table_operation::replace_entity operations fail if the entity has been changed since it was retrieved from the server. Kromě toho je nutné nejprve načíst entitu ze serveru, aby table_operation::replace_entity byla úspěšná.Furthermore, you must retrieve the entity from the server first in order for table_operation::replace_entity to be successful. Někdy nevíte, jestli na serveru existuje entita.Sometimes, you don't know if the entity exists on the server. Aktuální hodnoty, které jsou v něm uložené, nejsou důležité, protože by je vaše aktualizace měla přepsat.The current values stored in it are irrelevant, because your update should overwrite them all. K dosažení tohoto výsledku použijte table_operation::insert_or_replace_entity operaci.To accomplish this result, use a table_operation::insert_or_replace_entity operation. Tato operace vloží entitu, pokud neexistuje.This operation inserts the entity if it doesn't exist. Operace nahradí entitu, pokud existuje.The operation replaces the entity if it exists. V následujícím příkladu kódu je entita zákazníka pro Jeff Smith stále načtena, ale je pak uložena zpět na server pomocí table_operation::insert_or_replace_entity .In the following code example, the customer entity for Jeff Smith is still retrieved, but it's then saved back to the server by using table_operation::insert_or_replace_entity. Jakékoli aktualizace provedené v entitě mezi operací načtení a aktualizace se přepíšou.Any updates made to the entity between the retrieval and update operation will be overwritten.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Insert or replace an entity.
azure::storage::table_entity entity_to_insert_or_replace(U("Smith"), U("Jeff"));
azure::storage::table_entity::properties_type& properties_to_insert_or_replace = entity_to_insert_or_replace.properties();

properties_to_insert_or_replace.reserve(2);

// Specify a phone number.
properties_to_insert_or_replace[U("Phone")] = azure::storage::entity_property(U("425-555-0107"));

// Specify an email address.
properties_to_insert_or_replace[U("Email")] = azure::storage::entity_property(U("Jeffsm@contoso.com"));

// Create an operation to insert or replace the entity.
azure::storage::table_operation insert_or_replace_operation = azure::storage::table_operation::insert_or_replace_entity(entity_to_insert_or_replace);

// Submit the operation to the Table service.
azure::storage::table_result insert_or_replace_result = table.execute(insert_or_replace_operation);

Dotaz na podmnožinu vlastností entityQuery a subset of entity properties

Dotaz na tabulku dokáže z entity načíst pouze několik vlastností.A query to a table can retrieve just a few properties from an entity. Dotaz v následujícím kódu používá table_query::set_select_columns metodu pro vrácení pouze e-mailových adres entit v tabulce.The query in the following code uses the table_query::set_select_columns method to return only the email addresses of entities in the table.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Define the query, and select only the Email property.
azure::storage::table_query query;
std::vector<utility::string_t> columns;

columns.push_back(U("Email"));
query.set_select_columns(columns);

// Execute the query.
azure::storage::table_query_iterator it = table.execute_query(query);

// Display the results.
azure::storage::table_query_iterator end_of_results;
for (; it != end_of_results; ++it)
{
    std::wcout << U("PartitionKey: ") << it->partition_key() << U(", RowKey: ") << it->row_key();

    const azure::storage::table_entity::properties_type& properties = it->properties();
    for (auto prop_it = properties.begin(); prop_it != properties.end(); ++prop_it)
    {
        std::wcout << ", " << prop_it->first << ": " << prop_it->second.str();
    }

    std::wcout << std::endl;
}

Poznámka

Dotazování několika vlastností entity je efektivnější operace než načítání všech vlastností.Querying a few properties from an entity is a more efficient operation than retrieving all properties.

Odstranit obsahDelete content

Odstranění entityDelete an entity

Entitu můžete po jejím načtení odstranit.You can delete an entity after you retrieve it. Po načtení entity zavolejte table_operation::delete_entity s entitou, která se má odstranit.After you retrieve an entity, call table_operation::delete_entity with the entity to delete. Pak zavolejte cloud_table.execute metodu.Then call the cloud_table.execute method. Následující kód načte a odstraní entitu s klíčem oddílu Smith a klíčem řádku Jeff .The following code retrieves and deletes an entity with a partition key of Smith and a row key of Jeff.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Create an operation to retrieve the entity with partition key of "Smith" and row key of "Jeff".
azure::storage::table_operation retrieve_operation = azure::storage::table_operation::retrieve_entity(U("Smith"), U("Jeff"));
azure::storage::table_result retrieve_result = table.execute(retrieve_operation);

// Create an operation to delete the entity.
azure::storage::table_operation delete_operation = azure::storage::table_operation::delete_entity(retrieve_result.entity());

// Submit the delete operation to the Table service.
azure::storage::table_result delete_result = table.execute(delete_operation);  

Odstranění tabulkyDelete a table

Následující příklad kódu nakonec odstraní tabulku z účtu úložiště.Finally, the following code example deletes a table from a storage account. Odstraněná tabulka není k dispozici, aby ji bylo možné po odstranění znovu vytvořit.A table that has been deleted is unavailable to be re-created for some time following the deletion.

// Retrieve the storage account from the connection string.
azure::storage::cloud_storage_account storage_account = azure::storage::cloud_storage_account::parse(storage_connection_string);

// Create the table client.
azure::storage::cloud_table_client table_client = storage_account.create_cloud_table_client();

// Create a cloud table object for the table.
azure::storage::cloud_table table = table_client.get_table_reference(U("people"));

// Delete the table if it exists
if (table.delete_table_if_exists())
{
    std::cout << "Table deleted!";
}
else
{
    std::cout << "Table didn't exist";
}

Odstraňování potížíTroubleshooting

Pro Visual Studio Community Edition, pokud projekt získá chyby sestavení z důvodu souborů include storage_account. h a Table. h , odeberte přepínač kompilátoru /Permissive- :For Visual Studio Community Edition, if your project gets build errors because of the include files storage_account.h and table.h , remove the /permissive- compiler switch:

  1. V Průzkumníku řešení klikněte pravým tlačítkem na váš projekt a vyberte Vlastnosti.In Solution Explorer , right-click your project and select Properties.
  2. V dialogovém okně Stránky vlastností rozbalte Vlastnosti konfigurace , pak rozbalte C/C++ a vyberte Jazyk.In the Property Pages dialog box, expand Configuration Properties , expand C/C++ , and select Language.
  3. Nastavte Režim přizpůsobení na hodnotu Ne.Set Conformance mode to No.

Další krokyNext steps

Microsoft Azure Storage Explorer je bezplatná samostatná aplikace od Microsoftu, která umožňuje vizuálně pracovat s daty Azure Storage ve Windows, macOS a Linuxu.Microsoft Azure Storage Explorer is a free, standalone app from Microsoft that enables you to work visually with Azure Storage data on Windows, macOS, and Linux.

Další informace o službě Azure Storage a rozhraní Table API ve službě Azure Cosmos DB najdete na následujících odkazech:Follow these links to learn more about Azure Storage and the Table API in Azure Cosmos DB: