Service SFDatabases.Database

Le service Database permet d'accéder aux bases de données intégrées ou décrites dans les documents Base. Ce service fournit des méthodes pour :

Chaque instance du service Database représente une seule base de données et donne accès à ses tables, requêtes et données.

Ce service ne donne pas accès aux formulaires ou aux rapports du document Base qui contient la base de données. Pour accéder aux formulaires dans un document Base, reportez-vous à la méthode FormDocuments du service Base.

note

Tous les échanges entre ce service et la base de données se font uniquement en SQL.


Les instructions SQL peuvent être exécutées en mode direct ou indirect. En mode direct, l'instruction est transférée au moteur de base de données sans aucune vérification ou révision de la syntaxe.

Les interfaces fournies incluent des tables et des listes de requêtes simples, ainsi qu'un accès aux données de la base de données.

tip

Pour rendre les instructions SQL plus lisibles, vous pouvez utiliser des crochets "[ ]" afin d'inclure les noms de tables, de requêtes et de champs au lieu d'utiliser d'autres caractères englobants qui peuvent être exclusifs à certains systèmes de gestion de bases de données relationnelles (SGBDR). Mais attention, les caractères englobants sont obligatoires dans ce contexte.


Transaction handling

By default the database handles transactions in auto-commit mode, meaning that a commit is done after every SQL statement.

Use the SetTransactionMode method to change the default behavior, which allows for manual commits and rollbacks.

The methods Commit and Rollback are used to delimit transactions.

In LibreOfficeDev, there are five types of transaction isolation modes, as defined in the com.sun.star.sdbc.TransactionIsolation constant group:

Constant

Value

Interpretation

NONE

0

Transaction handling is disabled and the database is set to the default auto-commit mode.

READ_UNCOMMITTED

1

Dirty reads, non-repeatable reads and phantom reads can occur.

If a row is changed by a transaction, another transaction will be able to read these changes even if they have not been committed.

READ_COMMITTED

2

Dirty reads are prevented, however non-repeatable reads and phantom reads can occur.

This level prevents that rows with uncommitted changes are read.

REPEATABLE_READ

4

Dirty reads and non-repeatable reads are prevented. However, phantom reads can occur.

Besides preventing uncommitted data from being read, it also prevents that two read operations in the same transaction return different results.

SERIALIZABLE

8

Dirty reads, non-repeatable reads and phantom reads are prevented.

In addition to the constraints of the previous level, it also ensures that the set of records that match a WHERE clause remains unchanged inside the same transaction.


tip

Read the Wikipedia page on Isolation in Database Systems to learn more about transaction integrity.


Invocation du service

Avant d'utiliser le service Database, la bibliothèque ScriptForge doit être chargée ou importée :

note

• Les macros Basic nécessitent de charger la bibliothèque ScriptForge à l'aide de l'instruction suivante :
GlobalScope.BasicLibraries.loadLibrary("ScriptForge")

• Les scripts Python nécessitent un import depuis le module scriptforge :
from scriptforge import CreateScriptService


Syntaxe :

Pour créer une instance du service Database, vous pouvez utiliser la méthode CreateScriptService :

CreateScriptService("SFDatabases.Database", [filename: str], [registrationname], [readonly], [user, [password]]): svc

note

Dans la syntaxe décrite ci-dessus, vous pouvez utiliser "SFDatabases.Database" ou simplement "Database" comme premier argument de la méthode CreateScriptService.


Paramètres :

filename : le nom du fichier Base. Il doit être exprimé en utilisant la notation SF_FileSystem.FileNaming.

registrationname : le nom d'une base de données enregistrée. Si filename est fourni, cet argument ne doit pas être utilisé.

Inversement, si un registrationname est spécifié, le paramètre filename ne doit pas être défini.

readonly : détermine si la base de données sera ouverte en lecture seule (par défaut = True).

user, password : paramètres de connexion supplémentaires au serveur de base de données.

Exemple :

En Basic :

      GlobalScope.BasicLibraries.LoadLibrary("ScriptForge")
      Dim myDatabase as Object
      Set myDatabase = CreateScriptService("Database", "/home/user/Documents/myDB.odb")
      '  requêtes Run, instructions SQL, ...
      myDatabase.CloseDatabase()
    
