Come usare il servizio Tabella di archiviazione di Azure o l'API Tabelle di Azure Cosmos DB da PHPHow to use Azure Storage Table service or the Azure Cosmos DB Table API from PHP

Suggerimento

Il contenuto di questo articolo è applicabile al servizio di archiviazione tabelle di Azure e all'API Tabelle di Azure Cosmos DB.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. L'API Tabelle di Azure Cosmos DB è un'offerta Premium per il servizio di archiviazione tabelle, che include tabelle con ottimizzazione per la velocità effettiva, distribuzione globale e indici secondari automatici.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

PanoramicaOverview

Questa guida illustra come eseguire scenari comuni con il servizio Tabella di archiviazione di Azure e l'API Tabelle di Azure Cosmos DB.This guide shows you how to perform common scenarios using the Azure Storage Table service and the Azure Cosmos DB Table API. Gli esempi sono scritti in PHP e usano la libreria client PHP per Tabella di archiviazione di Azure.The samples are written in PHP and use the Azure Storage Table PHP Client Library. Gli scenari presentati includono operazioni di creazione ed eliminazione di una tabella, nonché di inserimento, eliminazione ed esecuzione di query sulle entità di una tabella.The scenarios covered include creating and deleting a table, and inserting, deleting, and querying entities in a table. Per altre informazioni sul servizio tabelle di Azure, vedere la sezione Passaggi successivi .For more information on the Azure Table service, see the Next steps section.

Creare un account del servizio di AzureCreate an Azure service account

È possibile usare tabelle con l'archiviazione tabelle di Azure o con Azure Cosmos DB.You can work with tables using Azure Table storage or Azure Cosmos DB. Per altre informazioni sulle differenze tra i servizi, vedere Offerte per tabelle.To learn more about the differences between the services, see Table offerings. Sarà necessario creare un account per il servizio che si intende usare.You'll need to create an account for the service you're going to use.

Creare un account di archiviazione di AzureCreate an Azure storage account

Il modo più semplice per creare un account di archiviazione di Azure consiste nell'usare il portale di Azure.The easiest way to create an Azure storage account is by using the Azure portal. Per altre informazioni, vedere Creare un account di archiviazione.To learn more, see Create a storage account.

È possibile anche creare un account di archiviazione di Azure usando Azure PowerShell o l'interfaccia della riga di comando di Azure.You can also create an Azure storage account by using Azure PowerShell or Azure CLI.

Se si preferisce non creare un account di archiviazione in questa fase, è anche possibile usare l'emulatore di archiviazione di Azure per eseguire e testare il codice in un ambiente locale.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. Per altre informazioni, vedere Usare l'emulatore di archiviazione di Azure per sviluppo e test.For more information, see Use the Azure storage emulator for development and testing.

Creare un account per l'API di tabella di Azure Cosmos DBCreate an Azure Cosmos DB Table API account

Per istruzioni per la creazione di un account per l'API Tabella di Azure Cosmos DB, vedere Creare un account di database.For instructions on creating an Azure Cosmos DB Table API account, see Create a database account.

Creare un'applicazione PHPCreate a PHP application

L'unico requisito per creare un'applicazione PHP per l'accesso al servizio Tabella di archiviazione o all'API del servizio tabelle di Azure Cosmos DB è fare riferimento alle classi nell'SDK azure-storage-table per PHP all'interno del codice.The only requirement to create a PHP application to access the Storage Table service or Azure Cosmos DB Table API is to reference classes in the azure-storage-table SDK for PHP from within your code. Per creare l'applicazione, è possibile usare qualsiasi strumento di sviluppo, incluso il Blocco note.You can use any development tools to create your application, including Notepad.

In questo documento vengono usate le funzionalità del servizio Tabella di archiviazione o di Azure Cosmos DB che possono essere chiamate da un'applicazione PHP a livello locale o nel codice in esecuzione in un ruolo Web, in un ruolo di lavoro o in un sito Web di Azure.In this guide, you use Storage Table service or Azure Cosmos DB features that can be called from within a PHP application locally, or in code running within an Azure web role, worker role, or website.

