Suite

Expression du calculateur de champ pour remplacer la chaîne uniquement si elle se produit


J'ai deux champs (RUE 1&AKA_STREET_TEST1).

J'ai un problème pour créer une simple instruction IF THEN Python dans la zone Field Calculator. J'ai cherché dans les discussions un exemple similaire mais en vain. Fondamentalement, la formule fonctionnerait quelque chose comme ça.

Si STREET1 contient "AVENUE", calculez AKA_STREET_TEST1 à "AVE", SINON laissez-le vide

(exemple ci-dessous)

Vous trouverez ci-dessous ma faible tentative de création de l'instruction if-then.


Quelques points à noter :

Votre bloc de code prend actuellement deux arguments, mais vous n'avez vraiment besoin d'en prendre qu'un.AKA_STREET_TEST1est le résultat que vous voulez, pas quelque chose quiCalculer()considérera lors du calcul. Donc votre expression devrait êtreCalc(!STREET1!)-- parce que vous voulez la fonctionCalcfaire quelque chose en utilisant les informations du terrainRUE 1, et cette valeur sera ensuite affectée àAKA_STREET_TEST1.

Vous pouvez utiliser une opération simple sur une ligne avec Pythonchaîne.remplacerfonction, qui incorpore essentiellement votre logique if-then automatiquement. SiRUEest dans la chaîne, il sera remplacé parAVE. SiRUEn'est pas là, il ne renvoie rien et doit laisser l'attribut vide.

def Calc(valeur) : si "AVENUE" dans la valeur : renvoie la valeur.replace('AVENUE','AVE')

Il semble que vous ayez la bonne idée, mais vous testez si STREET1 est parfaitement égal à "AVENUE". Parce que STREET1 contient le numéro de la route, il ne sera jamais égal. Par conséquent, vous auriez besoin de voir s'il contient AVENUE, pas seulement égal à AVENUE. Si vous utilisez la fonction python find() sur une chaîne et qu'elle ne contient pas la valeur que vous essayez de trouver, elle renverra une valeur de -1, alors essayez quelque chose comme :

def Calc(STREET1): if STREET1.find("AVENUE") != -1: return STREET1.replace("AVENUE","AVE") Calc(!STREET1!)

Essayez ceci si vous mettez à jour un champ existant et la méthode @radouxju pour remplir un nouveau champ :

def Calc(STREET1): return STREET1.replace('AVENUE','AVE')

vous pouvez utiliser la fonction find()

def Calc(rue): if street.upper().find("AVENUE") >=0: return street.upper().replace("AVENUE","AVE")

Calc(!rue!)

Notez que Python est sensible à la casse, j'ai donc ajouté upper() pour prendre en compte tous les cas


def calc(a) : si "AVENUE" dans a : renvoie "AVE" calc (!STREET1!)

Expressions régulières 101 : Regex en C++11

Il n'est pas rare d'utiliser C++ pour le traitement de texte par exemple, lire un fichier contenant du code HTML et écrire un autre fichier contenant le même code dans un format HTML différent. Pourriez-vous le faire en lisant et en analysant un caractère à la fois ? Bien sûr. Mais de telles tâches peuvent nécessiter beaucoup de travail. La nouvelle spécification C++11 ajoute les capacités de expressions régulières (regex) à la bibliothèque Standard, ce qui peut vous faciliter la vie.

En termes simples, une expression régulière est un modèle de texte. C'est une aubaine pour le traitement de texte, cependant, vous permettant de faire beaucoup avec seulement quelques lignes de code C++. Une grammaire d'expressions régulières est un langage en soi, mais un langage relativement simple et facile à apprendre. En utilisant cette grammaire, vous spécifiez des modèles pour la correspondance et (éventuellement) le remplacement. Ensuite, au moment de l'exécution, le programme crée une machine d'état à expression régulière qui fait la plupart du travail pour vous.

Tu n'as pas vraiment besoin de savoir comment Ça marche. En fait, vous n'avez besoin de savoir que quelques choses :

  • La grammaire d'expressions régulières utilisée par le C++11 expression régulière fonctions de bibliothèque
  • Les fonctions C++11 pertinentes et comment les appeler

La première partie de cet article se concentre sur la valeur par défaut expression régulière grammaire utilisée en C++11 : la grammaire ECMAScript. Vous souhaiterez généralement utiliser ECMAScript, car il offre des fonctionnalités puissantes tout en étant facile à utiliser. Pour simplifier, je vais me concentrer sur cette grammaire.


On dirait que tu cherches :

Notez que IF prend 3 paramètres : une expression qui évalue à vrai ou faux, quoi afficher si l'évaluation est vraie et quoi afficher si l'évaluation est fausse. Vous devez fournir l'intégralité de votre formule calculée actuelle pour le paramètre false-case.

Votre exemple spécifique ressemblerait à ceci :

Notez que nous fournissons la chaîne vide (" " ) pour le vrai paramètre, car nous disons si [Action Closed] est vide, alors fournissez ce qui semble être aucune valeur dans cette colonne - c'est ainsi que nous affichons un champ calculé aussi vide que votre question posée à l'origine.

J'encourage également vivement tous ceux qui recherchent plus d'informations sur les colonnes calculées à consulter la référence MSDN à l'adresse : https://msdn.microsoft.com/en-us/library/office/bb862071(v=office.14).aspx

Vous obtenez un nombre de -42 milliers, car une date vide correspond par défaut à la date passée la plus ancienne que SharePoint peut représenter, qui est le 31-21-1899 (ou 1900 ?)

Donc, comme les autres ont répondu, vous devez tester une valeur vide avec :

La référence MSDN est ne pas toujours correct, consultez la liste des fonctions et de la syntaxe SharePoint que j'ai récemment compilée.

Si vous éditez des formules calculées, mon signet CalcMaster est également d'une grande aide, car il vous donne un retour immédiat lors de l'édition.

Mettre à jour

Susanne, il est plus facile d'utiliser un éditeur de texte brut lors de l'écriture de formules, puis de les coller dans SharePoint. SharePoint ignorera toutes les nouvelles lignes afin que vous puissiez copier/coller des formules telles que" :

Cela montre comment vous pouvez imbriquer des fonctions, mais vous devez être très précis avec toutes les virgules et crochets !
Le signet CalcMaster que j'ai rendu public vous aiderait vraiment, mais vous devrez peut-être demander à un utilisateur expérimenté de SharePoint de vous aider à l'installer.

Une autre astuce consiste à les créer dans Excel, car vous obtenez des résultats immédiats dans une feuille Excel. Sachez simplement que toutes les fonctions Excel ne fonctionnent pas dans SharePoint.

La formule ci-dessus peut être testée dans Excel. Alors faites-le bien dans Excel d'abord. Remplacez les noms de colonnes par des références de cellules Excel telles que :

Si vous ne savez pas comment écrire des fonctions Excel, commencez par les apprendre. Beaucoup de cours en ligne autour.

SharePoint (Formules) c'est comme apprendre à faire du vélo sans roues latérales, mais cela vaut la peine de faire quelques chutes, de se relever et de persévérer.

Des questions bien formatées et détaillées vous donnent de meilleures réponses. Et marquer les réponses comme Réponse vous fait également gagner plus de crédit.


Renvoie uniquement la partie d'une ligne après un motif correspondant

Donc, ouvrir un fichier avec cat, puis utiliser grep pour obtenir les lignes correspondantes ne me permet d'aller plus loin que lorsque je travaille avec l'ensemble de journaux particulier avec lequel je traite. Il a besoin d'un moyen de faire correspondre les lignes à un motif, mais uniquement pour renvoyer la partie de la ligne après la correspondance. La portion avant et après le match variera constamment. J'ai joué avec sed ou awk , mais je n'ai pas réussi à comprendre comment filtrer la ligne pour supprimer la partie avant le match ou simplement renvoyer la partie après le match, l'un ou l'autre fonctionnera. Voici un exemple de ligne que je dois filtrer :

La portion dont j'ai besoin est tout après "calé".

L'arrière-plan derrière cela est que je peux découvrir à quelle fréquence quelque chose se bloque :

Ce que je dois faire, c'est découvrir combien de fois un certain nœud s'est bloqué (indiqué par la partie avant chaque deux-points après "calé". pas de blocage, ce qui ne m'aide pas.Je dois filtrer uniquement la partie bloquée pour pouvoir ensuite rechercher un nœud spécifique parmi ceux qui sont bloqués.

À toutes fins utiles, il s'agit d'un système freebsd avec des utilitaires de base GNU standard, mais je ne peux rien installer de plus pour aider.


Utilisez COLTEST pour effectuer des calculs conditionnels. COLTEST peut vérifier une ou plusieurs des conditions de colonne suivantes et renvoie TRUE si l'une des conditions de colonne suivantes est remplie.

PRESENT , qui indique qu'une colonne est présente dans l'enregistrement source et non nulle. Dans un enregistrement compressé, des colonnes peuvent être manquantes, mais ce n'est pas la même chose que null.

NULL , indiquant que la colonne est présente et NULL .

MISSING , indiquant que la colonne n'est pas présente.

INVALID , indiquant que la colonne est présente mais contient des données invalides. Par exemple, un champ PIC 9(3) qui contient des espaces génère une condition INVALID.

Le nom du champ ou de la colonne qui est la source des données testées.

L'un des éléments suivants : PRESENT , MISSING , INVALID ou NULL .

Cet exemple montre comment vous pouvez calculer la valeur d'une colonne HIGH_SALARY uniquement si le champ SALARY dans l'enregistrement source est à la fois présent et supérieur à un certain nombre. Configurez une condition de test avec la fonction @IF pour renvoyer le résultat de SALAIRE lorsqu'il fait partie de l'enregistrement en cours et dépasse 250000 , sinon renvoie NULL :

Dans cet exemple, la condition BASE_SALARY > 250000 est évaluée uniquement lorsque SALARY est présent dans l'enregistrement source et non nul. Si la présence de la colonne n'avait pas été testée en premier, la colonne n'aurait pas été mappée, car le résultat aurait été manquant.

Dans l'exemple suivant, 0 est renvoyé lorsque le champ AMT est manquant ou non valide, sinon AMT est renvoyé.


Opérateurs OLAP DML

Un opérateur est un symbole qui transforme une valeur ou la combine d'une manière ou d'une autre avec une autre valeur. Le Tableau 2-9, « Opérateurs OLAP DML » décrit les catégories d'opérateurs OLAP DML.

Tableau 2-9 Opérateurs DML OLAP

Opérateurs que vous pouvez utiliser dans des expressions numériques avec des données numériques pour produire un résultat numérique. Vous pouvez également utiliser des opérateurs arithmétiques dans les expressions de date avec un mélange de données de date et numériques, qui renvoient soit une date, soit un résultat numérique. Pour une liste des opérateurs arithmétiques, voir "Opérateurs arithmétiques". Pour plus d'informations sur les expressions numériques, voir "Expressions numériques"

Opérateurs que vous pouvez utiliser pour comparer deux valeurs du même type de base (numérique, texte, date ou, dans de rares cas, booléen), qui renvoie un résultat BOOLÉEN. Pour une liste des opérateurs de comparaison, voir "Comparaison et opérateurs logiques". Pour plus d'informations sur les expressions booléennes, consultez "Expressions booléennes".

Les opérateurs AND , OR et NOT que vous pouvez utiliser pour transformer des valeurs booléennes à l'aide d'opérations logiques, qui renvoient un résultat booléen. Pour obtenir une liste des opérateurs logiques, consultez "Comparaison et opérateurs logiques". Pour plus d'informations sur les expressions booléennes, consultez "Expressions booléennes".

Opérateur que vous utilisez pour affecter les résultats d'une expression à un objet ou pour affecter une valeur à une option OLAP DML. Pour plus d'informations sur l'utilisation des instructions d'affectation, consultez les commandes SET et SET1 et « Opérateur d'affectation ».

Le SI. ENSUITE. Les opérateurs ELSE , SWITCH et CASE que vous pouvez utiliser pour sélectionner des valeurs en fonction d'une condition. Pour plus d'informations, voir "Expressions conditionnelles".

L'opérateur & (esperluette) que vous pouvez utiliser pour évaluer une expression et substituer la valeur résultante. Pour plus d'informations, voir "Expressions de substitution".

Opérateurs arithmétiques

Le Tableau 2-10, « Opérateurs arithmétiques » présente les opérateurs arithmétiques OLAP DML, leurs opérations et leur priorité, où la priorité est l'ordre dans lequel cet opérateur est évalué. Les opérateurs de même priorité sont évalués de gauche à droite. Lorsque vous utilisez deux opérateurs ou plus dans une expression numérique, l'expression est évaluée selon les règles arithmétiques standard. Vous devez coder une virgule avant un nombre négatif qui suit une autre expression numérique, sinon le signe moins est interprété comme un opérateur de soustraction. Par exemple, intvar,-4

Tableau 2-10 Opérateurs arithmétiques

Comparaison et opérateurs logiques

Vous utilisez des opérateurs de comparaison et des opérateurs logiques pour créer des expressions de la même manière que les opérateurs arithmétiques. Chaque opérateur a une priorité qui détermine son ordre d'évaluation. Les opérateurs de priorité égale sont évalués de gauche à droite, à moins que les parenthèses ne modifient l'ordre d'évaluation. Cependant, l'évaluation est arrêtée lorsque la valeur de vérité est décidée.

Le Tableau 2-11, « Comparaison et opérateurs logiques » présente les opérateurs de comparaison et les opérateurs logiques OLAP DML ( AND , OR et NOT ). Il répertorie l'opérateur, les opérations, l'exemple et la priorité où la priorité est l'ordre dans lequel cet opérateur est évalué. Les opérateurs de même priorité sont évalués de gauche à droite.

Tableau 2-11 Comparaison et opérateurs logiques

Renvoie l'opposé de l'expression booléenne

Une date est-elle dans une période de temps ?

'1Jan02' DANS maDimension = OUI

Une valeur de texte correspond-elle à un modèle de texte spécifié ?

Les deux expressions sont vraies

L'une ou l'autre expression est vraie

Opérateur d'assignation

Dans le DML OLAP, comme dans de nombreux autres langages de programmation, le signe = (égal) est utilisé comme opérateur d'affectation.

Une expression crée des données temporaires, vous pouvez afficher les valeurs résultantes, mais ces valeurs ne sont pas automatiquement stockées dans votre espace de travail analytique pour référence future au cours d'une session. Vous utilisez une instruction d'affectation pour stocker le résultat d'une expression dans un objet qui a le même type de données et les mêmes dimensions que l'expression. Si vous mettez à jour et validez l'objet, les valeurs seront disponibles pour les sessions futures.

Comme d'autres langages de programmation, une instruction d'affectation dans le DML OLAP définit la valeur de l'expression cible égale aux résultats de l'expression source. Cependant, une instruction d'affectation OLAP DML ne fonctionne pas exactement comme dans d'autres langages de programmation. Comme beaucoup d'autres instructions OLAP DML, elle n'affecte pas de valeur à une seule cellule, à la place, lorsque l'expression cible est un objet multidimensionnel, Oracle OLAP parcourt les cellules de l'objet cible en définissant chacune sur les résultats de l'expression source. . De plus, vous pouvez utiliser UNRAVEL pour copier les valeurs d'une expression dans les cellules d'un objet cible lorsque les dimensions de l'expression sont différentes des dimensions de l'objet cible.

Pour plus d'informations sur l'utilisation des instructions d'affectation dans le DML OLAP, consultez SET et SET1.


Expression du calculateur de champ pour remplacer la chaîne uniquement si elle se produit - Systèmes d'information géographique

Si vous avez des besoins de correspondance de motifs qui vont au-delà de cela, envisagez d'écrire une fonction définie par l'utilisateur en Perl ou en Tcl.

Avertir

Alors que la plupart des recherches d'expressions régulières peuvent être exécutées très rapidement, des expressions régulières peuvent être inventées qui prennent des quantités arbitraires de temps et de mémoire à traiter. Méfiez-vous d'accepter des modèles de recherche d'expressions régulières provenant de sources hostiles. Si vous devez le faire, il est conseillé d'imposer un délai d'expiration de l'instruction.

Les recherches utilisant des modèles SIMILAR TO présentent les mêmes risques de sécurité, car SIMILAR TO fournit bon nombre des mêmes capacités que les expressions régulières de style POSIX.

Les recherches LIKE, étant beaucoup plus simples que les deux autres options, sont plus sûres à utiliser avec des sources de modèles potentiellement hostiles.

Les opérateurs de correspondance de modèle des trois types ne prennent pas en charge les classements non déterministes. Si nécessaire, appliquez un classement différent à l'expression pour contourner cette limitation.

9.7.1. AIMER

L'expression LIKE renvoie true si le chaîne de caractères correspond à celui fourni modèle . (Comme prévu, l'expression NOT LIKE renvoie false si LIKE renvoie true, et vice versa. Une expression équivalente est NOT ( chaîne de caractères AIMER modèle ) .)

