APSQL

Estimation de taille

Lors de la création d'une base et des tables qui vont la composer il est nécessaire de procéder à une estimation de l'espace occupé par ces dernières. Cette estimation pourra permettre de dimensionner les fichiers en conséquence.

Les calculs présentés ici ne concernent que l'estimation de la taille d'un index organisé. Cet, index, qui organise physiquement la table doit être défini sur des données stables, comme par exemple la clé primaire. Si cet index n'est pas définis sur des éléments qui représente un identifiant unique, alors une colonne de type uniqueidentifier est ajoutée. L'index est capable de dire s'il représente un identifiant unique s'il est créé par l'intermédiaire de la définition d'une contrainte de clé primaire ou d'unicité, ou bien encore, s'il est créé en tant qu'index UNIQUE.

Pour estimé l'espace occupé par une table qui utilise un index organisé, le calcul va se réalisé en deux étapes. La première étape va consister à calculer l'espace occupé par les feuilles de l'index. C'est à ce niveau que les données sont enregistrées. La seconde étape va consister à estimer la taille de l'arbre balancé correspondant à l'index.

schéma de structure de l'index

Calcul de l'espace utilisé au niveau feuille

Les informations sont stockées dans les pages du niveau feuille. Chaque page va contenir plusieurs lignes d'informations. Le calcul du nombre total de pages est donc la première étape nécessaire à l'estimation de l'espace occupé par la table.

Comme l'illustre le schéma ci-dessous, chaque page réserve un petit espace pour des informations qui lui sont propres, puis l'espace est occupé en respectant le facteur de remplissage initial FillFactor. L'espace libre ainsi conservé au niveau des pages, va permettre de gérer l'augmentation de taille des lignes.

Structure d'une page

Le premier élément à prendre en compte est le nombre de lignes (nombreLignes). Il s'agit ici du nombre de lignes réel ou estimé.

Le second paramètre à prendre en compte concerne les colonnes. Il y a cette fois plusieurs éléments à considérés qui sont:

  • Le nombre total de colonnes : nombreColonnes
  • La taille totale (en octet) qui sera occupé par les colonnes de longueur fixes: longueurColonnesFixe
  • Le nombre de colonnes de longueur variables: nombreColonnesLongueurVariable
  • La taille maximum de toutes ces colonnes de longueur variables: longueurMaxVariable

Dans le cas, rare, ou l'index organisé n'est pas unique, il est nécessaire de comptabiliser l'espace occupé par la colonne de type uniqueidentifier. Cette colonne contiendra une valeur non null, uniquement pour les colonnes qui ne possède pas d'identifiant unique. La présence de cette colonne est obligatoire afin de garantir que chaque ligne peut être identifiée de façon unique. Les modifications sont donc les suivantes:

  • nombreColonnes=nombreColonnes+1
  • nombreColonnesLongueurVariable = nombreColonnesLongueurVariable +1
  • lg_max_col_var=lg_max_col_var+4

Pour chaque ligne, un espace est réservé afin de gérer la nullité éventuelle de certaines colonnes. Cet espace est connu sous le nom de null bitmap ou image pour les valeurs nulls. Le calcul de cet espace est le suivant:espaceNull=2+((nombreColonnes+7)/8)

Seule la partie entière du résultat de ce calcul est à conserver.

Pour chaque ligne l'espace occupé par les données de longeur variable est estimé de la façon suivante: espaceVariable=2+(2* nombreColonnesLongueurVariable)+ longueurMaxVariable

Cette estimation repose bien entendu que chaque colonne de longueur variable est remplie à 100% ce qui n'est pas toujours vrai. Il convient alors de d'estimer de nouveau la valeur de longueurMaxVariable afin de prendre en compte la longueur moyenne occupée par chaque colonne.

La taille d'une ligne de donnée est alors obtenue de la façon suivante:tailleLigne= longueurColonnesFixe +espaceVariable+ espaceNull+4

Calculer le nombre de lignes de données qu'il est possible de stocker dans chaque page. lignesParPage=8096/(tailleLigne+2)

Etant donné qu'une ligne ne peut pas être fragmentée sur 2 pages lors de l'insertion, il est nécessaire de ne conserver que la partie entière de la division.

Ce nombre de lignes par pages et un calcul idéal, en effet lors de l'insertion des données, les pages sont remplies en tenant compte de la valeur affectée au paramètre FillFactor. Il est donc nécessaire de calculé l'espace libre par page:espaceLibreParPage=8096*((100-FillFactor)/100)/(tailleLigne+2)

Le nombre total de page pour stocker toutes les lignes est alors: nombrePages=nombreLignes/(lignesParPage-espaceLibreParPage)

Et donc l'espace occupé par les feuilles du niveau feuille est le suivant:

espaceNiveauFeuille=8192*nombrePages

Calcul de l'espace utilisé par l'arbre

L'estimation proposée ci-dessous, concerne uniquement l'estimation de le taille d'un arbre pour un index ordonné (clustered index).

Les index étant organisés sous la forme d'arbre balancés, il est nécessaire de calculé l'espace occupée par cette structure. Les éléments les plus influant vont être le nombre de ligne d'informations présentent dans l'index, le facteur de remplissage des différentes pages qui constituent l'arbre ainsi que la taille de clé qui permet de créer l'index organisé.

Pour les colonnes qui constituent la clé, il est nécessaire de connaitre:

  • NombreColonnesClé: nombre de colonnes présentes dans la clé
  • NombreColonneNullClé: nombre de colonnes de la clé qui peuvent prendre la valeur null.
  • TailleFixeClé: il s'agit ici de connaitre la taille totale de toutes les colonnes de longueur fixe qui composent la clé.
  • NombreColonnesVariableClé: cette valeur représente le nombre de colonnes définies sur un type de longueur variable qui participent à la définition de la clé.
  • TailleMaximumVariableClé: représente la taille maximum qui peut être utilisée par les colonnes définies sur des types de longueur variables et qui participes à la clé.

Dans le cas ou l'index ordonné n'est pas associé à une contrainte d'unicité, il est nécessaire de prévoir l'espace nécessaire pour stocker une variable de type uniqueidentifier:

  • NombreColonnesClé= NombreColonnesClé+1
  • NombreColonnesVariableClé= NombreColonnesVariableClé+1
  • TailleMaximumVariableClé= TailleMaximumVariableClé+4

Evaluation de l'espace nécessaire aux valeurs null espaceNull=2+(( NombreColonneNullClé +7)/8)

Si aucune colonne de la clé ne peut prendre de valeur null, alors l'espace pour les valeurs null est de 0.

Estimation de l'espace nécessaire pour les données de longueur variable. espaceVariableClé=2+( NombreColonnesVariableClé*2)+ TailleMaximumVariableClé

Cette estimation repose sur le fait que les espaces variables sont pleinement occupé. Si la longueur moyenne des données est inférieur à la taille maximum alors il convient de pondéré de calcul en fonction du ratio moyen d'occupation.

Estimation de la taille d'une ligne dans l'index tailleLigneIndex= TailleFixeClé +espaceVariableClé+espaceNull+1+6

Nombre de lignes d'index par page: lignesIndexParPage=8096/(tailleLigneIndex+2)

Nombre de niveau dans l'index: Calcul du nombre de niveaux

C'est l'entier immédiatement plus grand qui est retenu comme résultat de ce calcul.

Il est maintenant possible de calculer le nombre de pages dans l'index Calcul du nombre de pages

L'espace occupé par la structure de l'index est donc:

espaceIndex=nombrePagesIndex*8192

Ressources