En Python

      from scriptforge import CreateScriptService
      myDatabase = CreateScriptService("Database", "/home/user/Documents/myDB.odb")
      #  requêtes Run, instructions SQL, ...
      myDatabase.CloseDatabase()
    

Accéder aux bases de données à l'aide du service UI

Il est également possible d'accéder à la base de données associée à un document Base à l'aide du service ScriptForge.UI, comme illustré dans les exemples ci-dessous :

En Basic :

      Dim myDoc As Object, myDatabase As Object, ui As Object
      Set ui = CreateScriptService("UI")
      Set myDoc = ui.OpenBaseDocument("/home/user/Documents/myDB.odb")
      ' L'utilisateur et le mot de passe sont fournis ci-dessous, si nécessaire
      Set myDatabase = myDoc.GetDatabase()
      '  requêtes Run, instructions SQL, ...
      myDatabase.CloseDatabase()
      myDoc.CloseDocument()
    
En Python

      ui = CreateScriptService("UI")
      doc = ui.OpenBaseDocument("/home/user/Documents/myDB.odb")
      # L'utilisateur et le mot de passe sont fournis ci-dessous, si nécessaire
      myDatabase = doc.GetDatabase()
      #  requêtes Run, instructions SQL, ...
      myDatabase.CloseDatabase()
      doc.CloseDocument()
    
tip

La méthode GetDatabase utilisée dans l'exemple ci-dessus fait partie du service Base de ScriptForge.


Propriétés

Nom

Lecture seule

Type

Description

Queries

Oui

Matrice de chaînes

La liste des requêtes stockées.

Tables

Oui

Matrice de chaînes

La liste des tables stockées.

XConnection

Oui

XConnection

L'objet UNO représentant la connexion à la base de données active.

XMetaData

Oui

XDatabaseMetaData

L'objet UNO représentant les métadonnées décrivant les attributs du système de base de données.


Liste des méthodes dans le service Database

CloseDatabase
Commit
CreateDataset
DAvg
DCount
DMin

DMax
DSum
DLookup
GetRows
OpenFormDocument
OpenQuery

OpenSql
OpenTable
Rollback
RunSql
SetTransactionMode


CloseDatabase

Ferme la connexion à la base de données active.

Syntaxe :

db.CloseDatabase()

Exemple :


    myDatabase.CloseDatabase() ' Basic
  

    myDatabase.CloseDatabase() # Python
  

Commit

Commits all updates done since the previous Commit or Rollback call.

note

This method is ignored if commits are done automatically after each SQL statement, i.e. the database is set to the default auto-commit mode.


Syntaxe :

db.Commit()

Exemple :

En Basic :

      ' Set the REPEATABLE_READ transaction level
      myDB.SetTransactionMode(4)
      myDB.RunSql("UPDATE ...")
      myDB.Commit()
      myDB.RunSql("DELETE ...")
      ' Test some condition before committing
      If bSomeCondition Then
          myDB.Commit()
      Else
          myDB.Rollback()
      End If
      ' Restore auto-commit mode
      myDB.SetTransactionMode()
    
En Python

      myDB.SetTransactionMode(4)
      myDB.RunSql("UPDATE ...")
      myDB.Commit()
      myDB.RunSql("DELETE ...")
      if some_condition:
          myDB.Commit()
      else:
          myDB.Rollback()
      myDB.SetTransactionMode()
    

CreateDataset

Creates a Dataset service instance based on a table, query or SQL SELECT statement.

Syntaxe :

db.CreateDataset(sqlcommand: str, opt directsql: bool, opt filter: str, opt orderby: str): svc

Paramètres :

sqlcommand: A table name, a query name or a valid SQL SELECT statement. Identifiers may be enclosed with square brackets. This argument is case-sensitive.

directsql: Set this argument to True to send the statement directly to the database engine without preprocessing by LibreOfficeDev (Default = False).

filter: Specifies the condition that records must match to be included in the returned dataset. This argument is expressed as a SQL WHERE statement without the "WHERE" keyword.

orderby: Specifies the ordering of the dataset as a SQL ORDER BY statement without the "ORDER BY" keyword.

Exemple :

The following examples in Basic and Python return a dataset with the records of a table named "Customers".