Si modèle ne contient pas de signes de pourcentage ou de traits de soulignement, le motif ne représente que la chaîne elle-même, dans ce cas LIKE agit comme l'opérateur égal. Un trait de soulignement ( _ ) dans modèle représente (correspond à) n'importe quel caractère, un signe de pourcentage ( % ) correspond à n'importe quelle séquence de zéro ou plusieurs caractères.

La correspondance de motif LIKE couvre toujours la chaîne entière. Par conséquent, si l'on souhaite faire correspondre une séquence n'importe où dans une chaîne, le modèle doit commencer et se terminer par un signe de pourcentage.

Pour faire correspondre un trait de soulignement littéral ou un signe de pourcentage sans correspondre à d'autres caractères, le caractère respectif dans modèle doit être précédé du caractère d'échappement. Le caractère d'échappement par défaut est la barre oblique inverse, mais un autre peut être sélectionné à l'aide de la clause ESCAPE. Pour faire correspondre le caractère d'échappement lui-même, écrivez deux caractères d'échappement.

Si vous avez désactivé standard_conforming_strings, toutes les barres obliques inverses que vous écrivez dans les constantes de chaîne littérales devront être doublées. Voir la section 4.1.2.1 pour plus d'informations.

Il est également possible de ne sélectionner aucun caractère d'échappement en écrivant ESCAPE '' . Cela désactive efficacement le mécanisme d'échappement, ce qui rend impossible la désactivation de la signification particulière des signes de soulignement et de pourcentage dans le motif.

Selon la norme SQL, omettre ESCAPE signifie qu'il n'y a pas de caractère d'échappement (plutôt que d'utiliser par défaut une barre oblique inverse), et une valeur ESCAPE de longueur nulle est interdite. Le comportement de PostgreSQL à cet égard est donc légèrement non standard.

Le mot clé ILIKE peut être utilisé à la place de LIKE pour rendre la correspondance insensible à la casse en fonction de la locale active. Ce n'est pas dans le standard SQL mais c'est une extension PostgreSQL.

est équivalent à LIKE , et

* correspond à ILIKE . Il y a aussi !

* opérateurs qui représentent NOT LIKE et NOT ILIKE , respectivement. Tous ces opérateurs sont spécifiques à PostgreSQL. Vous pouvez voir ces noms d'opérateur dans la sortie EXPLAIN et dans des endroits similaires, car l'analyseur traduit en fait LIKE et al. à ces opérateurs.

Les expressions LIKE , ILIKE , NOT LIKE et NOT ILIKE sont généralement traitées comme des opérateurs dans la syntaxe PostgreSQL, par exemple elles peuvent être utilisées dans expression opérateur TOUT ( sous-requête ), bien qu'une clause ESCAPE ne puisse pas y être incluse. Dans certains cas obscurs, il peut être nécessaire d'utiliser à la place les noms d'opérateur sous-jacents.

Voir également l'opérateur de préfixe ^@ et la fonction start_with correspondante, qui sont utiles dans les cas où la simple correspondance du début d'une chaîne est nécessaire.

9.7.2. SIMILAIRE AUX Expressions Régulières

L'opérateur SIMILAR TO renvoie vrai ou faux selon que son modèle correspond à la chaîne donnée. Il est similaire à LIKE , sauf qu'il interprète le modèle en utilisant la définition du standard SQL d'une expression régulière. Les expressions régulières SQL sont un curieux croisement entre la notation LIKE et la notation d'expression régulière commune (POSIX).

Comme LIKE , l'opérateur SIMILAR TO ne réussit que si son motif correspond à la chaîne entière, contrairement au comportement courant des expressions régulières où le motif peut correspondre à n'importe quelle partie de la chaîne. Tout comme LIKE , SIMILAR TO utilise _ et % comme caractères génériques désignant respectivement n'importe quel caractère unique et n'importe quelle chaîne (ceux-ci sont comparables à . et .* dans les expressions régulières POSIX).

En plus de ces fonctionnalités empruntées à LIKE , SIMILAR TO prend en charge ces métacaractères de correspondance de modèles empruntés aux expressions régulières POSIX :

| désigne l'alternance (l'une des deux alternatives).

* indique la répétition de l'élément précédent zéro ou plusieurs fois.

+ indique la répétition de l'élément précédent une ou plusieurs fois.

? indique la répétition de l'élément précédent zéro ou une fois.

< m > indique exactement la répétition de l'élément précédent m fois.

< m ,> indique la répétition de l'élément précédent m ou plusieurs fois.

< m , m > indique la répétition de l'élément précédent au moins m et pas plus de m fois.

Les parenthèses () peuvent être utilisées pour regrouper des éléments en un seul élément logique.

Une expression entre crochets [. ] spécifie une classe de caractères, tout comme dans les expressions régulières POSIX.

Notez que le point ( . ) n'est pas un métacaractère pour SIMILAR TO .

Comme avec LIKE , une barre oblique inverse désactive la signification spéciale de l'un de ces métacaractères. Un caractère d'échappement différent peut être spécifié avec ESCAPE , ou la capacité d'échappement peut être désactivée en écrivant ESCAPE '' .

Selon la norme SQL, omettre ESCAPE signifie qu'il n'y a pas de caractère d'échappement (plutôt que d'utiliser par défaut une barre oblique inverse), et une valeur ESCAPE de longueur nulle est interdite. Le comportement de PostgreSQL à cet égard est donc légèrement non standard.

Une autre extension non standard est que suivre le caractère d'échappement avec une lettre ou un chiffre donne accès aux séquences d'échappement définies pour les expressions régulières POSIX voir Tableau 9.20, Tableau 9.21 et Tableau 9.22 ci-dessous.

La fonction substring avec trois paramètres fournit l'extraction d'une sous-chaîne qui correspond à un modèle d'expression régulière SQL. La fonction peut être écrite selon la syntaxe SQL99 :

ou comme une simple fonction à trois arguments :

Comme avec SIMILAR TO , le modèle spécifié doit correspondre à l'intégralité de la chaîne de données, sinon la fonction échoue et renvoie null. Pour indiquer la partie du motif pour laquelle la sous-chaîne de données correspondante est intéressante, le motif doit contenir deux occurrences du caractère d'échappement suivies d'un guillemet double ( " ). Le texte correspondant à la partie du motif entre ces séparateurs est renvoyé lorsque le match est réussi.

Les séparateurs escape-double-quote divisent en fait le motif de la sous-chaîne en trois expressions régulières indépendantes, par exemple, une barre verticale ( | ) dans l'une des trois sections n'affecte que cette section. De plus, la première et la troisième de ces expressions régulières sont définies pour correspondre à la plus petite quantité de texte possible, et non à la plus grande, lorsqu'il existe une ambiguïté sur la quantité de chaîne de données correspondant à quel modèle. (Dans le langage POSIX, les première et troisième expressions régulières sont forcées d'être non gourmandes.)

En tant qu'extension de la norme SQL, PostgreSQL permet d'avoir un seul séparateur d'échappement-guillemets doubles, auquel cas la troisième expression régulière est considérée comme vide ou aucun séparateur, auquel cas les première et troisième expressions régulières sont considérées comme vides .

Quelques exemples, avec #" délimitant la chaîne de retour :

9.7.3. Expressions régulières POSIX

Le tableau 9.16 répertorie les opérateurs disponibles pour la correspondance de modèle à l'aide d'expressions régulières POSIX.

Tableau 9.16. Opérateurs de correspondance d'expressions régulières

La chaîne correspond à l'expression régulière, en tenant compte de la casse

La chaîne correspond à l'expression régulière, sans tenir compte de la casse

La chaîne ne correspond pas à l'expression régulière, respecte la casse

La chaîne ne correspond pas à l'expression régulière, insensible à la casse

Une expression régulière est une séquence de caractères qui est une définition abrégée d'un ensemble de chaînes (un ensemble régulier). On dit qu'une chaîne correspond à une expression régulière si elle est membre de l'ensemble régulier décrit par l'expression régulière. Comme avec LIKE , les caractères de modèle correspondent exactement aux caractères de chaîne à moins qu'il ne s'agisse de caractères spéciaux dans le langage des expressions régulières — mais les expressions régulières utilisent des caractères spéciaux différents de ceux de LIKE. Contrairement aux modèles LIKE, une expression régulière est autorisée à correspondre n'importe où dans une chaîne, à moins que l'expression régulière ne soit explicitement ancrée au début ou à la fin de la chaîne.

La fonction substring avec deux paramètres, substring( chaîne de caractères de modèle ) , fournit l'extraction d'une sous-chaîne qui correspond à un modèle d'expression régulière POSIX. Il renvoie null s'il n'y a pas de correspondance, sinon la partie du texte qui correspond au modèle. Mais si le modèle contient des parenthèses, la partie du texte qui correspond à la première sous-expression entre parenthèses (celle dont la parenthèse gauche vient en premier) est renvoyée. Vous pouvez mettre des parenthèses autour de l'expression entière si vous souhaitez utiliser des parenthèses à l'intérieur sans déclencher cette exception. Si vous avez besoin de parenthèses dans le modèle avant la sous-expression que vous souhaitez extraire, consultez les parenthèses sans capture décrites ci-dessous.

La fonction regexp_replace fournit une substitution de nouveau texte pour les sous-chaînes qui correspondent aux modèles d'expressions régulières POSIX. Il a la syntaxe regexp_replace ( la source , modèle , remplacement [ , drapeaux ]). Le la source la chaîne est retournée inchangée s'il n'y a pas de correspondance avec le modèle . S'il y a correspondance, le la source la chaîne est renvoyée avec le remplacement chaîne substituée à la sous-chaîne correspondante. Le remplacement la chaîne peut contenir m , où m est compris entre 1 et 9, pour indiquer que la sous-chaîne source correspondant à la m La 'ième sous-expression entre parenthèses du motif doit être insérée et elle peut contenir & pour indiquer que la sous-chaîne correspondant au motif entier doit être insérée. Écrivez si vous devez mettre une barre oblique inverse littérale dans le texte de remplacement. Le drapeaux Le paramètre est une chaîne de texte facultative contenant zéro ou plusieurs indicateurs à une seule lettre qui modifient le comportement de la fonction. L'indicateur i spécifie une correspondance insensible à la casse, tandis que l'indicateur g spécifie le remplacement de chaque sous-chaîne correspondante plutôt que la première. Les indicateurs pris en charge (mais pas g ) sont décrits dans le tableau 9.24.

La fonction regexp_match renvoie un tableau de texte de sous-chaînes capturées résultant de la première correspondance d'un modèle d'expression régulière POSIX avec une chaîne. Il a la syntaxe regexp_match ( chaîne de caractères , modèle [ , drapeaux ]). S'il n'y a pas de correspondance, le résultat est NULL . Si une correspondance est trouvée et que le modèle ne contient aucune sous-expression entre parenthèses, le résultat est un tableau de texte à un seul élément contenant la sous-chaîne correspondant à l'ensemble du motif. Si une correspondance est trouvée et que le modèle contient des sous-expressions entre parenthèses, le résultat est un tableau de texte dont m 'ème élément est la sous-chaîne correspondant au m 'ème sous-expression entre parenthèses de la modèle (sans compter les parenthèses « non-capturantes », voir ci-dessous pour plus de détails). Le drapeaux Le paramètre est une chaîne de texte facultative contenant zéro ou plusieurs indicateurs à une seule lettre qui modifient le comportement de la fonction. Les indicateurs pris en charge sont décrits dans le Tableau 9.24.

Dans le cas courant où vous voulez juste toute la sous-chaîne correspondante ou NULL pour aucune correspondance, écrivez quelque chose comme

La fonction regexp_matches renvoie un ensemble de tableaux de texte de sous-chaînes capturées résultant de la correspondance d'un modèle d'expression régulière POSIX avec une chaîne. Il a la même syntaxe que regexp_match . Cette fonction ne renvoie aucune ligne s'il n'y a pas de correspondance, une ligne s'il y a une correspondance et que l'indicateur g n'est pas donné, ou N lignes s'il y a N correspond et le drapeau g est donné. Chaque ligne renvoyée est un tableau de texte contenant toute la sous-chaîne correspondante ou les sous-chaînes correspondant aux sous-expressions entre parenthèses du modèle , comme décrit ci-dessus pour regexp_match . regexp_matches accepte tous les drapeaux montrés dans le Tableau 9.24, plus le drapeau g qui lui commande de renvoyer toutes les correspondances, pas seulement la première.

