Utilizzo delle API per creare una tabella Singleton

La tabella è la struttura di base per contenere i dati utente. Utilizzare un comando SQL (istruzione CREATE TABLE) o comandi API TableRequest per creare una nuova tabella.

Puoi anche utilizzare la console OCI (Oracle NoSQL Cloud Infrastructure) o l'interfaccia della riga di comando OCI (OCI-cli) per creare una tabella in NDCS.

Linee guida per la creazione di una tabella:

La definizione della tabella deve includere almeno una definizione di campo ed esattamente una definizione di chiave primaria. Per ulteriori informazioni sulla definizione della chiave primaria, vedere Crea tabella.
La definizione del campo specifica il nome della colonna, il relativo tipo di dati, se la colonna è annullabile o meno, un valore predefinito facoltativo, se la colonna è una colonna IDENTITY e un commento facoltativo. Tutti i campi (diversi dalla chiave primaria) sono annullabili per impostazione predefinita.
La sintassi della specifica della chiave primaria (key_definition) specifica le colonne della chiave primaria della tabella come lista ordinata di nomi di campo.
Il valore Time To Live (TTL) viene utilizzato per calcolare il tempo di scadenza di una riga. Le righe scadute non vengono incluse nei risultati delle query e alla fine vengono rimosse automaticamente dalla tabella da Oracle NoSQL Database. Se si specifica un valore TTL durante la creazione della tabella, viene applicato come TTL predefinito per ogni riga inserita in questa tabella.

Creare una tabella:

Uso dei comandi SQL
Uso dell'API TableRequest

Uso dei comandi SQL

È possibile utilizzare il comando CREATE TABLE in SQL per creare tabelle NoSQL.

Nella sezione seguente vengono evidenziate le diverse opzioni che è possibile utilizzare durante la creazione di una tabella mediante l'istruzione CREATE TABLE DDL.

Esempio 1: creare una tabella dell'applicazione di tracciamento dei bagagli delle compagnie aeree che contenga le informazioni sui bagagli dei passeggeri in un sistema aereo.

CREATE TABLE BaggageInfo (
ticketNo LONG,
fullName STRING,
gender STRING,
contactPhone STRING,
confNo STRING,
bagInfo JSON,
PRIMARY KEY (ticketNo)
)

Nello schema precedente, è possibile utilizzare l'istruzione CREATE TABLE per definire una tabella BaggageInfo. Il numero del biglietto del passeggero, ticketNo, è la chiave primaria della tabella. I campi fullName, gender, contactPhone e confNo (numero di prenotazione) memorizzano le informazioni del passeggero, che fanno parte di uno schema fisso. La colonna bagInfo è un array JSON senza schema, che rappresenta le informazioni di tracciamento del bagaglio registrato di un passeggero.

Per ulteriori dettagli sull'applicazione di tracciamento dei bagagli delle compagnie aeree, vedere Applicazione di tracciamento dei bagagli delle compagnie aeree.

Esempio 2: creare una tabella del servizio di streaming multimediale con un campo JSON per tenere traccia dell'attività corrente del sottoscrittore.

CREATE TABLE stream_acct(
acct_id INTEGER,
profile_name STRING,
account_expiry TIMESTAMP(9),
acct_data JSON,
PRIMARY KEY(acct_id)
)USING TTL 5 DAYS

Nello schema precedente, è possibile utilizzare l'istruzione CREATE TABLE per creare una tabella stream_acct. Il campo ID account sottoscrittore acct_id è la chiave primaria in questa tabella. I campi profile_name e account_expiry memorizzano i dettagli del visualizzatore, che fanno parte dello schema fisso. La colonna acct_data è un campo JSON senza schema, che memorizza i dettagli degli spettacoli visualizzati da un sottoscrittore.

Per ulteriori dettagli sull'applicazione del servizio multimediale in streaming, vedere Streaming Media Service - Area di memorizzazione profili utente persistente.

È inoltre possibile specificare un valore TTL, dopo il quale le righe scadono automaticamente e non sono più disponibili. Il valore TTL deve essere in ORE o GIORNI. In questo schema, le righe della tabella scadono dopo 5 giorni.

Esempio 3: creare una tabella del servizio di streaming multimediale con varie definizioni di schema fisso.

CREATE TABLE IF NOT EXISTS stream_acct(
acct_id INTEGER,
profile_name STRING,
account_expiry TIMESTAMP(9),
acct_data RECORD (
firstName STRING,
lastName STRING,
country STRING,
shows JSON
),
PRIMARY KEY(acct_id)
)

