Utiliser des API pour créer une table unique

La table est la structure de base qui contient les données utilisateur. Vous utilisez une commande SQL (instruction CREATE TABLE) ou des commandes d'API TableRequest pour créer une table.

Vous pouvez également utiliser la console Oracle NoSQL Cloud Infrastructure(OCI) ou l'interface de ligne de commande OCI (OCI-cli) pour créer une table dans NDCS.

Instructions de création d'une table :

Créez une table :

Utilisation de commandes SQL

Vous pouvez utiliser la commande CREATE TABLE en SQL pour créer des tables NoSQL.

La section suivante met en évidence différentes options qui peuvent être utilisées lors de la création d'une TABLE à l'aide de l'instruction CREATE TABLE DDL.

Exemple 1 : Créez une table d'application de suivi des bagages de la compagnie aérienne qui contient les informations sur les bagages des passagers dans un système de compagnie aérienne.

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

Dans le schéma ci-dessus, vous utilisez l'instruction CREATE TABLE pour définir une TABLE BaggageInfo. Le numéro de ticket du passager, ticketNo, est la clé primaire de la table. Les champs fullName, gender, contactPhone et confNo (numéro de réservation) stockent les informations du passager, qui font partie d'un schéma fixe. La colonne bagInfo est un tableau JSON sans schéma, qui représente les informations de suivi des bagages enregistrés d'un passager.

Pour plus d'informations sur l'application de suivi des bagages des compagnies aériennes, voir Application de suivi des bagages des compagnies aériennes.

Exemple 2 : créez une table de service de média de transmission en continu avec un champ JSON pour suivre l'activité actuelle de l'abonné.

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

Dans le schéma ci-dessus, vous utilisez l'instruction CREATE TABLE pour créer une TABLE stream_acct. Le champ ID de compte de l'abonné, acct_id, est la clé primaire de cette table. Les champs profile_name et account_expiry stockent les détails de la vue, qui font partie d'un schéma fixe. La colonne acct_data est un champ JSON sans schéma, qui stocke les détails des affichages affichés par un abonné.

Pour plus d'informations sur l'application Streaming Media Service, reportez-vous à Streaming Media Service - Persistent user profile store.

Vous indiquez également une valeur de durée de vie, après laquelle les lignes expirent automatiquement et ne sont plus disponibles. La valeur de durée de vie doit être en heures ou en jours. Dans ce schéma, les lignes de la table expirent au bout de 5 jours.

Exemple 3 : créez une table de service de média en continu avec différentes définitions de schéma fixe.

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)
)

Dans le schéma ci-dessus, vous définissez une variation du schéma fixe en incluant le champ acct_data comme type de données RECORD.

Un enregistrement est un ensemble ordonné d'une ou plusieurs paires clé-élément. Les clés d'un enregistrement doivent être des chaînes et les éléments associés peuvent être de différents types de données. Les champs d'un enregistrement font partie du schéma fixe et vous ne pourrez pas les ajouter ou les supprimer. Dans l'exemple ci-dessus, les champs firstName, lastName, country et shows sont les clés de l'enregistrement acct_data. La définition d'un enregistrement est utile lorsque vous souhaitez stocker des données dans le cadre d'un ensemble de données plus volumineux. Vous pouvez insérer/mettre à jour/extraire l'ensemble du sous-ensemble d'un enregistrement à l'aide des expressions d'étape de champ.

Vous pouvez également imbriquer les enregistrements comme suit :

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)
)

Le champ shows est un type d'enregistrement imbriqué utilisé pour suivre les détails des affichages affichés.

Exemple 4 : créez une table de service de média de transmission en continu en tant que structure de table hiérarchique.

Dans les schémas suivants, vous créez une table stream_acct en tant que table parent et une table acct_data en tant que table enfant :

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))

Avec la définition de table parent-enfant ci-dessus, le service de diffusion en continu peut prendre en charge plusieurs profils utilisateur sous un seul abonnement.

Vous définissez la table acct_data en tant que table enfant avec une clé primaire profile_id pour identifier le profil d'un utilisateur. Outre la définition d'une clé primaire pour la table, la table acct_data hérite implicitement de la colonne de clé primaire acct_id de sa table stream_acct parent.

Vous pouvez définir plusieurs tables enfant sous la même table parent stream_acct. Vous pouvez définir des tables enfant supplémentaires pour la table acct_data. Toutes les tables de la hiérarchie ont la même colonne de clé de shard, qui est indiquée dans l'instruction de création de table de la table parent la plus élevée de la hiérarchie. Dans cet exemple, la clé primaire acct_id de la table parent est également la clé de shard pour les tables stream_acct et acct_data.

Exemple 5 : créez une table de service de média de transmission en continu avec la clé primaire comme colonne 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)
)

