Aumentare il numero di istanze dei database con il gestore delle mappe partizioniScale out databases with the shard map manager

Per aumentare facilmente il numero di istanze dei database in SQL Azure, usare un gestore delle mappe partizioni.To easily scale out databases on SQL Azure, use a shard map manager. Il gestore delle mappe partizioni è un database speciale che gestisce le informazioni di mapping globale su tutte le partizioni (database) in un set di partizioni.The shard map manager is a special database that maintains global mapping information about all shards (databases) in a shard set. I metadati consentono all'applicazione di connettersi al database corretto in base al valore della chiave di partizionamento orizzontale.The metadata allows an application to connect to the correct database based upon the value of the sharding key. Inoltre, ogni partizione nel set contiene le mappe che tengono traccia dei dati delle partizioni locali (i cosiddetti shardlet).In addition, every shard in the set contains maps that track the local shard data (known as shardlets).

Gestione mappe partizioni

Per gestire le mappe partizioni, è fondamentale comprenderne il processo di creazione.Understanding how these maps are constructed is essential to shard map management. A questo scopo si usa la classe ShardMapManager (Java, .NET, disponibile nella libreria client dei database elastici.This is done using the ShardMapManager class (Java, .NET, found in the Elastic Database client library to manage shard maps.

Mappe partizioni e mapping di partizioniShard maps and shard mappings

Per ogni partizione, è necessario selezionare il tipo di mappa partizioni da creare.For each shard, you must select the type of shard map to create. La scelta dipende dall'architettura del database:The choice depends on the database architecture:

  1. Singolo tenant per databaseSingle tenant per database
  2. Più tenant per database (due tipi):Multiple tenants per database (two types):
    1. Mapping di tipo elencoList mapping
    2. Mapping di tipo intervalloRange mapping

Per un modello a tenant singolo, creare una mappa partizioni con mapping di tipo elenco.For a single-tenant model, create a list-mapping shard map. Il modello single-tenant assegna un database per tenant.The single-tenant model assigns one database per tenant. Si tratta di un modello efficace per gli sviluppatori SaaS in quanto semplifica la gestione.This is an effective model for SaaS developers as it simplifies management.

Mapping di tipo elenco

Il modello multi-tenant assegna diversi tenant a un database singolo ed è possibile distribuire gruppi di tenant tra più database.The multi-tenant model assigns several tenants to a single database (and you can distribute groups of tenants across multiple databases). Usare questo modello quando si prevedono esigenze di dati ridotte per ogni tenant.Use this model when you expect each tenant to have small data needs. In questo modello viene assegnato un intervallo di tenant a un database usando il mapping di tipo intervallo.In this model, assign a range of tenants to a database using range mapping.

Mapping di tipo intervallo

In alternativa è possibile implementare un modello di database multi-tenant usando il mapping di tipo elenco per assegnare più tenant a un database singolo.Or you can implement a multi-tenant database model using a list mapping to assign multiple tenants to a single database. Ad esempio, DB1 viene usato per archiviare le informazioni sugli ID tenant 1 e 5 e DB2 archivia i dati per i tenant 7 e 10.For example, DB1 is used to store information about tenant ID 1 and 5, and DB2 stores data for tenant 7 and tenant 10.

Tenant multipli su database singolo

Tipi supportati per le chiavi di partizionamento orizzontaleSupported types for sharding keys

La scalabilità elastica supporta i tipi seguenti come chiavi di partizionamento orizzontale:Elastic Scale support the following types as sharding keys:

.NET.NET JavaJava
numero interointeger numero interointeger
longlong longlong
GUIDguid uuiduuid
byte[]byte[] byte[]byte[]
Datetimedatetime timestamptimestamp
Intervallo di tempotimespan durationduration
datetimeoffsetdatetimeoffset offsetdatetimeoffsetdatetime

Mappe partizioni di tipo elenco e intervalloList and range shard maps

Le mappe partizioni possono essere create usando elenchi di singoli valori di chiavi di partizionamento orizzontale oppure tramite intervalli di valori di chiavi di partizionamento orizzontale.Shard maps can be constructed using lists of individual sharding key values, or they can be constructed using ranges of sharding key values.

Mappe partizioni di tipo elencoList shard maps

Le partizioni includono shardlet e il mapping degli shardlet alle partizioni viene gestito da una mappa partizioni.Shards contain shardlets and the mapping of shardlets to shards is maintained by a shard map. Una mappa partizioni di tipo elenco è un'associazione tra i singoli valori di chiave che identificano gli shardlet e i database che fungono da partizioni.A list shard map is an association between the individual key values that identify the shardlets and the databases that serve as shards. I mapping di tipo elenco sono espliciti. È possibile eseguire il mapping di valori di chiave diversi allo stesso database.List mappings are explicit and different key values can be mapped to the same database. Il valore della chiave 1, ad esempio, è mappato al database A e i valori delle chiavi 3 e 6 sono entrambi mappati al database B.For example, key value 1 maps to Database A, and key values 3 and 6 both maps to Database B.

ChiaveKey Percorso della partizioneShard Location
11 Database_ADatabase_A
33 Database_BDatabase_B
44 Database_CDatabase_C
66 Database_BDatabase_B
...... ......

Mappa partizioni di tipo intervalloRange shard maps

In una mappa partizioni di tipo intervallo l'intervallo chiave è descritto da una coppia di tipo [Low Value, High Value), dove Low Value indica la chiave minima dell'intervallo e High Value è il primo valore superiore all'intervallo.In a range shard map, the key range is described by a pair [Low Value, High Value) where the Low Value is the minimum key in the range, and the High Value is the first value higher than the range.

Ad esempio, [0, 100) include tutti i numeri interi superiori o uguali a 0 e inferiori a 100.For example, [0, 100) includes all integers greater than or equal 0 and less than 100. Si noti che più intervalli possono fare riferimento allo stesso database e che sono supportati intervalli non contigui. Ad esempio, [100,200) e [400,600) fanno entrambi riferimento al Database C nell'esempio seguente.Note that multiple ranges can point to the same database, and disjoint ranges are supported (for example, [100,200) and [400,600) both point to Database C in the following example.)

ChiaveKey Percorso della partizioneShard Location
[1, 50)[1,50) Database_ADatabase_A
[50, 100)[50,100) Database_BDatabase_B
[100, 200)[100,200) Database_CDatabase_C
[400, 600)[400,600) Database_CDatabase_C
...... ......

Ognuna delle tabelle precedenti è un esempio concettuale di un oggetto ShardMap .Each of the tables shown above is a conceptual example of a ShardMap object. Ogni riga costituisce un esempio semplificato di un singolo oggetto PointMapping (per la mappa partizioni di tipo elenco) o RangeMapping (per la mappa partizioni di tipo intervallo).Each row is a simplified example of an individual PointMapping (for the list shard map) or RangeMapping (for the range shard map) object.

Gestore mappe partizioniShard map manager

Il gestore mappe partizioni nella libreria client è una raccolta di mappe partizioni.In the client library, the shard map manager is a collection of shard maps. I dati gestiti da un'istanza di ShardMapManager sono conservati in tre posizioni:The data managed by a ShardMapManager instance is kept in three places:

  1. Mappa globale partizioni: si specifica un database da usare come repository per tutte le mappe partizioni e i mapping corrispondenti.Global Shard Map (GSM): You specify a database to serve as the repository for all of its shard maps and mappings. Vengono create automaticamente tabelle speciali e stored procedure per la gestione delle informazioni.Special tables and stored procedures are automatically created to manage the information. Si tratta in genere di un database di piccole dimensioni e a cui si accede raramente ed è consigliabile non usarlo per altre esigenze dell'applicazione.This is typically a small database and lightly accessed, and it should not be used for other needs of the application. Le tabelle si trovano in uno schema speciale denominato __ShardManagement.The tables are in a special schema named __ShardManagement.
  2. Mappa locale partizioni: ogni database specificato per l'uso come partizione viene modificato in modo da includere varie tabelle di piccole dimensioni e stored procedure speciali, che includono e gestiscono informazioni sulle mappe partizioni specifiche per la partizione.Local Shard Map (LSM): Every database that you specify to be a shard is modified to contain several small tables and special stored procedures that contain and manage shard map information specific to that shard. Queste informazioni sono ridondanti rispetto alle informazioni nella mappa globale partizioni e permettono all'applicazione di convalidare le informazioni sulla mappa partizioni memorizzate nella cache, senza sovraccaricare la mappa globale partizioni. L'applicazione usa la mappa locale partizioni per determinare se un mapping memorizzato nella cache è ancora valido.This information is redundant with the information in the GSM, and it allows the application to validate cached shard map information without placing any load on the GSM; the application uses the LSM to determine if a cached mapping is still valid. Le tabelle corrispondenti alla mappa locale partizioni in ogni partizione sono disponibili anche nello schema __ShardManagement.The tables corresponding to the LSM on each shard are also in the schema __ShardManagement.
  3. Cache dell'applicazione: ogni istanza di applicazione che accede a un oggetto ShardMapManager gestisce una cache in memoria locale dei rispettivi mapping,Application cache: Each application instance accessing a ShardMapManager object maintains a local in-memory cache of its mappings. in cui vengono archiviate le informazioni di routing appena recuperate.It stores routing information that has recently been retrieved.

Creazione di un oggetto ShardMapManagerConstructing a ShardMapManager

Un oggetto ShardMapManager viene creato con un criterio factory (Java, .NET).A ShardMapManager object is constructed using a factory (Java, .NET) pattern. Il metodo ShardMapManagerFactory.GetSqlShardMapManager (Java, .NET) accetta credenziali, inclusi il nome del server e il nome del database contenente la mappa globale partizioni, sotto forma di oggetto ConnectionString, e restituisce un'istanza di un oggetto ShardMapManager.The ShardMapManagerFactory.GetSqlShardMapManager (Java, .NET) method takes credentials (including the server name and database name holding the GSM) in the form of a ConnectionString and returns an instance of a ShardMapManager.

Nota: è sufficiente creare una sola istanza di ShardMapManager per ogni dominio app, nel codice di inizializzazione dell'applicazione.Please Note: The ShardMapManager should be instantiated only once per app domain, within the initialization code for an application. La creazione di istanze aggiuntive di ShardMapManager nello stesso dominio comporta un aumento dell'utilizzo della memoria e della CPU dell'applicazione.Creation of additional instances of ShardMapManager in the same app domain results in increased memory and CPU utilization of the application. Un oggetto ShardMapManager può includere un numero qualsiasi di mappe partizioni.A ShardMapManager can contain any number of shard maps. Anche se è possibile che una singola mappa partizioni sia sufficiente per molte applicazioni, in alcune situazioni vengono usati diversi set di database per schemi diversi o per finalità specifiche. In questi casi è preferibile usare più mappe partizioni.While a single shard map may be sufficient for many applications, there are times when different sets of databases are used for different schema or for unique purposes; in those cases multiple shard maps may be preferable.

Nel codice seguente un'applicazione prova ad aprire un oggetto ShardMapManager esistente con il metodo TryGetSqlShardMapManager (Java, .NET.In this code, an application tries to open an existing ShardMapManager with the TryGetSqlShardMapManager (Java, .NET method. Se gli oggetti che rappresentano un oggetto ShardMapManager globale non esistono ancora nel database, vengono creati dalla libreria client con il metodo CreateSqlShardMapManager (Java, .NET).If objects representing a Global ShardMapManager (GSM) do not yet exist inside the database, the client library creates them using the CreateSqlShardMapManager (Java, .NET) method.

// Try to get a reference to the Shard Map Manager in the shardMapManager database.
// If it doesn't already exist, then create it.
ShardMapManager shardMapManager = null;
boolean shardMapManagerExists = ShardMapManagerFactory.tryGetSqlShardMapManager(shardMapManagerConnectionString,ShardMapManagerLoadPolicy.Lazy, refShardMapManager);
shardMapManager = refShardMapManager.argValue;

if (shardMapManagerExists) {
    ConsoleUtils.writeInfo("Shard Map %s already exists", shardMapManager);
}
else {
    // The Shard Map Manager does not exist, so create it
    shardMapManager = ShardMapManagerFactory.createSqlShardMapManager(shardMapManagerConnectionString);
    ConsoleUtils.writeInfo("Created Shard Map %s", shardMapManager);
}
// Try to get a reference to the Shard Map Manager via the Shard Map Manager database.  
// If it doesn't already exist, then create it. 
ShardMapManager shardMapManager; 
bool shardMapManagerExists = ShardMapManagerFactory.TryGetSqlShardMapManager(
                                        connectionString, 
                                        ShardMapManagerLoadPolicy.Lazy, 
                                        out shardMapManager); 

if (shardMapManagerExists) 
{ 
    Console.WriteLine("Shard Map Manager already exists");
} 
else
{
    // Create the Shard Map Manager. 
    ShardMapManagerFactory.CreateSqlShardMapManager(connectionString);
    Console.WriteLine("Created SqlShardMapManager"); 

    shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
            connectionString, 
            ShardMapManagerLoadPolicy.Lazy);

// The connectionString contains server name, database name, and admin credentials for privileges on both the GSM and the shards themselves.
} 

Per la versione .NET, è possibile usare PowerShell per creare un nuovo gestore delle mappe partizioni.For the .NET version, you can use PowerShell to create a new Shard Map Manager. Un esempio è disponibile qui.An example is available here.

Ottenere una mappa RangeShardMap o ListShardMapGet a RangeShardMap or ListShardMap

Dopo la creazione di un gestore di mappe partizioni, è possibile ottenere RangeShardMap (Java, .NET) o ListShardMap (Java, .NET) con il metodo TryGetRangeShardMap (Java, .NET), TryGetListShardMap (Java, .NET) o GetShardMap (Java, .NET).After creating a shard map manager, you can get the RangeShardMap (Java, .NET) or ListShardMap (Java, .NET) using the TryGetRangeShardMap (Java, .NET), the TryGetListShardMap (Java, .NET), or the GetShardMap (Java, .NET) method.

// Creates a new Range Shard Map with the specified name, or gets the Range Shard Map if it already exists.
static <T> RangeShardMap<T> createOrGetRangeShardMap(ShardMapManager shardMapManager,
            String shardMapName,
            ShardKeyType keyType) {
    // Try to get a reference to the Shard Map.
    ReferenceObjectHelper<RangeShardMap<T>> refRangeShardMap = new ReferenceObjectHelper<>(null);
    boolean isGetSuccess = shardMapManager.tryGetRangeShardMap(shardMapName, keyType, refRangeShardMap);
    RangeShardMap<T> shardMap = refRangeShardMap.argValue;

    if (isGetSuccess && shardMap != null) {
        ConsoleUtils.writeInfo("Shard Map %1$s already exists", shardMap.getName());
    }
    else {
        // The Shard Map does not exist, so create it
        try {
            shardMap = shardMapManager.createRangeShardMap(shardMapName, keyType);
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        ConsoleUtils.writeInfo("Created Shard Map %1$s", shardMap.getName());
    }

    return shardMap;
}
// Creates a new Range Shard Map with the specified name, or gets the Range Shard Map if it already exists.
public static RangeShardMap<T> CreateOrGetRangeShardMap<T>(ShardMapManager shardMapManager, string shardMapName)
{
    // Try to get a reference to the Shard Map.
    RangeShardMap<T> shardMap;
    bool shardMapExists = shardMapManager.TryGetRangeShardMap(shardMapName, out shardMap);

    if (shardMapExists)
    {
        ConsoleUtils.WriteInfo("Shard Map {0} already exists", shardMap.Name);
    }
    else
    {
        // The Shard Map does not exist, so create it
        shardMap = shardMapManager.CreateRangeShardMap<T>(shardMapName);
        ConsoleUtils.WriteInfo("Created Shard Map {0}", shardMap.Name);
    }

    return shardMap;
} 

Credenziali di amministrazione delle mappe partizioniShard map administration credentials

Le applicazioni che amministrano e modificano le mappe partizioni sono diverse da quelle che usano le mappe partizioni per il routing delle connessioni.Applications that administer and manipulate shard maps are different from those that use the shard maps to route connections.

Per amministrare le mappe partizioni (aggiunta o modifica di partizioni, mappe partizioni, mapping di partizioni e così via), è necessario creare istanze dell'oggetto ShardMapManager usando credenziali con privilegi di lettura/scrittura per il database della mappa globale partizioni e per ogni database usato come partizione.To administer shard maps (add or change shards, shard maps, shard mappings, etc.) you must instantiate the ShardMapManager using credentials that have read/write privileges on both the GSM database and on each database that serves as a shard. Le credenziali devono permettere operazioni di scrittura nelle tabelle nella mappa globale partizioni e nella mappa locale partizioni durante l'immissione o la modifica delle informazioni sulle mappe partizioni, oltre che per la creazione di tabelle della mappa locale partizioni nelle nuove partizioni.The credentials must allow for writes against the tables in both the GSM and LSM as shard map information is entered or changed, as well as for creating LSM tables on new shards.

Vedere Credenziali usate per accedere alla libreria client dei database elastici.See Credentials used to access the Elastic Database client library.

Impatto solo sui metadatiOnly metadata affected

I metodi usati per popolare o modificare i dati di ShardMapManager non influiscono sui dati utente archiviati nelle partizioni stesse.Methods used for populating or changing the ShardMapManager data do not alter the user data stored in the shards themselves. Ad esempio, i metodi come CreateShard, DeleteShard, UpdateMapping e così via interessano solo i metadati della mappa partizioni.For example, methods such as CreateShard, DeleteShard, UpdateMapping, etc. affect the shard map metadata only. Essi non rimuovono, aggiungono o modificano i dati utente contenuti nelle partizioni.They do not remove, add, or alter user data contained in the shards. Questi metodi sono stati invece progettati per l'uso insieme a operazioni separate eseguite per creare o rimuovere i database effettivi o per rimuovere righe da una partizione a un'altra, in modo da bilanciare nuovamente un ambiente partizionatoInstead, these methods are designed to be used in conjunction with separate operations you perform to create or remove actual databases, or that move rows from one shard to another to rebalance a sharded environment. (il servizio di suddivisione-unione incluso negli strumenti dei database elastici usa queste API, oltre a orchestrare lo spostamento effettivo dei dati tra le partizioni). Vedere Scalabilità tramite lo strumento di suddivisione-unione del database elastico.(The split-merge tool included with elastic database tools makes use of these APIs along with orchestrating actual data movement between shards.) See Scaling using the Elastic Database split-merge tool.

Routing dipendente dei datiData dependent routing

Lo strumento di gestione delle mappe partizioni viene usato dalle applicazioni che richiedono connessioni a database per eseguire operazioni specifiche sui dati.The shard map manager is used in applications that require database connections to perform the app-specific data operations. Tali connessioni devono essere associate al database corretto.Those connections must be associated with the correct database. Questa procedura è nota come routing dipendente dai dati.This is known as Data Dependent Routing. Per queste applicazioni è necessario creare istanze di un oggetto gestore delle mappe partizioni dal factory, usando le credenziali con accesso di sola lettura per il database della mappa globale partizioni.For these applications, instantiate a shard map manager object from the factory using credentials that have read-only access on the GSM database. Le singole richieste per connessioni successive forniscono le credenziali necessarie per la connessione al database partizioni appropriato.Individual requests for later connections supply credentials necessary for connecting to the appropriate shard database.

Si noti che queste applicazioni, che usano l'oggetto ShardMapManager aperto con credenziali di sola lettura, non possono apportare modifiche alle mappe o ai mapping.Note that these applications (using ShardMapManager opened with read-only credentials) cannot make changes to the maps or mappings. A questo scopo è possibile creare applicazioni specifiche per l'amministrazione o script di PowerShell che forniscono credenziali con privilegi elevati, come illustrato in precedenza.For those needs, create administrative-specific applications or PowerShell scripts that supply higher-privileged credentials as discussed earlier. Vedere Credenziali usate per accedere alla libreria client dei database elastici.See Credentials used to access the Elastic Database client library.

Per altre informazioni, vedere Routing dipendente dai dati.For more information, see Data dependent routing.

Modifica di una mappa partizioniModifying a shard map

È possibile modificare una mappa partizioni in molti modi diversi.A shard map can be changed in different ways. Tutti i seguenti metodi modificano i metadati che descrivono le partizioni e i rispettivi mapping, ma non modificano fisicamente i dati nelle partizioni e non creano o eliminano i database effettivi.All of the following methods modify the metadata describing the shards and their mappings, but they do not physically modify data within the shards, nor do they create or delete the actual databases. Potrebbe essere necessario coordinare alcune operazioni sulla mappa partizioni descritte di seguito con le azioni amministrative che spostano fisicamente i dati o che aggiungono e rimuovono i database che fungono da partizioni.Some of the operations on the shard map described below may need to be coordinated with administrative actions that physically move data or that add and remove databases serving as shards.

Questi metodi interagiscono tra loro come i blocchi predefiniti disponibili per la modifica della distribuzione complessiva dei dati nell'ambiente di database partizionati.These methods work together as the building blocks available for modifying the overall distribution of data in your sharded database environment.

  • Per aggiungere o rimuovere partizioni: usare CreateShard (Java, .NET) e DeleteShard (Java, .NET) della classe shardmap (Java, .NET).To add or remove shards: use CreateShard (Java, .NET) and DeleteShard (Java, .NET) of the shardmap (Java, .NET) class.

    Per permettere l'esecuzione di queste operazioni, è necessario che il server e il database che rappresentano la partizione di destinazione esistano già.The server and database representing the target shard must already exist for these operations to execute. Questi metodi non hanno alcun impatto sui database stessi. Influiscono solo sui metadati nella mappa partizioni.These methods do not have any impact on the databases themselves, only on metadata in the shard map.

  • Per creare o rimuovere punti o intervalli mappati alle partizioni: usare CreateRangeMapping (Java, .NET) e DeleteMapping (Java, .NET) della classe RangeShardMapping (Java, .NET) e CreatePointMapping (Java, .NET) della classe ListShardMap (Java, .NET).To create or remove points or ranges that are mapped to the shards: use CreateRangeMapping (Java, .NET), DeleteMapping (Java, .NET) of the RangeShardMapping (Java, .NET) class, and CreatePointMapping (Java, .NET) of the ListShardMap (Java, .NET) class.

    È possibile mappare molti punti o intervalli diversi alla stessa partizione.Many different points or ranges can be mapped to the same shard. Questi metodi influiscono solo sui metadati, non sui dati eventualmente già presenti nelle partizioni.These methods only affect metadata - they do not affect any data that may already be present in shards. Se è necessario rimuovere dati dal database per assicurare la coerenza con le operazioni di tipo DeleteMapping, eseguire queste operazioni separatamente, ma contemporaneamente all'uso di questi metodi.If data needs to be removed from the database in order to be consistent with DeleteMapping operations, you perform those operations separately but in conjunction with using these methods.

  • Per dividere in due gli intervalli esistenti o unire intervalli adiacenti in un unico intervallo: usare SplitMapping (Java, .NET) e MergeMappings (Java, .NET).To split existing ranges into two, or merge adjacent ranges into one: use SplitMapping (Java, .NET) and MergeMappings (Java, .NET).

    Si noti che le operazioni di suddivisione e unione non modificano la partizione a cui sono mappati i valori di chiave.Note that split and merge operations do not change the shard to which key values are mapped. Una suddivisione divide un intervallo esistente in due parti, ma ne mantiene il mapping alla stessa partizione.A split breaks an existing range into two parts, but leaves both as mapped to the same shard. Un'unione viene applicata a due intervalli adiacenti già mappati alla stessa partizione e li unisce in un singolo intervallo.A merge operates on two adjacent ranges that are already mapped to the same shard, coalescing them into a single range. Lo spostamento di punti o degli stessi intervalli tra le partizioni deve essere coordinato tramite l'uso di UpdateMapping insieme allo spostamento effettivo dei dati.The movement of points or ranges themselves between shards needs to be coordinated by using UpdateMapping in conjunction with actual data movement. È possibile usare il servizio di suddivisione/unione , incluso nello strumento dei database elastici, per coordinare le modifiche della mappa partizioni con lo spostamento dei dati, nei casi in cui lo spostamento è necessario.You can use the Split/Merge service that is part of elastic database tools to coordinate shard map changes with data movement, when movement is needed.

  • Per eseguire di nuovo il mapping di singoli punti o intervalli o spostare punti o intervalli in partizioni diverse usare UpdateMapping (Java, .NET).To re-map (or move) individual points or ranges to different shards: use UpdateMapping (Java, .NET).

    Poiché potrebbe essere necessario spostare i dati da una partizione a un'altra per mantenere la coerenza con le operazioni di tipo UpdateMapping, occorre eseguire separatamente lo spostamento, ma contemporaneamente all'uso di questi metodi.Since data may need to be moved from one shard to another in order to be consistent with UpdateMapping operations, you need to perform that movement separately but in conjunction with using these methods.

  • Per impostare i mapping come online e offline: usare MarkMappingOffline (Java, .NET) e MarkMappingOnline (Java, .NET) per controllare lo stato online di un mapping.To take mappings online and offline: use MarkMappingOffline (Java, .NET) and MarkMappingOnline (Java, .NET) to control the online state of a mapping.

    Alcune operazioni sui mapping di partizioni, incluse le operazioni UpdateMapping e DeleteMapping, sono consentite solo se lo stato del mapping è "offline".Certain operations on shard mappings are only allowed when a mapping is in an “offline” state, including UpdateMapping and DeleteMapping. Quando un mapping è offline, una richiesta dipendente dai dati e basata su una chiave inclusa nel mapping restituisce un errore.When a mapping is offline, a data-dependent request based on a key included in that mapping returns an error. Quando si porta offline per la prima volta un intervallo, inoltre, tutte le connessioni alla partizione interessata verranno terminate automaticamente per evitare risultati incoerenti o incompleti per le query dirette agli intervalli sottoposti a modifica.In addition, when a range is first taken offline, all connections to the affected shard are automatically killed in order to prevent inconsistent or incomplete results for queries directed against ranges being changed.

I mapping sono oggetti non modificabili in .NET.Mappings are immutable objects in .Net. Tutti i metodi precedenti che modificano i mapping invalidano anche tutti i riferimenti ad essi nel codice.All of the methods above that change mappings also invalidate any references to them in your code. Per semplificare l’esecuzione di sequenze di operazioni che modificano lo stato di un mapping, tutti i metodi che consentono di modificare un mapping restituiscono un nuovo riferimento di mapping, in modo che le operazioni possano essere concatenate.To make it easier to perform sequences of operations that change a mapping’s state, all of the methods that change a mapping return a new mapping reference, so operations can be chained. Ad esempio, per eliminare un mapping esistente in shardmap sm che contiene la chiave 25, è possibile eseguire le operazioni seguenti:For example, to delete an existing mapping in shardmap sm that contains the key 25, you can execute the following:

    sm.DeleteMapping(sm.MarkMappingOffline(sm.GetMappingForKey(25)));

Aggiunta di una partizioneAdding a shard

Per una mappa partizioni già esistente, le applicazioni devono spesso aggiungere nuove partizioni per gestire i dati previsti dalle nuove chiavi o dai nuovi intervalli di chiavi.Applications often need to add new shards to handle data that is expected from new keys or key ranges, for a shard map that already exists. Ad esempio, è possibile che un'applicazione partizionata dall'ID tenant debba eseguire il provisioning di una nuova partizione per un nuovo tenant, oppure è possibile che i dati partizionati ogni mese richiedano il provisioning di una nuova partizione prima dell'inizio di ogni nuovo mese.For example, an application sharded by Tenant ID may need to provision a new shard for a new tenant, or data sharded monthly may need a new shard provisioned before the start of each new month.

Se il nuovo intervallo di valori di chiave non è ancora incluso in un mapping esistente e non è necessario alcuno spostamento di dati, l'aggiunta della nuova partizione e l'associazione della nuova chiave o del nuovo intervallo a tale partizione sono semplici.If the new range of key values is not already part of an existing mapping and no data movement is necessary, it is simple to add the new shard and associate the new key or range to that shard. Per informazioni dettagliate sull'aggiunta di nuove partizioni, vedere Aggiunta di una nuova partizione.For details on adding new shards, see Adding a new shard.

Per gli scenari che richiedono lo spostamento di dati, tuttavia, il servizio di suddivisione-unione è necessario per l'orchestrazione dello spostamento di dati tra le partizioni insieme agli aggiornamenti necessari per la mappa partizioni.For scenarios that require data movement, however, the split-merge tool is needed to orchestrate the data movement between shards in combination with the necessary shard map updates. Per informazioni dettagliate sull'uso dello strumento di suddivisione-unione, vedere Panoramica dello strumento di suddivisione-unioneFor details on using the split-merge tool, see Overview of split-merge

Risorse aggiuntiveAdditional resources

Se non si usano gli strumenti di database elastici,Not using elastic database tools yet? vedere la Guida introduttiva.Check out our Getting Started Guide. Se ci sono domande, è possibile visitare il forum sul database SQL mentre è possibile inserire le richieste di nuove funzionalità nel forum relativo a commenti e suggerimenti sul database SQL.For questions, please reach out to us on the SQL Database forum and for feature requests, please add them to the SQL Database feedback forum.