En Basic :

      oDataset = myDatabase.CreateDataset("Customers", Filter := "[Name] LIKE 'A'")
    
En Python

      dataset = myDatabase.CreateDataset("Customers", Filter = "[Name] LIKE 'A'")
    

DAvg, DCount, DMin, DMax, DSum

Calcule la fonction d'agrégat donnée sur un champ ou une expression appartenant à une table.

Facultativement, une clause SQL WHERE peut être spécifiée comme filtre qui sera appliqué avant la fonction d'agrégation.

Syntaxe :

db.DAvg(expression: str, tablename: str, [criteria: str]): any

db.DCount(expression: str, tablename: str, [criteria: str]): any

db.DMin(expression: str, tablename: str, [criteria: str]): any

db.DMax(expression: str, tablename: str, [criteria: str]): any

db.DSum(expression: str, tablename: str, [criteria: str]): any

Paramètres :

expression : une expression SQL dans laquelle les noms de champ sont entourés de crochets.

tablename : un nom de table (sans crochets).

criteria : une clause WHERE sans le mot-clé "WHERE", dans laquelle les noms de champs sont entourés de crochets.

Exemple :

L'exemple ci-dessous suppose que le fichier Employees.odb a une table nommée EmployeeData.

En Basic :

      GlobalScope.BasicLibraries.LoadLibrary("ScriptForge")
      Dim myDB as Variant
      Set myDB = CreateScriptService("Database", "/home/user/Databases/Employees.odb")
      ' Compte le nombre d'employés dans la table
      MsgBox myDB.DCount("[ID]", "EmployeeData")
      ' Renvoie la somme de tous les salaires dans la table
      MsgBox myDB.DSum("[Salary]", "EmployeeData")
      ' Vous trouverez ci-dessous quelques exemples de filtrage des tableaux
      MsgBox myDB.DCount("[ID]", "EmployeeData", "[Position] = 'Manager'")
      MsgBox myDB.DCount("[ID]", "EmployeeData", "[Position] = 'Sales' AND [City] = 'Chicago'")
      MsgBox myDB.DCount("[ID]", "EmployeeData", "[FirstName] LIKE 'Paul%'")
    
En Python

      myDB = CreateScriptService("Database", "/home/user/Databases/Employees.odb")
      bas = CreateScriptService("Basic")
      bas.MsgBox(myDB.DCount("[ID]", "EmployeeData"))
      bas.MsgBox(myDB.DSum("[Salary]", "EmployeeData"))
      bas.MsgBox(myDB.DCount("[ID]", "EmployeeData", "[Position] = 'Manager'"))
      bas.MsgBox(myDB.DCount("[ID]", "EmployeeData", "[Position] = 'Sales' AND [City] = 'Chicago'"))
      bas.MsgBox(myDB.DCount("[ID]", "EmployeeData", "[FirstName] LIKE 'Paul%'"))
    

DLookup

Calcule une expression SQL sur un seul enregistrement renvoyé par une clause WHERE définie par le paramètre Criteria.

Si la requête renvoie plusieurs enregistrements, seul le premier est pris en compte. Utilisez le paramètre OrderClause pour déterminer comment les résultats de la requête sont triés.

Syntaxe :

db.DLookup(expression: str, tablename: str, [criteria:str], [orderclause: str]): any

Paramètres :

expression : une expression SQL dans laquelle les noms de champ sont entourés de crochets.

tablename : un nom de table (sans crochets).

criteria : une clause WHERE sans le mot-clé "WHERE", dans laquelle les noms de champs sont entourés de crochets.

orderclause : une clause ORDER BY sans les mots clés "ORDER BY". Les noms de champs doivent être entourés de crochets.

Exemple :

En Basic :

      MsgBox myDB.DLookup("[FirstName]", "EmployeeData", Criteria := "[LastName] LIKE 'Smith'", OrderClause := "[FirstName] DESC")
      MsgBox myDB.DLookup("[Salary]", "EmployeeData", Criteria := "[ID] = '3'")
      MsgBox myDB.DLookup("[Quantity] * [Value]", "Sales", Criteria := "[SaleID] = '5014'")
    