Dans cet exemple, vous créez la table stream_acct avec les mêmes champs définis dans l'exemple 2. Toutefois, le schéma définit la clé primaire acct_id comme une colonne IDENTITY. Lorsque vous définissez une colonne IDENTITY comme GENERATED BY DEFAULT AS IDENTITY, le système génère automatiquement les valeurs de la colonne IDENTITY si vous n'en fournissez pas. Le système commence à générer des valeurs acct_id à partir de 4, incrémentées de 1. Par conséquent, les valeurs de la colonne acct_id seront 4, 5, 6…, et ainsi de suite jusqu'à la valeur maximale du type de données LONG. Comme le schéma définit l'option NO CYCLE, le système génère une exception après la valeur maximale car il a atteint la fin du générateur de séquences.

Exemple 6 : créez une table de service de média de transmission en continu avec la clé primaire comme type de données 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)
)

Dans cet exemple, vous créez la table stream_acct avec les mêmes champs définis dans l'exemple 2. Cependant, le schéma définit la clé primaire acct_id comme un type de données UUID, GENERATED BY DEFAULT. Le système génère automatiquement une valeur pour la colonne UUID si vous n'en fournissez pas. L'avantage potentiel de la définition d'une clé primaire en tant que type de données UUID est que le système garantit l'unicité des colonnes IDENTITY uniquement au sein d'une banque de données NoSQL dans une région. Le type de données UUID génère un identificateur unique global pour les enregistrements d'une table qui s'étend sur plusieurs régions.

Tables de collection JSON

Exemple 7 : créez une table de service de média de transmission en continu en tant que table de collecte JSON.

Dans l'instruction CREATE TABLE suivante, vous créez la TABLE stream_acct en tant que TABLE de collecte JSON :

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

Cette table de collecte JSON inclut le champ de clé primaire acct_id. Il n'est pas nécessaire de fournir un autre champ à l'exception du champ de clé primaire dans la commande LDD.

Lorsque vous insérez des données dans cette table, la table de collecte JSON considère automatiquement les champs insérés autres que le champ acct_id comme des champs JSON. Vous pouvez utiliser cette table de collecte JSON pour stocker et extraire des données de diffusion en continu TV uniquement en tant que documents.

Exemple 8 : créez une table d'application d'achat en tant que table de collecte JSON.

L'instruction CREATE TABLE suivante définit une TABLE storeAcct, qui est une TABLE de collection JSON créée pour une application d'achat. Cette table inclut contactPhone comme champ de clé primaire de la chaîne de type.

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

Utilisation de l'API TableRequest

Vous pouvez utiliser l'API TableRequest pour créer des tables NoSQL.

La classe TableRequest permet de créer des tables. L'exécution des opérations indiquées par cette demande est asynchrone. Il s'agit d'opérations potentiellement longues. TableResult est renvoyé par les opérations TableRequest et encapsule l'état de la table. Pour plus de détails sur la classe TableRequest et ses méthodes, reportez-vous à Référence d'API du kit SDK Java Oracle NoSQL.

Téléchargez le code complet CreateTable.java à partir des exemples ici.

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);
}

Remarque : les limites de table sont applicables uniquement à Oracle NoSQL Database Cloud Service. Si des limites sont définies pour une base de données NoSQL sur site, elles sont ignorées en mode silencieux.

Création d'une table enfant : vous utilisez la même classe et les mêmes méthodes TableRequest pour exécuter une instruction LDD afin de créer une table enfant.

Lors de la création d'une table enfant :

  • Vous devez indiquer le nom complet de la table (nom_parent_table.nom_enfant_table)

  • Les limites de table ne doivent pas être explicitement définies car une table enfant hérite des limites d'une table parent.

Téléchargez le code complet TableJoins.java à partir des exemples pour comprendre comment créer une table parent-enfant ici.

Création d'une table de collecte JSON :

La table de collecte JSON inclut des documents avec un ou plusieurs champs de clé primaire et des champs JSON. L'exemple suivant crée une table stream_acct en tant que table de collecte 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 permet de créer une table. Tous les appels vers borneo.NoSQLHandle.table_request() sont asynchrones. Il est donc nécessaire de vérifier le résultat et d'appeler borneo.TableResult.wait_for_completion() pour attendre la fin de l'opération. Pour plus de détails sur table_request et ses méthodes, reportez-vous à Référence d'API de kit SDK Python Oracle NoSQL.

Téléchargez le code complet CreateTable.py à partir des exemples ici.

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()))

Remarque : les limites de table sont applicables uniquement à Oracle NoSQL Database Cloud Service. Si des limites sont définies pour une base de données NoSQL sur site, elles sont ignorées en mode silencieux.

Création d'une table enfant : vous utilisez la même classe et les mêmes méthodes TableRequest pour exécuter une instruction LDD afin de créer une table enfant.

Lors de la création d'une table enfant :

  • Vous devez indiquer le nom complet de la table (nom_parent_table.nom_enfant_table).

  • Les limites de table ne doivent pas être explicitement définies car une table enfant hérite des limites d'une table parent.

Téléchargez le code complet TableJoins.py à partir des exemples ici.