Nello schema precedente, è possibile definire una variazione dello schema fisso includendo il campo acct_data come tipo di dati RECORD.

Un record è una raccolta ordinata di una o più coppie chiave-elemento. Le chiavi di un record devono essere stringhe e gli elementi associati possono essere di tipi di dati diversi. I campi di un record fanno parte dello schema fisso e non sarà possibile aggiungerli o rimuoverli. Nell'esempio precedente, i campi firstName, lastName, country e shows sono le chiavi per il record acct_data. La definizione di un record è utile quando si desidera memorizzare i dati come parte di un set di dati più grande. È possibile inserire/aggiornare/recuperare l'intero subset in un record utilizzando le espressioni dei passi di campo.

È inoltre possibile nidificare i record come indicato di seguito.

CREATE TABLE IF NOT EXISTS  stream_acct(
acct_id INTEGER,
profile_name STRING,
account_expiry TIMESTAMP(9),
acct_data RECORD (
   firstName STRING,
   lastName STRING,
   country STRING,
   shows RECORD (
           showName STRING,
           showId INTEGER,
           type JSON,
           numSeasons INTEGER,
           seriesInfo ARRAY(JSON)
   )
),
PRIMARY KEY(acct_id)
)

Il campo shows è un tipo di RECORD nidificato utilizzato per tenere traccia dei dettagli degli spettacoli visualizzati.

Esempio 4: creare una tabella dei servizi multimediali di streaming come struttura di tabelle gerarchiche.

Negli schemi riportati di seguito è possibile creare una tabella stream_acct come tabella padre e una tabella acct_data come tabella figlio.

CREATE TABLE IF NOT EXISTS stream_acct(
acct_id INTEGER,
profile_name STRING,
account_expiry TIMESTAMP(9),
PRIMARY KEY(acct_id))

CREATE TABLE IF NOT EXISTS stream_acct.acct_data(
profile_id INTEGER,
user_name STRING,
firstName STRING,
lastName  STRING,
country   STRING,
shows     JSON,
PRIMARY KEY(profile_id))

Con la definizione della tabella padre-figlio precedente, il servizio di streaming multimediale può supportare più profili utente in una singola sottoscrizione.

La tabella acct_data viene definita come tabella figlio con chiave primaria profile_id per identificare il profilo di un utente. Oltre a definire una chiave primaria per la tabella, la tabella acct_data eredita implicitamente la colonna di chiave primaria acct_id della relativa tabella stream_acct padre.

È possibile definire più tabelle figlio nella stessa tabella padre stream_acct. È possibile definire ulteriormente le tabelle figlio per la tabella acct_data. Tutte le tabelle nella gerarchia hanno la stessa colonna chiave partizione, specificata nell'istruzione di creazione tabella della tabella padre più alta della gerarchia. In questo esempio, la chiave primaria acct_id della tabella padre è anche la chiave partizione per le tabelle stream_acct e acct_data.

Esempio 5: creare una tabella del servizio di streaming multimediale con chiave primaria come colonna IDENTITY.

CREATE TABLE IF NOT EXISTS stream_acct(
acct_id INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH 4 INCREMENT BY 1 NO CYCLE),
profile_name STRING,
account_expiry TIMESTAMP(9),
acct_data JSON,
PRIMARY KEY(acct_id)
)

In questo esempio, si crea la tabella stream_acct con gli stessi campi definiti nell'esempio 2. Tuttavia, lo schema definisce la chiave primaria acct_id come colonna IDENTITY. Quando si definisce una colonna IDENTITY come GENERATA DA DEFAULT AS IDENTITY, il sistema genera automaticamente i valori della colonna IDENTITY se non ne viene fornita una. Il sistema inizia a generare valori acct_id da 4 incrementando di 1. Pertanto, i valori per la colonna acct_id saranno 4, 5, 6… e così via fino al valore massimo del tipo di dati LONG. Poiché lo schema definisce l'opzione NO CYCLE, il sistema solleva un'eccezione dopo il valore massimo poiché ha raggiunto la fine del generatore di sequenza.

Esempio 6: creare una tabella di servizio dei supporti di streaming con chiave primaria come tipo di dati UUID.