Dans la plupart des cas, regexp_matches() doit être utilisé avec le drapeau g, car si vous ne voulez que la première correspondance, il est plus facile et plus efficace d'utiliser regexp_match() . Cependant, regexp_match() n'existe que dans PostgreSQL version 10 et supérieure. Lorsque vous travaillez dans des versions plus anciennes, une astuce courante consiste à placer un appel regexp_matches() dans une sous-sélection, par exemple :

Cela produit un tableau de texte s'il y a une correspondance, ou NULL sinon, comme le ferait regexp_match(). Sans la sous-sélection, cette requête ne produirait aucune sortie pour les lignes du tableau sans correspondance, ce qui n'est généralement pas le comportement souhaité.

La fonction regexp_split_to_table divise une chaîne en utilisant un modèle d'expression régulière POSIX comme délimiteur. Il a la syntaxe regexp_split_to_table ( chaîne de caractères , modèle [ , drapeaux ]). S'il n'y a pas de correspondance avec le modèle , la fonction renvoie le chaîne de caractères . S'il y a au moins une correspondance, pour chaque correspondance, il renvoie le texte de la fin de la dernière correspondance (ou du début de la chaîne) au début de la correspondance. Lorsqu'il n'y a plus de correspondance, il renvoie le texte de la fin de la dernière correspondance à la fin de la chaîne. Le drapeaux Le paramètre est une chaîne de texte facultative contenant zéro ou plusieurs indicateurs à une seule lettre qui modifient le comportement de la fonction. regexp_split_to_table prend en charge les indicateurs décrits dans le tableau 9.24.

La fonction regexp_split_to_array se comporte de la même manière que regexp_split_to_table, sauf que regexp_split_to_array renvoie son résultat sous forme de tableau de texte. Il a la syntaxe regexp_split_to_array ( chaîne de caractères , modèle [ , drapeaux ]). Les paramètres sont les mêmes que pour regexp_split_to_table .

Comme le montre le dernier exemple, les fonctions de division d'expression régulière ignorent les correspondances de longueur nulle qui se produisent au début ou à la fin de la chaîne ou immédiatement après une correspondance précédente. Ceci est contraire à la définition stricte de la correspondance d'expressions rationnelles qui est implémentée par regexp_match et regexp_matches , mais c'est généralement le comportement le plus pratique en pratique. D'autres systèmes logiciels tels que Perl utilisent des définitions similaires.

9.7.3.1. Détails des expressions régulières

Les expressions régulières de PostgreSQL sont implémentées à l'aide d'un progiciel écrit par Henry Spencer. Une grande partie de la description des expressions régulières ci-dessous est copiée textuellement de son manuel.

PostgreSQL suppose toujours au départ qu'une expression régulière suit les règles ARE. Cependant, les règles ERE ou BRE plus limitées peuvent être choisies en ajoutant un option intégrée au modèle RE, comme décrit à la section 9.7.3.4. Cela peut être utile pour la compatibilité avec les applications qui attendent exactement les règles POSIX 1003.2.

Une expression régulière est définie comme un ou plusieurs branches, séparés par | . Il correspond à tout ce qui correspond à l'une des branches.

Une branche vaut zéro ou plus atomes quantifiés ou alors contraintes, concaténé. Il correspond à une correspondance pour le premier, suivi d'une correspondance pour le second, etc. une branche vide correspond à la chaîne vide.

Un atome quantifié est un atome éventuellement suivi d'un seul quantificateur. Sans quantificateur, il correspond à une correspondance pour l'atome. Avec un quantificateur, il peut correspondre à un certain nombre de correspondances de l'atome. Une atome peut être l'une des possibilités présentées dans le tableau 9.17. Les quantificateurs possibles et leurs significations sont indiqués dans le tableau 9.18.

UNE contrainte correspond à une chaîne vide, mais correspond uniquement lorsque des conditions spécifiques sont remplies. Une contrainte peut être utilisée lorsqu'un atome pourrait être utilisé, sauf qu'il ne peut pas être suivi d'un quantificateur. Les contraintes simples sont présentées dans le tableau 9.19. D'autres contraintes sont décrites plus loin.

Tableau 9.17. Atomes d'expression régulière