En Python

      bas = CreateScriptService("Basic")
      bas.MsgBox(myDB.DLookup("[FirstName]", "EmployeeData", criteria = "[LastName] LIKE 'Smith'", orderclause = "[FirstName] DESC"))
      bas.MsgBox(myDB.DLookup("[Salary]", "EmployeeData", criteria = "[ID] = '3'"))
      bas.MsgBox(myDB.DLookup("[Quantity] * [Value]", "Sales", criteria = "[SaleID] = '5014'"))
    

GetRows

Stocke le contenu d'une table ou les résultats d'une requête SELECT ou d'une instruction SQL dans une matrice à deux dimensions. Le premier index de la matrice correspond aux lignes et le second index fait référence aux colonnes.

Une limite supérieure peut être spécifiée pour le nombre de lignes renvoyées. En option, les noms de colonne peuvent être insérés dans la première ligne de la matrice.

La matrice renvoyée sera vide si aucune ligne n'est renvoyée et que les entêtes de colonne ne sont pas requis.

Syntaxe :

db.GetRows(sqlcommand: str, directsql: bool = False, header: bool = False, maxrows: int = 0): any

Paramètres :

sqlcommand : un nom de table ou de requête (sans crochets) ou une instruction SQL SELECT.

directsql : lorsque True, la commande SQL est envoyée au moteur de base de données sans pré-analyse. La valeur par défaut est False. Cet argument est ignoré pour les tables. Pour les requêtes, l'option appliquée est celle définie lors de la définition de la requête.

header : lorsque True, la première ligne de la matrice renvoyée contient les en-têtes de colonne.

maxrows : le nombre maximum de lignes à renvoyer. La valeur par défaut est zéro, ce qui signifie qu'il n'y a pas de limite au nombre de lignes renvoyées.

Exemple :

Voici quelques exemples d'utilisation de la méthode GetRows :

En Basic :

      Dim queryResults as Variant
      ' Renvoie toutes les lignes du tableau avec les en-têtes de colonne
      queryResults = myDB.GetRows("EmployeeData", Header := True)
      ' Renvoie les 50 premiers enregistrements d'employés triés par le champ 'FirstName'
      queryResults = myDB.GetRows("SELECT * FROM EmployeeData ORDER BY [FirstName]", MaxRows := 50)
    
En Python

      queryResults = myDB.GetRows("EmployeeData", header = True)
      queryResults = myDB.GetRows("SELECT * FROM EmployeeData ORDER BY [FirstName]", maxrows = 50)
    

OpenFormDocument

Ouvre le document de formulaire spécifié en mode normal. Cette méthode renvoie une instance de service FormDocument correspondant au document de formulaire spécifié.

Si le document de formulaire est déjà ouvert, la fenêtre du document de formulaire est activée.

Si le document de formulaire spécifié n'existe pas, alors Rien est renvoyé.

Syntaxe :

svc.OpenFormDocument(formdocument: str): svc

Paramètres :

formdocument : Le nom du FormDocument à ouvrir, sous forme de chaîne sensible à la casse.

Exemple :

En Basic :

La plupart des documents de formulaire sont stockés à la racine du document Base et peuvent être ouverts simplement en utilisant leur nom, comme dans l'exemple ci-dessous :


    Dim oFormDoc As Object
    oFormDoc = myDB.OpenFormDocument("myFormDocument")
  

Si les documents de formulaire sont organisés en dossiers, il devient nécessaire d'inclure le nom du dossier pour spécifier le document de formulaire à ouvrir, comme illustré dans l'exemple suivant :


    oFormDoc = myDB.OpenFormDocument("myFolder/myFormDocument")
  
En Python

    formDoc = myDB.OpenFormDocument("myFormDocument")
  

    formDoc = myDB.OpenFormDocument("myFolder/myFormDocument")
  

OpenQuery

Ouvre la fenêtre Affichage des données de la requête spécifiée et renvoie une instance du service Datasheet.

Si la requête n'a pas pu être ouverte, alors Nothing est renvoyé.

Syntaxe :

db.OpenQuery(queryname: str): obj

Paramètres :

queryname : le nom d'une requête existante sous forme de chaîne sensible à la casse.

Exemple :

En Basic :

      myDatabase.OpenQuery("MyQuery")
    
En Python

      myDatabase.OpenQuery("MyQuery")
    

OpenSql