CREATE TABLE IF NOT EXISTS stream_acct(
acct_id STRING AS UUID GENERATED BY DEFAULT,
profile_name STRING,
account_expiry TIMESTAMP(9),
acct_data JSON,
PRIMARY KEY(acct_id)
)

In questo esempio, si crea la tabella stream_acct con gli stessi campi definiti nell'esempio 2. Tuttavia, lo schema definisce la chiave primaria acct_id come tipo di dati UUID, GENERATED BY DEFAULT. Se non ne viene fornito uno, il sistema genera automaticamente un valore per la colonna UUID. Il potenziale vantaggio di definire la chiave primaria come tipo di dati UUID è che, mentre il sistema garantisce l'univocità delle colonne IDENTITY solo all'interno di un data store NoSQL in un'area, il tipo di dati UUID genera un identificativo univoco globale per i record in una tabella che si estende su più aree.

Tabelle di raccolte JSON

Esempio 7: creare una tabella del servizio di streaming multimediale come tabella di raccolta JSON.

Nella seguente istruzione CREATE TABLE è possibile creare la tabella stream_acct come tabella di raccolta JSON:

CREATE TABLE IF NOT EXISTS stream_acct(
acct_id INTEGER,
PRIMARY KEY(acct_id)) AS JSON COLLECTION

Questa tabella di raccolta JSON include acct_id come campo chiave primaria. Non è necessario fornire altri campi tranne il campo chiave primaria nel comando DDL.

Quando si inseriscono dati in questa tabella, la tabella di raccolta JSON considera automaticamente i campi inseriti diversi dal campo acct_id come campi JSON. È possibile utilizzare questa tabella di raccolta JSON per memorizzare e recuperare i dati di streaming TV esclusivamente come documenti.

Esempio 8: creare una tabella dell'applicazione di acquisto come tabella di raccolta JSON.

L'istruzione CREATE TABLE riportata di seguito definisce una tabella storeAcct, ovvero una tabella di raccolta JSON creata per un'applicazione di acquisto. Questa tabella include contactPhone come campo chiave primaria della stringa di tipo.

CREATE TABLE storeAcct(
contactPhone string,
primary key(contactPhone)) AS JSON COLLECTION

Uso dell'API TableRequest

È possibile utilizzare l'API TableRequest per creare tabelle NoSQL.

La classe TableRequest viene utilizzata per creare le tabelle. L'esecuzione delle operazioni specificate da questa richiesta è asincrona. Si tratta di operazioni potenzialmente lunghe. TableResult viene restituito dalle operazioni TableRequest e incapsula lo stato della tabella. Per ulteriori dettagli sulla classe TableRequest e sui relativi metodi, vedere Oracle NoSQL Java SDK API Reference.

Scaricare il codice completo CreateTable.java dagli esempi qui.

private static void createTab(NoSQLHandle handle) throws Exception {
   String createTableDDL =
   "CREATE TABLE IF NOT EXISTS " + tableName +
                               "(acct_Id INTEGER," +
                               "profile_name STRING," +
                               "account_expiry TIMESTAMP(1) ," +
                               "acct_data JSON, " +
                               "PRIMARY KEY(acct_Id))";

   TableLimits limits = new TableLimits(20, 20, 1);
   TableRequest treq = new TableRequest()
          .setStatement(createTableDDL)
          .setTableLimits(limits);
   TableResult tres = handle.tableRequest(treq);
   /* The request is async,
    * so wait for the table to become active.
    */
    tres.waitForCompletion(handle, 60000,1000);
    System.out.println("Created Table: " + tableName);
}

Nota: i limiti delle tabelle sono applicabili solo a Oracle NoSQL Database Cloud Service. Se i limiti sono impostati per un database NoSQL in locale, vengono ignorati silenziosamente.

Creazione di una tabella figlio: per creare una tabella figlio si utilizzano la stessa classe TableRequest e gli stessi metodi per eseguire l'istruzione DDL.

Durante la creazione di una tabella figlio:

È necessario specificare il nome completo della tabella (name_parent_table.name_child_table)
I limiti della tabella non devono essere impostati in modo esplicito poiché una tabella figlio eredita i limiti di una tabella padre.

Scarica il codice completo TableJoins.java dagli esempi per capire come creare una tabella padre-figlio qui.

Creazione di una tabella di raccolta JSON:

La tabella di raccolta JSON include documenti con uno o più campi di chiave primaria e campi JSON. L'esempio riportato di seguito crea una tabella stream_acct come tabella di raccolta JSON.