Ottenere la libreria clientGet the client library

  1. Creare un file denominato composer.json nella radice del progetto e aggiungere nel file il codice seguente:Create a file named composer.json in the root of your project and add the following code to it:
    {
    "require": {
     "microsoft/azure-storage-table": "*"
    }
    }
    
  2. Scaricare composer.phar nella radice.Download composer.phar in your root.
  3. Aprire un prompt dei comandi ed eseguire il comando seguente nella radice del progetto:Open a command prompt and execute the following command in your project root:
    php composer.phar install
    
    In alternativa, passare alla libreria client PHP per Tabella di archiviazione di Azure in GitHub per clonare il codice sorgente.Alternatively, go to the Azure Storage Table PHP Client Library on GitHub to clone the source code.

Aggiungere i riferimenti necessariAdd required references

Per usare il servizio Tabella di archiviazione o le API di Azure Cosmos DB, è necessario:To use the Storage Table service or Azure Cosmos DB APIs, you must:

  • Fare riferimento al file autoloader mediante l'istruzione require_onceReference the autoloader file using the require_once statement, and
  • Fare riferimento a tutte le classi usate.Reference any classes you use.

L'esempio seguente illustra come includere il file autoloader e fare riferimento alla classe TableRestProxy.The following example shows how to include the autoloader file and reference the TableRestProxy class.

require_once 'vendor/autoload.php';
use MicrosoftAzure\Storage\Table\TableRestProxy;

Negli esempi seguenti viene mostrata sempre l'istruzione require_once , ma si fa riferimento solo alle classi necessarie per l'esecuzione dell'esempio.In the examples below, the require_once statement is always shown, but only the classes necessary for the example to execute are referenced.

Aggiungere una connessione al servizio Tabella di archiviazioneAdd a Storage Table service connection

Per creare un'istanza di un client del servizio Tabella di archiviazione, è necessario avere prima una stringa di connessione valida.To instantiate a Storage Table service client, you must first have a valid connection string. Di seguito è riportato il formato della stringa di connessione al servizio Tabella di archiviazione:The format for the Storage Table service connection string is:

$connectionString = "DefaultEndpointsProtocol=[http|https];AccountName=[yourAccount];AccountKey=[yourKey]"

Aggiungere una connessione ad Azure Cosmos DBAdd an Azure Cosmos DB connection

Per creare un'istanza di un client del servizio tabelle di Azure Cosmos DB, è necessario avere prima una stringa di connessione valida.To instantiate an Azure Cosmos DB Table client, you must first have a valid connection string. Di seguito è riportato il formato della stringa di connessione ad Azure Cosmos DB:The format for the Azure Cosmos DB connection string is:

$connectionString = "DefaultEndpointsProtocol=[https];AccountName=[myaccount];AccountKey=[myaccountkey];TableEndpoint=[https://myendpoint/]";

Aggiungere una connessione all'emulatore di archiviazioneAdd a Storage emulator connection

Per accedere all'emulatore di archiviazione:To access the emulator storage:

UseDevelopmentStorage = true

Per creare un client del servizio tabelle di Azure o di Azure Cosmos DB, è necessario usare la classe TableRestProxy.To create an Azure Table service client or Azure Cosmos DB client, you need to use the TableRestProxy class. È possibile:You can:

  • passare la stringa di connessione direttamente a essa oPass the connection string directly to it or
  • usare CloudConfigurationManager (CCM) per cercare la stringa di connessione in più origini esterne:Use the CloudConfigurationManager (CCM) to check multiple external sources for the connection string:
    • per impostazione predefinita viene fornito con il supporto per un'origine esterna - ovvero le variabili ambientaliBy default, it comes with support for one external source - environmental variables.
    • È possibile aggiungere nuove origini estendendo la classe ConnectionStringSource.You can add new sources by extending the ConnectionStringSource class.

Per gli esempi illustrati in questo articolo, la stringa di connessione viene passata direttamente.For the examples outlined here, the connection string is passed directly.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;

$tableClient = TableRestProxy::createTableService($connectionString);

Creare una tabellaCreate a table

