Utilisation des API pour créer une table singleton

La table est la structure de base qui contient les données utilisateur. Vous utilisez une commande SQL (énoncé CREATE TABLE) ou des commandes d'API TableRequest pour créer une nouvelle 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.

Directives pour la création d'une table :
  • La définition de table doit inclure au moins une définition de champ et exactement une définition de clé primaire. Pour plus d'informations sur la définition de la clé primaire, voir Créer une table.
  • La définition du champ indique le nom de la colonne, son type de données, si la colonne peut être nulle ou non, une valeur par défaut facultative, si la colonne est une colonne IDENTITY et un commentaire facultatif. Tous les champs (autres que la clé primaire) peuvent être nuls par défaut.
  • La syntaxe de la spécification de clé primaire (key_definition) spécifie les colonnes de clé primaire de la table sous la forme d'une liste ordonnée de noms de champ.
  • La valeur TTL est utilisée pour calculer l'heure d'expiration d'une ligne. Les rangées expirées ne sont pas incluses dans les résultats d'interrogation et sont éventuellement supprimées automatiquement de la table par Oracle NoSQL Database. Si vous spécifiez une valeur de durée de vie lors de la création de la table, elle s'applique par défaut à chaque ligne insérée dans cette table.

Utiliser des commandes SQL

Vous pouvez utiliser la commande CREATE TABLE dans 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 LDD CREATE TABLE.

Exemple 1 : Créez une table d'application de suivi des bagages des compagnies aériennes qui contient les informations sur les bagages des passagers d'un système aérien.
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'énoncé CREATE TABLE pour définir une TABLE BaggageInfo. Le numéro de billet du passager, ticketNo, est la clé primaire du tableau. Les champs fullName, gender, contactPhone et confNo (numéro de réservation) stockent les informations du passager, qui font partie du 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 de détails 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édias en continu avec un champ JSON pour suivre l'activité courante 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'énoncé CREATE TABLE pour créer une TABLE stream_acct. L'ID compte de l'abonné, champ acct_id, est la clé primaire dans ce tableau. Les champs profile_name, account_expiry stockent les détails de consultation, 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 expositions consultées par un abonné.

Pour plus de détails sur l'application de service de médias en continu, voir Service de médias en continu - Magasin de profils d'utilisateur persistants

Vous spécifiez é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 après 5 jours.

Exemple 3 : Créez une table de service de médias en continu avec diverses 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 de 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 types de données différents. 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 jeu 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 RECORD imbriqué utilisé pour suivre les détails des présentations affichées.

Exemple 4 : Créez une table de service de médias 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 médias en continu peut prendre en charge plusieurs profils d'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. En plus de définir 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 enfants sous la même table parent stream_acct. Vous pouvez définir davantage de tables enfants pour la table acct_data. Toutes les tables de la hiérarchie ont la même colonne de clé de partition, qui est spécifié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 partition pour les tables stream_acct et acct_data.

Utilisation de l'API TableRequest

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

La classe TableRequest est utilisée pour créer des tables. L'exécution des opérations spécifiées par cette demande est asynchrone. Il s'agit d'opérations potentiellement de longue durée. TableResult est retourné par les opérations TableRequest et encapsule l'état de la table. Voir Informations de référence sur l'API de la trousse SDK Java pour Oracle NoSQL pour plus de détails sur la classe TableRequest et ses méthodes.

Téléchargez le code complet CreateTable.java dans les 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);
}

Note :

Les limites de table s'appliquent uniquement à Oracle NoSQL Database Cloud Service. Si des limites sont définies pour une base de données NoSQL sur place, elles sont ignorées silencieusement.

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

Lors de la création d'une table enfant :
  • Vous devez spécifier le nom complet de la table (name_parent_table.name_child_table)
  • Il n'est pas nécessaire de définir explicitement des limites de table car une table enfant hérite des limites d'une table parent.

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

La classe borneo.TableRequest est utilisée pour créer une table. Tous les appels à 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. Voir Informations de référence sur l'API de la trousse SDK Python pour Oracle NoSQL pour plus de détails sur table_request et ses méthodes.

Téléchargez le code complet CreateTable.py dans les 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()))

Note :

Les limites de table s'appliquent uniquement à Oracle NoSQL Database Cloud Service. Si des limites sont définies pour une base de données NoSQL sur place, elles sont ignorées silencieusement.

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

Lors de la création d'une table enfant :
  • Vous devez spécifier le nom complet de la table (name_parent_table.name_child_table).
  • Il n'est pas nécessaire de définir explicitement des limites de table car une table enfant hérite des limites d'une table parent.

Téléchargez le code complet TableJoins.py dans les exemples ici.

La classe TableRequest est utilisée pour créer une table. L'exécution des opérations spécifiées par TableRequest est asynchrone. Il s'agit d'opérations potentiellement de longue durée. Cette demande est utilisée en tant qu'entrée d'une opération Client.DoTableRequest(), qui retourne une valeur TableResult qui peut être utilisée pour scruter jusqu'à ce que la table atteigne l'état souhaité. Voir Informations de référence sur l'API de la trousse SDK Go pour Oracle NoSQL pour plus de détails sur les différentes méthodes de la classe TableRequest.

Téléchargez le code complet CreateTable.go dans les 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
}

Note :

Les limites de table s'appliquent uniquement à Oracle NoSQL Database Cloud Service. Si des limites sont définies pour une base de données NoSQL sur place, elles sont ignorées silencieusement.

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

Lors de la création d'une table enfant :
  • Vous devez spécifier le nom complet de la table (name_parent_table.name_child_table).
  • Il n'est pas nécessaire de définir explicitement des limites de table car une table enfant hérite des limites d'une table parent.

Téléchargez le code complet TableJoins.go dans les exemples ici.

Vous pouvez créer une table à l'aide de la méthode tableDDL. Cette méthode est asynchrone et retourne une promesse de TableResult. TableResult est un objet JavaScript brut qui contient le statut de l'opération LDD, par exemple TableState, nom, schéma et TableLimits. Pour plus de détails sur la méthode, voir la classe NoSQLClient.

La méthode tableDDL utilise l'objet TableDDLOpt comme deuxième argument facultatif. Lorsque vous créez une table, vous devez spécifier TableLimits dans le cadre de l'argument opt. TableLimits spécifie le débit maximal et la capacité de stockage pour la table en tant que 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);
}
Après le retour de l'appel ci-dessus, le résultat reflétera 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 un énoncé LDD afin de créer une table enfant.

Lors de la création d'une table enfant :
  • Vous devez spécifier le nom complet de la table (name_parent_table.name_child_table)
  • Il n'est pas nécessaire de définir explicitement des limites de table 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.

Pour créer une table, utilisez l'une des méthodes ExecuteTableDDLAsync ou ExecuteTableDDLWithCompletionAsync. Ces deux méthodes retournent 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, voir Informations de référence sur l'API de la trousse SDK Dotnet pour Oracle NoSQL.

Téléchargez le code complet CreateTable.cs dans les 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);  
}

Note :

Les limites de table s'appliquent uniquement à Oracle NoSQL Database Cloud Service. Si des limites sont définies pour une base de données NoSQL sur place, elles sont ignorées silencieusement.

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

Lors de la création d'une table enfant :
  • Vous devez spécifier le nom complet de la table (name_parent_table.name_child_table)
  • Il n'est pas nécessaire de définir explicitement des limites de table car une table enfant hérite des limites d'une table parent.

Téléchargez le code complet TableJoins.cs dans les exemples ici.