/* Create a JSON collection table with an integer primary key */
private static void createTable(NoSQLHandle handle) throws Exception {
    String createTableDDL =
        "CREATE TABLE IF NOT EXISTS " + tableName +
        "(acct_Id INTEGER, PRIMARY KEY(acct_Id)) AS JSON COLLECTION";

    TableRequest treq = new TableRequest().setStatement(createTableDDL);

    System.out.println("Creating table");
    TableResult tres = handle.tableRequest(treq);

    /* The table request is asynchronous, so wait for the table to become active. */
    TableResult.waitForState(handle, tres.getTableName(), TableResult.State.ACTIVE, 60000, 1000);
}

La classe borneo.TableRequest viene utilizzata per creare una tabella. Tutte le chiamate a borneo.NoSQLHandle.table_request() sono asincrone quindi è necessario controllare il risultato e chiamare borneo.TableResult.wait_for_completion() per attendere il completamento dell'operazione. Per ulteriori dettagli su table_request e sui relativi metodi, consultare Oracle NoSQL Python SDK API Reference.

Scarica il codice completo CreateTable.py dagli esempi qui.

def create_table(handle):
  statement = '''create table if not exists
              stream_acct (acct_Id INTEGER,
                           profile_name STRING,
                           account_expiry TIMESTAMP(1),
                           acct_data JSON,
                           primary key(acct_Id))'''

    request = TableRequest().set_statement(statement)
                            .set_table_limits(TableLimits(20, 10, 1))

    table_result = handle.do_table_request(request, 40000, 3000)
    table_result.wait_for_completion(handle, 40000, 3000)

    if (table_result.get_state() == State.ACTIVE):
        print('Created table: stream_acct')
    else:
        raise NameError('Table stream_acct is in an unexpected state ' +
                             str(table_result.get_state()))

Nota: i limiti delle tabelle sono applicabili solo a Oracle NoSQL Database Cloud Service. Se i limiti sono impostati per un database NoSQL in locale, vengono ignorati silenziosamente.

Creazione di una tabella figlio: per creare una tabella figlio si utilizzano la stessa classe TableRequest e gli stessi metodi per eseguire l'istruzione DDL.

Durante la creazione di una tabella figlio:

È necessario specificare il nome completo della tabella (name_parent_table.name_child_table).
I limiti della tabella non devono essere impostati in modo esplicito poiché una tabella figlio eredita i limiti di una tabella padre.

Scarica il codice completo TableJoins.py dagli esempi qui.

Creazione di una tabella di raccolta JSON:

La tabella di raccolta JSON include documenti con uno o più campi di chiave primaria e campi JSON. L'esempio riportato di seguito crea una tabella stream_acct come tabella di raccolta JSON.

# Create a JSON collection table with an integer primary key
statement = '''CREATE TABLE IF NOT EXISTS stream_acct
               (acct_Id INTEGER, PRIMARY KEY(acct_Id))
               AS JSON COLLECTION'''

print('Creating table: ' + statement)

request = TableRequest().set_statement(statement)

# Wait for 60 seconds, polling every 1 second
result = handle.do_table_request(request, 60000, 1000)
result.wait_for_completion(handle, 60000, 1000)

print('Created table: stream_acct')

La classe TableRequest viene utilizzata per creare una tabella. L'esecuzione delle operazioni specificate da TableRequest è asincrona. Si tratta di operazioni potenzialmente lunghe. Questa richiesta viene utilizzata come input di un'operazione Client.DoTableRequest(), che restituisce un valore TableResult che può essere utilizzato per eseguire il polling fino a quando la tabella non raggiunge lo stato desiderato. Per ulteriori dettagli sui vari metodi della classe TableRequest, vedere Oracle NoSQL Go SDK API Reference.

Scaricare il codice completo CreateTable.go dagli esempi qui.

func createTable(client *nosqldb.Client, err error, tableName string)(){
// Creates a table
 stmt := fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s ("+
     	"acct_Id INTEGER," +
     	"profile_name STRING," +
     	"account_expiry TIMESTAMP(1) ," +
     	"acct_data JSON, " +
     	"PRIMARY KEY(acct_Id))",tableName)

 tableReq := &nosqldb.TableRequest{
		Statement: stmt,
		TableLimits: &nosqldb.TableLimits{
			ReadUnits:  20,
			WriteUnits: 20,
			StorageGB:  1,
              },
 }

 tableRes, err := client.DoTableRequest(tableReq)
 if err != nil {
    fmt.Printf("cannot initiate CREATE TABLE request: %v\n", err)
    return
 }
 // The create table request is asynchronous,
 // wait for table creation to complete.
 _, err = tableRes.WaitForCompletion(client, 60*time.Second, time.Second)

 if err != nil {
    fmt.Printf("Error finishing CREATE TABLE request: %v\n", err)
    return
 }
 fmt.Println("Created table: ", tableName)
 return
}