Un oggetto TableRestProxy consente di creare una tabella usando il metodo createTable.A TableRestProxy object lets you create a table with the createTable method. Durante la creazione di una tabella, è possibile impostare il timeout del servizio tabelle.When creating a table, you can set the Table service timeout. Per altre informazioni sul timeout del servizio tabelle, vedere Setting Timeouts for Table Service Operations (Impostazione di timeout per le operazioni del servizio tabelle).(For more information about the Table service timeout, see Setting Timeouts for Table Service Operations.)

require_once 'vendor\autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;

// Create Table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

try    {
    // Create table.
    $tableClient->createTable("mytable");
}
catch(ServiceException $e){
    $code = $e->getCode();
    $error_message = $e->getMessage();
    // Handle exception based on error codes and messages.
    // Error codes and messages can be found here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
}

Per informazioni sulle restrizioni ai nomi delle tabelle, vedere Understanding the Table Service Data Model (Informazioni sul modello di dati del servizio tabelle).For information about restrictions on table names, see Understanding the Table Service Data Model.

Aggiungere un'entità a una tabellaAdd an entity to a table

Per aggiungere un'entità a una tabella, creare un nuovo oggetto Entity e passarlo a TableRestProxy->insertEntity.To add an entity to a table, create a new Entity object and pass it to TableRestProxy->insertEntity. Si noti che durante la creazione di un'entità, è necessario specificare le chiavi PartitionKey e RowKey.Note that when you create an entity, you must specify a PartitionKey and RowKey. Si tratta di identificatori univoci dell'entità e sono valori che possono essere interrogati molto più velocemente rispetto ad altre proprietà dell'entità.These are the unique identifiers for an entity and are values that can be queried much faster than other entity properties. Il sistema usa PartitionKey per distribuire automaticamente le entità della tabella in molti nodi di archiviazione.The system uses PartitionKey to automatically distribute the table's entities over many Storage nodes. Le entità con lo stesso PartitionKey vengono archiviate nello stesso nodo.Entities with the same PartitionKey are stored on the same node. Operazioni su più entità archiviate nello stesso nodo vengono eseguite più efficacemente che non su entità archiviate in nodi diversi. RowKey è l'ID univoco di un'entità all'interno di una partizione.(Operations on multiple entities stored on the same node perform better than on entities stored across different nodes.) The RowKey is the unique ID of an entity within a partition.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;
use MicrosoftAzure\Storage\Table\Models\Entity;
use MicrosoftAzure\Storage\Table\Models\EdmType;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

$entity = new Entity();
$entity->setPartitionKey("tasksSeattle");
$entity->setRowKey("1");
$entity->addProperty("Description", null, "Take out the trash.");
$entity->addProperty("DueDate",
                        EdmType::DATETIME,
                        new DateTime("2012-11-05T08:15:00-08:00"));
$entity->addProperty("Location", EdmType::STRING, "Home");

try{
    $tableClient->insertEntity("mytable", $entity);
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
}

Per informazioni sulle proprietà e i tipi di tabelle, vedere Understanding the Table Service Data Model (Informazioni sul modello di dati del servizio tabelle).For information about Table properties and types, see Understanding the Table Service Data Model.

