Suite

Concaténer des données de chaîne et des données numériques dans le calculateur de champ ArcMap ?

Concaténer des données de chaîne et des données numériques dans le calculateur de champ ArcMap ?


J'utilise ArcMap 10.2.2.

J'ai trois champs d'attribut (Address_No : 1, StreetName : Main, Street_Ty : ST) que je veux fusionner. Comment concaténer les données de chaîne trouvées dans le tableau et les données numériques ?

Je voudrais le résultat suivant : 1 champ d'attribut - Adresse : 1 Main ST


Pas besoin d'écrire une fonction ici. Appuyez simplement sur le bouton radio Python, puis écrivez ceci dans la case :

Adresse : + " " + str(!Address_No!) + " " + !StreetName! + " " + !Street_Ty!

Ce qui est important:
- les noms de champs sont représentés par leur nom mais embrassés par points d'exclamation: !
- tout champ numérique doit être converti en chaîne lors de la concaténation avec d'autres chaînes. Pour le faire en Python, utilisez le str() une fonction. Tout ce qui se trouve entre parenthèses sera converti en chaîne, même s'il s'agit d'un nombre
- Vous devez ajouter des caractères vides (" ") entre vos parties, pour bien le formater, il apparaît donc comme: Adresse : 1 rue principale à la place de Adresse:1MainST


J'utiliserais un simple script Python dans l'outil de calcul de champ.

Ajoutez ceci dans la zone Codeblock :

def my_concaténation(address_nr, my_street_name, my_street_ty): my_address_nr = str(address_nr) # convertit le numéro d'adresse en chaînes afin qu'il puisse être concaténé avec le reste. my_result_string = "Address : {0} {1} {2}".format(my_address_nr,my_street_name,my_street_ty) # ajoute "Adresse :", concatène toutes les chaînes avec un espace entre les deux. renvoyer ma_chaîne_résultats

Ensuite, dans votre champ d'expression (sous le bloc de code), vous taperez :

my_concaténation(!Address_No!, !StreetName!, !Street_Ty!)

Je suppose que les noms de champs d'attribut que vous utilisez dans votre question sont les noms réels des champs. Sinon, remplacez ces noms entre le "!" dans ton expression. Assurez-vous de cocher le bouton radio de l'analyseur Python dans votre fenêtre de calcul de champ.


La version VB Script/alternative à la réponse de BritishSteel :