Exécute une commande SQL SELECT, ouvre une fenêtre d'affichage des données avec les résultats et renvoie une instance du service Datasheet.

Syntaxe :

db.OpenSql(sql: str, directsql: bool): obj

Paramètres :

sql : une chaîne contenant une instruction SQL SELECT valide. Les identificateurs peuvent être entourés de crochets.

directsql : lorsque True, la commande SQL est envoyée au moteur de base de données sans pré-analyse (par défaut = False).

Exemple :

En Basic :

      myDatabase.OpenSql("SELECT * FROM [Customers] ORDER BY [CITY]")
    
En Python

      myDatabase.OpenSql("SELECT * FROM [Customers] ORDER BY [CITY]")
    

OpenTable

Ouvre la fenêtre Affichage des données de la table spécifiée et renvoie une instance du service Datasheet.

Syntaxe :

db.OpenTable(tablename: str): obj

Paramètres :

tablename : le nom d'une table existante sous la forme d'une chaîne sensible à la casse.

Exemple :

En Basic :

      myDatabase.OpenTable("MyTable")
    
En Python

      myDatabase.OpenTable("MyTable")
    

Rollback

Cancels all changes made to the database since the last Commit or Rollback call.

Syntaxe :

db.Rollback()

Exemple :

En Basic :

      myDB.SetTransactionMode(1)
      myDB.RunSql("UPDATE ...")
      ' ...
      If bSomeCondition Then
          myDB.Rollback()
      End If
    
En Python

      myDB.SetTransactionMode(1)
      myDB.RunSql("UPDATE ...")
      # ...
      if bSomeCondition:
          myDB.Rollback()
    

RunSql

Exécute une requête d'action d'une instruction SQL telle que la création d'une table, ainsi que l'insertion, la mise à jour et la suppression d'enregistrements.

La méthode renvoie True en cas de succès.

tip

La méthode RunSql est rejetée avec un message d'erreur dans le cas où la base de données a été précédemment ouverte en mode lecture seule.


Syntaxe :

db.RunSql(sqlcommand: str, directsql: bool = False): bool

Paramètres :

sqlcommand : un nom de requête (sans crochets) ou une instruction SQL.

directsql : lorsque True, la commande SQL est envoyée au moteur de base de données sans pré-analyse (par défaut = False). Pour les requêtes, l'option appliquée est celle définie lors de la définition de la requête.

Exemple :

En Basic :

      myDatabase.RunSql("INSERT INTO [EmployeeData] VALUES(25, 'Smith', 'John')", DirectSQL := True)
    
En Python

      myDatabase.RunSql("INSERT INTO [EmployeeData] VALUES(25, 'Smith', 'John')", directsql = True)
    

SetTransactionMode

Defines the level of isolation in database transactions.

By default databases manage transactions in auto-commit mode, which means that a Commit is automatically performed after every SQL statement.

Use this method to manually determine the isolation level of transactions. When a transaction mode other than NONE is set, the script has to explicitly call the Commit method to apply the changes to the database.

This method returns True when successful.

warning

Changing the transaction mode closes all Dataset instances created from the current database.


Syntaxe :

db.SetTransactionMode(transactionmode: int = 0): bool

Paramètres :

transactionmode: Specifies the transaction mode. This argument must be one of the constants defined in com.sun.star.sdbc.TransactionIsolation (Default = NONE)

note

Read the section Transaction handling above to learn more about the transaction isolation levels used in LibreOfficeDev.


Exemple :

En Basic :

      myDB.SetTransactionMode(com.sun.star.sdbc.TransactionIsolation.REPEATABLE_READ)
      oDataset = myDB.CreateDataset("SELECT ...")
      ' ...
      ' Reset the transaction mode to default
      myDB.SetTransactionMode()
    
En Python

      from com.sun.star.sdbc import TransactionIsolation
      myDB.SetTransactionMode(TransactionIsolation.REPEATABLE_READ)
      dataset = myDB.CreateDataset("SELECT ...")
      # ...
      myDB.SetTransactionMode()
    
warning

Toutes les routines ou identifiants de base ScriptForge qui sont préfixés par un caractère de soulignement "_" sont réservés à un usage interne. Ils ne sont pas destinés à être utilisés dans des macros de base ou des scripts Python.