Nota: i limiti delle tabelle sono applicabili solo a Oracle NoSQL Database Cloud Service. Se i limiti sono impostati per un database NoSQL in locale, vengono ignorati silenziosamente.

Creazione di una tabella figlio: per creare una tabella figlio si utilizzano la stessa classe TableRequest e gli stessi metodi per eseguire l'istruzione DDL.

Durante la creazione di una tabella figlio:

È necessario specificare il nome completo della tabella (name_parent_table.name_child_table).
I limiti della tabella non devono essere impostati in modo esplicito poiché una tabella figlio eredita i limiti di una tabella padre.

Scarica il codice completo TableJoins.go dagli esempi qui.

Creazione di una tabella di raccolta JSON:

La tabella di raccolta JSON include documenti con uno o più campi di chiave primaria e campi JSON. L'esempio riportato di seguito crea una tabella stream_acct come tabella di raccolta JSON.

/* Create a JSON collection table with an integer primary key */

func createTable(client *nosqldb.Client) error {
	tableName := "stream_acct"

	stmt := fmt.Sprintf(
		"CREATE TABLE IF NOT EXISTS %s "+
			"(acct_Id INTEGER, PRIMARY KEY(acct_Id)) "+
			"AS JSON COLLECTION",
		tableName,
	)

	fmt.Println("Creating table:", stmt)

	tableReq := &nosqldb.TableRequest{
		Statement: stmt,
	}

	tableRes, err := client.DoTableRequest(tableReq)
	if err != nil {
		return err
	}

	// Wait for 60 seconds, polling every 1 second.
	_, err = tableRes.WaitForCompletion(
		client,
		60*time.Second,
		time.Second,
	)
	if err != nil {
		return err
	}

	fmt.Println("Created table:", tableName)
	return nil
}

È possibile creare una tabella utilizzando il metodo tableDDL. Questo metodo è asincrono e restituisce una promessa di TableResult. TableResult è un oggetto JavaScript non codificato che contiene lo stato dell'operazione DDL, ad esempio TableState, name, schema e TableLimits. Per i dettagli del metodo, vedere la classe NoSQLClient.

Il metodo tableDDL accetta l'oggetto TableDDLOpt come secondo argomento facoltativo. Quando si crea una tabella, è necessario specificarne TableLimits come parte dell'argomento opt. TableLimits specifica il throughput massimo e la capacità di storage per la tabella come la quantità di unità di lettura, unità di scrittura e Gigabyte di storage.

Scarica il codice JavaScript completo CreateTable.js dagli esempi qui e il codice TypeScript completo CreateTable.ts dagli esempi qui.

import {NoSQLClient, TableState } from 'oracle-nosqldb';
const client = new NoSQLClient('config.json');
const TABLE_NAME = 'stream_acct;
async function createTable(handle) {
  const createDDL = `CREATE TABLE IF NOT EXISTS
                  ${TABLE_NAME} (acct_Id INTEGER,
                                 profile_name STRING,
                                 account_expiry TIMESTAMP(1),
                                 acct_data JSON,
                                 primary key(acct_Id))`;
   /* For Provisioned Capacity specify read units, write units, and storage limit as shown below*/
   /* For On-demand Capacity - set only the storage limit and specify the mode as shown here.
    * { storageGB: 25, mode: CapacityMode.ON_DEMAND };
    */
  let res =  await handle.tableDDL(createDDL, {
             complete: true,
             tableLimits: {
              readUnits: 20,
              writeUnits: 20,
              storageGB: 1
             }
  });
  console.log('Created table: ' + TABLE_NAME);
}

Dopo il ritorno della chiamata precedente, il risultato rifletterà lo stato finale dell'operazione. In alternativa, per utilizzare l'opzione completa, sostituire il codice nel blocco di prova sopra con il seguente esempio di codice.