Atome La description
( ) (où est une expression régulière) correspond à une correspondance pour , avec la correspondance notée pour un éventuel rapport
(?: ) comme ci-dessus, mais la correspondance n'est pas notée pour le rapport (un ensemble de parenthèses « non-capturantes ») (ARE uniquement)
. correspond à n'importe quel caractère
[ caractères ] une expression de parenthèse, correspondant à l'un des caractères (voir Section 9.7.3.2 pour plus de détails)
k (où k est un caractère non alphanumérique) correspond à ce caractère pris comme un caractère ordinaire, par exemple, correspond à une barre oblique inverse
c c est alphanumérique (éventuellement suivi d'autres caractères) est un échapper, voir la section 9.7.3.3 (ARE uniquement dans les ERE et les BRE, cela correspond c )
< lorsqu'il est suivi d'un caractère autre qu'un chiffre, correspond à l'accolade gauche < lorsqu'il est suivi d'un chiffre, c'est le début d'un bondir (voir ci-dessous)
X X est un caractère unique sans autre signification, correspond à ce caractère

Un RE ne peut pas se terminer par une barre oblique inverse ( ).

Si vous avez désactivé standard_conforming_strings, toutes les barres obliques inverses que vous écrivez dans les constantes de chaîne littérales devront être doublées. Voir la section 4.1.2.1 pour plus d'informations.

Tableau 9.18. Quantificateurs d'expressions régulières

Quantificateur Allumettes
* une séquence de 0 ou plusieurs correspondances de l'atome
+ une séquence de 1 ou plusieurs correspondances de l'atome
? une séquence de 0 ou 1 correspondances de l'atome
< m > une séquence d'exactement m matchs de l'atome
< m ,> une séquence de m ou plusieurs correspondances de l'atome
< m , m > une séquence de m par m correspondances (incluses) de l'atome m ne peut pas dépasser m
*? version non gourmande de *
+? version non gourmande de +
?? version non gourmande de ?
< m >? version non gourmande de < m >
< m ,>? version non gourmande de < m ,>
< m , m >? version non gourmande de < m , m >

Les formulaires utilisant < . > sont connus comme bornes. Les nombres m et m dans une limite se trouvent des entiers décimaux non signés avec des valeurs admissibles de 0 à 255 inclus.

Non gourmand quantificateurs (disponibles dans les ARE uniquement) correspondent aux mêmes possibilités que leur normale correspondante (cupide), mais préfèrent le plus petit nombre plutôt que le plus grand nombre de correspondances. Voir la section 9.7.3.5 pour plus de détails.

Un quantificateur ne peut pas suivre immédiatement un autre quantificateur, par exemple, ** n'est pas valide. Un quantificateur ne peut pas commencer une expression ou une sous-expression ou suivre ^ ou | .

Tableau 9.19. Contraintes d'expression régulière

Contrainte La description
^ correspond au début de la chaîne
$ correspond à la fin de la chaîne
(?= ) anticipation positive correspond à tout point où une sous-chaîne correspondant commence (ARE uniquement)
(?! ) prévision négative correspond à tout moment où aucune correspondance de sous-chaîne commence (ARE uniquement)
(?<= ) regard en arrière positif correspond à tout point où une sous-chaîne correspondant se termine (ARE uniquement)
(?<! ) rétrospective négative correspond à tout point où aucune correspondance de sous-chaîne se termine (ARE uniquement)

Les contraintes d'anticipation et d'anticipation ne peuvent pas contenir références arrière (voir Section 9.7.3.3), et toutes les parenthèses qu'elles contiennent sont considérées comme non capturantes.

9.7.3.2. Expressions entre parenthèses

UNE expression de parenthèse est une liste de caractères entre [] . Il correspond normalement à n'importe quel caractère de la liste (mais voir ci-dessous). Si la liste commence par ^ , elle correspond à n'importe quel caractère ne pas du reste de la liste. Si deux caractères de la liste sont séparés par - , il s'agit d'un raccourci pour la plage complète de caractères entre ces deux (inclus) dans la séquence de classement, par exemple, [0-9] en ASCII correspond à n'importe quel chiffre décimal. Il est illégal pour deux plages de partager un point de terminaison, par exemple, a-c-e . Les plages sont très dépendantes de la séquence de classement, les programmes portables doivent donc éviter de s'y fier.

Pour inclure un littéral ] dans la liste, faites-en le premier caractère (après ^ , s'il est utilisé). Pour inclure un littéral - , faites-en le premier ou le dernier caractère, ou le deuxième point de terminaison d'une plage. Pour utiliser un littéral - comme premier point de terminaison d'une plage, placez-le dans [. et .] pour en faire un élément de collationnement (voir ci-dessous). À l'exception de ces caractères, de certaines combinaisons utilisant [ (voir les paragraphes suivants) et d'échappements (ARE uniquement), tous les autres caractères spéciaux perdent leur signification particulière dans une expression entre crochets. En particulier, n'est pas spécial lorsque l'on suit les règles ERE ou BRE, bien qu'il soit spécial (en introduisant un échappement) dans les ARE.

Dans une expression entre crochets, un élément de classement (un caractère, une séquence de plusieurs caractères qui s'assemble comme s'il s'agissait d'un seul caractère, ou un nom de séquence de classement pour l'un ou l'autre) entouré de [. et .] représente la séquence de caractères de cet élément de classement. La séquence est traitée comme un élément unique de la liste des expressions entre crochets. Cela permet à une expression entre crochets contenant un élément de classement à plusieurs caractères de correspondre à plus d'un caractère, par exemple, si la séquence de classement comprend un élément de classement ch, alors le RE [[.ch.]]*c correspond aux cinq premiers caractères de chchcc .

PostgreSQL ne prend actuellement pas en charge les éléments de classement multi-caractères. Ces informations décrivent un comportement futur possible.

Dans une expression entre crochets, un élément de classement entre [= et =] est un classe d'équivalence, représentant les séquences de caractères de tous les éléments de collation équivalents à celui-ci, y compris lui-même. (S'il n'y a pas d'autres éléments de classement équivalents, le traitement est comme si les délimiteurs englobants étaient [. et .] .) Par exemple, si o et ^ sont les membres d'une classe d'équivalence, alors [[=o=]] , [[=^=]] , et [o^] sont tous synonymes. Une classe d'équivalence ne peut pas être le point de terminaison d'une plage.

Dans une expression entre crochets, le nom d'une classe de caractères entre [: et :] représente la liste de tous les caractères appartenant à cette classe. Une classe de caractères ne peut pas être utilisée comme point de terminaison d'une plage. La norme POSIX définit ces noms de classes de caractères : alnum (lettres et chiffres numériques), alpha (lettres), blank (espace et tabulation), cntrl (caractères de contrôle), digit (chiffres numériques), graph (caractères imprimables sauf espace), lower (lettres minuscules), print (caractères imprimables, y compris l'espace), ponctuation (ponctuation), espace (tout espace blanc), majuscule (lettres majuscules) et xdigit (chiffres hexadécimaux). Le comportement de ces classes de caractères standard est généralement cohérent sur toutes les plates-formes pour les caractères de l'ensemble ASCII 7 bits. Le fait qu'un caractère non ASCII donné soit considéré comme appartenant à l'une de ces classes dépend de la collation qui est utilisé pour la fonction ou l'opérateur d'expression régulière (voir Section 23.2), ou par défaut sur le paramètre de locale LC_CTYPE de la base de données (voir Section 23.1). La classification des caractères non ASCII peut varier d'une plate-forme à l'autre, même dans des paramètres régionaux portant le même nom. (Mais la locale C ne considère jamais les caractères non ASCII comme appartenant à l'une de ces classes.) En plus de ces classes de caractères standard, PostgreSQL™ définit la classe de caractères ASCII, qui contient exactement l'ensemble ASCII 7 bits.

Il existe deux cas particuliers d'expressions entre crochets : les expressions entre crochets [[:<:]] et [[:>:]] sont des contraintes, correspondant à des chaînes vides au début et à la fin d'un mot respectivement.Un mot est défini comme une séquence de caractères de mot qui n'est ni précédée ni suivie de caractères de mot. Un caractère de mot est un caractère alnum (tel que défini par la classe de caractères POSIX décrite ci-dessus) ou un trait de soulignement. Il s'agit d'une extension compatible mais non spécifiée par POSIX 1003.2 et doit être utilisée avec prudence dans les logiciels destinés à être portables vers d'autres systèmes. Les échappements de contraintes décrits ci-dessous sont généralement préférables, ils ne sont plus standard, mais sont plus faciles à saisir.

9.7.3.3. Échappements d'expressions régulières

Evasions sont des séquences spéciales commençant par suivi d'un caractère alphanumérique. Les échappements se présentent sous plusieurs formes : saisie de caractères, raccourcis de classe, échappements de contrainte et références arrière. Un suivi d'un caractère alphanumérique mais ne constituant pas un échappement valide est illégal dans les ARE. Dans les ERE, il n'y a pas d'échappement : en dehors d'une expression entre crochets, un suivi d'un caractère alphanumérique représente simplement ce caractère en tant que caractère ordinaire, et à l'intérieur d'une expression entre crochets, est un caractère ordinaire. (Ce dernier est la seule incompatibilité réelle entre les ERE et les ARE.)

Echappements de caractères existent pour faciliter la spécification des caractères non imprimables et autres caractères gênants dans les RE. Ils sont présentés dans le tableau 9.20.

Les évasions abrégées de classe fournissent des raccourcis pour certaines classes de caractères couramment utilisées. Ils sont présentés dans le tableau 9.21.

UNE échappement de contrainte est une contrainte, correspondant à la chaîne vide si des conditions spécifiques sont remplies, écrite sous forme d'échappement. Ils sont présentés dans le tableau 9.22.

UNE référence arrière ( m ) correspond à la même chaîne qui correspond à la sous-expression précédente entre parenthèses spécifiée par le nombre m (voir tableau 9.23). Par exemple, ([bc])1 correspond à bb ou cc mais pas à bc ou cb . La sous-expression doit précéder entièrement la référence arrière dans le RE. Les sous-expressions sont numérotées dans l'ordre de leurs parenthèses initiales. Les parenthèses non capturantes ne définissent pas de sous-expressions.

Tableau 9.20. Échappements de saisie de caractères d'expression régulière

Échapper La description
une caractère d'alerte (cloche), comme dans C
 retour arrière, comme en C
B synonyme de barre oblique inverse ( ) pour aider à réduire le besoin de doubler la barre oblique inverse
c X (où X est un caractère quelconque) le caractère dont les 5 bits de poids faible sont les mêmes que ceux de X , et dont les autres bits sont tous à zéro
e le caractère dont le nom de la séquence de classement est ESC , ou à défaut, le caractère de valeur octale 033
F saut de page, comme en C
nouvelle ligne, comme en C
retour chariot, comme en C
tabulation horizontale, comme en C
u wxyz (où wxyz est exactement quatre chiffres hexadécimaux) le caractère dont la valeur hexadécimale est 0x wxyz
U stuvwxyz (où stuvwxyz est exactement huit chiffres hexadécimaux) le caractère dont la valeur hexadécimale est 0x stuvwxyz
v tabulation verticale, comme en C
X hhh (où hhh est une séquence de chiffres hexadécimaux) le caractère dont la valeur hexadécimale est 0x hhh (un seul caractère quel que soit le nombre de chiffres hexadécimaux utilisés)
le caractère dont la valeur est 0 (l'octet nul)
xy (où xy est exactement deux chiffres octaux, et n'est pas un référence arrière) le caractère dont la valeur octale est 0 xy
xyz (où xyz est exactement trois chiffres octaux, et n'est pas un référence arrière) le caractère dont la valeur octale est 0 xyz

Les chiffres hexadécimaux sont 0-9, a-f et A-F. Les chiffres octaux sont de 0 à 7 .

Les échappements de caractères numériques spécifiant des valeurs en dehors de la plage ASCII (0-127) ont des significations dépendantes de l'encodage de la base de données. Lorsque l'encodage est UTF-8, les valeurs d'échappement sont équivalentes aux points de code Unicode, par exemple u1234 signifie le caractère U+1234 . Pour les autres codages multi-octets, les échappements de saisie de caractère spécifient généralement simplement la concaténation des valeurs d'octet pour le caractère. Si la valeur d'échappement ne correspond à aucun caractère légal dans l'encodage de la base de données, aucune erreur ne sera générée, mais elle ne correspondra à aucune donnée.

Les échappements de saisie de caractères sont toujours considérés comme des caractères ordinaires. Par exemple, 135 est ] en ASCII, mais 135 ne termine pas une expression entre crochets.

Tableau 9.21. Escapes de classe d'expression régulière

Échapper La description
é [[:chiffre:]]
s [[:espace:]]
w [[:alnum:]_] (notez que le trait de soulignement est inclus)
[^[:chiffre:]]
S [^[:espace:]]
W [^[:alnum:]_] (notez que le trait de soulignement est inclus)

Dans les expressions entre crochets, d , s et w perdent leurs crochets externes et D , S et W sont illégaux. (Donc, par exemple, [a-cd] est équivalent à [a-c[:digit:]] . De plus, [a-cD] , qui est équivalent à [a-c^[:digit:]] , est illégal.)

Tableau 9.22. Échappements de contrainte d'expression régulière

Échapper La description
UNE correspond uniquement au début de la chaîne (voir la section 9.7.3.5 pour savoir en quoi cela diffère de ^ )
m ne correspond qu'au début d'un mot
M ne correspond qu'à la fin d'un mot
y ne correspond qu'au début ou à la fin d'un mot
A correspond uniquement à un point qui n'est ni le début ni la fin d'un mot
 correspond uniquement à la fin de la chaîne (voir la section 9.7.3.5 pour savoir en quoi cela diffère de $ )

Un mot est défini comme dans la spécification de [[:<:]] et [[:>:]] ci-dessus. Les échappements de contrainte sont illégaux dans les expressions entre crochets.

Tableau 9.23. Références d'expressions régulières

Échapper La description
m (où m est un chiffre différent de zéro) une référence arrière au m 'ème sous-expression
mnn (où m est un chiffre différent de zéro, et nn est un peu plus de chiffres, et la valeur décimale mnn n'est pas supérieur au nombre de parenthèses de capture fermantes vues jusqu'à présent) une référence arrière au mnn 'ème sous-expression

Il existe une ambiguïté inhérente entre les échappements de saisie de caractères octaux et les références arrière, qui est résolue par les heuristiques suivantes, comme indiqué ci-dessus. Un zéro non significatif indique toujours un échappement octal. Un seul chiffre différent de zéro, non suivi d'un autre chiffre, est toujours pris comme référence arrière. Une séquence à plusieurs chiffres ne commençant pas par un zéro est considérée comme une référence arrière si elle vient après une sous-expression appropriée (c'est-à-dire que le nombre est dans la plage légale pour une référence arrière), et sinon est considérée comme octale.

9.7.3.4. Métasyntaxe d'expression régulière

En plus de la syntaxe principale décrite ci-dessus, il existe des formes spéciales et diverses facilités syntaxiques disponibles.

Un RE peut commencer par l'un des deux réalisateur préfixes. Si un RE commence par *** : , le reste du RE est considéré comme un ARE. (Cela n'a normalement aucun effet dans PostgreSQL , puisque les RE sont supposés être des ARE mais cela a un effet si le mode ERE ou BRE avait été spécifié par le drapeaux paramètre à une fonction regex.) Si un RE commence par ***= , le reste du RE est considéré comme une chaîne littérale, tous les caractères étant considérés comme des caractères ordinaires.

Une ARE peut commencer par options intégrées: une séquence (? xyz ) (où xyz est un ou plusieurs caractères alphabétiques) spécifie les options affectant le reste de l'ER. Ces options remplacent toutes les options précédemment déterminées - en particulier, elles peuvent remplacer le comportement de sensibilité à la casse impliqué par un opérateur regex, ou le drapeaux paramètre à une fonction regex. Les lettres d'option disponibles sont indiquées dans le Tableau 9.24. Notez que ces mêmes lettres d'option sont utilisées dans le drapeaux paramètres des fonctions regex.

Tableau 9.24. SONT les lettres d'options intégrées

Option La description
b le reste de RE est un BRE
c correspondance sensible à la casse (remplace le type d'opérateur)
e le reste de RE est un ERE
je correspondance insensible à la casse (voir Section 9.7.3.5) (remplace le type d'opérateur)
m synonyme historique de n
m correspondance sensible au saut de ligne (voir la section 9.7.3.5)
p correspondance partielle sensible au saut de ligne (voir la section 9.7.3.5)
q le reste de RE est une chaîne littérale ( " entre guillemets " ), tous les caractères ordinaires
s correspondance non sensible au saut de ligne (par défaut)
t syntaxe serrée (par défaut voir ci-dessous)
w correspondance partielle inverse sensible au saut de ligne ( « bizarre » ) (voir la section 9.7.3.5)
X syntaxe étendue (voir ci-dessous)

Les options intégrées prennent effet à la fin de la séquence. Ils ne peuvent apparaître qu'au début d'un ARE (après le *** : réalisateur s'il y en a un).

En plus de l'habituel (serré) Syntaxe RE, dans laquelle tous les caractères sont significatifs, il existe une étendu syntaxe, disponible en spécifiant l'option x intégrée. Dans la syntaxe étendue, les espaces blancs dans le RE sont ignorés, de même que tous les caractères entre un # et la nouvelle ligne suivante (ou la fin du RE). Cela permet de paragraphes et de commenter une RE complexe. Il existe trois exceptions à cette règle de base :

un caractère espace blanc ou # précédé de est conservé

l'espace blanc ou le # dans une expression entre crochets est conservé

les espaces blancs et les commentaires ne peuvent pas apparaître dans les symboles à plusieurs caractères, tels que (? :

À cette fin, les espaces blancs sont les blancs, les tabulations, les sauts de ligne et tout caractère appartenant au espace classe de caractères.

Enfin, dans un ARE, en dehors des expressions entre crochets, la séquence (?# tt ) (où tt est tout texte ne contenant pas de ) ) est un commentaire, complètement ignoré. Encore une fois, cela n'est pas autorisé entre les caractères des symboles à plusieurs caractères, comme (?: . De tels commentaires sont plus un artefact historique qu'une fonctionnalité utile, et leur utilisation est déconseillée, utilisez plutôt la syntaxe étendue.

Rien de ces extensions de métasyntaxe est disponible si un directeur ***= initial a spécifié que l'entrée de l'utilisateur doit être traitée comme une chaîne littérale plutôt que comme un RE.

9.7.3.5. Règles de correspondance des expressions régulières

Dans le cas où un RE pourrait correspondre à plus d'une sous-chaîne d'une chaîne donnée, le RE correspond à celui commençant le plus tôt dans la chaîne. Si le RE peut correspondre à plus d'une sous-chaîne à partir de ce point, la correspondance la plus longue possible ou la correspondance la plus courte possible sera prise, selon que le RE est cupide ou alors non gourmand.

Qu'un RE soit gourmand ou non est déterminé par les règles suivantes :

La plupart des atomes, et toutes les contraintes, n'ont pas d'attribut de gourmandise (parce qu'ils ne peuvent de toute façon pas correspondre à des quantités variables de texte).

Ajouter des parenthèses autour d'un RE ne change pas sa gourmandise.

Un atome quantifié avec un quantificateur à répétition fixe ( < m > ou < m > ? ) a la même gourmandise (éventuellement aucune) que l'atome lui-même.

Un atome quantifié avec d'autres quantificateurs normaux (y compris < m , m > avec m égal à m ) est gourmand (préfère la correspondance la plus longue).

Un atome quantifié avec un quantificateur non gourmand (incluant < m , m > ? avec m égal à m ) n'est pas gourmand (préfère la correspondance la plus courte).

Une branche, c'est-à-dire une RE qui n'a pas de | opérateur — a la même gourmandise que le premier atome quantifié qui a un attribut de gourmandise.

Une ER constituée de deux ou plusieurs branches reliées par le | l'opérateur est toujours gourmand.

Les règles ci-dessus associent les attributs de gourmandise non seulement aux atomes quantifiés individuels, mais aussi aux branches et aux ER entiers qui contiennent des atomes quantifiés. Cela signifie que la correspondance est effectuée de manière à ce que la branche, ou l'ensemble de l'ER, corresponde à la sous-chaîne la plus longue ou la plus courte possible dans son ensemble . Une fois la longueur de la correspondance entière déterminée, la partie de celle-ci qui correspond à une sous-expression particulière est déterminée sur la base de l'attribut de gourmandise de cette sous-expression, les sous-expressions commençant plus tôt dans l'ER ayant la priorité sur celles commençant plus tard.

Un exemple de ce que cela signifie :

Dans le premier cas, l'ER dans son ensemble est gourmand car Y* est gourmand. Il peut correspondre à partir du Y , et il correspond à la chaîne la plus longue possible commençant là, c'est-à-dire Y123 . La sortie est la partie entre parenthèses de cela, ou 123 . Dans le second cas, l'ER dans son ensemble est non gourmand car Y*? est non gourmand. Il peut correspondre à partir du Y , et il correspond à la chaîne la plus courte possible commençant là, c'est-à-dire Y1 . La sous-expression [0-9] <1,3> est gourmande mais elle ne peut pas changer la décision quant à la longueur globale de la correspondance, elle est donc forcée de ne correspondre qu'à 1 .

En bref, lorsqu'un RE contient à la fois des sous-expressions gourmandes et non gourmandes, la longueur totale de la correspondance est soit la plus longue possible, soit la plus courte possible, selon l'attribut attribué à l'ensemble RE. Les attributs attribués aux sous-expressions n'affectent que la quantité de cette correspondance qu'elles sont autorisées à « manger » les unes par rapport aux autres.

Les quantificateurs <1,1>et <1,1> ? peut être utilisé pour forcer l'avidité ou la non-avidité, respectivement, sur une sous-expression ou un RE entier. Ceci est utile lorsque vous avez besoin que l'ensemble de l'ER ait un attribut de gourmandise différent de ce qui est déduit de ses éléments. Par exemple, supposons que nous essayons de séparer une chaîne contenant des chiffres en chiffres et en parties avant et après eux. On peut essayer de faire comme ça :

Cela n'a pas fonctionné : le premier .* est gourmand donc il « mange » autant qu'il le peut, laissant le d+ correspondre à la dernière place possible, le dernier chiffre. Nous pourrions essayer de résoudre ce problème en le rendant non gourmand :

Cela n'a pas fonctionné non plus, car maintenant le RE dans son ensemble n'est pas gourmand et il met donc fin au match global dès que possible. On peut obtenir ce qu'on veut en forçant l'ER dans son ensemble à être gourmand :

Contrôler la gourmandise globale du RE séparément de la gourmandise de ses composants permet une grande flexibilité dans la gestion des modèles de longueur variable.

Lors du choix d'une correspondance plus longue ou plus courte, les longueurs de correspondance sont mesurées en caractères, et non en éléments d'assemblage. Une chaîne vide est considérée comme plus longue qu'aucune correspondance. Par exemple : bb* correspond aux trois caractères du milieu de abbbc (week|wee)(night|knights) correspond aux dix caractères de weeknights quand (.*).* est comparé à abc la sous-expression entre parenthèses correspond aux trois caractères et quand (a *)* est comparé à bc à la fois le RE entier et la sous-expression entre parenthèses correspondent à une chaîne vide.

Si une correspondance indépendante de la casse est spécifiée, l'effet est comme si toutes les distinctions de casse avaient disparu de l'alphabet. Lorsqu'une lettre alphabétique qui existe dans plusieurs cas apparaît comme un caractère ordinaire en dehors d'une expression entre crochets, elle est effectivement transformée en une expression entre crochets contenant les deux cas, par exemple, x devient [xX] . Lorsqu'il apparaît à l'intérieur d'une expression entre crochets, toutes ses contreparties en casse sont ajoutées à l'expression entre crochets, par exemple, [x] devient [xX] et [^x] devient [^xX] .

Si une correspondance sensible au saut de ligne est spécifiée, . et les expressions de crochet utilisant ^ ne correspondront jamais au caractère de nouvelle ligne (de sorte que les correspondances ne traverseront jamais les nouvelles lignes à moins que le RE ne l'arrange explicitement) et ^ et $ correspondront à la chaîne vide après et avant une nouvelle ligne respectivement, en plus de la correspondance au début et à la fin de chaîne respectivement. Mais les échappements ARE A et  continuent de correspondre au début ou à la fin de la chaîne seulement .

Si une correspondance partielle sensible au saut de ligne est spécifiée, cela affecte . et les expressions entre crochets comme pour la correspondance sensible aux sauts de ligne, mais pas ^ et $ .

Si une correspondance partielle inverse sensible au saut de ligne est spécifiée, cela affecte ^ et $ comme pour la correspondance sensible au saut de ligne, mais pas . et les expressions entre crochets. Ce n'est pas très utile mais c'est prévu pour la symétrie.

9.7.3.6. Limites et compatibilité

Aucune limite particulière n'est imposée sur la longueur des RE dans cette mise en œuvre. Cependant, les programmes destinés à être hautement portables ne devraient pas utiliser de RE de plus de 256 octets, car une mise en œuvre conforme à POSIX peut refuser d'accepter de telles RE.

La seule caractéristique des ARE qui est réellement incompatible avec les ERE POSIX est que ne perd pas sa signification particulière à l'intérieur des expressions entre crochets. Toutes les autres fonctionnalités ARE utilisent une syntaxe illégale ou ayant des effets indéfinis ou non spécifiés dans les ERE POSIX. La syntaxe *** des directeurs est également en dehors de la syntaxe POSIX pour les BRE et les ERE.

La plupart des extensions ARE sont empruntées à Perl, mais certaines ont été modifiées pour les nettoyer, et quelques extensions Perl ne sont pas présentes. Les incompatibilités à noter incluent  , B , l'absence de traitement spécial pour un retour à la ligne de fin, l'ajout d'expressions de crochets complétées aux éléments affectés par la correspondance sensible aux retours à la ligne, les restrictions sur les parenthèses et les références arrière dans les contraintes d'anticipation/regard en arrière, et la sémantique de correspondance la plus longue/la plus courte (plutôt que la première correspondance).

Deux incompatibilités importantes existent entre les ARE et la syntaxe ERE reconnue par les versions pré-7.4 de PostgreSQL :

Dans les ARE, suivi d'un caractère alphanumérique est soit un échappement soit une erreur, alors que dans les versions précédentes, c'était juste une autre façon d'écrire l'alphanumérique. Cela ne devrait pas être vraiment un problème car il n'y avait aucune raison d'écrire une telle séquence dans les versions précédentes.

Dans les ARE, reste un caractère spécial dans [] , donc un littéral dans une expression entre crochets doit être écrit .

9.7.3.7. Expressions régulières de base

Les BRE diffèrent des ERE à plusieurs égards. Dans les BRE, | , + et ? sont des caractères ordinaires et il n'y a pas d'équivalent pour leur fonctionnalité. Les délimiteurs des limites sont < et >, avec < et > par eux-mêmes des caractères ordinaires. Les parenthèses pour les sous-expressions imbriquées sont ( et ) , avec ( et ) par eux-mêmes des caractères ordinaires. ^ est un caractère ordinaire sauf au début de l'ER ou au début d'une sous-expression entre parenthèses, $ est un caractère ordinaire sauf à la fin de l'ER ou à la fin d'une sous-expression entre parenthèses, et * est un caractère ordinaire s'il apparaît à le début du RE ou le début d'une sous-expression entre parenthèses (après un éventuel ^ ). Enfin, des références arrière à un chiffre sont disponibles, et < et > sont des synonymes de [[:<:]] et [[:>:]] respectivement, aucun autre échappement n'est disponible dans les BRE.

9.7.3.8. Différences par rapport à XQuery ( LIKE_REGEX )

Depuis SQL:2008, la norme SQL inclut un opérateur LIKE_REGEX qui effectue une correspondance de modèle selon la norme d'expression régulière XQuery. PostgreSQL n'implémente pas encore cet opérateur, mais vous pouvez obtenir un comportement très similaire en utilisant la fonction regexp_match(), car les expressions régulières XQuery sont assez proches de la syntaxe ARE décrite ci-dessus.

Les différences notables entre la fonctionnalité d'expression régulière basée sur POSIX et les expressions régulières XQuery incluent :

La soustraction de classe de caractères XQuery n'est pas prise en charge. Un exemple de cette fonctionnalité consiste à utiliser ce qui suit pour faire correspondre uniquement les consonnes anglaises : [a-z-[aeiou]] .

Les raccourcis des classes de caractères XQuery c , C , i et I ne sont pas pris en charge.

Éléments de classe de caractères XQuery utilisant p ou l'inverse P ne sont pas pris en charge.

POSIX interprète les classes de caractères telles que w (voir Tableau 9.21) en fonction de la locale prédominante (que vous pouvez contrôler en attachant une clause COLLATE à l'opérateur ou à la fonction). XQuery spécifie ces classes par référence aux propriétés des caractères Unicode, de sorte qu'un comportement équivalent est obtenu uniquement avec un paramètre régional qui suit les règles Unicode.

Le standard SQL (pas XQuery lui-même) tente de prendre en charge plus de variantes de « newline » que POSIX. Les options de correspondance sensibles au retour à la ligne décrites ci-dessus considèrent uniquement ASCII NL ( ) comme un saut de ligne, mais SQL nous demande de traiter CR ( ), CRLF ( ) (un saut de ligne de style Windows) et certains Les caractères Unicode uniquement tels que LINE SEPARATOR (U+2028) ainsi que les nouvelles lignes. Notamment, . et s devrait compter comme un caractère et non deux selon SQL.

Parmi les échappements de saisie de caractères décrits dans le tableau 9.20, XQuery ne prend en charge que , et .

XQuery ne prend pas en charge le [: Nom :] syntaxe pour les classes de caractères dans les expressions entre crochets.

XQuery n'a pas de contraintes d'anticipation ou d'anticipation, ni aucun des échappements de contraintes décrits dans le tableau 9.22.

Les formes de métasyntaxe décrites à la section 9.7.3.4 n'existent pas dans XQuery.

Les lettres d'indicateur d'expression régulière définies par XQuery sont liées, mais pas identiques, aux lettres d'option pour POSIX (tableau 9.24). Alors que les options i et q se comportent de la même manière, d'autres ne le font pas :

Les drapeaux s (autoriser le point à correspondre à la nouvelle ligne) et m (autoriser ^ et $ à correspondre aux nouvelles lignes) donnent accès aux mêmes comportements que les drapeaux n , p et w de POSIX, mais ils le font ne pas correspondent au comportement des indicateurs s et m de POSIX. Notez en particulier que dot-matches-newline est le comportement par défaut dans POSIX mais pas dans XQuery.

L'indicateur x (ignorer les espaces dans le motif) de XQuery est sensiblement différent de l'indicateur de mode étendu de POSIX. Le drapeau x de POSIX permet également # de commencer un commentaire dans le motif, et POSIX n'ignorera pas un caractère d'espacement après une barre oblique inverse.


5 réponses 5

Si vous avez GNU sed (donc Linux non embarqué ou Cygwin) :

Si vous avez une barre sur deux lignes consécutives, cela supprimera la deuxième ligne sans l'analyser. Par exemple, si vous avez un fichier de 3 lignes bar / bar / foo , la ligne foo restera.

Si la barre peut apparaître sur des lignes consécutives, vous pouvez faire :

qui peut être adapté pour supprimer plus de 2 lignes en changeant les 2 ci-dessus avec le nombre de lignes à supprimer y compris celle correspondante.

Sinon, cela se fait facilement en sed avec la solution de @MichaelRollins ou :

Je ne parle pas couramment sed, mais c'est facile de le faire dans awk :

Le script awk lit : pour une ligne contenant bar, obtenez la ligne suivante (getline), puis ignorez tout traitement ultérieur (next). Le motif 1 à la fin imprime les lignes restantes.

Mettre à jour

Comme indiqué dans le commentaire, la solution ci-dessus ne fonctionnait pas avec la barre consécutive . Voici une solution révisée, qui la prend en considération :

Nous continuons maintenant à lire pour sauter toutes les lignes /bar/.

Vous voudrez utiliser les capacités de script de sed pour accomplir cela.

La commande "N" ajoute la ligne d'entrée suivante dans l'espace de motif. Ceci combiné avec la ligne de la correspondance de motif (/bar/) sera les lignes que vous souhaitez supprimer. Vous pouvez ensuite supprimer normalement avec la commande "d".

Si une ligne qui suit immédiatement une correspondance doit être supprimée, votre programme sed devra considérer les correspondances consécutives. En d'autres termes, si vous supprimez une ligne à la suite d'une correspondance qui correspond également, vous devriez probablement également supprimer la ligne qui la suit.

Il est mis en œuvre assez simplement - mais vous devez regarder un peu en arrière.

Cela fonctionne en échangeant les espaces de maintien et de motif pour chaque ligne lue - de sorte que la dernière ligne puisse être comparée à la ligne actuelle à chaque fois. Ainsi, lorsque sed lit une ligne, il échange le contenu de ses tampons - et la ligne précédente est alors le contenu de son tampon d'édition, tandis que la ligne actuelle est mise en attente.

Donc sed vérifie la ligne précédente pour une correspondance avec correspondre , et si c'est ! not found les deux expressions de la < fonction > sont exécutées. sed obtiendra l'espace de maintien en écrasant l'espace de motif - ce qui signifie que la ligne actuelle se trouve alors à la fois dans les espaces de maintien et de motif - et ensuite // vérifiera si elle correspond à son expression régulière la plus récemment compilée - correspondre - et si il ne fait pas correspondre il est imprimé.

Cela signifie qu'une ligne n'est imprimée que si elle ne correspondre et la ligne immédiatement précédente ne correspondre . Il renonce également à tout échange inutile contre des séquences de correspondre es.

Si vous vouliez une version qui pourrait supprimer un nombre arbitraire de lignes se produisant après un correspondre il faudrait un peu plus de travail :

. remplacer le 5 par le nombre de lignes (y compris la ligne correspondante) que vous souhaitez supprimer.


Codage sécurisé en C et C++ : chaînes et débordements de tampon

S'il existait une règle stricte pour la programmation sécurisée en C et C++, ce serait celle-ci : n'invoquez jamais le obtient () une fonction. Le obtient () Cette fonction a été largement utilisée dans les exemples de programmes vulnérables de ce livre. Le obtient () La fonction lit une ligne de l'entrée standard dans un tampon jusqu'à ce qu'une fin de ligne ou une fin de fichier (EOF) soit trouvée. Aucune vérification de débordement de tampon n'est effectuée. La citation suivante provient de la page de manuel de la fonction :

    Ne jamais utiliser obtient (). Parce qu'il est impossible de dire sans connaître les données à l'avance combien de caractères obtient () lira, et parce que obtient () continuera à stocker des caractères au-delà de la fin du tampon, il est extrêmement dangereux à utiliser. Il a été utilisé pour briser la sécurité informatique.

Comme déjà mentionné, le obtient () La fonction a été dépréciée dans ISO/IEC 9899:TC3 et supprimée de C11.

Deux options pour une application strictement conforme à C99 sont de remplacer obtient () soit fgets() ou alors getchar().

La norme C fgets() la fonction a un comportement similaire à obtient (). Le fgets() La fonction accepte deux arguments supplémentaires : le nombre de caractères à lire et un flux d'entrée. Lorsque standard est spécifié comme le flux, fgets() peut être utilisé pour simuler le comportement de obtient ().

Le fragment de programme de l'exemple 2.9 lit une ligne de texte de standard en utilisant le fgets() une fonction.

Exemple 2.9. Lecture à partir de stdin Utilisation de fgets()

contrairement à obtient (), les fgets() fonction conserve le caractère de nouvelle ligne, ce qui signifie que la fonction ne peut pas être utilisée comme un remplacement direct pour obtient ().

Lors de l'utilisation fgets(), il est possible de lire une ligne partielle. La troncature de l'entrée utilisateur peut être détectée car le tampon d'entrée ne contiendra pas de caractère de nouvelle ligne.

Le fgets() La fonction lit, au plus, un de moins que le nombre de caractères spécifiés à partir du flux dans un tableau. Aucun caractère supplémentaire n'est lu après un caractère de nouvelle ligne ou un EOF. Un caractère nul est écrit immédiatement après le dernier caractère lu dans le tableau.

Il est possible d'utiliser fgets() pour traiter en toute sécurité les lignes d'entrée trop longues pour être stockées dans le tableau de destination, mais cela n'est pas recommandé pour des raisons de performances. Le fgets() La fonction peut entraîner un débordement de tampon si le nombre spécifié de caractères à saisir dépasse la longueur du tampon de destination.

Une deuxième alternative pour remplacer le obtient () fonction dans une application strictement conforme à C99 est d'utiliser le getchar() une fonction. Le getchar() la fonction renvoie le caractère suivant du flux d'entrée pointé par standard. Si le flux est à EOF, l'indicateur EOF pour le flux est défini et getchar() Retour FEO. Si une erreur de lecture se produit, l'indicateur d'erreur pour le flux est défini et getchar() Retour FEO. Le fragment de programme de l'exemple 2.10 lit une ligne de texte de standard en utilisant le getchar() une fonction.

Exemple 2.10. Lecture à partir de stdin Utilisation de getchar()

Si à la fin de la boucle feof(stdin) ! = 0, la boucle a lu jusqu'à la fin du fichier sans rencontrer de caractère de nouvelle ligne. Si à la fin de la boucle ferreur(stdin) ! = 0, une erreur de lecture s'est produite avant que la boucle ne rencontre un caractère de nouvelle ligne. Si à la fin de la boucle chars_read > index, la chaîne d'entrée a été tronquée. La norme de codage sécurisé CERT C [Seacord 2008], “FIO34-C. Utilisation entier pour capturer la valeur de retour des fonctions d'E/S de caractère,” est également appliqué dans cette solution.

En utilisant le getchar() La fonction à lire dans une ligne peut toujours entraîner un débordement de la mémoire tampon si les écritures dans la mémoire tampon ne sont pas correctement délimitées.

La lecture d'un caractère à la fois offre plus de flexibilité dans le contrôle du comportement sans surcharge de performances supplémentaire. Le test suivant pour le tandis que la boucle est normalement suffisante :

while (( (ch = getchar()) ! = ' ') && ch ! = EOF )

Voir La norme de codage sécurisé CERT C [Seacord 2008], “FIO35-C. Utilisation feof() et ferreur() pour détecter les erreurs de fin de fichier et de fichier lorsque sizeof(int) == sizeof(char),” pour le cas où feof() et ferreur() doit être utilisé à la place.

C11 Annexe K Interfaces de vérification des limites : gets_s()

Le C11 obtient_s() est une version compatible mais plus sécurisée de obtient (). Le obtient_s() fonction est un remplacement plus proche de la obtient () fonction que fgets() en ce qu'il lit uniquement à partir du flux pointé par standard et ne conserve pas le caractère de nouvelle ligne. Le obtient_s() la fonction accepte un argument supplémentaire, taille_t, qui spécifie le nombre maximum de caractères à saisir. Une condition d'erreur se produit si cet argument est égal à zéro ou supérieur à RSIZE_MAX ou si le pointeur vers le tableau de caractères de destination est NUL. Si une condition d'erreur se produit, aucune entrée n'est effectuée et le tableau de caractères n'est pas modifié. Sinon, le obtient_s() La fonction lit, au plus, un de moins que le nombre de caractères spécifiés, et un caractère nul est écrit immédiatement après le dernier caractère lu dans le tableau. Le fragment de programme montré dans l'exemple 2.11 lit une ligne de texte de standard en utilisant le obtient_s() une fonction.

Exemple 2.11. Lecture à partir de stdin à l'aide de gets_s()

Le obtient_s() La fonction renvoie un pointeur vers le tableau de caractères en cas de succès. Un pointeur nul est renvoyé si les arguments de la fonction ne sont pas valides, une fin de fichier est rencontrée et aucun caractère n'a été lu dans le tableau ou si une erreur de lecture se produit pendant l'opération.

Le obtient_s() La fonction ne réussit que si elle lit une ligne complète (c'est-à-dire qu'elle lit un caractère de nouvelle ligne). Si une ligne complète ne peut pas être lue, la fonction renvoie NUL, définit le tampon sur la chaîne nulle et efface le flux d'entrée jusqu'au caractère de nouvelle ligne suivant.

Le obtient_s() La fonction peut toujours entraîner un débordement de tampon si le nombre spécifié de caractères à saisir dépasse la longueur du tampon de destination.

Comme indiqué précédemment, le fgets() La fonction permet aux programmes correctement écrits de traiter en toute sécurité les lignes d'entrée qui sont trop longues pour être stockées dans le tableau de résultats. En général, cela exige que les appelants de fgets() faites attention à la présence ou à l'absence d'un caractère de nouvelle ligne dans le tableau résultat. En utilisant obtient_s() avec des lignes d'entrée qui pourraient être trop longues nécessite de remplacer son gestionnaire de contraintes d'exécution (et de le réinitialiser à sa valeur par défaut une fois terminé). Pensez à utiliser fgets() (avec tout traitement nécessaire basé sur les caractères de nouvelle ligne) au lieu de obtient_s().

Fonctions d'allocation dynamique

ISO/IEC TR 24731-2 décrit la obtenir la ligne() fonction dérivée de POSIX. Le comportement du obtenir la ligne() fonction est similaire à celle de fgets() mais offre plusieurs fonctionnalités supplémentaires. Premièrement, si la ligne d'entrée est trop longue, plutôt que de tronquer l'entrée, la fonction redimensionne le tampon en utilisant réalloc(). Deuxièmement, en cas de succès, il renvoie le nombre de caractères lus, ce qui est utile pour déterminer si l'entrée a des caractères nuls avant le saut de ligne. Le obtenir la ligne() la fonction ne fonctionne qu'avec les tampons alloués avec malloc(). Si passé un pointeur nul, obtenir la ligne() alloue un tampon de taille suffisante pour contenir l'entrée. A ce titre, l'utilisateur doit explicitement libre() le tampon plus tard. Le obtenir la ligne() fonction est équivalente à la obtenirdelim() fonction (également définie dans ISO/IEC TR 24731-2) avec le caractère délimiteur égal au caractère de nouvelle ligne. Le fragment de programme montré dans l'exemple 2.12 lit une ligne de texte de standard en utilisant le obtenir la ligne() une fonction.

Exemple 2.12. Lecture à partir de stdin à l'aide de getline()

Le obtenir la ligne() La fonction renvoie le nombre de caractères écrits dans le tampon, y compris le caractère de nouvelle ligne s'il en a été rencontré avant la fin du fichier. Si une erreur de lecture se produit, l'indicateur d'erreur pour le flux est défini, et obtenir la ligne() renvoie 𔂿. Par conséquent, la conception de cette fonction viole La norme de codage sécurisé CERT C [Seacord 2008], “ERR02-C. Évitez les indicateurs d'erreur dans la bande, comme en témoigne l'utilisation du taille_t type qui a été créé dans le but de fournir des indicateurs d'erreur dans la bande.

Notez que ce code ne vérifie pas non plus si malloc() réussit. Si malloc() échoue, cependant, il retourne NUL, qui est transmis à obtenir la ligne(), qui alloue rapidement un tampon qui lui est propre.

Le tableau 2.4 résume certaines des fonctions alternatives pour obtient () décrit dans cette section. Toutes ces fonctions peuvent être utilisées en toute sécurité.

Tableau 2.4. Fonctions alternatives pour gets()

Conserve le caractère de nouvelle ligne

Alloue dynamiquement de la mémoire

Strcpy() et strcat()

Le strcpy() et strcat() Les fonctions sont des sources fréquentes de débordements de tampon car elles ne permettent pas à l'appelant de spécifier la taille du tableau de destination, et de nombreuses stratégies de prévention recommandent des variantes plus sécurisées de ces fonctions.

Toutes les utilisations de strcpy() sont défectueux. Par exemple, il est souvent possible d'allouer dynamiquement l'espace requis, comme illustré dans l'exemple 2.13.

Exemple 2.13. Allocation dynamique de l'espace requis

Pour que ce code soit sécurisé, la chaîne source doit être entièrement validée [Wheeler 2004], par exemple, pour s'assurer que la chaîne n'est pas trop longue. Dans certains cas, il est clair qu'il n'existe aucun potentiel d'écriture au-delà des limites du tableau. Par conséquent, il peut ne pas être rentable de remplacer ou de sécuriser chaque appel vers strcpy(). Dans d'autres cas, il peut toujours être souhaitable de remplacer le strcpy() avec un appel à une fonction alternative plus sûre pour éliminer les messages de diagnostic générés par les compilateurs ou les outils d'analyse.

La norme C strncpy() fonction est fréquemment recommandée comme alternative à la strcpy() une fonction. Malheureusement, strncpy() est sujette à des erreurs de terminaison nulle et à d'autres problèmes et n'est donc pas considérée comme une alternative sûre à strcpy().

OpenBSD

Le strlcpy() et strlcat() fonctions sont apparues pour la première fois dans OpenBSD 2.4. Ces fonctions copient et concaténent les chaînes de manière moins sujette aux erreurs que les fonctions C Standard correspondantes. Ces prototypes de fonctions sont les suivants :

Le strlcpy() la fonction copie la chaîne terminée par NULL à partir de src à dst (Jusqu'à Taille personnages). Le strlcat() la fonction ajoute la chaîne terminée par le caractère nul src jusqu'à la fin de dst (mais pas plus de Taille caractères seront dans la destination).

Pour éviter d'écrire en dehors des limites du tableau, le strlcpy() et strlcat() Les fonctions acceptent la taille complète de la chaîne de destination comme paramètre de taille.

Les deux fonctions garantissent que la chaîne de destination se termine par un zéro pour tous les tampons de longueur différente de zéro.

Le strlcpy() et strlcat() les fonctions renvoient la longueur totale de la chaîne qu'elles ont essayé de créer. Pour strlcpy(), c'est simplement la longueur de la source pour strlcat(), c'est la longueur de la destination (avant concaténation) plus la longueur de la source. Pour vérifier la troncature, le programmeur doit vérifier que la valeur de retour est inférieure au paramètre size. Si la chaîne résultante est tronquée, le programmeur dispose désormais du nombre d'octets nécessaires pour stocker la chaîne entière et peut réaffecter et recopier.

Ni strlcpy() ni strlcat() zéro remplit sa chaîne de destination (autre que l'octet nul obligatoire pour terminer la chaîne). Le résultat est une performance proche de celle de strcpy() et bien meilleur que celui de strncpy().

C11 Annexe K Interfaces de vérification des limites

Le strcpy_s() et strcat_s() les fonctions sont définies dans l'annexe K C11 comme des fonctions de remplacement proches pour strcpy() et strcat(). Le strcpy_s() fonction a un paramètre supplémentaire donnant la taille du tableau de destination pour éviter le débordement de tampon :

Le strcpy_s() la fonction est similaire à strcpy() lorsqu'il n'y a pas de violation de contrainte. Le strcpy_s() La fonction copie les caractères d'une chaîne source vers un tableau de caractères de destination jusqu'au caractère nul de fin inclus.

Le strcpy_s() La fonction ne réussit que lorsque la chaîne source peut être entièrement copiée vers la destination sans déborder le tampon de destination. La fonction renvoie 0 en cas de succès, ce qui implique que tous les caractères demandés de la chaîne pointée par s2 tenir dans le tableau pointé par s1 et que le résultat en s1 se termine par un zéro. Sinon, une valeur différente de zéro est renvoyée.

Le strcpy_s() La fonction applique une variété de contraintes d'exécution. Une erreur de contrainte d'exécution se produit si s1 ou alors s2 est un pointeur nul si la longueur maximale du tampon de destination est égale à zéro, supérieure à RSIZE_MAX, ou inférieur ou égal à la longueur de la chaîne source ou si la copie a lieu entre des objets qui se chevauchent. La chaîne de destination est définie sur la chaîne nulle et la fonction renvoie une valeur différente de zéro pour augmenter la visibilité du problème.

L'exemple 2.15 montre l'implémentation Open Watcom du strcpy_s() une fonction. Les contrôles d'erreur de contrainte d'exécution sont suivis de commentaires.

Exemple 2.14. Open Watcom Implémentation de la fonction strcpy_s()

Le strcat_s() La fonction ajoute les caractères de la chaîne source, jusqu'au caractère nul inclus, à la fin de la chaîne de destination. Le caractère initial de la chaîne source écrase le caractère nul à la fin de la chaîne de destination.

Le strcat_s() la fonction renvoie 0 en cas de succès. Cependant, la chaîne de destination est définie sur la chaîne nulle et une valeur différente de zéro est renvoyée si le pointeur source ou de destination est NUL ou si la longueur maximale du buffer de destination est égale à 0 ou supérieure à RSIZE_MAX. Le strcat_s() La fonction échouera également si la chaîne de destination est déjà pleine ou s'il n'y a pas assez de place pour ajouter entièrement la chaîne source.

Le strcpy_s() et strcat_s() Les fonctions peuvent toujours entraîner un débordement de tampon si la longueur maximale du tampon de destination est incorrectement spécifiée.

Fonctions d'allocation dynamique

ISO/IEC TR 24731-2 [ISO/IEC TR 24731-2:2010] décrit le POSIX strdup() fonction, qui peut également être utilisée pour copier une chaîne. ISO/IEC TR 24731-2 ne définit aucune fonction alternative à strcat(). Le strdup() La fonction accepte un pointeur vers une chaîne et renvoie un pointeur vers une chaîne en double nouvellement allouée. Cette mémoire doit être récupérée en passant le pointeur renvoyé à libre().

Résumé des alternatives

Le tableau 2.5 résume certaines des fonctions alternatives de copie de chaînes décrites dans cette section.

Tableau 2.5. Fonctions de copie de chaîne

Protection contre le débordement de la mémoire tampon

Garantit une résiliation nulle

Peut tronquer la chaîne

Alloue la mémoire dynamique

Le tableau 2.6 résume certaines des fonctions alternatives pour strcat() décrit dans cette section. TR 24731-2 ne définit pas de fonction alternative à strcat().

Tableau 2.6. Fonctions de concaténation de chaînes

Protection contre le débordement de la mémoire tampon

Garantit une résiliation nulle

Peut tronquer la chaîne

Alloue la mémoire dynamique

Strncpy() et strncat()

Le strncpy() et strncat() les fonctions sont similaires aux strcpy() et strcat() fonctions, mais chacun a un taille_t paramètre m qui limite le nombre de caractères à copier. Ces fonctions peuvent être considérées comme des fonctions de copie et de concaténation tronquées.

Le strncpy() la fonction de bibliothèque exécute une fonction similaire à strcpy() mais permet une taille maximale m à préciser:

Le strncpy() La fonction peut être utilisée comme indiqué dans l'exemple suivant :

Parce que le strncpy() fonction n'est pas garantie de terminer la chaîne de destination par le caractère nul, le programmeur doit veiller à ce que la chaîne de destination se termine correctement par le caractère nul sans écraser le dernier caractère.

La norme C strncpy() est fréquemment recommandée comme une alternative “plus sûre” à strcpy(). Pourtant, strncpy() est sujette aux erreurs de terminaison de chaîne, comme détaillé sous “C11 Annexe K Bounds-Checking Interfaces.”

Le strncat() fonction a la signature suivante :

Le strncat() la fonction n'ajoute pas plus de m caractères (un caractère nul et les caractères qui le suivent ne sont pas ajoutés) du tableau pointé par s2 à la fin de la chaîne pointée par s1. Le caractère initial de s2 écrase le caractère nul à la fin de s1. Un caractère nul de fin est toujours ajouté au résultat. Par conséquent, le nombre maximum de caractères pouvant se retrouver dans le tableau pointé par s1 est strlen(s1) + n + 1.

Le strncpy() et strncat() Les fonctions doivent être utilisées avec précaution, ou ne doivent pas être utilisées du tout, d'autant plus que des alternatives moins sujettes aux erreurs sont disponibles. Ce qui suit est un exemple de code réel résultant d'une transformation simpliste du code existant à partir de strcpy() et strcat() à strncpy() et strncat():

Le problème est que le dernier argument de strncat() ne doit pas être la longueur totale de la mémoire tampon, mais l'espace restant après l'appel à strncpy(). Les deux fonctions nécessitent que vous spécifiiez l'espace restant et non la taille totale de la mémoire tampon. Étant donné que l'espace restant change à chaque fois que des données sont ajoutées ou supprimées, les programmeurs doivent suivre ou recalculer constamment l'espace restant. Ces processus sont sujets aux erreurs et peuvent entraîner des vulnérabilités. L'appel suivant calcule correctement l'espace restant lors de la concaténation d'une chaîne à l'aide strncat():

strncat(dest, source, dest_size-strlen(dest)-1)

Un autre problème avec l'utilisation strncpy() et strncat() comme alternative à strcpy() et strcat() fonctions est qu'aucune des anciennes fonctions ne fournit de code d'état ou ne signale lorsque la chaîne résultante est tronquée. Les deux fonctions renvoient un pointeur vers le tampon de destination, ce qui nécessite un effort important de la part du programmeur pour déterminer si la chaîne résultante a été tronquée.

Il y a aussi un problème de performances avec strncpy() en ce qu' il remplit la totalité du tampon de destination avec des octets nuls après épuisement des données source. Bien qu'il n'y ait aucune raison valable pour ce comportement, de nombreux programmes en dépendent désormais et, par conséquent, il est difficile de le modifier.

Le strncpy() et strncat() fonctions jouent un rôle en dehors de leur utilisation en tant que fonctions alternatives à strcpy() et strcat(). Le but initial de ces fonctions était de permettre la copie et la concaténation d'une sous-chaîne. Cependant, ces fonctions sont sujettes aux débordements de mémoire tampon et aux erreurs de terminaison nulle.

C11 Annexe K Interfaces de vérification des limites

C11 L'annexe K précise les strncpy_s() et strncat_s() fonctionne comme un proche remplaçant pour strncpy() et strncat().

Le strncpy_s() La fonction ne copie pas plus d'un nombre spécifié de caractères successifs (les caractères qui suivent un caractère nul ne sont pas copiés) d'une chaîne source vers un tableau de caractères de destination. Le strncpy_s() fonction a la signature suivante :

Le strncpy_s() La fonction a un paramètre supplémentaire donnant la taille du tableau de destination pour éviter le débordement de la mémoire tampon. Si une violation de contrainte d'exécution se produit, le tableau de destination est défini sur la chaîne vide pour augmenter la visibilité du problème.

Le strncpy_s() La fonction arrête de copier la chaîne source dans le tableau de destination lorsque l'une des deux conditions suivantes se produit :

  1. Le caractère nul terminant la chaîne source est copié vers la destination.
  2. Le nombre de caractères spécifié par le m l'argument a été copié.

Le résultat dans la destination est fourni avec un caractère de fin de caractère nul s'il n'a pas été copié à partir de la source. Le résultat, y compris le terminateur null, doit tenir dans la destination, sinon une violation de contrainte d'exécution se produit. Le stockage en dehors de la baie de destination n'est jamais modifié.

Le strncpy_s() la fonction renvoie 0 pour indiquer le succès. Si les arguments d'entrée ne sont pas valides, il renvoie une valeur différente de zéro et définit la chaîne de destination sur la chaîne nulle. La validation d'entrée échoue si le pointeur source ou de destination est NUL ou si la taille maximale de la chaîne de destination est 0 ou supérieure à RSIZE_MAX. L'entrée est également considérée comme invalide lorsque le nombre spécifié de caractères à copier dépasse RSIZE_MAX.

UNE strncpy_s() L'opération peut en fait réussir lorsque le nombre de caractères spécifiés à copier dépasse la longueur maximale de la chaîne de destination tant que la chaîne source est plus courte que la longueur maximale de la chaîne de destination. Si le nombre de caractères à copier est supérieur ou égal à la taille maximale de la chaîne de destination et que la chaîne source est plus longue que le tampon de destination, l'opération échouera.

Parce que le nombre de caractères dans la source est limité par le m paramètre et la destination a un paramètre séparé donnant le nombre maximum d'éléments dans la destination, le strncpy_s() La fonction peut copier en toute sécurité une sous-chaîne, pas seulement une chaîne entière ou sa queue.

Étant donné que la troncature de chaîne inattendue est une vulnérabilité de sécurité possible, strncpy_s() ne tronque pas la source (telle que délimitée par le terminateur nul et le m paramètre) pour s'adapter à la destination. La troncature est une violation de contrainte d'exécution. Cependant, il existe un idiome qui permet à un programme de forcer la troncature en utilisant le strncpy_s() une fonction. Si la m l'argument est la taille de la destination moins 1, strncpy_s() copiera l'intégralité de la source vers la destination ou la tronquera pour l'adapter (comme toujours, le résultat se terminera par un zéro). Par exemple, l'appel suivant copiera src à la destin tableau, résultant en une chaîne correctement terminée par NULL dans dest. La copie s'arrêtera lorsque dest est plein (y compris le terminateur nul) ou lorsque tous src a été copié.

strncpy_s(dest, sizeof dest, src, (sizeof dest)-1)

Bien que la fonction OpenBSD strlcpy() est similaire à strncpy(), il ressemble plus à strcpy_s() que de strncpy_s(). contrairement à strlcpy(), strncpy_s() prend en charge la vérification des contraintes d'exécution telles que la taille du tableau de destination, et il ne tronquera pas la chaîne.

Utilisation de la strncpy_s() fonction est moins susceptible d'introduire une faille de sécurité car la taille du tampon de destination et le nombre maximum de caractères à ajouter doivent être spécifiés. Considérez les définitions suivantes :

Comme il y a suffisamment de stockage dans le tableau de caractères de destination, l'appel suivant à strncpy_s() attribue la valeur 0 à r1 et la séquence bonjour à dst1:

r1 = strncpy_s(dst1, sizeof(dst1), src1, sizeof(src1))

L'appel suivant affecte la valeur 0 à r2 et la séquence bien à dst2:

r2 = strncpy_s(dst2, sizeof(dst2), src2, 4)

Cependant, il n'y a pas suffisamment d'espace pour copier le src1 chaîne à dst3. Par conséquent, si l'appel suivant à strncpy_s() Retour, r3 reçoit une valeur non nulle et dst3[0] est assigné '':

r3 = strncpy_s(dst3, sizeof(dst3), src1, sizeof(src1))

Si strncpy() avait été utilisé à la place de strncpy_s(), le tableau de destination dst3 n'aurait pas été correctement terminé par null.

Le strncat_s() La fonction n'ajoute pas plus d'un nombre spécifié de caractères successifs (les caractères qui suivent un caractère nul ne sont pas copiés) d'une chaîne source à un tableau de caractères de destination. Le caractère initial de la chaîne source écrase le caractère nul à la fin du tableau de destination. Si aucun caractère nul n'a été copié à partir de la chaîne source, un caractère nul est écrit à la fin de la chaîne ajoutée. Le strncat_s() fonction a la signature suivante :

Une violation de contrainte d'exécution se produit et le strncat_s() la fonction renvoie une valeur non nulle si le pointeur source ou de destination est NUL ou si la longueur maximale du buffer de destination est égale à 0 ou supérieure à RSIZE_MAX. La fonction échoue lorsque la chaîne de destination est déjà pleine ou s'il n'y a pas assez de place pour ajouter entièrement la chaîne source. Le strncat_s() La fonction assure également la terminaison nulle de la chaîne de destination.

Le strncat_s() La fonction a un paramètre supplémentaire donnant la taille du tableau de destination pour éviter le débordement de la mémoire tampon. La chaîne d'origine dans la destination ainsi que les nouveaux caractères ajoutés à partir de la source doivent s'adapter et être terminés par NULL pour éviter une violation de la contrainte d'exécution. Si une violation de contrainte d'exécution se produit, le tableau de destination est défini sur une chaîne nulle pour augmenter la visibilité du problème.

Le strncat_s() La fonction arrête d'ajouter la chaîne source au tableau de destination lorsque la première des deux conditions suivantes se produit :

  1. La chaîne source à terminaison nulle est copiée vers la destination.
  2. Le nombre de caractères spécifié par le m paramètre a été copié.

Le résultat dans la destination est fourni avec un caractère de fin de caractère nul s'il n'a pas été copié à partir de la source. Le résultat, y compris le terminateur null, doit tenir dans la destination, sinon une violation de contrainte d'exécution se produit. Le stockage en dehors de la baie de destination n'est jamais modifié.

Parce que le nombre de caractères dans la source est limité par le m paramètre et la destination a un paramètre séparé donnant le nombre maximum d'éléments dans la destination, le strncat_s() La fonction peut ajouter en toute sécurité une sous-chaîne, pas seulement une chaîne entière ou sa queue.

Étant donné que la troncature de chaîne inattendue est une vulnérabilité de sécurité possible, strncat_s() ne tronque pas la source (comme spécifié par le terminateur null et le m paramètre) pour s'adapter à la destination. La troncature est une violation de contrainte d'exécution. Cependant, il existe un idiome qui permet à un programme de forcer la troncature en utilisant le strncat_s() une fonction. Si la m l'argument est le nombre d'éléments moins 1 restant dans la destination, strncat_s() ajoutera la source entière à la destination ou la tronquera pour l'adapter (comme toujours, le résultat se terminera par un zéro). Par exemple, l'appel suivant ajoutera src à la dest tableau, résultant en une chaîne correctement terminée par NULL dans destin. La concaténation s'arrêtera lorsque destin est plein (y compris le terminateur nul) ou lorsque tous src a été ajouté :

Bien que la fonction OpenBSD strlcat() est similaire à strncat(), il ressemble plus à strcat_s() que de strncat_s(). contrairement à strlcat(), strncat_s() prend en charge la vérification des contraintes d'exécution telles que la taille du tableau de destination, et il ne tronquera pas la chaîne.

Le strncpy_s() et strncat_s() Les fonctions peuvent toujours déborder d'un tampon si la longueur maximale du tampon de destination et le nombre de caractères à copier sont incorrectement spécifiés.

Fonctions d'allocation dynamique

ISO/IEC TR 24731-2 [ISO/IEC TR 24731-2:2010] décrit le strndup() fonction, qui peut également être utilisée comme une fonction alternative à strncpy(). ISO/IEC TR 24731-2 ne définit aucune fonction alternative à strncat(). Le strndup() fonction est équivalente à la strdup() fonction, en dupliquant la chaîne fournie dans un nouveau bloc de mémoire alloué comme si en utilisant malloc(), à l'exception que strndup() copies, au plus, m plus 1 octet dans la mémoire nouvellement allouée, terminant la nouvelle chaîne par un octet nul. Si la longueur de la chaîne est supérieure à m, seulement m les octets sont dupliqués. Si m est supérieur à la longueur de la chaîne, tous les octets de la chaîne sont copiés dans la nouvelle mémoire tampon, y compris l'octet nul de fin. La chaîne nouvellement créée sera toujours correctement terminée. La chaîne allouée doit être récupérée en passant le pointeur renvoyé à libre().

Résumé des alternatives

Le tableau 2.7 résume certaines des fonctions alternatives pour tronquer la copie décrites dans cette section.


Services d'analyse SQL Server 2016

SQL Server 2016 Analysis Services inclut de nombreuses nouvelles améliorations offrant des performances améliorées, une création de solution plus facile, une gestion de base de données automatisée, des relations améliorées avec un filtrage croisé bidirectionnel, un traitement de partition parallèle et bien plus encore. Au cœur de la plupart des améliorations de cette version se trouve le nouveau niveau de compatibilité 1200 pour les bases de données de modèles tabulaires.

Services d'analyse SQL Server 2016 Service Pack 1 (SP1)

SQL Server 2016 Service SP1 Analysis Services offre des performances et une évolutivité améliorées grâce à la prise en compte de l'accès non uniforme à la mémoire (NUMA) et à une allocation de mémoire optimisée basée sur Blocs de construction Intel Threading (Intel TBB). Cette nouvelle fonctionnalité permet de réduire le coût total de possession (TCO) en prenant en charge plus d'utilisateurs sur des serveurs d'entreprise moins nombreux et plus puissants.

En particulier, SQL Server 2016 SP1 Analysis Services présente des améliorations dans ces domaines clés :

  • Sensibilisation au NUMA - Pour une meilleure prise en charge de NUMA, le moteur en mémoire (VertiPaq) d'Analysis Services gère désormais une file d'attente de travaux distincte sur chaque nœud NUMA. Cela garantit que les travaux d'analyse de segment s'exécutent sur le même nœud où la mémoire est allouée pour les données de segment. Notez que la reconnaissance NUMA n'est activée par défaut que sur les systèmes avec au moins quatre nœuds NUMA. Sur les systèmes à deux nœuds, les coûts d'accès à la mémoire allouée à distance ne justifient généralement pas la surcharge de gestion des spécificités NUMA.
  • Allocation de mémoire - Analysis Services a été accéléré avec Intel Threading Building Blocks, un répartiteur évolutif qui fournit des pools de mémoire séparés pour chaque cœur. À mesure que le nombre de cœurs augmente, le système peut évoluer de manière presque linéaire.
  • Fragmentation du tas - L'allocateur évolutif basé sur Intel TBB permet également d'atténuer les problèmes de performances dus à la fragmentation du tas qui se produit avec le tas Windows.

Les tests de performances et d'évolutivité ont montré des gains significatifs dans le débit des requêtes lors de l'exécution de SQL Server 2016 SP1 Analysis Services sur de grands serveurs d'entreprise multinœuds.

Bien que la plupart des améliorations de cette version soient spécifiques aux modèles tabulaires, un certain nombre d'améliorations ont été apportées aux modèles multidimensionnels, par exemple, l'optimisation ROLAP du nombre distinct pour les sources de données telles que DB2 et Oracle, la prise en charge de la multi-sélection d'exploration avec Excel 2016 et Excel optimisations de requêtes.

Services d'analyse de disponibilité générale (GA) de SQL Server 2016

La modélisation

Performances de modélisation améliorées pour les modèles tabulaires 1200

Pour les modèles tabulaires 1200, les opérations de métadonnées dans SSDT sont beaucoup plus rapides que les modèles tabulaires 1100 ou 1103. Par comparaison, sur le même matériel, la création d'une relation sur un modèle défini au niveau de compatibilité SQL Server 2014 (1103) avec 23 tables prend 3 secondes, alors que la même relation sur un modèle créé défini au niveau de compatibilité 1200 prend un peu moins d'une seconde .

Modèles de projet ajoutés pour les modèles tabulaires 1200 dans SSDT

Avec cette version, vous n'avez plus besoin de deux versions de SSDT pour créer des projets relationnels et BI. SQL Server Data Tools pour Visual Studio 2015 ajoute des modèles de projet pour les solutions Analysis Services, y compris Projets tabulaires Analysis Services utilisé pour construire des modèles au niveau de compatibilité 1200. D'autres modèles de projet Analysis Services pour les solutions multidimensionnelles et d'exploration de données sont également inclus, mais au même niveau fonctionnel (1100 ou 1103) que dans les versions précédentes.

Afficher les dossiers

Les dossiers d'affichage sont désormais disponibles pour les modèles tabulaires 1200. Définis dans SQL Server Data Tools et rendus dans des applications clientes comme Excel ou Power BI Desktop, les dossiers d'affichage vous aident à organiser un grand nombre de mesures dans des dossiers individuels, en ajoutant une hiérarchie visuelle pour une navigation plus facile dans les listes de champs.

Filtrage croisé bidirectionnel

La nouveauté de cette version est une approche intégrée pour activer les filtres croisés bidirectionnels dans les modèles tabulaires, éliminant ainsi le besoin de solutions de contournement DAX conçues à la main pour propager le contexte de filtre dans les relations de table. Les filtres ne sont générés automatiquement que lorsque la direction peut être établie avec un degré élevé de certitude. S'il existe une ambiguïté sous la forme de plusieurs chemins de requête dans les relations de table, un filtre ne sera pas créé automatiquement. Voir Filtres croisés bidirectionnels pour les modèles tabulaires dans SQL Server 2016 Analysis Services pour plus de détails.

Traductions

Vous pouvez désormais stocker les métadonnées traduites dans un modèle tabulaire 1200. Les métadonnées du modèle incluent des champs pour Culture, les légendes traduites et les descriptions traduites. Pour ajouter des traductions, utilisez le Modèle > Traductions commande dans les outils de données SQL Server. Voir Traductions dans les modèles tabulaires (Analysis Services) pour plus de détails.

Tableaux collés

Vous pouvez désormais mettre à niveau un modèle tabulaire 1100 ou 1103 vers 1200 lorsque le modèle contient des tableaux collés. Nous vous recommandons d'utiliser les outils de données SQL Server. Dans SSDT, définissez Niveau de compatibilité à 1200, puis déployez sur une instance SQL Server 2017 d'Analysis Services. Voir Niveau de compatibilité pour les modèles tabulaires dans Analysis Services pour plus de détails.

Tables calculées en SSDT

UNE table calculée est une construction de modèle uniquement basée sur une expression ou une requête DAX dans SSDT. Lorsqu'elle est déployée dans une base de données, une table calculée est indiscernable des tables ordinaires.

Il existe plusieurs utilisations des tables calculées, notamment la création de nouvelles tables pour exposer une table existante dans un rôle spécifique. L'exemple classique est une table Date qui fonctionne dans plusieurs contextes (date de commande, date d'expédition, etc.). En créant une table calculée pour un rôle donné, vous pouvez désormais activer une relation de table pour faciliter les requêtes ou l'interaction des données à l'aide de la table calculée. Une autre utilisation des tables calculées consiste à combiner des parties de tables existantes dans une toute nouvelle table qui n'existe que dans le modèle. Voir Créer une table calculée pour en savoir plus.

Correction de formule

Avec la correction de formule sur un modèle tabulaire 1200, SSDT mettra automatiquement à jour toutes les mesures faisant référence à une colonne ou une table qui a été renommée.

Prise en charge du gestionnaire de configuration Visual Studio

Pour prendre en charge plusieurs environnements, tels que les environnements de test et de pré-production, Visual Studio permet aux développeurs de créer plusieurs configurations de projet à l'aide du gestionnaire de configuration. Les modèles multidimensionnels exploitent déjà cela, mais pas les modèles tabulaires. Avec cette version, vous pouvez désormais utiliser le gestionnaire de configuration pour déployer sur différents serveurs.

Gestion des instances

Administrer les modèles Tabular 1200 dans SSMS

Dans cette version, une instance Analysis Services en mode serveur tabulaire peut exécuter des modèles tabulaires à n'importe quel niveau de compatibilité (1100, 1103, 1200). La dernière version de SQL Server Management Studio est mise à jour pour afficher les propriétés et fournir une administration de modèle de base de données pour les modèles tabulaires au niveau de compatibilité 1200.

Traitement parallèle pour plusieurs partitions de table dans les modèles tabulaires

Cette version inclut une nouvelle fonctionnalité de traitement parallèle pour les tables avec deux partitions ou plus, augmentant les performances de traitement. Il n'y a pas de paramètres de configuration pour cette fonctionnalité. Pour plus d'informations sur la configuration des partitions et des tables de traitement, consultez Partitions de modèle tabulaire.

Ajouter des comptes d'ordinateur en tant qu'administrateurs dans SSMS

Les administrateurs Analysis Services peuvent désormais utiliser SQL Server Management Studio pour configurer des comptes d'ordinateur afin qu'ils soient membres du groupe d'administrateurs Analysis Services. Dans le Sélectionnez des utilisateurs ou des groupes boîte de dialogue, définissez le Emplacements pour le domaine des ordinateurs, puis ajoutez le Des ordinateurs type d'objet. Pour plus d'informations, consultez Accorder des droits d'administrateur de serveur à une instance Analysis Services.

DBCC pour Analysis Services

Database Consistency Checker (DBCC) s'exécute en interne pour détecter les problèmes potentiels de corruption des données lors du chargement de la base de données, mais peut également être exécuté à la demande si vous suspectez des problèmes dans vos données ou votre modèle. DBCC exécute différentes vérifications selon que le modèle est tabulaire ou multidimensionnel. Voir Database Consistency Checker (DBCC) pour les bases de données tabulaires et multidimensionnelles Analysis Services pour plus de détails.

Mises à jour des événements étendus

Cette version ajoute une interface utilisateur graphique à SQL Server Management Studio pour configurer et gérer les événements étendus d'Analysis Services. Vous pouvez configurer des flux de données en direct pour surveiller l'activité du serveur en temps réel, conserver les données de session chargées en mémoire pour une analyse plus rapide ou enregistrer des flux de données dans un fichier pour une analyse hors ligne. Pour plus d'informations, consultez Surveiller Analysis Services avec les événements étendus de SQL Server.

Script

PowerShell pour les modèles tabulaires

Cette version inclut des améliorations PowerShell pour les modèles tabulaires au niveau de compatibilité 1200. Vous pouvez utiliser toutes les applets de commande applicables, ainsi que les applets de commande spécifiques au mode tabulaire : Invoke-ProcessASDatabase et Invoke-ProcessTable applet de commande.

Opérations de base de données de script SSMS

Dans le dernier SQL Server Management Studio (SSMS), le script est désormais activé pour les commandes de base de données, notamment Créer, Modifier, Supprimer, Sauvegarder, Restaurer, Attacher, Détacher. La sortie est le langage de script de modèle tabulaire (TMSL) en JSON. Voir Référence du langage de script de modèle tabulaire (TMSL) pour plus d'informations.

Analysis Services exécuter la tâche DDL

Analysis Services Execute DDL Task accepte désormais également les commandes TMSL (Tabular Model Scripting Language).

Applet de commande SSAS PowerShell

Applet de commande SSAS PowerShell Invoquer-ASCmd accepte désormais les commandes TMSL (Tabular Model Scripting Language). D'autres applets de commande SSAS PowerShell peuvent être mises à jour dans une future version pour utiliser les nouvelles métadonnées tabulaires (des exceptions seront signalées dans les notes de version). Consultez la référence de PowerShell Analysis Services pour plus de détails.

Langage de script de modèle tabulaire (TMSL) pris en charge dans SSMS

En utilisant la dernière version de SSMS, vous pouvez désormais créer des scripts pour automatiser la plupart des tâches administratives pour les modèles tabulaires 1200. Actuellement, les tâches suivantes peuvent être scriptées : Traiter à n'importe quel niveau, plus CREATE, ALTER, DELETE au niveau de la base de données.

Fonctionnellement, TMSL est équivalent à l'extension XMLA ASSL qui fournit des définitions d'objets multidimensionnels, sauf que TMSL utilise des descripteurs natifs comme maquette, tableau, et relation pour décrire les métadonnées tabulaires. Voir Référence du langage de script de modèle tabulaire (TMSL) pour plus de détails sur le schéma.

Un script JSON généré pour un modèle tabulaire peut ressembler à ce qui suit :

La charge utile est un document JSON qui peut être aussi minime que l'exemple ci-dessus, ou très agrémenté de l'ensemble complet de définitions d'objets. La référence TMSL (Tabular Model Scripting Language) décrit la syntaxe.

Au niveau de la base de données, les commandes CREATE, ALTER et DELETE afficheront le script TMSL dans la fenêtre XMLA familière. D'autres commandes, telles que Process, peuvent également être scriptées dans cette version. La prise en charge des scripts pour de nombreuses autres actions pourrait être ajoutée dans une future version.

Commandes scriptables La description
créer Ajoute une base de données, une connexion ou une partition. L'équivalent ASSL est CREATE.
créerOuRemplacer Met à jour une définition d'objet existante (base de données, connexion ou partition) en écrasant une version précédente. L'équivalent ASSL est ALTER avec AllowOverwrite défini sur true et ObjectDefinition sur ExpandFull.
effacer Supprime une définition d'objet. L'équivalent ASSL est DELETE.
rafraîchir Traite l'objet. L'équivalent ASSL est PROCESS.

Amélioration de l'édition des formules DAX

Les mises à jour de la barre de formule vous aident à écrire des formules plus facilement en différenciant les fonctions, les champs et les mesures à l'aide de la coloration de la syntaxe, elle fournit des suggestions intelligentes de fonctions et de champs et vous indique si des parties de votre expression DAX sont erronées en utilisant l'erreur gribouillis. Il vous permet également d'utiliser plusieurs lignes (Alt + Entrée) et l'indentation (Tab). La barre de formule vous permet désormais également d'écrire des commentaires dans le cadre de vos mesures, tapez simplement "//" et tout ce qui suit ces caractères sur la même ligne sera considéré comme un commentaire.

Variables DAX

Cette version inclut désormais la prise en charge des variables dans DAX. Les variables peuvent désormais stocker le résultat d'une expression en tant que variable nommée, qui peut ensuite être transmise en tant qu'argument à d'autres expressions de mesure. Une fois que les valeurs résultantes ont été calculées pour une expression de variable, ces valeurs ne changent pas, même si la variable est référencée dans une autre expression. Pour plus d'informations, voir Fonction VAR.

Nouvelles fonctions DAX

Avec cette version, DAX introduit plus de cinquante nouvelles fonctions pour prendre en charge des calculs plus rapides et des visualisations améliorées dans Power BI. Pour en savoir plus, voir Nouvelles fonctions DAX.

Enregistrer les mesures incomplètes

Vous pouvez désormais enregistrer des mesures DAX incomplètes directement dans un projet de modèle tabulaire 1200 et le récupérer lorsque vous êtes prêt à continuer.

Améliorations supplémentaires du DAX

  • Calcul non vide - Réduit le nombre de scans nécessaires pour non vide.
  • Fusion de mesures - Plusieurs mesures de la même table seront combinées en un seul moteur de stockage - requête.
  • Ensembles de regroupement - Lorsqu'une requête demande des mesures à plusieurs granularités (Total/Année/Mois), une seule requête est envoyée au niveau le plus bas et le reste des granularités est dérivé du niveau le plus bas.
  • Élimination des jointures redondantes - Une seule requête adressée au moteur de stockage renvoie à la fois les colonnes de dimension et les valeurs de mesure.
  • Évaluation stricte de IF/SWITCH - Une branche dont la condition est fausse n'entraînera plus de requêtes de moteur de stockage. Auparavant, les branches étaient évaluées avec empressement, mais les résultats ont été rejetés plus tard.

Développeur

Espace de noms Microsoft.AnalysisServices.Tabular pour la programmabilité Tabular 1200 dans AMO

Analysis Services Management Objects (AMO) est mis à jour pour inclure un nouvel espace de noms tabulaire pour la gestion d'une instance en mode tabulaire de SQL Server 2016 Analysis Services, ainsi que pour fournir le langage de définition de données pour créer ou modifier des modèles tabulaires 1200 par programmation. Visitez Microsoft.AnalysisServices.Tabular pour en savoir plus sur l'API.

Mises à jour des objets de gestion Analysis Services (AMO)

Analysis Services Management Objects (AMO) a été remanié pour inclure un deuxième assembly, Microsoft.AnalysisServices.Core.dll. Le nouvel assembly sépare les classes communes telles que Server, Database et Role qui ont une large application dans Analysis Services, quel que soit le mode serveur. Auparavant, ces classes faisaient partie de l'assembly Microsoft.AnalysisServices d'origine. Les déplacer vers un nouvel assemblage ouvre la voie à de futures extensions d'AMO, avec une division claire entre les API génériques et spécifiques au contexte. Les applications existantes ne sont pas affectées par les nouveaux assemblys. Toutefois, si vous choisissez de reconstruire des applications à l'aide du nouvel assembly AMO pour une raison quelconque, veillez à ajouter une référence à Microsoft.AnalysisServices.Core. De même, les scripts PowerShell qui se chargent et appellent dans AMO doivent désormais charger Microsoft.AnalysisServices.Core.dll. Assurez-vous de mettre à jour tous les scripts.

Éditeur JSON pour les fichiers BIM

La vue Code dans Visual Studio 2015 rend désormais le fichier BIM au format JSON pour les modèles tabulaires 1200. La version de Visual Studio détermine si le fichier BIM est rendu au format JSON via l'éditeur JSON intégré ou sous forme de texte simple.

Pour utiliser l'éditeur JSON, avec la possibilité de développer et de réduire les sections du modèle, vous aurez besoin de la dernière version de SQL Server Data Tools plus Visual Studio 2015 (toute édition, y compris l'édition communautaire gratuite). Pour toutes les autres versions de SSDT ou Visual Studio, le fichier BIM est rendu en JSON sous forme de texte simple. Au minimum, un modèle vide contiendra le JSON suivant :

Évitez de modifier directement le JSON. Cela peut corrompre le modèle.

Nouveaux éléments dans le schéma MS-CSDLBI 2.0

Les éléments suivants ont été ajoutés au TPropriété type complexe défini dans le schéma [MS-CSDLBI] 2.0 :

Élément Définition
Valeur par défaut Propriété qui spécifie la valeur utilisée lors de l'évaluation de la requête. La propriété DefaultValue est facultative, mais elle est automatiquement sélectionnée si les valeurs du membre ne peuvent pas être agrégées.
Statistiques Ensemble de statistiques à partir des données sous-jacentes associées à la colonne. Ces statistiques sont définies par le type complexe TPropertyStatistics et sont fournies uniquement si elles ne sont pas coûteuses en calculs à générer, comme décrit dans la section 2.1.13.5 du document Format de fichier de définition de schéma conceptuel avec annotations décisionnelles.

Requête directe

Nouvelle implémentation de DirectQuery

Cette version voit des améliorations significatives dans DirectQuery pour les modèles tabulaires 1200. Voici un résumé :

  • DirectQuery génère désormais des requêtes plus simples qui offrent de meilleures performances.
  • Contrôle supplémentaire sur la définition des exemples d'ensembles de données utilisés pour la conception et les tests du modèle.
  • La sécurité au niveau des lignes (RLS) est désormais prise en charge pour les modèles tabulaires 1200 en mode DirectQuery. Auparavant, la présence de RLS empêchait le déploiement d'un modèle tabulaire en mode DirectQuery.
  • Les colonnes calculées sont désormais prises en charge pour les modèles tabulaires 1200 en mode DirectQuery. Auparavant, la présence de colonnes calculées empêchait de déployer un modèle tabulaire en mode DirectQuery.
  • Les optimisations de performances incluent l'élimination des jointures redondantes pour VertiPaq et DirectQuery.

Nouvelles sources de données pour le mode DirectQuery

Les sources de données prises en charge pour les modèles tabulaires 1200 en mode DirectQuery incluent désormais Oracle, Teradata et Microsoft Analytics Platform (anciennement Parallel Data Warehouse). Pour en savoir plus, consultez Mode DirectQuery.


Voir la vidéo: Développement et factorisation 12 Résoudre une équation en factorisant (Octobre 2021).