Ajoutez un nouveau champ de texte avec suffisamment de caractères pour contenir votre adresse la plus longue dans la table attributaire (doit être fait en dehors d'une session d'édition). Cliquez avec le bouton droit sur le nouveau champ et choisissez Calculateur de champ (dans ou hors d'une session d'édition, mais hors signifie pas d'annulation). Dans la zone Champs, double-cliquez sur le premier champ que vous souhaitez inclure. Il est ajouté à la case inférieure. Pour créer un espace entre celui-ci et la valeur du champ suivant que vous ajoutez, tapez

& " " &

dans la case inférieure après le premier nom de champ. J'aime laisser des espaces dans l'expression pour la rendre lisible, mais rappelez-vous que seuls les espaces entre guillemets seront rendus dans la sortie. Si vous ne vouliez pas d'espaces, vous utiliseriez simplement & (esperluette) qui est le caractère/symbole de concaténation comme + est en Python. Notez également que dans Python, les noms de champs sont entourés d'exlamations, mais dans VB Script, ce sont des crochets. Double-cliquez sur le champ suivant pour l'ajouter à l'expression, ajoutez les caractères d'espacement et d'esperluette, et ainsi de suite jusqu'à ce que vous ayez tous les champs souhaités.


Vous pouvez utiliser le formatage de chaîne Python dans le calculateur de champs sans utiliser de bloc de code, ce qui rend les choses un peu plus claires pour les opérations simples :

En règle générale, il est généralement préférable d'utiliser le formatage des chaînes et d'éviter d'utiliser la concaténation. Cela est particulièrement vrai lorsque vous souhaitez avoir une mise en forme numérique plus complexe, telle que la mise en forme de la devise ou de la date. Je vous suggère également de jeter un œil à la documentation Python pour voir plus d'exemples d'utilisation du formatage de chaîne :

Formatage de chaîne Python


Valeurs calculées et logique conditionnelle

La boîte de dialogue Générateur d'expressions peut être utilisée pour créer une logique conditionnelle, des valeurs calculées, des messages d'erreur ou pour simuler une base de données. Cette boîte de dialogue s'ouvre soit lorsque vous souhaitez ajouter une condition à un événement, soit lorsque vous souhaitez créer une action de valeur définie avec une valeur calculée.

La partie supérieure de la boîte de dialogue affiche l'expression ou la condition en cours de création. Si une condition est en cours de construction, l'expression serait entre deux crochets et précédée du mot ‘when’. C'est une aide visuelle pour souligner que le résultat de l'expression qui y est construite doit être résolu en vrai ou en faux. Pas un numéro ou un texte.

Outre la définition des conditions, la boîte de dialogue Générateur d'expressions peut également être utilisée pour définir des valeurs calculées pour les types d'action d'événement suivants : Définir la valeur, Faire pivoter, Redimensionner et Déplacer.

Pour utiliser cette boîte de dialogue pour créer une condition, cliquez sur le lien “Ajouter une condition” qui apparaît dans la palette Événements après avoir créé un événement.


Entités ponctuelles en entrée contenant les valeurs z à interpoler.

Champ contenant une valeur de hauteur ou de magnitude pour chaque point. Il peut s'agir d'un champ numérique ou du champ Forme si les entités en entrée contiennent des valeurs z ou des valeurs m.

La couche géostatistique produite. Cette couche est requise en sortie uniquement si aucun raster en sortie n'est requis.

Le raster en sortie. Ce raster est requis en sortie uniquement si aucune couche géostatistique en sortie n'est requise.

La taille de cellule à laquelle le raster en sortie sera créé.

Cette valeur peut être explicitement définie sous Analyse raster à partir des Paramètres d'environnement .

S'il n'est pas défini, il s'agit de la largeur ou de la hauteur la plus courte de l'étendue des entités ponctuelles en entrée, dans la référence spatiale en entrée, divisée par 250.

L'ordre du polynôme.

Définit quels points environnants seront utilisés pour contrôler la sortie. La norme est la valeur par défaut.

  • majorSemiaxis — La valeur du demi-axe principal du voisinage de recherche.
  • minorSemiaxis — La valeur du demi-axe mineur du voisinage de recherche.
  • angle : l'angle de rotation de l'axe (cercle) ou du demi-grand axe (ellipse) de la fenêtre mobile.
  • nbrMax : nombre maximal de voisins qui seront utilisés pour estimer la valeur à l'emplacement inconnu.
  • nbrMin : nombre minimal de voisins qui seront utilisés pour estimer la valeur à l'emplacement inconnu.
  • sectorType : la géométrie du voisinage.
    • ONE_SECTOR —Ellipse simple.
    • FOUR_SECTORS —Ellipse divisée en quatre secteurs.
    • FOUR_SECTORS_SHIFTED —Ellipse divisée en quatre secteurs et décalée de 45 degrés.
    • EIGHT_SECTORS —Ellipse divisée en huit secteurs.
    • majorSemiaxis — La valeur du demi-axe principal du voisinage de recherche.
    • minorSemiaxis — La valeur du demi-axe mineur du voisinage de recherche.
    • angle : l'angle de rotation de l'axe (cercle) ou du demi-grand axe (ellipse) de la fenêtre mobile.
    • smoothFactor : l'option Lisser l'interpolation crée une ellipse externe et une ellipse interne à une distance égale au demi-axe majeur multiplié par le facteur de lissage. Les points situés à l'extérieur de la plus petite ellipse mais à l'intérieur de la plus grande ellipse sont pondérés à l'aide d'une fonction sigmoïde avec une valeur comprise entre zéro et un.
    • radius : la longueur du rayon du cercle de recherche.
    • angle : l'angle de rotation de l'axe (cercle) ou du demi-grand axe (ellipse) de la fenêtre mobile.
    • nbrMax : nombre maximal de voisins qui seront utilisés pour estimer la valeur à l'emplacement inconnu.
    • nbrMin : nombre minimal de voisins qui seront utilisés pour estimer la valeur à l'emplacement inconnu.
    • sectorType : la géométrie du voisinage.
      • ONE_SECTOR —Ellipse simple.
      • FOUR_SECTORS —Ellipse divisée en quatre secteurs.
      • FOUR_SECTORS_SHIFTED —Ellipse divisée en quatre secteurs et décalée de 45 degrés.
      • EIGHT_SECTORS —Ellipse divisée en huit secteurs.
      • radius : la longueur du rayon du cercle de recherche.
      • smoothFactor : l'option Lisser l'interpolation crée une ellipse externe et une ellipse interne à une distance égale au demi-axe majeur multiplié par le facteur de lissage. Les points qui tombent à l'extérieur de la plus petite ellipse mais à l'intérieur de la plus grande ellipse sont pondérés à l'aide d'une fonction sigmoïde avec une valeur comprise entre zéro et un.

      La fonction noyau utilisée dans la simulation.

      • EXPONENTIAL — La fonction augmente ou diminue proportionnellement.
      • GAUSSIAN — Fonction en forme de cloche qui tombe rapidement vers plus/moins l'infini.
      • QUARTIC — Fonction polynomiale du quatrième ordre.
      • EPANECHNIKOV — Une fonction parabolique discontinue.
      • POLYNOMIAL5 — Fonction polynomiale du cinquième ordre.
      • CONSTANT —Une fonction d'indicateur.

      Option pour contrôler la création d'erreurs standard de prédiction et de prédiction lorsque les prédictions sont instables. Cette option n'est disponible que pour les polynômes d'ordre 1, 2 et 3.

      • NO_USE_CONDITION_NUMBER —Des erreurs standard de prédiction et de prédiction peuvent être créées lorsque les prédictions sont instables. C'est la valeur par défaut.
      • USE_CONDITION_NUMBER —Les erreurs standard de prédiction et de prédiction ne seront pas créées lorsque les prédictions sont instables.

      Utilisé pour spécifier la distance maximale à laquelle les points de données sont utilisés pour la prédiction. Avec l'augmentation de la bande passante, le biais de prédiction augmente et la variance de prédiction diminue.

      Chaque matrice carrée inversible a un numéro de condition qui indique à quel point la solution des équations linéaires peut être imprécise avec un petit changement dans les coefficients de la matrice (cela peut être dû à des données imprécises). Si le nombre de conditions est grand, un petit changement dans les coefficients de la matrice entraîne un grand changement dans le vecteur de solution.

      Utilisé pour souligner une observation. Plus le poids est grand, plus il a d'impact sur la prédiction. Pour les observations coïncidentes, attribuez le poids le plus élevé à la mesure la plus fiable.


      Une base de données SIG pilote des failles actives du mont. Etna (Sicile) : Un outil pour l'évaluation intégrée des dangers

      Un système pilote basé sur le SIG a été mis en œuvre pour l'évaluation et l'analyse des risques liés aux failles actives affectant les flancs est et sud du mont. Etna. La structure du système a été développée dans l'environnement ArcGis® et se compose de différents ensembles de données thématiques qui incluent des caractéristiques d'arc référencées spatialement et une base de données associée. Les caractéristiques de type arc, géoréférencées dans la projection WGS84 Ellipsoid UTM zone 33, représentent les cinq principaux systèmes de failles qui se développent dans la région analysée. L'épine dorsale du système basé sur le SIG est constituée par la grande quantité d'informations qui ont été collectées à partir de la littérature puis stockées et correctement géocodées dans une base de données numérique. Cela se compose de trente-cinq champs alphanumériques qui incluent tous les paramètres de défaut disponibles dans la littérature tels que l'emplacement, la cinématique, le relief, le taux de glissement, etc.

      Bien que le système ait été mis en œuvre selon les procédures les plus courantes utilisées par les développeurs de SIG, l'architecture et le contenu de la base de données représentent une épine dorsale pilote pour le stockage numérique des paramètres de faille, fournissant un outil puissant pour modéliser les risques liés à la tectonique active du mont. Etna. La base de données collecte, organise et partage toutes les informations scientifiques actuellement disponibles sur les failles actives du volcan. De plus, grâce aux efforts considérables consacrés à la définition des champs de la base de données, la structure proposée dans cet article est ouverte à la collecte de données supplémentaires provenant d'améliorations futures de la connaissance des systèmes de failles. En superposant des informations géographiques supplémentaires spécifiques à l'utilisateur et en gérant la base de données proposée (interrogation topologique), une grande diversité de cartes d'aléas et de vulnérabilité peut être produite par l'utilisateur. Il s'agit d'une proposition de colonne vertébrale pour une base de données géographique complète des systèmes de défaillance, universellement applicable à d'autres sites.

      Points forts

      ► Un système basé sur SIG a été mis en œuvre pour analyser le danger lié aux failles actives sur le mont. Etna. ► Le SIG a été développé en ArcGis® et comprend des caractéristiques de type arc et la base de données associée. ► La base de données contient des informations sur les géométries et la cinématique des défauts. ► Les informations archivées peuvent être représentées dans une grande diversité de cartes d'aléas. ► Le SIG proposé peut représenter le socle commun des futurs travaux scientifiques et aléas.


      Vous faites une mauvaise affectation de var.

      Vous êtes censé envoyer "$passvar" à md5sum . Il ne passera pas par le tuyau | par lui-même, vous devez donc soit utiliser echo , soit printf . Cela produira des choses dans le flux stdout. Vous pouvez capturer cela dans une variable avec la substitution de commande $(. ) . En d'autres termes, vous devriez faire :

      N'oubliez pas non plus de citer les variables pour préserver l'intégrité des données qui y sont stockées et éviter le fractionnement des mots.

      Remarquez deux choses ici : il n'y a pas de nouvelle ligne après "Votre mot de passe", vous pouvez donc vouloir ajouter un écho après cette commande. Deuxièmement, notez que md5sum renvoie le nom de fichier après la somme de contrôle md5 calculée, qui dans ce cas est - ou stdin stream. Vous voudrez peut-être envisager de vous débarrasser de cette partie via n'importe quel utilitaire de traitement de texte qui vous permettra de couper des mots, comme awk :

      Alternativement, vous pouvez simplement utiliser les bash read et here-string <<< (voir ceci pour plus d'informations sur cet opérateur) :

      Last but not least, votre #! la ligne est manquante / avant bin - elle devrait être #!/bin/bash .

      Le script complet devrait être le suivant :

      Notez que j'ai commenté la redirection vers un fichier, juste pour voir la sortie sur le terminal à des fins de test. Voilà comment cela fonctionne:

      Pour référence future, vous pouvez ajouter set -x après #!/bin/bash (étant donné que vous avez bien défini la ligne #!, bien sûr) pour dépanner le script et voir quelles commandes s'exécutent réellement et quelles erreurs pourraient survenir. Ou utilisez simplement l'outil en ligne shellcheck.


      Validation technique

      Les données de l'USWTDB sont soumises à un contrôle qualité rigoureux et à une validation à l'aide de plusieurs méthodes. Ceux-ci incluent : (1) l'utilisation d'images aériennes à haute résolution pour valider les emplacements WT, (2) la comparaison et la corroboration entre plusieurs ensembles de données sources, (3) une revue interne trimestrielle approfondie et un contrôle qualité par les auteurs, (4) une revue externe trimestrielle par des experts techniques extérieurs à l'équipe de base de données, (5) examen interne des données et métadonnées trimestrielles par des non-membres de l'équipe dans le cadre des pratiques scientifiques fondamentales de l'USGS, et (6) commentaires des utilisateurs de la base de données.

      L'utilisation de l'imagerie aérienne pour vérifier les emplacements WT a été décrite en détail dans la section méthodes. Entre mars 2017 et octobre 2019, plus de 43 500 points WT ont été examinés visuellement, plus de 12 500 points en double ont été identifiés et supprimés, plus de 4 900 WT ont été marqués comme démontés et supprimés, plus de 4 100 points ont été déplacés pour la précision de localisation, et plus de 660 les points qui n'étaient pas des WT à l'échelle utilitaire ont été identifiés et supprimés. L'erreur humaine a été minimisée dans le processus de vérification visuelle grâce à l'utilisation de contrôles internes et d'un examen par les pairs par plusieurs analystes d'équipe. La figure 5 montre le pourcentage de points WT installés chaque année qui ont été déplacés pour la précision de localisation, et la figure 6 montre la distance moyenne des WT déplacés par année d'installation. Les points WT dans l'USWTDB sont ajustés à la base de la turbine avec une tolérance de 10 mètres au minimum (c'est-à-dire que les points WT qui semblent être à moins de 10 m de la base WT ne sont pas déplacés). En octobre 2019, 58 026 (95,8 %) des 60 576 WT de l'USWTDB ont le score de confiance de localisation le plus élevé, tandis que 288 (0,5 %) ont une confiance de localisation partielle, et 2 262 (3,7 %) ont une confiance faible (voir Fig. 7, ces les scores sont définis dans la section « Enregistrements de données » ci-dessus). La confiance en l'emplacement est très élevée dans l'ensemble, mais a tendance à être plus faible pour les WT plus récentes, car les images aériennes disponibles peuvent retarder de plusieurs années les installations réelles (cela explique la confiance réduite en 2018-2019 illustrée à la figure 7).

      Pourcentage de points WT déplacés pour la précision de la localisation, par année (en octobre 2019).


      11.3 Types de date et d'heure

      Les types de date et d'heure pour représenter les valeurs temporelles sont DATE , TIME , DATETIME , TIMESTAMP et YEAR . Chaque type temporel a une plage de valeurs valides, ainsi qu'une valeur « zéro » qui peut être utilisée lorsque vous spécifiez une valeur invalide que MySQL ne peut pas représenter. Le type TIMESTAMP a un comportement de mise à jour automatique spécial, décrit plus loin. Pour les exigences de stockage de type temporel, reportez-vous à la Section 11.8, « Exigences de stockage de type de données ».

      Gardez à l'esprit ces considérations générales lorsque vous travaillez avec des types de date et d'heure :

      MySQL récupère les valeurs pour un type de date ou d'heure donné dans un format de sortie standard, mais il tente d'interpréter une variété de formats pour les valeurs d'entrée que vous fournissez (par exemple, lorsque vous spécifiez une valeur à attribuer ou à comparer à une date ou type de temps). Pour une description des formats autorisés pour les types de date et d'heure, reportez-vous à la Section 9.1.3, « Littéraux de date et d'heure ». Vous devez fournir des valeurs valides. Des résultats imprévisibles peuvent se produire si vous utilisez des valeurs dans d'autres formats.

      Bien que MySQL essaie d'interpréter les valeurs dans plusieurs formats, les parties de date doivent toujours être données dans l'ordre année-mois-jour (par exemple, '98-09-04' ), plutôt que dans l'ordre mois-jour-année ou jour-mois- commandes annuelles couramment utilisées ailleurs (par exemple, '09-04-98' , '04-09-98' ).

      Les dates contenant des valeurs d'année à deux chiffres sont ambiguës car le siècle est inconnu. MySQL interprète les valeurs d'année à deux chiffres en utilisant ces règles :

      Les valeurs de l'année dans la plage 70-99 sont converties en 1970-1999.

      Les valeurs de l'année dans la plage 00-69 sont converties en 2000-2069 .

      La conversion des valeurs d'un type temporel à un autre se produit selon les règles de la Section 11.3.7, « Conversion entre les types date et heure ».

      MySQL convertit automatiquement une valeur de date ou d'heure en nombre si la valeur est utilisée dans un contexte numérique et vice versa.

      Par défaut, lorsque MySQL rencontre une valeur pour un type de date ou d'heure qui est hors plage ou non valide pour le type, il convertit la valeur en la valeur « zéro » pour ce type. L'exception est que les valeurs TIME hors plage sont écrêtées au point de terminaison approprié de la plage TIME.

      En définissant le mode SQL sur la valeur appropriée, vous pouvez spécifier plus précisément le type de dates que MySQL prend en charge. (Voir Section 5.1.10, « Modes SQL du serveur ».) Vous pouvez faire en sorte que MySQL accepte certaines dates, telles que '2009-11-31' , en activant le mode SQL ALLOW_INVALID_DATES. Ceci est utile lorsque vous souhaitez stocker une valeur « peut-être erronée » que l'utilisateur a spécifiée (par exemple, dans un formulaire Web) dans la base de données pour un traitement futur. Dans ce mode, MySQL vérifie uniquement que le mois est compris entre 1 et 12 et que le jour est compris entre 1 et 31.

      MySQL vous permet de stocker des dates où le jour ou le mois et le jour sont à zéro dans une colonne DATE ou DATETIME. Ceci est utile pour les applications qui doivent stocker des dates de naissance dont vous ne connaissez peut-être pas la date exacte. Dans ce cas, vous enregistrez simplement la date sous la forme '2009-00-00' ou '2009-01-00' . Si vous stockez des dates telles que celles-ci, vous ne devez pas vous attendre à obtenir des résultats corrects pour des fonctions telles que DATE_SUB() ou DATE_ADD() qui nécessitent des dates complètes. Pour interdire les parties zéro mois ou jour dans les dates, activez le mode NO_ZERO_IN_DATE.

      MySQL vous permet de stocker une valeur « zéro » de « 0000-00-00 » comme une « date factice. ” Ceci est dans certains cas plus pratique que l'utilisation de valeurs NULL et utilise moins d'espace de données et d'index. Pour interdire '0000-00-00' , activez le mode NO_ZERO_DATE.

      Les valeurs de date ou d'heure « zéro » utilisées via Connector/ODBC sont converties automatiquement en NULL car ODBC ne peut pas gérer de telles valeurs.

      Le tableau suivant montre le format de la valeur « zéro » pour chaque type. Les valeurs « zéro » sont spéciales, mais vous pouvez les stocker ou vous y référer explicitement en utilisant les valeurs indiquées dans le tableau. Vous pouvez également le faire en utilisant les valeurs '0' ou 0 , qui sont plus faciles à écrire. Pour les types temporels qui incluent une partie date ( DATE , DATETIME et TIMESTAMP ), l'utilisation de ces valeurs génère des avertissements si le mode SQL NO_ZERO_DATE est activé.

      11.3.1 Les types DATE, DATETIME et TIMESTAMP

      Les types DATE , DATETIME et TIMESTAMP sont liés. Cette section décrit leurs caractéristiques, leurs similitudes et leurs différences. MySQL reconnaît les valeurs DATE , DATETIME et TIMESTAMP dans plusieurs formats, décrits dans Section 9.1.3, « Littéraux de date et d'heure ». Pour les descriptions de plage DATE et DATETIME, « supporté » signifie que même si les valeurs antérieures peuvent fonctionner, il n'y a aucune garantie.

      Le type DATE est utilisé pour les valeurs avec une partie date mais pas une partie heure. MySQL récupère et affiche les valeurs DATE au format 'AAAA-MM-JJ'. La plage prise en charge est '1000-01-01' à '9999-12-31' .

      Le type DATETIME est utilisé pour les valeurs qui contiennent à la fois des parties de date et d'heure. MySQL récupère et affiche les valeurs DATETIME au format 'AAAA-MM-JJ HH:MM:SS'. La plage prise en charge est de '1000-01-01 00:00:00' à '9999-12-31 23:59:59' .

      Le type de données TIMESTAMP est utilisé pour les valeurs qui contiennent à la fois des parties de date et d'heure. TIMESTAMP a une plage de '1970-01-01 00:00:01' UTC à '2038-01-19 03:14:07' UTC.

      Une valeur DATETIME ou TIMESTAMP peut inclure une fraction de seconde à la fin avec une précision allant jusqu'à la microseconde (6 chiffres). En particulier, toute partie fractionnaire d'une valeur insérée dans une colonne DATETIME ou TIMESTAMP est stockée plutôt que supprimée. Avec la partie fractionnaire incluse, le format de ces valeurs est 'YYYY-MM-DD HH:MM:SS[.fraction]' , la plage pour les valeurs DATETIME est '1000-01-01 00:00:00.000000' à '9999 -12-31 23:59:59.999999' , et la plage des valeurs TIMESTAMP est '1970-01-01 00:00:01.000000' à '2038-01-19 03:14:07.999999' . La partie fractionnaire doit toujours être séparée du reste du temps par un point décimal, aucun autre délimiteur de fractions de seconde n'est reconnu. Pour plus d'informations sur la prise en charge des fractions de secondes dans MySQL, consultez Section 11.3.6, « Secondes fractionnaires dans les valeurs temporelles ».

      Les types de données TIMESTAMP et DATETIME offrent une initialisation et une mise à jour automatiques à la date et à l'heure actuelles. Pour plus d'informations, reportez-vous à la Section 11.3.5, « Initialisation et mise à jour automatiques pour TIMESTAMP et DATETIME ».

      MySQL convertit les valeurs TIMESTAMP du fuseau horaire actuel en UTC pour le stockage, et de l'UTC au fuseau horaire actuel pour la récupération. (Cela ne se produit pas pour les autres types tels que DATETIME .) Par défaut, le fuseau horaire actuel pour chaque connexion est l'heure du serveur. Le fuseau horaire peut être défini pour chaque connexion. Tant que le réglage du fuseau horaire reste constant, vous récupérez la même valeur que vous avez stockée. Si vous stockez une valeur TIMESTAMP, puis modifiez le fuseau horaire et récupérez la valeur, la valeur récupérée est différente de la valeur que vous avez stockée. Cela se produit parce que le même fuseau horaire n'a pas été utilisé pour la conversion dans les deux sens. Le fuseau horaire actuel est disponible en tant que valeur de la variable système time_zone. Pour plus d'informations, consultez Section 5.1.12, « Prise en charge du fuseau horaire de MySQL Server ».

      Les valeurs DATE , DATETIME ou TIMESTAMP non valides sont converties en la valeur « zéro » du type approprié ( '0000-00-00' ou '0000-00-00 00:00:00' ).

      Soyez conscient de certaines propriétés d'interprétation de la valeur de date dans MySQL :

      MySQL autorise un format « détendu » pour les valeurs spécifiées sous forme de chaînes, dans lequel tout caractère de ponctuation peut être utilisé comme délimiteur entre les parties date ou heure. Dans certains cas, cette syntaxe peut être trompeuse. Par exemple, une valeur telle que '10:11:12' peut ressembler à une valeur temporelle à cause du : , mais est interprétée comme l'année '2010-11-12' si elle est utilisée dans un contexte de date. La valeur '10:45:15' est convertie en '0000-00-00' car '45' n'est pas un mois valide.

      Le seul délimiteur reconnu entre une partie date et heure et une partie fraction de seconde est le point décimal.

      Le serveur exige que les valeurs du mois et du jour soient valides, et pas seulement dans la plage 1 à 12 et 1 à 31, respectivement. Lorsque le mode strict est désactivé, les dates invalides telles que « 2004-04-31 » sont converties en « 0000-00-00 » et un avertissement est généré. Avec le mode strict activé, les dates invalides génèrent une erreur. Pour autoriser ces dates, activez ALLOW_INVALID_DATES . Voir Section 5.1.10, « Modes SQL du serveur », pour plus d'informations.

      MySQL n'accepte pas les valeurs TIMESTAMP qui incluent un zéro dans la colonne du jour ou du mois ou des valeurs qui ne sont pas une date valide. La seule exception à cette règle est la valeur spéciale « zéro » '0000-00-00 00:00:00' .

      Les dates contenant des valeurs d'année à deux chiffres sont ambiguës car le siècle est inconnu. MySQL interprète les valeurs d'année à deux chiffres en utilisant ces règles :

      Les valeurs de l'année dans la plage 00-69 sont converties en 2000-2069 .

      Les valeurs de l'année dans la plage 70-99 sont converties en 1970-1999.

      Le serveur MySQL peut être exécuté avec le mode MAXDB SQL activé. Dans ce cas, TIMESTAMP est identique à DATETIME . Si ce mode est activé au moment de la création d'une table, les colonnes TIMESTAMP sont créées en tant que colonnes DATETIME. Par conséquent, ces colonnes utilisent le format d'affichage DATETIME, ont la même plage de valeurs et il n'y a pas d'initialisation ou de mise à jour automatique à la date et à l'heure actuelles. Voir Section 5.1.10, « Modes SQL du serveur ».

      Depuis MySQL 5.7.22, MAXDB est obsolète. Il sera supprimé dans une future version de MySQL.

      11.3.2 Le type de temps

      MySQL récupère et affiche les valeurs TIME au format 'HH:MM:SS' (ou au format 'HHH:MM:SS' pour les grandes valeurs d'heures). Les valeurs TIME peuvent aller de "-838:59:59" à "838:59:59" . La partie heures peut être si grande parce que le type TIME peut être utilisé non seulement pour représenter une heure de la journée (qui doit être inférieure à 24 heures), mais aussi le temps écoulé ou un intervalle de temps entre deux événements (qui peut être beaucoup plus grand que 24 heures, voire négative).

      MySQL reconnaît les valeurs TIME dans plusieurs formats, dont certains peuvent inclure une fraction de seconde à la fin avec une précision allant jusqu'à la microseconde (6 chiffres). Voir Section 9.1.3, « Littéraux de date et d'heure ». Pour plus d'informations sur la prise en charge des fractions de secondes dans MySQL, consultez Section 11.3.6, « Secondes fractionnaires dans les valeurs temporelles ». En particulier, toute partie fractionnaire d'une valeur insérée dans une colonne TIME est stockée plutôt que supprimée. Avec la partie fractionnaire incluse, la plage des valeurs TIME est de '-838:59:59.000000' à '838:59:59.000000' .

      Soyez prudent lorsque vous attribuez des valeurs abrégées à une colonne TIME. MySQL interprète les valeurs TIME abrégées avec des deux-points comme l'heure de la journée. C'est-à-dire que '11:12' signifie '11:12:00' , et non '00:11:12' . MySQL interprète les valeurs abrégées sans deux-points en supposant que les deux chiffres les plus à droite représentent les secondes (c'est-à-dire le temps écoulé plutôt que l'heure de la journée). Par exemple, vous pourriez penser à "1112" et 1112 comme signifiant "11:12:00" (12 minutes après 11 heures), mais MySQL les interprète comme "00:11:12" (11 minutes, 12 secondes) . De même, '12' et 12 sont interprétés comme '00:00:12' .

      Le seul délimiteur reconnu entre une partie de temps et une partie de fraction de seconde est le point décimal.

      Par défaut, les valeurs qui se situent en dehors de la plage TIME mais qui sont par ailleurs valides sont tronquées au point de terminaison le plus proche de la plage. Par exemple, '-850:00:00' et '850:00:00' sont convertis en '-838:59:59' et '838:59:59' . Les valeurs TIME non valides sont converties en '00:00:00' . Notez que parce que '00:00:00' est lui-même une valeur TIME valide, il n'y a aucun moyen de dire, à partir d'une valeur de '00:00:00' stockée dans une table, si la valeur d'origine a été spécifiée comme '00 : 00:00' ou s'il était invalide.

      Pour un traitement plus restrictif des valeurs TIME non valides, activez le mode SQL strict pour provoquer des erreurs. Voir Section 5.1.10, « Modes SQL du serveur ».

      11.3.3 Le type ANNÉE

      Le type YEAR est un type à 1 octet utilisé pour représenter les valeurs de l'année. Il peut être déclaré comme YEAR ou YEAR(4) et a une largeur d'affichage de quatre caractères.

      Le type de données YEAR(2) est obsolète et sa prise en charge est supprimée dans MySQL 5.7.5. Pour convertir les colonnes YEAR(2) en YEAR(4) , reportez-vous à la Section 11.3.4, « Limitations de YEAR(2) et migration vers YEAR(4) ».

      MySQL affiche les valeurs YEAR au format YYYY, avec une plage de 1901 à 2155 , ou 0000 .

      Vous pouvez spécifier les valeurs YEAR d'entrée dans une variété de formats :

      Sous forme de nombre à 4 chiffres compris entre 1901 et 2155 .

      Sous forme de chaîne à 4 chiffres dans la plage « 1901 » à « 2155 ».

      Sous forme de nombre à 1 ou 2 chiffres compris entre 1 et 99 . MySQL convertit les valeurs dans les plages 1 à 69 et 70 à 99 en valeurs YEAR dans les plages 2001 à 2069 et 1970 à 1999 .

      Sous forme de chaîne à 1 ou 2 chiffres dans la plage « 0 » à « 99 ». MySQL convertit les valeurs comprises entre " 0 " et " 69 " et " 70 " à " 99 " en valeurs YEAR comprises entre 2000 et 2069 et 1970 à 1999 .

      Le résultat de l'insertion d'un 0 numérique a une valeur d'affichage de 0000 et une valeur interne de 0000 . Pour insérer zéro et le faire interpréter comme 2000 , spécifiez-le comme une chaîne '0' ou '00' .

      En tant que résultat d'une fonction qui renvoie une valeur acceptable dans un contexte YEAR, telle que NOW() .

      MySQL convertit les valeurs YEAR invalides en 0000 .

      11.3.4 Limitations de YEAR(2) et migration vers YEAR(4)

      Cette section décrit les problèmes pouvant survenir lors de l'utilisation de YEAR(2) et fournit des informations sur la conversion des colonnes YEAR(2) existantes en YEAR(4) .

      Bien que la plage interne de valeurs pour YEAR(4) et le type obsolète YEAR(2) soit la même ( 1901 à 2155 et 0000 ), la largeur d'affichage pour YEAR(2) rend ce type intrinsèquement ambigu car les valeurs affichées n'indiquent que le les deux derniers chiffres des valeurs internes et omettre les chiffres du siècle. Le résultat peut être une perte d'informations dans certaines circonstances. Pour cette raison, avant MySQL 5.7.5, évitez d'utiliser YEAR(2) dans vos applications et utilisez YEAR(4) partout où vous avez besoin d'un type de données YEAR. Depuis MySQL 5.7.5, la prise en charge de YEAR(2) est supprimée et les colonnes YEAR(2) existantes doivent être converties en YEAR(4) pour redevenir utilisables.

      ANNÉE(2) Limites

      Les problèmes avec le type de données YEAR(2) incluent l'ambiguïté des valeurs affichées et la perte possible d'informations lorsque les valeurs sont vidées et rechargées ou converties en chaînes.

      Les valeurs YEAR(2) affichées peuvent être ambiguës. Il est possible que jusqu'à trois valeurs YEAR(2) ayant des valeurs internes différentes aient la même valeur affichée, comme le montre l'exemple suivant :

      Si tu utilises mysqldump pour vider la table créée dans l'élément précédent, le fichier de vidage représente toutes les valeurs y2 en utilisant la même représentation à 2 chiffres (12). Si vous rechargez la table à partir du fichier de vidage, toutes les lignes résultantes ont la valeur interne 2012 et la valeur d'affichage 12 , perdant ainsi les distinctions entre elles.

      La conversion d'une valeur de données YEAR(2) ou YEAR(4) sous forme de chaîne utilise la largeur d'affichage du type YEAR. Supposons que les colonnes YEAR(2) et YEAR(4) contiennent toutes deux la valeur 1970 . L'affectation de chaque colonne à une chaîne donne respectivement la valeur '70' ou '1970' . C'est-à-dire qu'une perte d'informations se produit pour la conversion de YEAR(2) en chaîne.

      Les valeurs en dehors de la plage de 1970 à 2069 sont stockées de manière incorrecte lorsqu'elles sont insérées dans une colonne YEAR(2) dans une table CSV. Par exemple, l'insertion de 2111 entraîne une valeur d'affichage de 11 mais une valeur interne de 2011 .

      Pour éviter ces problèmes, utilisez YEAR(4) plutôt que YEAR(2) . Des suggestions concernant les stratégies de migration apparaissent plus loin dans cette section.

      Prise en charge réduite/supprimée de YEAR(2) dans MySQL 5.7

      Avant MySQL 5.7.5, la prise en charge de YEAR(2) est diminuée. Depuis MySQL 5.7.5, la prise en charge de YEAR(2) est supprimée.

      Les définitions de colonne YEAR(2) pour les nouvelles tables génèrent des avertissements ou des erreurs :

      Avant MySQL 5.7.5, les définitions de colonne YEAR(2) pour les nouvelles tables sont converties (avec un avertissement ER_INVALID_YEAR_COLUMN_LENGTH) en YEAR(4) :

      Depuis MySQL 5.7.5, les définitions de colonne YEAR(2) pour les nouvelles tables produisent une erreur ER_INVALID_YEAR_COLUMN_LENGTH :

      La colonne ANNÉE(2) dans les tables existantes reste comme ANNÉE(2) :

      Avant MySQL 5.7.5, YEAR(2) était traité dans les requêtes comme dans les anciennes versions de MySQL.

      Depuis MySQL 5.7.5, les colonnes YEAR(2) dans les requêtes produisent des avertissements ou des erreurs.

      Plusieurs programmes ou instructions convertissent automatiquement YEAR(2) en YEAR(4) :

      Les instructions ALTER TABLE qui entraînent une reconstruction de la table.

      REPAIR TABLE (que CHECK TABLE vous recommande d'utiliser s'il constate qu'une table contient des colonnes YEAR(2)).

      Jeter avec mysqldump et recharger le fichier de vidage. Contrairement aux conversions effectuées par les trois éléments précédents, un vidage et un rechargement ont le potentiel de modifier les valeurs.

      Une mise à niveau MySQL implique généralement au moins l'un des deux derniers éléments. Cependant, en ce qui concerne l'ANNÉE(2) , mysql_upgrade est préférable. Vous devriez éviter d'utiliser mysqldump car, comme indiqué, cela peut changer les valeurs.

      Migration de YEAR(2) à YEAR(4)

      Pour convertir les colonnes YEAR(2) en YEAR(4) , vous pouvez le faire manuellement à tout moment sans effectuer de mise à niveau. Alternativement, vous pouvez passer à une version de MySQL avec une prise en charge réduite ou supprimée de YEAR(2) (MySQL 5.6.6 ou version ultérieure), puis demander à MySQL de convertir automatiquement les colonnes YEAR(2). Dans ce dernier cas, évitez de mettre à niveau en vidant et en rechargeant vos données car cela peut modifier les valeurs des données. De plus, si vous utilisez la réplication, vous devez prendre en compte des considérations de mise à niveau.

      Pour convertir manuellement les colonnes YEAR(2) en YEAR(4), utilisez ALTER TABLE ou REPAIR TABLE . Supposons qu'une table t1 ait cette définition :

      Modifiez la colonne à l'aide de ALTER TABLE comme suit :

      L'instruction ALTER TABLE convertit la table sans modifier les valeurs YEAR(2). Si le serveur est un maître de réplication, l'instruction ALTER TABLE se réplique vers les esclaves et modifie la table correspondante sur chacun.

      Une autre méthode de migration consiste à effectuer une mise à niveau binaire : installez MySQL sans vider ni recharger vos données. Puis cours mysql_upgrade , qui utilise REPAIR TABLE pour convertir les colonnes YEAR(2) en YEAR(4) sans modifier les valeurs des données. Si le serveur est un maître de réplication, les instructions REPAIR TABLE se répliquent sur les esclaves et apportent les modifications de table correspondantes sur chacun, sauf si vous appelez mysql_upgrade avec l'option --skip-write-binlog.

      Les mises à niveau vers les serveurs de réplication impliquent généralement la mise à niveau des esclaves vers une version plus récente de MySQL, puis la mise à niveau du maître. Par exemple, si un maître et un esclave exécutent tous les deux MySQL 5.5, une séquence de mise à niveau typique implique la mise à niveau de l'esclave vers la 5.6, puis la mise à niveau du maître vers la 5.6. En ce qui concerne le traitement différent de YEAR(2) depuis MySQL 5.6.6, cette séquence de mise à jour pose un problème : supposons que l'esclave ait été mis à jour mais pas encore le maître. Ensuite, la création d'une table contenant une colonne YEAR(2) sur le maître aboutit à une table contenant une colonne YEAR(4) sur l'esclave. Par conséquent, ces opérations auront un résultat différent sur le maître et l'esclave, si vous utilisez la réplication basée sur les instructions :

      Insertion du chiffre 0 . La valeur résultante a une valeur interne de 2000 sur le maître mais de 0000 sur l'esclave.

      Conversion de YEAR(2) en chaîne. Cette opération utilise la valeur d'affichage de YEAR(2) sur le maître mais YEAR(4) sur l'esclave.

      Pour éviter de tels problèmes, modifiez toutes les colonnes YEAR(2) sur le maître en YEAR(4) avant la mise à niveau. (Utilisez ALTER TABLE , comme décrit précédemment.) Ensuite, vous pouvez mettre à niveau normalement (l'esclave d'abord, puis le maître) sans introduire de différences YEAR(2) à YEAR(4) entre le maître et l'esclave.

      Une méthode de migration doit être évitée : ne sauvegardez pas vos données avec mysqldump et rechargez le fichier de vidage après la mise à niveau. Cela a le potentiel de modifier les valeurs YEAR(2), comme décrit précédemment.

      Une migration de YEAR(2) vers YEAR(4) devrait également impliquer l'examen du code d'application pour la possibilité d'un changement de comportement dans des conditions telles que celles-ci :

      Code qui s'attend à ce que la sélection d'une colonne YEAR produise exactement deux chiffres.

      Code qui ne tient pas compte de la gestion différente des insertions de 0 numérique : L'insertion de 0 dans YEAR(2) ou YEAR(4) entraîne une valeur interne de 2000 ou 0000 , respectivement.

      11.3.5 Initialisation et mise à jour automatiques pour TIMESTAMP et DATETIME

      Les colonnes TIMESTAMP et DATETIME peuvent être automatiquement initialisées et mises à jour à la date et à l'heure actuelles (c'est-à-dire l'horodatage actuel).

      Pour toute colonne TIMESTAMP ou DATETIME d'une table, vous pouvez affecter l'horodatage actuel comme valeur par défaut, la valeur de mise à jour automatique ou les deux :

      Une colonne auto-initialisée est définie sur l'horodatage actuel pour les lignes insérées qui ne spécifient aucune valeur pour la colonne.

      Une colonne mise à jour automatiquement est automatiquement mise à jour avec l'horodatage actuel lorsque la valeur de toute autre colonne de la ligne est modifiée par rapport à sa valeur actuelle. Une colonne mise à jour automatiquement reste inchangée si toutes les autres colonnes sont définies sur leurs valeurs actuelles. Pour empêcher une colonne mise à jour automatiquement de se mettre à jour lorsque d'autres colonnes changent, définissez-la explicitement sur sa valeur actuelle. Pour mettre à jour une colonne mise à jour automatiquement même lorsque les autres colonnes ne changent pas, définissez-la explicitement sur la valeur qu'elle devrait avoir (par exemple, définissez-la sur CURRENT_TIMESTAMP ).

      De plus, si la variable système explicit_defaults_for_timestamp est désactivée, vous pouvez initialiser ou mettre à jour n'importe quelle colonne TIMESTAMP (mais pas DATETIME ) à la date et à l'heure actuelles en lui attribuant une valeur NULL, à moins qu'elle n'ait été définie avec l'attribut NULL pour autoriser les valeurs NULL .

      Pour spécifier des propriétés automatiques, utilisez les clauses DEFAULT CURRENT_TIMESTAMP et ON UPDATE CURRENT_TIMESTAMP dans les définitions de colonne. L'ordre des clauses n'a pas d'importance. Si les deux sont présents dans une définition de colonne, l'un ou l'autre peut se produire en premier. Tous les synonymes de CURRENT_TIMESTAMP ont la même signification que CURRENT_TIMESTAMP . Il s'agit de CURRENT_TIMESTAMP() , NOW() , LOCALTIME , LOCALTIME() , LOCALTIMESTAMP et LOCALTIMESTAMP() .

      L'utilisation de DEFAULT CURRENT_TIMESTAMP et ON UPDATE CURRENT_TIMESTAMP est spécifique à TIMESTAMP et DATETIME . La clause DEFAULT peut également être utilisée pour spécifier une valeur par défaut constante (non automatique), par exemple, DEFAULT 0 ou DEFAULT '2000-01-01 00:00:00' .

      Les exemples suivants utilisent DEFAULT 0 , une valeur par défaut qui peut générer des avertissements ou des erreurs selon que le mode SQL strict ou le mode SQL NO_ZERO_DATE est activé. Sachez que le mode SQL TRADITIONNEL inclut le mode strict et NO_ZERO_DATE . Voir Section 5.1.10, « Modes SQL du serveur ».

      Les définitions de colonne TIMESTAMP ou DATETIME peuvent spécifier l'horodatage actuel pour les valeurs par défaut et de mise à jour automatique, pour l'une mais pas pour l'autre, ou pour aucune. Différentes colonnes peuvent avoir différentes combinaisons de propriétés automatiques. Les règles suivantes décrivent les possibilités :

      Avec DEFAULT CURRENT_TIMESTAMP et ON UPDATE CURRENT_TIMESTAMP , la colonne a l'horodatage actuel pour sa valeur par défaut et est automatiquement mise à jour avec l'horodatage actuel.

      Avec une clause DEFAULT mais pas de clause ON UPDATE CURRENT_TIMESTAMP, la colonne a la valeur par défaut donnée et n'est pas automatiquement mise à jour avec l'horodatage actuel.

      La valeur par défaut dépend si la clause DEFAULT spécifie CURRENT_TIMESTAMP ou une valeur constante. Avec CURRENT_TIMESTAMP , la valeur par défaut est l'horodatage actuel.

      Avec une constante, la valeur par défaut est la valeur donnée. Dans ce cas, la colonne n'a aucune propriété automatique.

      Avec une clause ON UPDATE CURRENT_TIMESTAMP et une clause DEFAULT constante, la colonne est automatiquement mise à jour avec l'horodatage actuel et a la valeur par défaut constante donnée.

      Avec une clause ON UPDATE CURRENT_TIMESTAMP mais pas de clause DEFAULT, la colonne est automatiquement mise à jour avec l'horodatage actuel mais n'a pas l'horodatage actuel pour sa valeur par défaut.

      La valeur par défaut dans ce cas dépend du type. TIMESTAMP a une valeur par défaut de 0 à moins qu'il ne soit défini avec l'attribut NULL, auquel cas la valeur par défaut est NULL .

      DATETIME a une valeur par défaut de NULL à moins qu'elle ne soit définie avec l'attribut NOT NULL, auquel cas la valeur par défaut est 0.

      Les colonnes TIMESTAMP et DATETIME n'ont pas de propriétés automatiques à moins qu'elles ne soient spécifiées explicitement, avec cette exception : Si la variable système explicit_defaults_for_timestamp est désactivée, le première La colonne TIMESTAMP a à la fois DEFAULT CURRENT_TIMESTAMP et ON UPDATE CURRENT_TIMESTAMP si aucun n'est spécifié explicitement. Pour supprimer les propriétés automatiques de la première colonne TIMESTAMP, utilisez l'une des stratégies suivantes :

      Activez la variable système explicit_defaults_for_timestamp. Dans ce cas, les clauses DEFAULT CURRENT_TIMESTAMP et ON UPDATE CURRENT_TIMESTAMP qui spécifient l'initialisation et la mise à jour automatiques sont disponibles, mais ne sont affectées à aucune colonne TIMESTAMP à moins qu'elles ne soient explicitement incluses dans la définition de colonne.

      Sinon, si explicit_defaults_for_timestamp est désactivé, effectuez l'une des actions suivantes :

      Définissez la colonne avec une clause DEFAULT qui spécifie une valeur par défaut constante.

      Spécifiez l'attribut NULL. Cela amène également la colonne à autoriser les valeurs NULL, ce qui signifie que vous ne pouvez pas affecter l'horodatage actuel en définissant la colonne sur NULL . L'affectation de NULL définit la colonne sur NULL , et non sur l'horodatage actuel. Pour affecter l'horodatage actuel, définissez la colonne sur CURRENT_TIMESTAMP ou un synonyme tel que NOW() .

      Considérez ces définitions de table :

      Les tables ont ces propriétés :

      Dans chaque définition de table, la première colonne TIMESTAMP n'a pas d'initialisation ou de mise à jour automatique.

      Les tables diffèrent dans la façon dont la colonne ts1 gère les valeurs NULL. Pour t1 , ts1 n'est PAS NULL et lui attribuer une valeur NULL le définit sur l'horodatage actuel. Pour t2 et t3 , ts1 autorise NULL et lui assigner une valeur NULL le définit sur NULL .

      t2 et t3 diffèrent par la valeur par défaut de ts1 . Pour t2 , ts1 est défini pour autoriser NULL , donc la valeur par défaut est également NULL en l'absence d'une clause DEFAULT explicite. Pour t3 , ts1 autorise NULL mais a une valeur par défaut explicite de 0.

      Si une définition de colonne TIMESTAMP ou DATETIME inclut une valeur de précision en fractions de seconde explicite n'importe où, la même valeur doit être utilisée dans toute la définition de colonne. Ceci est autorisé :

      Initialisation TIMESTAMP et attribut NULL

      Si la variable système explicit_defaults_for_timestamp est désactivée, les colonnes TIMESTAMP par défaut ne sont PAS NULL , ne peuvent pas contenir de valeurs NULL et l'affectation de NULL affecte l'horodatage actuel. Pour permettre à une colonne TIMESTAMP de contenir NULL , déclarez-la explicitement avec l'attribut NULL. Dans ce cas, la valeur par défaut devient également NULL à moins qu'elle ne soit remplacée par une clause DEFAULT qui spécifie une valeur par défaut différente. DEFAULT NULL peut être utilisé pour spécifier explicitement NULL comme valeur par défaut. (Pour une colonne TIMESTAMP non déclarée avec l'attribut NULL, DEFAULT NULL n'est pas valide.) Si une colonne TIMESTAMP autorise les valeurs NULL, l'affectation de NULL la définit sur NULL , et non sur l'horodatage actuel.

      Le tableau suivant contient plusieurs colonnes TIMESTAMP qui autorisent les valeurs NULL :

      Une colonne TIMESTAMP qui autorise les valeurs NULL ne ne pas prend l'horodatage actuel au moment de l'insertion, sauf dans l'une des conditions suivantes :

      Sa valeur par défaut est définie comme CURRENT_TIMESTAMP et aucune valeur n'est spécifiée pour la colonne

      CURRENT_TIMESTAMP ou l'un de ses synonymes tels que NOW() est explicitement inséré dans la colonne

      En d'autres termes, une colonne TIMESTAMP définie pour autoriser les valeurs NULL ne s'initialise automatiquement que si sa définition inclut DEFAULT CURRENT_TIMESTAMP :

      Si la colonne TIMESTAMP autorise les valeurs NULL mais que sa définition n'inclut pas DEFAULT CURRENT_TIMESTAMP , vous devez explicitement insérer une valeur correspondant à la date et l'heure actuelles. Supposons que les tables t1 et t2 aient ces définitions :

      Pour définir la colonne TIMESTAMP dans l'une des tables sur l'horodatage actuel au moment de l'insertion, affectez-lui explicitement cette valeur. Par exemple:

      Si la variable système explicit_defaults_for_timestamp est activée, les colonnes TIMESTAMP autorisent les valeurs NULL uniquement si elles sont déclarées avec l'attribut NULL. De plus, les colonnes TIMESTAMP ne permettent pas d'affecter NULL pour affecter l'horodatage actuel, qu'il soit déclaré avec l'attribut NULL ou NOT NULL. Pour affecter l'horodatage actuel, définissez la colonne sur CURRENT_TIMESTAMP ou un synonyme tel que NOW() .

      11.3.6 Secondes fractionnaires dans les valeurs de temps

      MySQL 5.7 prend en charge les fractions de seconde pour les valeurs TIME , DATETIME et TIMESTAMP , avec une précision allant jusqu'à la microseconde (6 chiffres) :

      Pour définir une colonne qui inclut une fraction de seconde, utilisez la syntaxe nom_type ( fsp ) , où nom_type est TIME , DATETIME ou TIMESTAMP , et fsp est la précision à la fraction de seconde. Par exemple:

      Le fsp valeur, si elle est donnée, doit être comprise entre 0 et 6. Une valeur de 0 signifie qu'il n'y a pas de partie fractionnaire. S'il est omis, la précision par défaut est 0. (Ceci diffère de la valeur par défaut SQL standard de 6, pour la compatibilité avec les versions précédentes de MySQL.)

      L'insertion d'une valeur TIME , DATE ou TIMESTAMP avec une fraction de seconde dans une colonne du même type mais comportant moins de chiffres fractionnaires entraîne un arrondi. Considérons une table créée et remplie comme suit :

      Les valeurs temporelles sont insérées dans le tableau avec arrondi :

      Aucun avertissement ou erreur n'est donné lorsqu'un tel arrondi se produit. Ce comportement suit la norme SQL et n'est pas affecté par le paramètre sql_mode du serveur.

      Les fonctions qui prennent des arguments temporels acceptent des valeurs avec des fractions de seconde. Les valeurs de retour des fonctions temporelles incluent les fractions de seconde, le cas échéant. Par exemple, NOW() sans argument renvoie la date et l'heure actuelles sans fraction, mais prend un argument facultatif de 0 à 6 pour spécifier que la valeur de retour inclut une fraction de seconde de ce nombre de chiffres.

      La syntaxe des littéraux temporels produit des valeurs temporelles : DATE ' str ' , TEMPS ' str ' , et TIMESTAMP ' str ' , et les équivalents de la syntaxe ODBC. La valeur résultante inclut une fraction de seconde à la fin si elle est spécifiée. Auparavant, le mot-clé de type temporel était ignoré et ces constructions produisaient la valeur de chaîne. Voir les littéraux de date et d'heure SQL standard et ODBC

      11.3.7 Conversion entre les types de date et d'heure

      Dans une certaine mesure, vous pouvez convertir une valeur d'un type temporel à un autre. Cependant, il peut y avoir une altération de la valeur ou une perte d'informations. Dans tous les cas, la conversion entre les types temporels est soumise à la plage de valeurs valides pour le type résultant. Par exemple, bien que les valeurs DATE , DATETIME et TIMESTAMP puissent toutes être spécifiées à l'aide du même ensemble de formats, les types n'ont pas tous la même plage de valeurs. Les valeurs TIMESTAMP ne peuvent pas être antérieures à 1970 UTC ou postérieures à '2038-01-19 03:14:07' UTC. Cela signifie qu'une date telle que '1968-01-01' , bien qu'elle soit valide en tant que valeur DATE ou DATETIME, n'est pas valide en tant que valeur TIMESTAMP et est convertie en 0 .

      La conversion en une valeur DATETIME ou TIMESTAMP ajoute une partie d'heure de « 00:00:00 » car la valeur DATE ne contient aucune information d'heure.

      La conversion en une valeur TIME n'est pas utile, le résultat est '00:00:00' .

      Conversion des valeurs DATETIME et TIMESTAMP :

      La conversion en une valeur DATE prend en compte les fractions de secondes et arrondit la partie temporelle. Par exemple, '1999-12-31 23:59:59.499' devient '1999-12-31' , tandis que '1999-12-31 23:59:59.500' devient '2000-01-01' .

      La conversion en une valeur TIME supprime la partie date car le type TIME ne contient aucune information de date.

      Pour la conversion des valeurs TIME en d'autres types temporels, la valeur de CURRENT_DATE() est utilisée pour la partie date. L'HEURE est interprétée comme le temps écoulé (pas l'heure de la journée) et ajoutée à la date. Cela signifie que la partie date du résultat diffère de la date actuelle si la valeur de l'heure est en dehors de la plage de '00:00:00' à '23:59:59' .

      Supposons que la date actuelle soit '2012-01-01' . Les valeurs TIME de '12:00:00' , '24:00:00' et '-12:00:00' , lorsqu'elles sont converties en valeurs DATETIME ou TIMESTAMP, donnent '2012-01-01 12:00:00 ' , '2012-01-02 00:00:00' et '2011-12-31 12:00:00' , respectivement.

      La conversion de TIME en DATE est similaire mais supprime la partie de temps du résultat : '2012-01-01' , '2012-01-02' et '2011-12-31' , respectivement.

      La conversion explicite peut être utilisée pour remplacer la conversion implicite. Par exemple, en comparaison des valeurs DATE et DATETIME, la valeur DATE est forcée au type DATETIME en ajoutant une partie d'heure de '00:00:00' . Pour effectuer la comparaison en ignorant la partie heure de la valeur DATETIME, utilisez la fonction CAST() de la manière suivante :

      La conversion des valeurs TIME et DATETIME sous forme numérique (par exemple, en ajoutant +0 ) dépend du fait que la valeur contient ou non une fraction de seconde. TEMPS( N ) ou DATEHEURE( N ) est converti en entier lorsque N est 0 (ou omis) et à une valeur DECIMAL avec N chiffres décimaux lorsque N est supérieur à 0 :

      11.3.8 Années à deux chiffres dans les dates

      Les valeurs de date avec des années à deux chiffres sont ambiguës car le siècle est inconnu. De telles valeurs doivent être interprétées sous une forme à quatre chiffres car MySQL stocke les années en interne à l'aide de quatre chiffres.

      Pour les types DATETIME , DATE et TIMESTAMP , MySQL interprète les dates spécifiées avec des valeurs d'année ambiguës en utilisant ces règles :

      Les valeurs de l'année dans la plage 00-69 sont converties en 2000-2069 .

      Les valeurs de l'année dans la plage 70-99 sont converties en 1970-1999.

      Pour YEAR , les règles sont les mêmes, à cette exception près : un 00 numérique inséré dans YEAR(4) donne 0000 plutôt que 2000 . Pour spécifier zéro pour YEAR(4) et le faire interpréter comme 2000 , spécifiez-le comme une chaîne '0' ou '00' .

      N'oubliez pas que ces règles ne sont que des heuristiques qui fournissent des suppositions raisonnables sur la signification des valeurs de vos données. Si les règles utilisées par MySQL ne produisent pas les valeurs dont vous avez besoin, vous devez fournir une entrée non ambiguë contenant des valeurs d'année à quatre chiffres.

      ORDER BY trie correctement les valeurs YEAR qui ont des années à deux chiffres.

      Certaines fonctions comme MIN() et MAX() convertissent une ANNÉE en nombre. Cela signifie qu'une valeur avec une année à deux chiffres ne fonctionne pas correctement avec ces fonctions. Le correctif dans ce cas consiste à convertir l'ANNÉE au format d'année à quatre chiffres.


      Des modes de réalisation concernent des systèmes et des procédés de surveillance et de test de réseau à l'aide d'une plate-forme de médiation de données générique entre une ou plusieurs sondes et un ou plusieurs tableaux de bord. La plate-forme générique de médiation de données effectue la corrélation des données, l'enrichissement du filtrage et l'agrégation des événements obtenus à partir des réseaux surveillés.

      FIGUE. 1 est un schéma fonctionnel de haut niveau d'un mode de réalisation d'une méthodologie de description de KPI flexible conformément à un mode de réalisation.

      FIGUE. 2 illustre des modes de réalisation pour deux événements de données générés dans un système de téléphonie informatique selon un mode de réalisation.

      FIGUE. 3 illustre l'utilisation d'un ensemble de règles pour créer des événements de données KPI à partir d'événements de données d'entrée conformément à un mode de réalisation.

      FIGUE. 4 illustre un événement de données unique résultant en trois événements de données KPI conformément à un mode de réalisation.

      FIGUE. 5 illustre le mappage entre un événement de données KPI et un événement KPI agrégé via des agrégateurs KPI conformément à un mode de réalisation.

      FIGUES. 6A, 6Bande 6C illustre un ensemble de règles utilisées pour mapper des événements de données sur des événements de données KPI conformément à un mode de réalisation.

      FIGUE. 7 illustre une règle utilisée pour définir un agrégateur KPI conformément à un mode de réalisation.

      FIGUES. 8A-8B illustrent une configuration et une sortie réelle, conformément à un mode de réalisation, pour une sortie KPI pour l'agrégateur KPI illustré sur la Fig. 7.

      FIGUE. 9A illustre une règle qui traite des enregistrements de données d'événement SIP conformément à un mode de réalisation.

      FIGUE. 9B illustre l'utilisation de tables de consultation pour des calculs conformément à un mode de réalisation.

      FIGUE. 10 illustre deux sources d'entrée contenant des événements ordonnés localement à communiquer à une application selon un mode de réalisation.

      FIGUE. 11 illustre une application recevant des événements associés de différentes sources d'entrée via des nuages ​​de réseau conformément à un mode de réalisation.

      FIGUE. 12 illustre un diagramme d'état d'une source d'entrée selon un mode de réalisation.

      FIGUE. 13 est un schéma fonctionnel illustrant des détails associés à une application demandant un événement à partir d'un séquenceur conformément à un mode de réalisation.

      FIGUE. 14 est un organigramme illustrant des détails associés à une application demandant un événement à un séquenceur conformément à un mode de réalisation.

      FIGUE. 15 est une illustration d'un tas max binaire selon un mode de réalisation.

      FIGUE. 16 illustre l'utilisation d'une plate-forme CEP pour analyser des événements de réseau conformément à un mode de réalisation.

      FIGUE. 17 illustre comment une plate-forme de médiation de données peut être incorporée dans un environnement de surveillance ou de test de réseau existant conformément à un mode de réalisation.

      FIGUE. 18 illustre une architecture de système pour une plate-forme générique de médiation de données selon un mode de réalisation.


      1.5 Importer et formater des ensembles de données

      # modifier le temps pour inclure les secondes
      temp$time <- paste(as.character(temp$LMT_TIME),"00",sep=":")
      # convertir en date chrono
      temp$date_time <-chron(as.character(temp$LMT_DATE),
      temp$time,format=c(dates="m/d/y",times="h:m:s"))
      # diff calc en minutes
      timediff <- diff(temp$date_time)*24*60
      # supprimer la première entrée sans aucune différence
      temp <- temp[-1,]
      # attribuer une colonne timediff
      temp$timediff <- as.numeric(timediff)

      Ensuite, nous pouvons ajouter le code ci-dessous pour inclure la nuit et le jour dans les ensembles de données et également pour
      compte de l'heure d'été. Le package RATmosphere éliminera le besoin de
      morceau de code ci-dessous si vous travaillez sur une version antérieure de R (c'est-à-dire que le code n'est pas disponible pour R
      3.2.1 plus). Merci à Duane Diefenbach, chef d'unité PA Coop, d'avoir compilé tout cela
      à partir de sources en ligne.
      ###################################################################
      #Nous devons d'abord créer un SPDF et le transformer en Lat Long, puis revenir à un
      #Trame de données. Vous n'avez besoin de cette section de code que si vous devez acquérir les coordonnées Lat #Long pour votre ensemble de données
      ###################################################################
      #utm.crs <-CRS("+proj=utm +zone=12 +datum=WGS84")
      #dataSPDF<-data.frame(x = temp$UTMe, y = temp$UTMn)
      #utm.spdf <- SpatialPointsDataFrame(coords = dataSPDF, data = temp,
      chaîne proj4 = utm.crs)
      #ll.crs <- CRS("+proj=longlat +ellps=WGS84")
      #datall <-spTransform(utm.spdf, CRS=ll.crs)
      #str(datall)

      Séparez les heures en catégories "Jour" et "Nuit" en fonction du tableau lever-coucher du soleil en exécutant la fonction ci-dessous ou simplement en utilisant le package RAtmosphere si disponible

      Première ligne de code ci-dessous avec d étant le jour de l'année, Lat est la latitude en décimal
      degrés, et Long est la longitude en degrés décimaux (négatif == Ouest) disponible à
      calc solaire
      suncalc <- function(d,Lat=39.14133,Long=-106.7722)<
      ##Cette méthode est copiée de :
      ##Teets, D.A. 2003. Prédiction des heures de lever et de coucher du soleil.
      ## The College Mathematics Journal 34(4):317-321.
      ## À l'emplacement par défaut, les estimations du lever et du coucher du soleil sont dans
      ## sept minutes des temps corrects
      ##(http://aa.usno.navy.mil/data/docs/RS_OneYear.php)
      ## avec une moyenne d'erreur de 2,4 minutes.
      ## Fonction pour convertir les degrés en radians
      rad <- fonction(x)pi*x/180
      ##Rayon de la terre (km)
      R=6378
      ##Radians entre le plan xy et le plan de l'écliptique
      epsilon=rad(23,45)
      ##Convertir la latitude de l'observateur en radians
      L=rad(Lat)
      ## Calculer le décalage du lever du soleil en fonction de la longitude (min)
      ## Si Long est négatif, alors le mod représente les degrés à l'ouest de
      ## un méridien horaire standard, donc l'heure du lever et du coucher du soleil devrait
      ## être fait plus tard.
      ##REMARQUE : Si vous travaillez avec les heures UTC, utilisez le fuseau horaire = -4*(abs(Long)%%15)*sign(Long)
      fuseau horaire = -6*(abs(Long)%%15)*sign(Long)
      ## Distance moyenne de la Terre au Soleil (km)
      r = 149598000
      thêta = 2*pi/365.25*(d-80)
      z.s = r*sin(thêta)*sin(epsilon)
      r.p = sqrt(r^2-z.s^2)
      t0 = 1440/(2*pi)*acos((R-z.s*sin(L))/(r.p*cos(L)))
      ##un ajustement kludge pour le rayon du soleil
      que = t0+5

      ## Ajuster "midi" pour le fait que l'orbite terrestre n'est pas circulaire :
      n = 720-10*sin(4*pi*(d-80)/365,25)+8*sin(2*pi*d/365,25)
      ## maintenant le lever et après le coucher du soleil sont :
      lever du soleil = (n-ce+fuseau horaire)/60
      coucher de soleil = (n+ce+fuseau horaire)/60
      suntime <-cbind (lever du soleil, coucher du soleil)
      retour (soleil)
      >


      cette entrée est un aperçu franc (vue technique et impartiale) des trois options de clé primaire alternatives dans un modèle de coffre de données 2.0. il y a des avantages et des inconvénients à chaque sélection. J'espère que vous apprécierez cette entrée factuelle.

      (c) copyright 2018 dan linstedt tous droits réservés, aucune réimpression autorisée sans l'autorisation écrite expresse de dan linstedt

      il existe trois alternatives principales pour sélectionner les valeurs de clé primaire dans un modèle de coffre de données 2.0 :

      numéros de séquence

      les numéros de séquence existent depuis le début des machines. ce sont des valeurs numériques uniques, générées par le système, qui sont de nature incrémentielle (séquentielle). les numéros de séquence présentent les problèmes suivants :

      • limite supérieure (la taille du champ numérique pour les valeurs non décimales)
      • introduisent un problème de processus lors de l'utilisation de séquences pendant le chargement, car elles nécessitent que toute entité enfant recherche son enregistrement parent correspondant pour hériter de la valeur parent.
      • n'a pas de sens commercial

      le plus critique des problèmes ci-dessus est celui des impacts négatifs sur les performances associés aux processus de recherche ou de jointure, en particulier dans des environnements hétérogènes ou dans des environnements où les données ne sont légalement pas autorisées à « vivre » ou à être répliquées sur d'autres environnements (répartis géographiquement ou sur -prémise et mix in-cloud). ce problème de processus est exacerbé lors des flux iot ou en temps réel à grande vitesse. Considérez ce qui se passe dans un flux iot ou en temps réel lorsque les données circulent rapidement vers des milliards d'enregistrements enfants, et chaque enregistrement doit alors attendre une séquence de « recherche » (un enregistrement à la fois) que le flux en temps réel peut sauvegarder.

      les recherches provoquent également des problèmes de « pré-cache » sous des charges de volume. par exemple, supposons que la table parent soit facture et que la table enfant soit commande. si la table des factures contient 500 millions d'enregistrements et que la table des commandes contient 5 milliards d'enregistrements et que chaque commande a au moins une ligne parente correspondante (probablement plus) - alors chaque enregistrement entrant dans la commande doit « rechercher » au moins une facture. ce processus de recherche se produira 5 milliards de fois, une fois pour chaque enregistrement enfant.

      peu importe que la technologie soit un moteur etl, un moteur de processus en temps réel ou un moteur compatible avec la gestion des données SQL. ce processus doit avoir lieu pour éviter tout dossier orphelin potentiel. si l'intégrité référentielle est coupée, le processus de chargement peut s'exécuter en parallèle sur les deux tables. cependant, pour remplir la « séquence parent », elle doit toujours être « recherchée/recherchée » ligne par ligne. l'ajout de parallélisme et de partitionnement améliorera les performances, mais finira par atteindre un goulot d'étranglement de limite supérieure.

      dans un environnement mpp (stockage mpp), les données seront redistribuées pour permettre à la jointure de se produire, et ce n'est pas seulement la séquence qui doit être expédiée, c'est la séquence plus la clé métier entière à laquelle elle est liée. dans un moteur mpp avec stockage non-mpp (comme snowflake db), les données n'ont pas besoin d'être expédiées mais le processus de recherche doit toujours avoir lieu.

      cet acte de recherche sur une seule chaîne, un enregistrement à la fois, peut avoir un impact considérable (et négatif) sur les performances de charge. dans les solutions à grande échelle (pensez à 1000 « tables » ou ensembles de données contenant chacun 1 milliard d'enregistrements ou plus), ce problème de performances est considérablement augmenté (les temps de chargement sont considérablement augmentés).

      et s'il y a une table enfant ? et si la conception du modèle de données a des tables parent->child->child->child ? ou des relations profondes à plusieurs niveaux ? puis le problème s'aggrave à mesure que la longueur des cycles de charge augmente de façon exponentielle.

      pour être juste, abordons maintenant certaines des notions positives de l'utilisation des numéros de séquence. les numéros de séquence ont les impacts positifs suivants une fois établis :

      • petite taille d'octet (généralement inférieure à nombre (38)) (38 "9") ou 10^125
      • avantage du processus : les jointures entre les tables peuvent tirer parti des comparaisons de petites tailles d'octets
      • avantage du processus : les jointures peuvent tirer parti des comparaisons numériques (plus rapides que les comparaisons de caractères ou binaires)
      • toujours unique pour chaque nouvel enregistrement inséré
      • certains moteurs peuvent encore partitionner (groupement) dans l'ordre croissant les séquences numériques et tirer parti de l'élagage de sous-partition (micro-partition) en exploitant la sélection de plage pendant le processus de jointure (en parallèle).

      qu'est-ce qu'une clé de hachage ? une clé de hachage est une clé métier (peut être des champs composites) exécutée par une fonction de calcul appelée hachage, puis assignée comme clé primaire de la table. les fonctions de hachage sont appelées déterministe. étant déterministe signifie que sur la base d'une entrée donnée x (à chaque fois que la fonction de hachage est fournie x), elle produira la sortie y (pour la même entrée, la même sortie sera générée). les définitions des fonctions de hachage, ce qu'elles sont et comment elles fonctionnent, peuvent être trouvées sur wikipedia.

      avantages clés de hachage pour tout modèle de données :

      • Processus de chargement indépendants à 100 % parallèles (tant que l'intégrité référentielle est désactivée) même si ces processus de chargement sont répartis sur plusieurs plates-formes ou plusieurs emplacements
      • les jointures paresseuses, c'est-à-dire la possibilité de joindre plusieurs plates-formes à l'aide de technologies telles que drill (ou quelque chose de similaire), même sans intégrité référentielle. Notez que les jointures paresseuses sur des séquences ne peuvent pas être effectuées dans des environnements de plateforme hétérogènes. les séquences ne sont même pas prises en charge dans certains moteurs nosql.
      • attribut de clé primaire à champ unique (même avantage ici que la solution de numérotation de séquence)
      • déterministe - il peut même être pré-calculé sur les systèmes sources ou à la périphérie pour les périphériques iot / edge computing.
      • peut représenter des ensembles de données non structurés et multistructurés - sur la base de clés de hachage d'entrée spécifiques peuvent être calculées encore et encore (en parallèle). en d'autres termes, une clé de hachage peut être construite comme une clé commerciale pour l'audio, les images, la vidéo et les documents. c'est quelque chose que les séquences ne peuvent pas faire de manière déterministe.
      • si l'on souhaite créer une fonction de hachage intelligente, une signification peut être attribuée aux bits du hachage (similaire à teradata - et à ce qu'il calcule pour le stockage sous-jacent et l'accès aux données).

      les clés de hachage sont importantes pour le coffre de données 2.0 en raison des efforts déployés pour connecter des environnements de données hétérogènes tels que hadoop et oracle. Les clés de hachage sont également importantes car elles suppriment les dépendances lors du « chargement » des structures du coffre de données 2.0. une clé de hachage peut être calculée valeur par valeur. la clé "parente" peut également être calculée et peut être répétée pour autant de clés parentes qu'il existe de valeurs pour. il n'y a pas de dépendance de recherche, pas besoin de pré-cacher, d'utiliser la zone temporaire ou quoi que ce soit d'autre pour calculer chaque valeur parent pendant le traitement du chargement.

      il est presque impossible de faire évoluer correctement les charges du système Big Data avec des dépendances de numérotation de séquence en place. les séquences (qu'elles soient dans des modèles dv1 ou dimensionnels ou tout autre modèle de données) forcent le chargement du parent, puis des structures enfants. ces dépendances sur « le parent d'abord – puis rechercher la valeur du parent » provoquent une opération séquentielle ligne par ligne pendant les cycles de chargement, inhibant ainsi les possibilités de montée en charge offertes par le parallélisme.

      ce type de dépendance non seulement ralentit le processus de chargement, mais élimine également tout potentiel de parallélisme, même lorsque l'intégrité référentielle est désactivée. en outre, il place une dépendance dans le flux de chargement dans des environnements hétérogènes. par exemple, lors du chargement de données satellite dans hadoop (peut-être un document json), le flux de chargement nécessite une recherche du numéro de séquence du hub qui peut exister dans une base de données relationnelle. cette dépendance à elle seule va à l'encontre de tout l'objectif d'avoir un système comme hadoop en premier lieu.

      les clés de hachage ont leurs problèmes :

      • longueur de la valeur de calcul résultante lorsque le stockage du hachage est supérieur aux séquences
      • collision possible (les probabilités de collision dépendent de la fonction de hachage choisie pour l'utilisation).

      le premier problème conduit à des jointures SQL plus lentes et à des requêtes plus lentes. c'est parce qu'il faut plus de temps pour « faire correspondre » ou comparer des champs de plus grande longueur que pour comparer des valeurs numériques. les hachages (dans oracle et sqlserver) sont généralement stockés sous forme binaire fixe (oui, cela fonctionne comme une clé primaire). hachages dans Hive ou d'autres technologies basées sur Hadoop, et certains autres moteurs relationnels doivent stocker les hachages sous forme de longueurs de jeu de caractères fixes. par exemple, un résultat de hachage md5 est binaire(16), ce qui donne une chaîne codée en hexadécimal de longueur fixe char(32).

      le revers de la médaille est l'utilisation d'un hachage, c'est son évolutivité illimitée en chargement parallèle. toutes les données peuvent être chargées en parallèle à tout moment sur plusieurs plates-formes (même celles qui sont réparties géographiquement ou réparties sur site et dans le cloud). Les clés de hachage (ou clés métier) font partie du succès du coffre de données 2.0 dans un monde big data et nosql. le hachage est facultatif dans dv2. il existe une variété d'algorithmes de hachage disponibles pour une utilisation qui incluent:

      • md5 (obsolète vers 2018)
      • sha 0, 1, 2, 3 – sha1 (obsolète vers 2018)
      • hachages parfaits
      • et plus…

      le hachage est basé sur les clés métier qui arrivent dans les zones de transit. toutes les dépendances de recherche sont donc supprimées et l'ensemble du système peut se charger en parallèle dans des environnements hétérogènes. l'ensemble de données dans le modèle peut désormais être réparti dans les environnements mpp en sélectionnant la valeur de hachage comme clé de distribution. cela permet une meilleure distribution principalement aléatoire, principalement uniforme entre les nœuds mpp si la clé de hachage est la clé de distribution du compartiment mpp.

      "lors du test d'une fonction de hachage, l'uniformité de la distribution des valeurs de hachage peut être évaluée par le test du chi carré. " https://en.wikipedia.org/wiki/hash_function – notez qu'il y a ceux qui prétendent ne pas voir la distribution aléatoire moyenne, cela signifie simplement qu'ils ne comprennent pas les mathématiques de la distribution du hachage valeurs ou comment l'appliquer.

      heureusement, les fonctions de hachage sont déjà conçues et les concepteurs ont pris en compte ce peu de mathématiques de la distribution. la fonction de hachage choisie (si le hachage doit être utilisé) peut être à la discrétion de l'équipe de conception. depuis environ 2018, les équipes ont choisi sha-256.

      l'un des éléments discutés est que plus la sortie de hachage (nombre de bits) est longue, moins il y a de probabilité / moins de probabilité d'une collision potentielle. c'est quelque chose à prendre en considération, surtout si les jeux de données sont volumineux (big data, 1 milliard d'enregistrements en entrée par cycle de chargement par table par exemple).

      si une clé de hachage est choisie pour la mise en œuvre, une stratégie de collision de hachage doit également être conçue. c'est la responsabilité de l'équipe. il existe plusieurs options disponibles pour traiter les collisions de hachage. l'une des stratégies recommandées est le hachage inversé.

      il s'agit uniquement du modèle de coffre de données 2.0 qui sert d'entrepôt d'entreprise. il est toujours possible (et même conseillé) d'utiliser ou de tirer parti des numéros de séquence dans les magasins d'informations persistants (data marts) en aval pour engager les jointures les plus rapides possibles dans un environnement homogène.

      le plus grand avantage n'est pas du côté de la modélisation de la maison, mais du point de vue du chargement et de l'interrogation. pour le chargement, il libère les dépendances et autorise les charges vers hadoop et d'autres environnements nosql en parallèle avec les charges vers les systèmes rdbms. pour les requêtes, il permet une « jointure tardive » ou une liaison au moment de l'exécution des données via la connectivité jdbc et odbc entre les moteurs hadoop, nosql et rdbms à la demande. il n'est pas suggéré que ce sera rapide, mais plutôt que cela peut être facilement accompli.

      une analyse plus approfondie de ce sujet est couverte dans les cours de formation sur le camp d'entraînement de Data Vault 2.0 et dans les documents publiés sur Data Vault 2.0. il est au-delà de la portée de cet article de plonger plus profondément dans ce sujet.

      clés d'entreprise

      les clés métier existent depuis longtemps, s'il y a eu des données dans les applications opérationnelles. les clés d'entreprise doivent être intelligentou alors intelligenteclés et doit être mappé sur notions d'entreprise. Cela dit, la plupart des clés commerciales d'aujourd'hui sont des identifiants de substitution du système source et elles présentent les mêmes problèmes que les séquences mentionnées ci-dessus.

      une intelligentou alors intelligente La clé est généralement définie comme une somme de composants où les chiffres ou les parties d'un seul champ ont une signification pour l'entreprise. chez lockheed martin, par exemple, un numéro de pièce se composait de plusieurs pièces (c'était une sorte de super-clé). la clé de pièce comprenait la marque, le modèle, la révision, l'année, etc. de la pièce. comme un vin (numéro d'identification du véhicule) trouvé sur les automobiles aujourd'hui.

      les avantages d'une clé intelligente ou intelligente vont bien au-delà de la simple clé commerciale de substitution ou de séquence. ces clés métier présentent généralement le comportement positif suivant au niveau métier :

      • ils ont la même valeur pendant toute la durée de vie de l'ensemble de données
      • ils ne changent pas lorsque les données sont transférées entre et entre les applications oltp d'entreprise
      • ils ne sont pas modifiables par l'entreprise (la plupart du temps) dans l'application système source
      • elles peuvent être considérées comme des clés de données principales
      • ils traversent les processus métier et offrent une traçabilité ultime des données
      • plus grand avantage : peut permettre le chargement parallèle (comme les hachages) et également fonctionner comme des clés pour des ensembles de données répartis géographiquement - sans avoir besoin de recalculer ou de rechercher.

      ils ont les défauts suivants :

      • longueur - généralement les clés d'entreprise intelligentes peuvent comporter plus de 40 caractères,
      • sens au fil du temps - la définition de base peut changer tous les 5 à 15 ans environ (il suffit de regarder comment le numéro de vin a évolué au cours des 100 dernières années)
      • Parfois, les applications sources peuvent modifier les clés de l'entreprise, ce qui fait des ravages dans toutes les analyses qui doivent être effectuées.
      • ils peuvent être multi-champs / multi-attributs
      • ils peuvent être « pas assez uniques ou spécifiques » pour identifier de manière unique les données.

      si vous aviez le choix entre des séquences de substitution, des hachages ou des clés commerciales naturelles, les clés commerciales naturelles seraient la préférence. la définition originale (même aujourd'hui) indique qu'un hub est défini comme une liste unique de clés métier. la préférence est d'utiliser des clés commerciales naturelles qui ont un sens pour l'entreprise.

      l'une des fonctions d'un bien construit cruLe modèle de coffre-fort de données 2.0 est de fournir une traçabilité à travers les secteurs d'activité. pour cela, les clés métier doitêtre stockés dans les structures du moyeu selon un ensemble de normes de conception.

      la plupart des clés métier du système source aujourd'hui sont des numéros de séquence de substitution définis par l'application source. le monde est plein de ces valeurs numériques « idiotes » générées par des machines. les exemples incluent : numéro de client, numéro de compte, numéro de facture, numéro de commande, et la liste continue.

      clés métier de séquence du système source

      Les clés métier basées sur la séquence du système source représentent 98 % des données source que tout entrepôt de données ou système d'analyse reçoit. même jusqu'à l'identifiant de transaction, l'identifiant de messagerie ou certains ensembles de données non structurés, tels que l'identifiant de document, contiennent des substituts. la théorie est que ces séquences ne devraient jamais changer et devraient représenter les mêmes données une fois établies et attribuées.

      cela dit, le plus gros problème qui existe dans les systèmes opérationnels est celui que la solution analytique est toujours appelée à résoudre. c'est-à-dire comment intégrer (ou maîtriser) l'ensemble de données, le combiner à travers les processus métier et donner un sens aux données qui ont été affectées à plusieurs clés métier de séquence tout au long du cycle de vie de l'entreprise.

      un exemple de ceci peut être le compte client. compte client dans SAP peut signifier la même chose qu'un compte client dans Oracle Financials ou une autre solution CRM ou ERP. généralement, lorsque les données sont transmises de SAP à Oracle Financials, l'application oltp réceptrice attribue généralement une nouvelle « clé métier » ou un identifiant de séquence de substitution. c'est toujours le même compte client mais le même ensemble de données représentatif a maintenant une nouvelle clé.

      le problème devient, comment reconstituez-vous les enregistrements ? il s'agit d'une question de gestion des données de référence (mdm), et avec une solution mdm en place (y compris une bonne gouvernance et de bonnes personnes) peut être résolue et approximée avec un apprentissage en profondeur et des réseaux de neurones. même l'analyse statistique des « attributs similaires » peut détecter avec une marge d'erreur les multiples enregistrements qui « devraient » être les mêmes mais contenir des clés différentes.

      ce problème commercialse perpétue dans l'entrepôt de données et la solution d'analyse, généralement parce qu'aucune solution de gestion des données de référence n'a été implémentée en amont de l'entrepôt de données. par conséquent, pour assembler ce qui semble être « une version du dossier client » et non un double ou triple comptage, des algorithmes sont appliqués pour relier les clés entre elles.

      dans le paysage du coffre-fort de données, nous appelons cela un lien hiérarchique ou identique. hiérarchique s'il représente une hiérarchie à plusieurs niveaux, et même que s'il s'agit d'une hiérarchie unique (remappage parent-enfant) de termes.

      placer ces numéros de séquence en tant que clés métier dans les hubs pose les problèmes suivants :

      • ils n'ont pas de sens - un humain ne peut pas déterminer ce que la clé représente (contextuellement) sans examiner les détails pendant un moment
      • ils peuvent changer – c'est souvent le cas, même avec quelque chose d'aussi « simple » qu'une mise à niveau du système source – cela entraîne une grave perte de traçabilité des artefacts historiques. sans une carte « ancienne clé » à « nouvelle clé », il n'y a pas de traçabilité définitive.
      • ils peuvent entrer en collision. Même si conceptuellement dans l'ensemble de l'entreprise, il existe un élément appelé « compte client », la même séquence d'identifiants peut être attribuée dans différentes instances pour différents comptes client. dans ce cas, ils ne doivent jamais être combinés. un exemple de ceci serait deux implémentations différentes de SAP, une au Japon et une au Canada. chacun attribue l'identifiant client #1, cependant, dans le système japonais, #1 représente "joe johnson" alors que dans le système canadien, #1 représente "margarite smith". la dernière chose que vous voulez dans l'analyse est de « combiner » ces deux enregistrements pour la création de rapports simplement parce qu'ils ont le même identifiant de substitution.

      une question supplémentaire se pose si le choix est fait d'utiliser des numéros de séquence de coffre de données pour les hubs et les clés métier du système source sont des substituts. la question est, pourquoi « re-clé » ou « renuméroter » la clé commerciale d'origine ? pourquoi ne pas simplement utiliser la clé d'entreprise d'origine ? (ce qui d'ailleurs est la façon dont le hub d'origine est défini).

      pour arrêter la collision (comme présenté dans l'exemple ci-dessus) - qu'une séquence de substitution, une clé de hachage ou la clé métier source soit choisie pour la structure du hub - un autre élément doit être ajouté. cet élément secondaire garantit l'unicité de cette clé métier de substitution. l'une des meilleures pratiques ici consiste à attribuer des codes géographiques. Par exemple, jap pour tout identifiant de compte client provenant de l'instance SAP du Japon, et peut pour tout identifiant de compte client provenant de l'instance SAP du Canada.

      clés métier source en plusieurs parties

      l'utilisation d'un code géographique, comme mentionné ci-dessus, soulève un autre problème. si le hub est créé uniquement sur la base de la clé métier du système source (et non de la séquence de substitution ou de la clé de hachage), alors avec le choix ci-dessus (pour ajouter une division de code géographique), le modèle doit être conçu et construit avec une clé métier en plusieurs parties.

      le problème avec une clé métier en plusieurs parties concerne les performances d'une jointure. il existe plusieurs tests mathématiques et résultats quantitatifs qui montrent à maintes reprises que les critères de jointure multi-champs sont plus lents que les critères de jointure à champ unique. il ne va "plus lentement" que dans les solutions de gros volume ou de données volumineuses. à ce stade, peut-être, une clé de hachage ou une séquence de substitution dans le coffre-fort de données peut être plus rapide qu'une jointure à plusieurs champs car elle réduit la jointure à une valeur de champ unique.

      une autre alternative consiste à concaténer les valeurs multi-champs ensemble, formant ainsi une sorte de clé intelligente, avec ou sans délimiteurs. cela dépendrait de la manière dont l'entreprise souhaite définir une norme définie pour concaténer les valeurs multi-champs (c'est-à-dire les règles nécessaires - tout comme les règles nécessaires pour définir une clé intelligente).

      la dernière chose à surveiller lors du choix d'une clé métier en plusieurs parties est la longueur du champ combiné ou concaténé. si la longueur des champs concaténés est plus longue que la longueur d'un résultat de hachage ou d'un identifiant de séquence de substitution, la jointure s'exécutera plus lentement qu'une jointure sur un champ plus court. pour rappel, ces différences de performances ne sont généralement visibles que dans de grands ensembles de données (500 m ou 1 milliard d'enregistrements ou plus). le matériel a progressé et continuera à progresser tellement que les petits ensembles de données présentent de bonnes performances. il n'y a tout simplement pas assez de différence dans un petit ensemble de données pour prendre une décision éclairée sur le choix de la « clé primaire » pour les hubs.

      la suggestion est finalement de redéfinir les solutions de données source, d'ajouter une clé intelligente ou intelligente « en amont » qui peut transporter les données entre les instances, les processus métier, les mises à niveau, les données de référence, les environnements hybrides et ne jamais changer . cela centraliserait et allégerait la douleur et le coût des « données de référence » et faciliterait l'utilisation d'un moteur de virtualisation. cela peut ne pas nécessiter d'analyses complexes, de réseaux neuronaux ou d'algorithmes d'apprentissage automatique pour relier les ensembles de données plus tard.

      en fait, la résolution de ces problèmes de ressaisie, selon une estimation, coûte à l'entreprise 7 fois plus d'argent pour « réparer » ce problème dans l'entrepôt, au lieu de le résoudre dans les applications source. résoudre le problème dans l'entrepôt de données est une forme de dette technique. (citation et mesures paraphrasées de nols ebersohn).

      si le système source ne peut pas être ressaisi ou le système source ne peut pas ajouter une « intelligente » ou une « clé intelligente » qui est une clé contextuelle, la recommandation est de mettre en œuvre la gestion des données de référence en amont. si mdm ne peut pas être mis en œuvre, la recommandation suivante consiste à tirer parti des clés métier du système source (sauf s'il existe des clés métier composites) - auquel cas, un hachage est la recommandation par défaut au niveau de base.


      Voir la vidéo: A Complete Beginners Guide to ArcGIS Desktop Part 1