const createDDL = `CREATE TABLE IF NOT EXISTS
                  ${TABLE_NAME} (acct_Id INTEGER,
                                 profile_name STRING,
                                 account_expiry TIMESTAMP(1),
                                 acct_data JSON,
                                 primary key(acct_Id))`;
 let res =  await client.tableDDL(createDDL, {complete: true,});
console.log('Created table: ' + TABLE_NAME);

Creazione di una tabella figlio: per creare una tabella figlio si utilizzano la stessa classe TableRequest e gli stessi metodi per eseguire l'istruzione DDL.

Durante la creazione di una tabella figlio:

È necessario specificare il nome completo della tabella (name_parent_table.name_child_table)
I limiti della tabella non devono essere impostati in modo esplicito poiché una tabella figlio eredita i limiti di una tabella padre.

Scarica il codice JavaScript completo TableJoins.js dagli esempi qui e il codice TypeScript completo TableJoins.ts dagli esempi qui.

Creazione di una tabella di raccolta JSON:

La tabella di raccolta JSON include documenti con uno o più campi di chiave primaria e campi JSON. L'esempio riportato di seguito crea una tabella stream_acct come tabella di raccolta JSON.

/* Create a JSON collection table with an integer primary key */

const client = new NoSQLClient('config.json');
const TABLE_NAME = 'stream_acct';

async function createTable() {
    const createDDL =
        `CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ` +
        `(acct_Id INTEGER, PRIMARY KEY(acct_Id)) ` +
        `AS JSON COLLECTION`;

    console.log('Create table: ' + createDDL);

    try {
        await client.tableDDL(createDDL, {
            complete: true
        });

        console.log('Created table: ' + TABLE_NAME);
    } catch (error) {
        console.error('Table creation failed:', error);
        throw error;
    }
}

Per creare una tabella, utilizzare i metodi ExecuteTableDDLAsync o ExecuteTableDDLWithCompletionAsync. Entrambi i metodi restituiscono Task<TableResult>. L'istanza TableResult contiene lo stato dell'operazione DDL, ad esempio TableState e lo schema di tabella. Per ulteriori dettagli su questi metodi, consulta la riferimento API Oracle NoSQL Dotnet SDK.

Scaricare il codice completo CreateTable.cs dagli esempi qui.

private static async Task createTable(NoSQLClient client){
// Create a table
  var sql =
    $@"CREATE TABLE IF NOT EXISTS
         {TableName}(acct_Id INTEGER,
                     profile_name STRING,
                     account_expiry TIMESTAMP(1),
                     acct_data JSON,
                     primary key(acct_Id))";
  var tableResult = await client.ExecuteTableDDLAsync(sql,
    new TableDDLOptions{TableLimits = new TableLimits(20, 20, 1)});

  // Wait for the operation completion
  await tableResult.WaitForCompletionAsync();
  Console.WriteLine("  Created table: ",tableResult.TableName);
}

Nota: i limiti delle tabelle sono applicabili solo a Oracle NoSQL Database Cloud Service. Se i limiti sono impostati per un database NoSQL in locale, vengono ignorati silenziosamente.

Creazione di una tabella figlio: per creare una tabella figlio si utilizzano la stessa classe TableRequest e gli stessi metodi per eseguire l'istruzione DDL.

Durante la creazione di una tabella figlio:

È necessario specificare il nome completo della tabella (name_parent_table.name_child_table)
I limiti della tabella non devono essere impostati in modo esplicito poiché una tabella figlio eredita i limiti di una tabella padre.

Scarica il codice completo TableJoins.cs dagli esempi qui.

Creazione di una tabella di raccolta JSON:

La tabella di raccolta JSON include documenti con uno o più campi di chiave primaria e campi JSON. L'esempio riportato di seguito crea una tabella stream_acct come tabella di raccolta JSON.

/* Create a JSON collection table with an integer primary key */

private static async Task CreateTableAsync(NoSQLClient client)
{
    const string tableName = "stream_acct";

    var statement =
        $"CREATE TABLE IF NOT EXISTS {tableName} " +
        "(acct_Id INTEGER, PRIMARY KEY(acct_Id)) " +
        "AS JSON COLLECTION";

    Console.WriteLine($"Creating table: {statement}");

    var result = await client.ExecuteTableDDLAsync(statement);
    await result.WaitForCompletionAsync();

    Console.WriteLine($"Table {tableName} created.");
}

Utilizzo delle API per creare una tabella Singleton

Uso dei comandi SQL

Uso dell'API TableRequest

Argomenti correlati