Création d'une table de collecte JSON :

La table de collecte JSON inclut des documents avec un ou plusieurs champs de clé primaire et des champs JSON. L'exemple suivant crée une table stream_acct en tant que table de collecte 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 permet de créer une table. L'exécution des opérations indiquées par TableRequest est asynchrone. Il s'agit d'opérations potentiellement longues. Cette demande est utilisée en tant qu'entrée d'une opération Client.DoTableRequest(), qui renvoie une valeur TableResult qui peut être utilisée pour interroger jusqu'à ce que la table atteigne l'état souhaité. Pour plus de détails sur les différentes méthodes de la classe TableRequest, reportez-vous à Référence d'API du kit SDK Go Oracle NoSQL.

Téléchargez le code complet CreateTable.go à partir des exemples ici.

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
}

Remarque : les limites de table sont applicables uniquement à Oracle NoSQL Database Cloud Service. Si des limites sont définies pour une base de données NoSQL sur site, elles sont ignorées en mode silencieux.

Création d'une table enfant : vous utilisez la même classe et les mêmes méthodes TableRequest pour exécuter une instruction LDD afin de créer une table enfant.

Lors de la création d'une table enfant :

  • Vous devez indiquer le nom complet de la table (nom_parent_table.nom_enfant_table).

  • Les limites de table ne doivent pas être explicitement définies car une table enfant hérite des limites d'une table parent.

Téléchargez le code complet TableJoins.go à partir des exemples ici.

Création d'une table de collecte JSON :

La table de collecte JSON inclut des documents avec un ou plusieurs champs de clé primaire et des champs JSON. L'exemple suivant crée une table stream_acct en tant que table de collecte 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
}

Vous pouvez créer une table à l'aide de la méthode tableDDL. Cette méthode est asynchrone et renvoie la promesse TableResult. TableResult est un objet JavaScript simple qui contient le statut de l'opération LDD, tel que son état de table, son nom, son schéma et ses limites de table. Pour plus de détails sur la méthode, reportez-vous à la classe NoSQLClient.

La méthode tableDDL prend l'objet TableDDLOpt comme deuxième argument facultatif. Lorsque vous créez une table, vous devez indiquer sa valeur TableLimits dans le cadre de l'argument opt. La valeur TableLimits indique le débit et la capacité de stockage maximaux pour la table comme la quantité d'unités de lecture, d'unités d'écriture et de gigaoctets de stockage.

Téléchargez le code JavaScript complet CreateTable.js à partir des exemples ici et le code TypeScript complet CreateTable.ts à partir des exemples ici.

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);
}

Une fois l'appel ci-dessus renvoyé, le résultat reflète l'état final de l'opération. Alternativement, pour utiliser l'option complète, remplacez le code dans le bloc try-catch ci-dessus par l'exemple de code suivant.

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);

Création d'une table enfant : vous utilisez la même classe et les mêmes méthodes TableRequest pour exécuter une instruction LDD afin de créer une table enfant.

Lors de la création d'une table enfant :

  • Vous devez indiquer le nom complet de la table (nom_parent_table.nom_enfant_table)

  • Les limites de table ne doivent pas être explicitement définies car une table enfant hérite des limites d'une table parent.

Téléchargez le code JavaScript complet TableJoins.js à partir des exemples ici et le code TypeScript complet TableJoins.ts à partir des exemples ici.

Création d'une table de collecte JSON :

La table de collecte JSON inclut des documents avec un ou plusieurs champs de clé primaire et des champs JSON. L'exemple suivant crée une table stream_acct en tant que table de collecte 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;
    }
}

Pour créer une table, utilisez l'une des méthodes ExecuteTableDDLAsync ou ExecuteTableDDLWithCompletionAsync. Ces deux méthodes renvoient Task<TableResult>. L'instance TableResult contient le statut de l'opération LDD, telle que TableState et le schéma de table. Pour plus de détails sur ces méthodes, reportez-vous à Référence d'API du kit SDK Oracle NoSQL Dotnet.

Téléchargez le code complet CreateTable.cs à partir des exemples ici.

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);
}

Remarque : les limites de table sont applicables uniquement à Oracle NoSQL Database Cloud Service. Si des limites sont définies pour une base de données NoSQL sur site, elles sont ignorées en mode silencieux.

Création d'une table enfant : vous utilisez la même classe et les mêmes méthodes TableRequest pour exécuter une instruction LDD afin de créer une table enfant.

Lors de la création d'une table enfant :

  • Vous devez indiquer le nom complet de la table (nom_parent_table.nom_enfant_table)

  • Les limites de table ne doivent pas être explicitement définies car une table enfant hérite des limites d'une table parent.

Téléchargez le code complet TableJoins.cs à partir des exemples ici.

Création d'une table de collecte JSON :

La table de collecte JSON inclut des documents avec un ou plusieurs champs de clé primaire et des champs JSON. L'exemple suivant crée une table stream_acct en tant que table de collecte 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.");
}