La classe TableRestProxy offre due metodi alternativi per l'inserimento di entità: insertOrMergeEntity e insertOrReplaceEntity.The TableRestProxy class offers two alternative methods for inserting entities: insertOrMergeEntity and insertOrReplaceEntity. Per utilizzare questi metodi, creare una nuova Entity e passarla come parametro a uno dei due metodi.To use these methods, create a new Entity and pass it as a parameter to either method. Ogni metodo inserirà l'entità se non esiste già.Each method will insert the entity if it does not exist. Se l'entità esiste già, insertOrMergeEntity aggiornerà i valori delle proprietà esistenti e aggiungerà nuove proprietà se non esistono, mentre insertOrReplaceEntity sostituirà completamente un'entità esistente.If the entity already exists, insertOrMergeEntity updates property values if the properties already exist and adds new properties if they do not exist, while insertOrReplaceEntity completely replaces an existing entity. Nell'esempio seguente viene illustrato come utilizzare insertOrMergeEntity.The following example shows how to use insertOrMergeEntity. Se l'entità con PartitionKey "tasksSeattle" e RowKey "1" non esiste già, verrà inserita.If the entity with PartitionKey "tasksSeattle" and RowKey "1" does not already exist, it will be inserted. Tuttavia, se è già stata inserita (come illustrato nell'esempio precedente), viene aggiornata la proprietà DueDate e viene aggiunta la proprietà Status.However, if it has previously been inserted (as shown in the example above), the DueDate property is updated, and the Status property is added. Verranno aggiornate anche le proprietà Description e Location, ma con valori che non apporteranno alcuna modifica.The Description and Location properties are also updated, but with values that effectively leave them unchanged. Se queste due ultime proprietà non sono state aggiunte come illustrato nell'esempio, ma erano disponibili nell'entità di destinazione, i loro valori esistenti non subiranno alcuna modifica.If these latter two properties were not added as shown in the example, but existed on the target entity, their existing values would remain unchanged.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;
use MicrosoftAzure\Storage\Table\Models\Entity;
use MicrosoftAzure\Storage\Table\Models\EdmType;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

//Create new entity.
$entity = new Entity();

// PartitionKey and RowKey are required.
$entity->setPartitionKey("tasksSeattle");
$entity->setRowKey("1");

// If entity exists, existing properties are updated with new values and
// new properties are added. Missing properties are unchanged.
$entity->addProperty("Description", null, "Take out the trash.");
$entity->addProperty("DueDate", EdmType::DATETIME, new DateTime()); // Modified the DueDate field.
$entity->addProperty("Location", EdmType::STRING, "Home");
$entity->addProperty("Status", EdmType::STRING, "Complete"); // Added Status field.

try    {
    // Calling insertOrReplaceEntity, instead of insertOrMergeEntity as shown,
    // would simply replace the entity with PartitionKey "tasksSeattle" and RowKey "1".
    $tableClient->insertOrMergeEntity("mytable", $entity);
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

Recuperare una singola entitàRetrieve a single entity

Il metodo TableRestProxy->getEntity consente di recuperare una singola entità eseguendo una query su PartitionKey e RowKey.The TableRestProxy->getEntity method allows you to retrieve a single entity by querying for its PartitionKey and RowKey. Nell'esempio seguente la chiave di partizione tasksSeattle e la chiave di riga 1 vengono passate al metodo getEntity.In the example below, the partition key tasksSeattle and row key 1 are passed to the getEntity method.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

try    {
    $result = $tableClient->getEntity("mytable", "tasksSeattle", 1);
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

$entity = $result->getEntity();

echo $entity->getPartitionKey().":".$entity->getRowKey();

Recuperare tutte le entità di una partizioneRetrieve all entities in a partition

Le query di entità vengono create usando i filtri. Per altre informazioni, vedere Querying Tables and Entities (Query di tabelle ed entità).Entity queries are constructed using filters (for more information, see Querying Tables and Entities). Per recuperare tutte le entità in una partizione usare il filtro "PartitionKey eq partition_name".To retrieve all entities in partition, use the filter "PartitionKey eq partition_name". Nell'esempio seguente viene illustrato come recuperare tutte le entità nella partizione tasksSeattle passando un filtro al metodo queryEntities .The following example shows how to retrieve all entities in the tasksSeattle partition by passing a filter to the queryEntities method.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

$filter = "PartitionKey eq 'tasksSeattle'";

try    {
    $result = $tableClient->queryEntities("mytable", $filter);
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

$entities = $result->getEntities();

foreach($entities as $entity){
    echo $entity->getPartitionKey().":".$entity->getRowKey()."<br />";
}

Recuperare un subset di entità in una partizioneRetrieve a subset of entities in a partition

Lo stesso modello applicato nell'esempio precedente può essere usato per recuperare un subset di entità in una partizione.The same pattern used in the previous example can be used to retrieve any subset of entities in a partition. Il subset di entità recuperato viene determinato dal filtro usato. Per altre informazioni, vedere Querying Tables and Entities (Query di tabelle ed entità). L'esempio seguente illustra come usare un filtro per recuperare tutte le entità con un valore Location specifico e un valore DueDate precedente a una data specificata.The subset of entities you retrieve are determined by the filter you use (for more information, see Querying Tables and Entities).The following example shows how to use a filter to retrieve all entities with a specific Location and a DueDate less than a specified date.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

$filter = "Location eq 'Office' and DueDate lt '2012-11-5'";

try    {
    $result = $tableClient->queryEntities("mytable", $filter);
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

$entities = $result->getEntities();

foreach($entities as $entity){
    echo $entity->getPartitionKey().":".$entity->getRowKey()."<br />";
}

Recuperare un subset di proprietà di entitàRetrieve a subset of entity properties

È possibile recuperare un subset di proprietà di entità eseguendo una query.A query can retrieve a subset of entity properties. Questa tecnica, denominata proiezione, consente di ridurre la larghezza di banda e di migliorare le prestazioni della query, in particolare per entità di grandi dimensioni.This technique, called projection, reduces bandwidth and can improve query performance, especially for large entities. Per specificare una proprietà da recuperare, passare il nome della proprietà al metodo Query->addSelectField.To specify a property to retrieve, pass the name of the property to the Query->addSelectField method. Per aggiungere altre proprietà, è possibile chiamare questo metodo più volte.You can call this method multiple times to add more properties. Dopo l'esecuzione di TableRestProxy->queryEntities, per le entità restituite saranno presenti solo le proprietà selezionate.After executing TableRestProxy->queryEntities, the returned entities will only have the selected properties. Se si desidera restituire un subset di entità di tabella, utilizzare un filtro come illustrato nelle query precedenti.(If you want to return a subset of Table entities, use a filter as shown in the queries above.)

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;
use MicrosoftAzure\Storage\Table\Models\QueryEntitiesOptions;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

$options = new QueryEntitiesOptions();
$options->addSelectField("Description");

try    {
    $result = $tableClient->queryEntities("mytable", $options);
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

// All entities in the table are returned, regardless of whether
// they have the Description field.
// To limit the results returned, use a filter.
$entities = $result->getEntities();

foreach($entities as $entity){
    $description = $entity->getProperty("Description")->getValue();
    echo $description."<br />";
}

Aggiornare un'entitàUpdate an entity

È possibile aggiornare un'entità esistente usando i metodi Entity->setProperty ed Entity->addProperty sull'entità e quindi chiamando TableRestProxy->updateEntity.You can update an existing entity by using the Entity->setProperty and Entity->addProperty methods on the entity, and then calling TableRestProxy->updateEntity. Nell'esempio seguente viene recuperata un'entità, modificata una proprietà, rimossa un'altra proprietà e aggiunta una nuova proprietà.The following example retrieves an entity, modifies one property, removes another property, and adds a new property. Si noti che per rimuovere una proprietà, è necessario impostarne il valore su Null.Note that you can remove a property by setting its value to null.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;
use MicrosoftAzure\Storage\Table\Models\Entity;
use MicrosoftAzure\Storage\Table\Models\EdmType;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

$result = $tableClient->getEntity("mytable", "tasksSeattle", 1);

$entity = $result->getEntity();
$entity->setPropertyValue("DueDate", new DateTime()); //Modified DueDate.
$entity->setPropertyValue("Location", null); //Removed Location.
$entity->addProperty("Status", EdmType::STRING, "In progress"); //Added Status.

try    {
    $tableClient->updateEntity("mytable", $entity);
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

Eliminare un'entitàDelete an entity

Per eliminare un'entità passare il nome della tabella e le chiavi PartitionKey e RowKey dell'entità al metodo TableRestProxy->deleteEntity.To delete an entity, pass the table name, and the entity's PartitionKey and RowKey to the TableRestProxy->deleteEntity method.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

try    {
    // Delete entity.
    $tableClient->deleteEntity("mytable", "tasksSeattle", "2");
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

Ai fini dei controlli di concorrenza, è possibile impostare il valore Etag di un'entità da eliminare usando il metodo DeleteEntityOptions->setEtag e passando l'oggetto DeleteEntityOptions a deleteEntity come quarto parametro.For concurrency checks, you can set the Etag for an entity to be deleted by using the DeleteEntityOptions->setEtag method and passing the DeleteEntityOptions object to deleteEntity as a fourth parameter.

Operazioni batch su tabellaBatch table operations

Il metodo TableRestProxy->batch consente di eseguire più operazioni in una sola richiesta.The TableRestProxy->batch method allows you to execute multiple operations in a single request. In questo caso è necessario aggiungere le operazioni all'oggetto BatchRequest e quindi passare l'oggetto BatchRequest al metodo TableRestProxy->batch.The pattern here involves adding operations to BatchRequest object and then passing the BatchRequest object to the TableRestProxy->batch method. Per aggiungere un'operazione all'oggetto BatchRequest , è possibile chiamare più volte uno dei metodi seguenti:To add an operation to a BatchRequest object, you can call any of the following methods multiple times:

  • addInsertEntity (per aggiungere un'operazione insertEntity)addInsertEntity (adds an insertEntity operation)
  • addUpdateEntity (per aggiungere un'operazione updateEntity)addUpdateEntity (adds an updateEntity operation)
  • addMergeEntity (per aggiungere un'operazione mergeEntity)addMergeEntity (adds a mergeEntity operation)
  • addInsertOrReplaceEntity (per aggiungere un'operazione insertOrReplaceEntity)addInsertOrReplaceEntity (adds an insertOrReplaceEntity operation)
  • addInsertOrMergeEntity (per aggiungere un'operazione insertOrMergeEntity)addInsertOrMergeEntity (adds an insertOrMergeEntity operation)
  • addDeleteEntity (per aggiungere un'operazione deleteEntity)addDeleteEntity (adds a deleteEntity operation)

L'esempio seguente illustra come eseguire le operazioni insertEntity e deleteEntity in una sola richiesta.The following example shows how to execute insertEntity and deleteEntity operations in a single request.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;
use MicrosoftAzure\Storage\Table\Models\Entity;
use MicrosoftAzure\Storage\Table\Models\EdmType;
use MicrosoftAzure\Storage\Table\Models\BatchOperations;

// Configure a connection string for Storage Table service.
$connectionString = "DefaultEndpointsProtocol=[http|https];AccountName=[yourAccount];AccountKey=[yourKey]"

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

// Create list of batch operation.
$operations = new BatchOperations();

$entity1 = new Entity();
$entity1->setPartitionKey("tasksSeattle");
$entity1->setRowKey("2");
$entity1->addProperty("Description", null, "Clean roof gutters.");
$entity1->addProperty("DueDate",
                        EdmType::DATETIME,
                        new DateTime("2012-11-05T08:15:00-08:00"));
$entity1->addProperty("Location", EdmType::STRING, "Home");

// Add operation to list of batch operations.
$operations->addInsertEntity("mytable", $entity1);

// Add operation to list of batch operations.
$operations->addDeleteEntity("mytable", "tasksSeattle", "1");

try    {
    $tableClient->batch($operations);
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

Per altre informazioni su operazioni batch su tabelle, vedere Performing Entity Group Transactions (Esecuzione di transazioni di gruppi di entità).For more information about batching Table operations, see Performing Entity Group Transactions.

Eliminare una tabellaDelete a table

Infine, per eliminare una tabella, passare il nome della tabella al metodo TableRestProxy->deleteTable.Finally, to delete a table, pass the table name to the TableRestProxy->deleteTable method.

require_once 'vendor/autoload.php';

use MicrosoftAzure\Storage\Table\TableRestProxy;
use MicrosoftAzure\Storage\Common\Exceptions\ServiceException;

// Create table REST proxy.
$tableClient = TableRestProxy::createTableService($connectionString);

try    {
    // Delete table.
    $tableClient->deleteTable("mytable");
}
catch(ServiceException $e){
    // Handle exception based on error codes and messages.
    // Error codes and messages are here:
    // https://docs.microsoft.com/rest/api/storageservices/Table-Service-Error-Codes
    $code = $e->getCode();
    $error_message = $e->getMessage();
    echo $code.": ".$error_message."<br />";
}

Passaggi successiviNext steps

Dopo aver appreso le nozioni di base sul servizio tabelle di Azure e su Azure Cosmos DB, usare i collegamenti seguenti per visualizzare altre informazioni.Now that you've learned the basics of the Azure Table service and Azure Cosmos DB, follow these links to learn more.