Suite

Contrôler les résultats du géotraitement liés aux valeurs de données par défaut calculées pour les entrées nulles

Contrôler les résultats du géotraitement liés aux valeurs de données par défaut calculées pour les entrées nulles


Je recherche des informations sur les valeurs de données par défaut pour les différents types de données dans ArcGIS. Nous exécutons une série d'opérations de l'outil Overlay Route Events (référencement linéaire). Si l'une des valeurs des deux tables sources d'entrée est nulle, les valeurs de la table de résultats sont des valeurs de données par défaut. Par exemple, pour les types de champ Date qui ont des valeurs nulles dans les tables d'entrée, les valeurs qui sont renseignées dans le résultat de l'opération de superposition sont « 30/12/1899 0:00:00 ».

Cela se produit dans une géodatabase fichier sur ArcMap 10.1 et Windows Server 2008.

Quelqu'un a-t-il des informations sur les valeurs de données par défaut pour les types de données spécifiquement en référence au géotraitement ? Des suggestions pour que les valeurs nulles restent lorsque la superposition est calculée ?

Les propriétés de champ indiquent que allow null est yes.

J'ai reçu un message d'Esri indiquant qu'il s'agissait d'un bogue connu dans l'outil NIM081760. Je serais intéressé d'entendre des solutions de contournement.


Comme l'a commenté le demandeur :

J'ai été informé par esri qu'il s'agissait d'un bogue connu dans l'outil #NIM081760.

Je n'ai rien pu trouver sur le statut de NIM081760.


4 réponses 4

Utilisez un composant contrôlé pour cette situation, définissez une propriété de valeur de l'élément d'entrée comme ceci :

Chaque fois que vous mettrez à jour cette variable, cette valeur sera automatiquement renseignée dans l'élément d'entrée.

Vous pouvez maintenant remplir une valeur par défaut en attribuant une valeur à variable_name et l'utilisateur peut mettre à jour cette valeur par la fonction onChange.

Un élément de formulaire d'entrée dont la valeur est contrôlée par React de cette manière est appelé "composant contrôlé".

Passez la propriété value pour l'entrée :

vous pouvez utiliser le composant contrôlé et lui transmettre la valeur.

Bonne question. J'ai le même problème et je viens de trouver une solution.

  • Vous ne pouvez pas simplement utiliser l'état par défaut du composant modal pour définir la valeur d'entrée initiale, car le modal est rendu une fois dans le composant parent (commençant invisible), donc l'état par défaut du modal ne suivra pas les modifications apportées à les informations « pré-remplies » dans le magasin auxquelles les entrées du modal nécessitent un accès.
  • Vous ne pouvez pas utiliser l'attribut value de l'entrée pour référencer un accessoire de magasin redux, car cela est nécessaire pour référencer la fonction onChange afin que l'utilisateur puisse apporter des modifications à ces informations pré-remplies.
  • Et, vous ne pouvez pas utiliser la fonction onChange pour définir la valeur initiale, car il est nécessaire de mettre à jour l'état local avec les modifications des utilisateurs - pas de définir une valeur initiale. Quoi qu'il en soit, cela nécessite que l'utilisateur clique sur quelque chose, et vous voulez que les entrées modales soient pré-remplies avant que l'utilisateur ne fasse quoi que ce soit dès que le modal s'ouvre.

Alors. Ce dont nous avons besoin, c'est de mettre à jour ces champs de saisie à chaque fois que l'attribut modal isModalOpen (ou tout ce que vous utilisez) change.

(c'est-à-dire, pré-remplir les champs lorsque le modal est ouvert).

Encore une fois, notez que l'ouverture du modal n'est pas RENDU le modal, il a déjà été rendu, une fois, et est resté invisible jusqu'à ce que cet attribut isModalOpen soit changé en vrai.

Étape 1: créer une fonction de gestionnaire dans le composant modal qui préremplit les données d'entrée en mettant à jour l'état local du composant modal. Le mien ressemble à ça :

Étape 2: Faites que cette fonction se déclenche UNIQUEMENT lorsque l'attribut isOpen du modal changements du faux au vrai. (C'est la viande de votre problème je pense). Utiliser la méthode du cycle de vie composantDidUpdate. Cela exécutera à chaque fois les props du changement modal.


Si vous définissez l'attribut autocomplete=off , le contenu ne sera jamais stocké.

Alternativement, il existe une multitude de façons d'accomplir cela avec javascript, selon exactement ce que vous voulez accomplir, qu'il s'agisse d'effacer tout le formulaire (utilisez la méthode reset()) ou de réinitialiser un seul champ.

Vous pouvez ajouter form.reset() au body onload :

Mise à jour : bien que cela puisse être une technique utile, j'ai maintenant découvert qu'elle ne répond pas réellement à la question du demandeur.

Que diriez-vous de définir une valeur par défaut sur DOM ready avec javascript ?

Pour autant que je sache, il n'y a pas de moyen standard de l'implémenter, donc avant de pouvoir le désactiver, vous devez d'abord déterminer comment le site le fait. Ils auraient pu le faire de plusieurs manières, comme vous pouvez le voir à partir de la variété de réponses différentes ici.

Une bonne façon de comprendre ce qui se passe est de réduire le code à l'exemple le plus simple possible qui reproduit toujours le problème. Supprimez tous les graphiques, le texte inutile, les feuilles de style et autres mises en forme, le javascript non pertinent, les balises HTML non pertinentes, etc. mais en vérifiant toujours que vous pouvez toujours reproduire le problème. Finalement, il restera si peu de code qu'il devrait être évident de savoir ce qui provoque la réinitialisation des champs. Vous devrez faire tout cela sur la machine de production, puisque vous ne pouvez pas le reproduire localement. Pour ce faire, faites une copie des scripts et renommez-les en index2.html, etc. Assurez-vous d'avoir des sauvegardes de votre système de production avant de faire cela, au cas où quelque chose se passerait mal.

Si vous ne comprenez toujours pas comment résoudre le problème après cela, le code doit être suffisamment petit pour qu'il puisse être publié ici et que quelqu'un d'autre puisse le résoudre.


6 réponses 6

Je recommanderais de vérifier null et de ne pas faire le calcul plutôt que de lever une exception.

Une exception doit être « exceptionnelle » et rare, et non un moyen de gérer le flux de contrôle.

Je vous suggère également d'établir un contrat avec vos clients concernant les paramètres d'entrée. Si les valeurs NULL sont autorisées, précisez-le s'ils ne le sont pas, indiquez clairement ce qui doit être transmis, les valeurs par défaut et ce que vous promettez de retourner si une valeur NULL est transmise.

Si le passage de l'argument null est un cas exceptionnel, alors je lancerais une NullPointerException .

Si passer null est un cas autorisé, alors je sauterais le calcul et retournerais finalement null . Mais cela a à mon avis moins de sens. Passer null en première instance semblerait être un bogue dans le code appelant.

Quelle que soit la manière que vous choisissez, elle doit être correctement documentée dans la Javadoc pour éviter les surprises à l'utilisateur de l'API.

S'il y a plus de 50 % de chances d'obtenir une valeur nulle, ce n'est pas vraiment une exception ?

Personnellement, je dirais que si vous vous attendez à ce que quelque chose se produise, vous devez le coder de manière appropriée - dans ce cas, vérifier la valeur null et faire ce qui est approprié. J'ai toujours compris que lancer une exception n'était pas excessivement bon marché, mais je ne pouvais pas le dire avec certitude.

Essayez et attrapez sont proches du "gratuit" mais les lancers peuvent être très coûteux. En règle générale, les créateurs de VM n'optimisent pas les chemins d'exception car, eh bien, ils sont exceptionnels (censés être rares).

NullPointerException indique une erreur du programmeur (RuntimeException) et ne doit pas être interceptée. Au lieu d'attraper l'exception NullPointerException, vous devez corriger votre code pour que l'exception ne soit pas levée en premier lieu.

Pire encore, si vous interceptez l'exception NullPointerException et qu'une partie différente du code de calcul lève l'exception NullPointerException que celle que vous vous attendez à lancer, vous avez maintenant masqué un bogue.

Pour répondre pleinement à votre question, je le mettrais en œuvre dans un sens, le profilerais, puis le mettrais en œuvre dans l'autre sens et le profilerais. alors je n'utiliserais que celui avec l'instruction if qui évite de lancer l'exception NullPointerException, peu importe ce qui est plus rapide simplement à cause du point ci-dessus.

Je suis d'accord avec la plupart des autres réponses selon lesquelles vous devriez préférer le contrôle null au try-catch. Et j'ai voté pour certains d'entre eux.

Mais vous devriez essayer d'éviter autant que possible le besoin.

Il y a > 50 % de chances d'obtenir des valeurs nulles, car dans cette application. il est courant d'avoir une valeur nulle si aucune donnée n'a été saisie. donc tenter un calcul à l'aide d'un null est monnaie courante.

C'est ce que vous devriez vraiment réparer.

Proposez des valeurs par défaut sensées qui garantissent que le calcul fonctionne ou évitent d'appeler un calcul sans fournir les données d'entrée nécessaires.

Pour de nombreux types de données standard et les calculs les impliquant, il existe des valeurs par défaut raisonnables. Les nombres par défaut à 0 ou 1 selon leur signification, les chaînes et les collections par défaut à vider, et de nombreux calculs fonctionnent. Pour des objets plus complexes de votre propre fabrication, considérez le modèle Null Object.

Si vous avez un cas où un résultat ou une entrée ne peut pas être géré par votre programme, cela devrait être une erreur. Vous devez savoir ce que votre programme peut gérer et autoriser uniquement cela. En ce qui concerne les cas futurs possibles où un résultat pourrait être traité mais ne l'est pas encore, je suggérerais toujours de le considérer comme une erreur jusqu'à ce que vous ayez réellement besoin de ce résultat. En cas de doute, vous ne savez pas, le programme ne sait pas, il ne peut pas être manipulé, vous n'avez pas équipé votre programme pour le gérer donc c'est une erreur. Le programme ne peut plus que s'arrêter.

Pour l'entrée de l'utilisateur, c'est une très mauvaise idée de s'appuyer sur votre programme pour éventuellement planter. Vous ne savez pas quand ni même s'il va planter. Il pourrait simplement finir par faire la mauvaise chose ou faire dix choses puis planter qu'il n'aurait pas dû faire et n'aurait pas fait si l'entrée avait été validée.

En termes de protection contre vos propres erreurs, c'est plus un sac mélangé. Vous voudrez vous concentrer beaucoup plus sur le fait que les choses fonctionnent en testant, en éliminant les inconnues, en relisant les épreuves, en vous assurant de savoir exactement comment fonctionne votre programme, etc. Vous aurez néanmoins parfois des cas où le traitement interne peut produire des résultats indésirables.

Lorsqu'il s'avère qu'un résultat n'est pas une erreur pour un cas donné, vous ne gérez pas l'exception, vous gérez null, pas une exception. Dans ce cas, le résultat n'est pas une erreur. Vous gérez donc le résultat et non l'erreur. Cela ne pourrait pas être plus simple. Si vous interceptez une exception et que vous faites quelque chose qui peut être fait avec un if tel que :

Alors ce n'est pas juste. Vous avez un plan d'action parfaitement acceptable si vous n'avez pas la chose supplémentaire.

C'est bien mieux et cela garde votre intention claire sans la verbosité supplémentaire :

Notez ici que vous n'avez besoin de rien de spécial pour éviter d'attraper une exception d'une autre couche. La façon dont je mets try catch ci-dessus est une mauvaise pratique. Vous ne devriez envelopper que la chose qui lève une exception :

Quand vous pensez à ça comme ça, il suffit de convertir null en exception, puis de revenir. C'est le codage Yo-Yo.

Jusqu'à ce que vous soyez réellement capable d'implémenter la gestion de null. Si vous êtes en mesure d'implémenter la gestion de l'exception, vous pouvez implémenter la gestion du null.

Lorsqu'il s'avère que quelque chose n'est pas toujours nécessaire, ajoutez cette méthode ou modifiez i_need_it (si null est toujours géré) :

Une alternative consiste à vérifier s'il existe d'abord :

La raison pour laquelle cela n'est pas fait si souvent est que cela se présente généralement comme suit :

Cela a tendance à être plus sujet aux problèmes de simultanéité, peut nécessiter plus d'appels qui peuvent ne pas être fiables (IO sur le réseau) et peut être inefficace (deux RTT au lieu d'un). D'autres appels sont souvent fusionnés comme ceci, tels que update if exist, insert if unique, update if existe ou insert, etc. qui renvoient ensuite ce qui serait normalement le résultat d'une vérification initiale à la place. Certains d'entre eux ont des conflits sur l'efficacité de la taille de la charge utile et l'efficacité RTT qui peuvent également varier en fonction d'un certain nombre de facteurs.

Cependant, c'est moins cher lorsque vous avez besoin d'un comportement alternatif en fonction de l'existence ou non de quelque chose, mais que vous n'avez pas besoin de travailler dessus. Si vous n'avez pas non plus à vous soucier des problèmes ci-dessus, c'est un peu plus clair.

C'est encore une fois utile car si vous avez seulement besoin de vous assurer que quelque chose existe, c'est souvent moins cher que de l'obtenir. Cependant, il est rare que vous en ayez besoin car dans la plupart des cas, vous voudrez savoir si quelque chose existe afin de travailler directement dessus.

Une façon de le concevoir est que vous ne feriez pas que 'does_it_exist' lève une exception alors qu'il peut simplement renvoyer un booléen explicitement vers le haut de la pile d'appels, 'i_want_it' est un combiné 'has' et 'get' en vigueur.

Bien que le fait d'avoir deux méthodes distinctes sépare plus clairement les signatures de méthode, vous devrez parfois transmettre quelque chose d'autre et le moyen le plus simple pour cela si vous n'exploitez pas un peu d'ambiguïté est :

C'est mieux car vous transmettez le contrat au fil de la chaîne d'appel plutôt que de construire sur une maison de sable basée sur l'action à distance. Il existe des moyens de transmettre votre contrat de manière plus explicite, mais il a tendance à être compliqué YAGNI (c'est-à-dire, transmettre un appelant de méthode).

Vous devez lancer des exceptions tôt et vous pouvez vouloir être en sécurité plutôt que désolé, donc les faux positifs sont acceptables. Une fois que vous découvrez qu'il s'agit d'un faux positif, vous le réparez à la source.

Il devrait être extrêmement rare que vous gériez des exceptions. La grande majorité devrait atteindre le sommet, puis invoquer un gestionnaire de journalisation et de sortie. Le reste, vous corrigez de manière appropriée en transmettant directement le résultat et en le manipulant. Lorsque vous avez un faux positif parmi de nombreuses utilisations, uniquement celui-ci. Ne vous contentez pas de supprimer la vérification à la racine et de casser les nombreux autres cas où il s'agit toujours d'une erreur.

Java est un langage malheureux car je ne peux pas avoir un moyen de dire ne pas passer null ou cette variable doit être non null.

Lorsqu'une telle fonctionnalité fait défaut, il est souvent préférable de vérifier les valeurs NULL à leurs sources, des choses telles que les E/S plutôt que pour chaque fois que quelque chose est passé à l'une de vos méthodes. Sinon, c'est une quantité absurde de vérification nulle.

Vous pouvez appliquer ce modèle pour créer des fonctions pour remplacer vos ifs pour la vérification des paramètres si vous en avez vraiment besoin. Vous remplaceriez id par l'objet lui-même, par exemple :

Dommage qu'il n'y ait pas de type passthru.

Vous pouvez avoir un Getter spécifique plutôt qu'un générique.

Si vous ne le faites que sur la limite à la place (lorsque vous appelez des choses hors de votre contrôle où un résultat non nul ne peut pas être garanti), alors qu'il est préférable de le faire là-bas ou pour toute utilisation d'une méthode documentée comme renvoyant null et seulement là, car c'est là que c'est vraiment nécessaire, cela signifie que lorsque vous obtenez un null où il n'appartient pas (des erreurs se produisent), vous n'aurez pas de difficulté à découvrir d'où il vient. Il peut être beaucoup transmis par IO et ne pas produire d'exception de pointeur nul tant que quelque chose n'essaie pas de l'utiliser. De telles valeurs nulles peuvent être transmises dans le système pendant des jours, voire des mois, sous la forme d'une bombe à retardement attendant de se déclencher.

Je ne le ferais pas moi-même, mais je ne blâmerais pas les gens dans certains cas pour avoir mis en œuvre l'approche de programmation défensive ci-dessus, ce qui pourrait être nécessaire en raison du système de type cassé de Java qui est lâche par défaut et ne peut pas être restreint. Dans les langages à typage robuste, null n'est pas autorisé à moins que vous ne le disiez explicitement.

Veuillez noter que bien que je l'appelle cassé, j'utilise généralement des langages beaucoup plus souples depuis des décennies pour construire des systèmes volumineux, complexes et critiques sans avoir à encombrer la base de code de vérifications superflues. La discipline et la compétence sont ce qui détermine la qualité.

Un faux positif se produit lorsqu'un résultat ou une condition se produit que vous supposez être un résultat qui ne peut pas être géré par tous les appelants, mais il s'avère qu'au moins un appelant peut le gérer de manière appropriée. Dans ce cas, vous ne gérez pas l'exception mais donnez le résultat à l'appelant. Il y a très peu d'exceptions à cela.

Java 8 a facultatif mais cela n'a pas vraiment l'air utile. C'est un cas horrible d'effet de plate-forme interne essayant d'implémenter une nouvelle syntaxe en tant que classes et finissant par devoir ajouter la moitié de la syntaxe Java existante, ce qui la rend très maladroite. Comme d'habitude, la POO Java moderne résout tous les problèmes des personnes souhaitant moins de fudge en ajoutant plus de fudge et en compliquant les choses. Si vous voulez vraiment enchaîner comme ça, vous voudrez peut-être essayer quelque chose comme kotlin qui implémente directement cette syntaxe.

Une langue moderne signifie que vous n'avez pas à vous soucier de la plupart de ces éléments et que vous disposez simplement de :

Un langage moderne pourrait même renvoyer l'objet d'origine pour une méthode sans retour (remplacer void par self comme standard et retour automatique) afin que les gens puissent avoir leur enchaînement fantaisiste ou tout ce qui est à la mode de nos jours dans la programmation.

Vous ne pouvez pas non plus avoir une usine avec une classe de base qui vous donne un Null ou NotNull car vous devrez toujours passer la classe de base et ce sera une violation de type lorsque vous direz que vous voulez NotNull.

Vous voudrez peut-être jouer avec les aspects, l'analyse statique, etc. bien que ce soit un peu un trou de lapin. Toute la documentation doit indiquer si null peut être renvoyé (bien que, indirectement, il puisse potentiellement être omis).

Vous pouvez créer une classe telle que MightHave pour envelopper votre résultat où vous pouvez mettre des méthodes comme get, require et has si vous n'aimez pas la statique mais que vous voulez manger un if bien que ce soit aussi dans le domaine de légèrement alambiqué et de jouer avec tout de vos signatures de méthode partout boxant tout partout, une solution laide. Ce n'est vraiment pratique qu'en tant qu'alternative aux rares cas de gestion des exceptions où les exceptions semblent utiles en raison de la complexité du graphe d'appels et du nombre d'inconnues présentes à travers les couches.

Un cas exceptionnellement rare est celui où votre source sait quelle exception lancer, mais pas si elle doit être levée, mais il est difficile de la transmettre (bien que le couplage de deux couches à une distance où tout peut arriver entre les deux doit être abordé avec prudence). Certaines personnes pourraient également vouloir cela car cela peut facilement donner une trace à la fois de l'origine de l'élément manquant et de l'endroit où il était requis, ce que l'utilisation de vérifications peut ne pas donner (ils sont susceptibles d'échouer près de la source mais ce n'est pas garanti). Des précautions doivent être prises car ces types de problèmes peuvent être plus révélateurs d'un mauvais contrôle de flux ou d'une complexité excessive qu'un problème de polymorphisme justifié, de codage méta/dynamique, etc.

Des précautions doivent être prises avec des éléments tels que les valeurs par défaut ou le modèle Null Object. Les deux peuvent finir par cacher des erreurs et devenir les meilleures suppositions ou un remède pire que la maladie. Des choses telles qu'un modèle NullObject et Optional peuvent souvent être utilisées pour simplement désactiver ou plutôt bipasser la gestion des erreurs intégrée dans votre interpréteur.

Les valeurs par défaut ne sont pas toujours mauvaises, mais peuvent tomber dans le domaine de la conjecture. Cacher les erreurs de l'utilisateur finit par les faire échouer. Les défauts (et la désinfection) doivent toujours être pensés avec soin.

Des éléments tels que le modèle NullObject et Facultatif peuvent être surutilisés pour désactiver efficacement la vérification du pointeur nul. Cela suppose simplement que null n'est jamais une erreur qui aboutit à des programmes faisant quelque chose, pas d'autres mais vous ne savez pas quoi. Dans certains cas, cela peut avoir des résultats hilarants, par exemple si la carte de crédit de l'utilisateur est nulle. Assurez-vous que si vous utilisez de telles choses, vous ne les utilisez pas dans le but de simplement envelopper tout votre code dans un try catch qui ignore une exception de pointeur null. C'est très courant car les gens ont tendance à corriger les erreurs là où l'exception a été levée. En réalité, la véritable erreur a tendance à être plus éloignée. Vous vous retrouvez avec un élément de gestion des E/S défectueux qui renvoie par erreur null et ce null est transmis dans tout le programme. Au lieu de réparer cette seule source de null, les gens essaieront plutôt de la réparer à tous les endroits où elle atteint où elle provoque une erreur.

Les motifs NullObject ou MagicNoop ont leur place mais ne sont pas d'usage courant. Vous ne devriez pas les utiliser jusqu'à ce qu'il devienne immédiatement évident qu'ils sont utiles d'une manière justifiée qui ne va pas causer plus de problèmes qu'elle n'en résout. Parfois, un noop est effectivement une erreur.


Discussion

Cette étude a examiné la TE et la SE du système de santé provincial en Chine et le rôle des facteurs environnementaux dans l'influence à la fois de la SE et de la PTE en ce qui concerne l'ISR, le MSR et les HLY_NCD. Ce travail revêt une importance politique particulière compte tenu des ressources limitées en matière de santé et des besoins de santé sans cesse croissants.

Nos résultats indiquent que l'ETP corrigée du biais était généralement élevée dans toutes les provinces (c.-à-d. 0,9947). Cependant, étant donné les niveaux relativement élevés d'inefficacité de l'échelle (c'est-à-dire 13,47 %), le niveau OTE corrigé du biais, en moyenne, était plutôt faible (c'est-à-dire 0,8022). De plus, l'OTE était assez hétérogène d'une province à l'autre. Les provinces du corridor de développement économique élevé de l'est de la Chine avaient tendance à avoir un OTE relativement élevé, tandis que les provinces des régions moins développées ont eu des performances moins efficaces, en particulier les provinces du nord-est, qui affichaient le OTE le plus faible. Certaines des provinces aisées ont également connu une grande inefficacité dans leurs systèmes de santé locaux. Par exemple, Pékin, Shanghai, Jiangsu et Zhejiang ont obtenu des valeurs OTE corrigées des biais inférieures à 0,80, ce qui signifie que des ressources considérables investies dans ces régions n'ont pas généré l'impact souhaité sur les résultats de santé. Néanmoins, ce qui est encore plus préoccupant, c'est que les provinces moins développées avec de mauvais résultats en matière de santé, telles que le Xinjiang, le Heilongjiang et le Qinghai, ont également souffert d'une OTE médiocre dans la production de santé.

Dans notre étude, la faible OTE des systèmes de santé dans toutes les provinces était généralement causée par un niveau élevé d'inefficacité d'échelle observé dans toutes les provinces. Les résultats ont indiqué que seulement 41,9% des provinces fonctionnaient au MPSS, tandis que 58,1% présentaient un DRS, ce qui impliquait qu'une augmentation des intrants ne peut générer qu'une augmentation plus faible des résultats pour la santé. En général, la densité des lits d'hôpitaux a joué un rôle important dans le SE des provinces. Si la densité de lits d'hôpitaux était supérieure à 5,0 pour 1 000 habitants, les chances qu'une province soit inefficace à l'échelle étaient plus grandes. Cela reflétait le phénomène de médecine dit « flat-of-the-curve », se référant à un niveau d'intensité des soins qui n'apporte aucun avantage supplémentaire pour la santé38. Par coïncidence, un nombre croissant d'études ont montré une diminution des rendements des intrants du système de santé sur les résultats de santé . Par exemple, Asandului et al ont révélé que 26 des 30 pays européens examinés affichaient un DRS, et que quatre pays seulement présentaient un système efficace à l'échelle.39 Cetin et Bahce ont indiqué que l'efficacité technique serait augmentée en utilisant des ressources inférieures pour 11 pays de l'OCDE dotés de systèmes de santé caractérisés par le DRS.40 Un autre Une étude a montré que la réduction des niveaux d'intrants de santé peut aider à améliorer l'efficacité des systèmes de santé d'Asie centrale.41 Cela vaut également dans le cas de la Chine. Zhang et al ont révélé que la réduction de l'ES est une loi objective lorsqu'ils ont étudié l'efficacité du système de santé en Chine dans son ensemble par rapport à d'autres pays.10

Les variables d'analyse ont été sélectionnées sur la base des preuves d'études antérieures similaires et de la disponibilité des données. Compte tenu de l'OTE hétérogène des systèmes de santé dans les provinces chinoises, la procédure en deux étapes de Simar et Wilson a été utilisée pour examiner et mieux comprendre les moteurs de cette variation24. Plusieurs résultats sont mis en évidence ici. Premièrement, les résultats suggèrent que plus le pourcentage d'OOP dans les dépenses totales de santé est élevé, plus le niveau d'inefficacité est élevé, ce qui implique qu'un système de soins dominé par le financement public est plus adapté pour créer une production de santé plus efficace. Conformément aux conclusions de González et al,42 ils ont signalé que la part publique dans les dépenses de santé est positivement associée à l'amélioration de la performance du système de santé. soleil et al ont constaté qu'une augmentation de 1 % de la part des dépenses de sécurité sociale pourrait améliorer l'efficacité du système de santé de 1,9 %. équipé. Ces dernières années, le gouvernement chinois a reconnu que le risque financier actuel est élevé en Chine, et de nouveaux efforts pour améliorer le financement public ont été soulignés. Selon le plan Healthy China 2030, le pourcentage de POO dans les dépenses totales de santé devrait passer de 29 % en 2015 à 25 % d'ici à 2030.3

Deuxièmement, dans notre étude, l'association négative des taux d'admission avec l'efficacité impliquait qu'une utilisation des services d'hospitalisation à forte intensité de ressources était préjudiciable à l'efficacité du système de santé. Nos résultats sont similaires à ceux de Chowdhury et Zelenyuk qui ont signalé que le ratio ambulatoires/patients hospitalisés est un facteur important d'efficacité.37 Si des ressources de santé limitées ne sont pas allouées rationnellement et utilisées pour maximiser les résultats de santé, une faible efficacité technique se produira. En Chine, au cours des 37 dernières années, c'est-à-dire depuis la « politique d'ouverture », les dépenses totales de santé ont augmenté rapidement, avec un taux de croissance annuel de 11,7 %4. L'une des causes sous-jacentes de l'escalade sans précédent des dépenses de santé est un système hospitalier public en pleine expansion, les lits d'hôpitaux étant une composante majeure. Les hôpitaux représentent 54 % des dépenses totales de santé de la Chine,4 ce qui est supérieur au niveau moyen de l'OCDE de 38 %44. Comme le dit l'adage, « un lit d'hôpital construit est un lit rempli ».45 La Chine a doublé, passant de 1,2 million à 2,2 millions entre 1980 et 2000, et a atteint 5,3 millions en 2015.46 Actuellement, le système de prestation de santé chinois est doté d'un système de soins fortement centré sur l'hôpital avec un système de santé primaire qui est marginalisé et fragmenté.47 48 Le le niveau de densité de lits d'hôpitaux en Chine dépasse désormais certains pays de l'OCDE comme le Canada, le Royaume-Uni, les États-Unis et l'Espagne.44

Le SSE est l'un des prédicteurs les plus puissants de l'indicateur de santé, et il pourrait être important d'aborder plusieurs composantes du SSE (c.-à-d. la pauvreté monétaire et le faible niveau d'instruction) pour améliorer la santé de la population49. avec indice socioéconomique provincial. Les résultats de l'étude actuelle étaient incompatibles avec ceux de Ramin et al, Achoko et al et de Cos et Moral-Benito.28-30. En termes de santé maternelle et infantile, de nombreuses études ont démontré que l'alphabétisation maternelle joue un rôle crucial dans l'amélioration des services vitaux pour les mères et les enfants.50 51 De plus, il a été prouvé dans de nombreuses études montrent que le niveau économique (par exemple, le PIB par habitant) était positivement associé à l'efficacité du système de santé29. 52 Cependant, l'effet de l'urbanisation sur la santé n'est pas clair en Chine. Alors que la vie urbaine offre aux individus les avantages d'un accès à des services de santé, de nutrition et d'assainissement améliorés, elle les expose également à la pollution de l'air, aux risques de trafic routier et aux risques comportementaux associés à l'évolution des régimes alimentaires et des habitudes d'activité physique.53

Enfin, étant donné le niveau élevé d'inefficacité d'échelle en Chine, il est impératif que les décideurs en matière de santé explorent l'échelle de fonctionnement optimale des systèmes de santé et rationalisent l'approvisionnement des systèmes de santé, plutôt que d'augmenter aveuglément les investissements dans les ressources de santé pour améliorer la santé de la population. Il est bien connu que la santé pourrait être grandement améliorée en réaffectant les ressources des interventions qui ne sont pas rentables à celles qui sont plus rentables mais pas entièrement mises en œuvre pour les systèmes de santé.22 38 42

Limites et suggestions pour de futures recherches

Notre analyse n'est pas sans limites. Premièrement, il s'est concentré uniquement sur l'efficacité du système de santé en utilisant des données transversales. Les recherches futures peuvent utiliser plusieurs points de données et examiner comment l'efficacité a changé dans le pays au fil du temps, en examinant en particulier l'impact des réformes des soins de santé sur l'efficacité et la productivité du système de santé. Deuxièmement, nous n'avons examiné que l'efficacité du système de santé au niveau provincial, principalement en raison des limites des données. Cependant, une analyse plus approfondie axée sur le niveau du comté est également nécessaire étant donné les variations dans les intrants et les extrants de la santé au sein de chaque province. Troisièmement, dans notre analyse, les DMU primaires (c'est-à-dire les provinces) sont supposées être indépendantes les unes des autres, ce qui peut ne pas être le cas. Par conséquent, un modèle d'efficacité spatialement sensible, comme ceux développés pour la SFA54, peut être envisagé dans les études futures.


SQL : chaîne vide vs valeur NULL

Je sais que ce sujet est un peu controversé et que de nombreux articles/opinions circulent sur Internet. Malheureusement, la plupart d'entre eux supposent que la personne ne sait pas quelle est la différence entre une chaîne NULL et une chaîne vide. Ils racontent donc des histoires sur des résultats surprenants avec des jointures/agrégats et font généralement des leçons SQL un peu plus avancées. En faisant cela, ils passent absolument à côté de l'essentiel et sont donc inutiles pour moi. J'espère donc que cette question et toutes les réponses feront avancer le sujet un peu.

Supposons que j'ai un tableau avec des informations personnelles (nom, naissance, etc.) où l'une des colonnes est une adresse e-mail de type varchar. Nous supposons que pour une raison quelconque, certaines personnes pourraient ne pas vouloir fournir d'adresse e-mail. Lors de l'insertion de telles données (sans e-mail) dans la table, deux choix sont disponibles : définir la cellule sur NULL ou la définir sur une chaîne vide (''). Supposons que je connaisse toutes les implications techniques du choix d'une solution plutôt qu'une autre et que je puisse créer des requêtes SQL correctes pour l'un ou l'autre scénario. Le problème est que même lorsque les deux valeurs diffèrent au niveau technique, elles sont exactement les mêmes au niveau logique. Après avoir regardé NULL et '' je suis arrivé à une seule conclusion: je ne connais pas l'adresse e-mail du gars. De plus, peu importe à quel point j'ai essayé, je n'ai pas pu envoyer d'e-mail en utilisant une chaîne NULL ou vide, donc apparemment, la plupart des serveurs SMTP sont d'accord avec ma logique. J'ai donc tendance à utiliser NULL où je ne connais pas la valeur et considère la chaîne vide comme une mauvaise chose.

Après d'intenses discussions avec des collègues, j'ai posé deux questions :

ai-je raison de supposer que l'utilisation d'une chaîne vide pour une valeur inconnue provoque le "mentir" d'une base de données sur les faits ? Pour être plus précis : en utilisant l'idée de SQL de ce qui est valeur et de ce qui ne l'est pas, je pourrais arriver à la conclusion : nous avons une adresse e-mail, juste en découvrant qu'elle n'est pas nulle. Mais plus tard, en essayant d'envoyer un e-mail, j'arriverai à une conclusion contradictoire : non, nous n'avons pas d'adresse e-mail, cette @!#$ Database doit avoir menti !

Existe-t-il un scénario logique dans lequel une chaîne vide '' pourrait être un si bon support d'informations importantes (en plus de la valeur et de l'absence de valeur), qui serait gênant/inefficace à stocker d'une autre manière (comme une colonne supplémentaire). J'ai vu de nombreux articles affirmant qu'il est parfois bon d'utiliser une chaîne vide avec des valeurs réelles et des valeurs NULL, mais jusqu'à présent, je n'ai pas vu de scénario qui serait logique (en termes de conception SQL/DB).


3 réponses 3

Étant donné que recalculateFormulas() a toujours un bogue, vous pouvez l'utiliser comme solution de contournement pour définir les champs de formule :

C'est aussi une bonne chose à utiliser lorsque vous vous moquez.

La solution générale à ce problème est double

    Si la logique de la formule est particulièrement complexe et que vous souhaitez conserver une suite de tests de régression pour elle, créez une méthode de test apex juste pour elle, en passant diverses combinaisons d'entrées. La façon dont vous créez cette entrée de test peut être explicitement via la construction APEX SObject ou peut-être avec une bibliothèque de données JSON conservée dans un StaticResource

Utilisez une propriété @TestVisible dans votre code qui renvoie la valeur du champ de formule telle que celle-ci :

Votre code ne fait jamais référence au sobject.formulaField , remplacez à la place toutes ces références à cette propriété spéciale

Ensuite, dans votre méthode de test, après avoir construit la classe,

De cette façon, le champ de formule renvoie une constante 10 quel que soit le cas d'utilisation dans les méthodes de test et renvoie la valeur réelle de la formule dans les cas d'utilisation PROD.

Si ce qui précède est trop limitatif, vous pouvez écrire une façade fictive plus sophistiquée en utilisant votre propre classe avec injection via des arguments de constructeur - de la même manière que HttpMock fonctionne.

Pour ce qui est de réglage la valeur, vous ne contrôlez vraiment que les entrées et, comme vous le dites, devez définir des champs spécifiques pour obtenir la valeur que je veux. Si vous souhaitez que le champ soit accessible en écriture, déplacez la formule vers une mise à jour de champ de workflow et ajoutez quelque chose dans vos critères de règle de workflow pour éviter les écrasements.

Si vous voulez pouvoir avoir la valeur sans la surcharge d'une insertion/requête, essayez la méthode SObject recalculateFormulas(). À partir de la documentation :

recalculerFormules()
Recalcule tous les champs de formule sur un sObject et définit les valeurs de champ mises à jour. Plutôt que d'insérer ou de mettre à jour des objets chaque fois que vous souhaitez tester les modifications apportées à votre logique de formule, appelez cette méthode et inspectez vos nouvelles valeurs de champ. Apportez ensuite d'autres modifications logiques si nécessaire.

Signature
public Void recalculerFormules()

Valeur de retour
Type : Vide

Usage
Cette méthode ne recalcule pas les formules inter-objets. Si vous appelez cette méthode sur des objets qui ont à la fois des champs de formule inter-objets et non inter-objets, seuls les champs de formule non inter-objets sont recalculés.

Voir également:
Que sont les formules inter-objets ?


Calculer les estimations de population

Vous calculerez les estimations de population dans vos fichiers de limites à l'aide de l'outil Statistiques zonales sous forme de tableau. Cet outil est extrêmement utile pour effectuer une analyse statistique spatiale et fournir une sortie tabulaire. Dans ce cas, une sortie tabulaire est préférée à une sortie spatiale car elle est plus facile à ajouter à l'entité Congo RDC. Vous exécuterez l'outil pour calculer la somme de la population estimée dans le pays et les zones géographiques administratives dans un tableau qui sera ensuite joint à la classe d'entités respective.

Tout d'abord, vous allez calculer la population pour la couche de pays.

Assurez-vous d'avoir activé l'extension Spatial Analyst pour ArcGIS Pro . Pour activer l'extension, cliquez sur l'onglet Projet et sélectionnez Licences pour vérifier vos paramètres.

  1. Dans le volet Géotraitement, recherchez et choisissez l'outil Statistiques zonales sous forme de table (Outils Spatial Analyst).

Les outils de statistiques zonales sont un moyen simple mais puissant de résumer les informations raster en polygones, tels que des limites administratives ou des tables.

  • Pour Données raster ou de zone d'entités en entrée , choisissez DRC_Country .
  • Le champ Confirmer la zone est défini sur Pays .
  • Pour Raster de valeurs en entrée , choisissez Estimation de la population mondiale 2016 .
  • Pour Table de sortie , tapez CountryPop .
  • Pour le type Statistiques , choisissez Somme .

L'exécution de l'outil peut prendre quelques minutes. Lorsque l'outil a fini de s'exécuter, la table CountryPop est ajoutée au volet Contenu sous Tables autonomes .

In the attribute table, you can see in the SUM field that the population estimate for the entire country is 79,549,483.

Next you will use the Zonal Statistics tool for the DRC_Admin layer.

  • For Input raster or feature zone set , choose DRC_Admin .
  • For Zone field , confirm Name is selected.
  • For Input value raster , choose World Population Estimate 2016 .
  • For Output table , type AdminPop .
  • For Statistics type , choose Sum .

When the tool finishes running, the AdminPop table is added to the Contents pane under Standalone Tables .

Now that you have calculated population estimates, you no longer need the World Population Estimates 2016 layer.


Creating a new model

Creating models in Service Operations is a fairly iterative process that commonly starts with sketching the general service or application model to monitor, and how it breaks down in terms of main building blocks, subsystems, and so forth, generally reaching the lowest level of detail with the atomic KPIs and/or KQIs that rule the operational, performance or business related-status of their affecting entities. Once that rough design of the service model is done, it becomes a far simpler task to begin translating that design in terms of actual entities and relationships in Service Operations. As a general recommendation, it is a good idea to work with two browser tabs simultaneously, the first one to navigate and perform the actual configurations on Service Operations and the second one to run and refine any queries that will be necessary for the model creation.

Please follow the steps specified in the next section to complete the creation of a new model:

Go to the administration interface by clicking on the config icon in the Service Operations main menu.

Cliquer sur Manage models under the Des modèles main section on the left menu. A list of all available maps in the domain and their associated categories will be shown:

Creating entities

Click on the "+" button to add a new entity to the model. A form will be shown with all necessary parameters to be set in order to create the new entity:

Entity definition section

La description

Overall behavior of the entity in terms of its status calculation. When auto-mode = off, the value of the entity will be retrieved from the result of the associated query defined for it. If auto-mode = on, the result of the value will be ignored and overrode with the warning and critical status definition as specified below.

Textual description of the entity

Graphical representation of the entity

Icon of the Devo icons list

Logical group the entity belongs to

LinQ-format Devo query used to calculate the numeric value of the entity. The numeric value assumed by the entity will correspond to the last ‘select’ clause in the query

Discovery key (Component value)

Column value used to identify all entity instances

Single value from the last grouping key of the specified Devo query

LinQ-format Devo query used to retrieve the inventory information referred to the same entity.

Critical status definition

List of status criteria that correspond to ‘critical’ status for a summary entity

Warning status definition

List of status criteria that correspond to ‘warning’ status for a summary entity

Metadata section

La description

Main category that defines the entity being modeled.

Some of the entity types are utilized for automatic calculations of service metrics and incidents. For example, the ‘KPI’ type is reserved for any fundamental entity that monitors a concrete metric affecting its parent node.

Additionally, types ‘user’, ‘session’ and ‘device’ are utilized by the User Experience module to automatically compose the status of the service from an end-user perspective.

List of predefined values

Subtype of the entity, more oriented to the environment or purpose it is defined, e.g., business-specific, operational, etc.

List of predefined values or custom string

Additional metadata fields

Customizable data fields per entity that can hold any sort of additional information or parameters.

Typically, these metadata fields are utilized as filtering criteria together with ‘type’ and ‘subtype’.

Metadata fields are configured as key/value pairs. The key is defined as a string, whereas the value has two different possibilities: static value (treated as another string) or a query

Key, value pairs, composed by string + string or string + LinQ query

Impact assessment section

La description

Textual information that can provide a guidance on the best way to understand or diagnose an incident whenever it occurs

Textual information listing the steps that could be taken to fix or mitigate the impact of an incident.

Impact evaoluation definition

Query that is triggered any time an incident affects the corresponding entity to calculate the amount of entities directly affected by it.

For example, if an entity definition models the operational status of a web server, the impact evaluation query could be defined to calculate the subset of client hosts that have received an HTTP 500 code as a result of any connection request.

Description or unit of the entities affected by an incident (e.g., “end-users”, “network nodes”)

Linking entities

To link two already-created entities use the following procedure:

Click on the source entity. The entity will be shown highlighted in the model, and a icon in the upper part of the node will be displayed.

Clique sur le button, keeping the button pressed down by your mouse, and start dragging the arrow to its destination.

Release the button on your mouse when the arrow is pointing at the border of the targeted entity.

NOTE: Remember the relationship you are establishing is based upon impact. That means, links should be read as ‘source entity impacts the status of the targeted entity’.

Linking entities using a link criteria

The mechanism described in the previous paragraph is the standard to link entities in an all-to-all way. That means, the following table of results shall be expected when linking entities using that approach:

Cardinality of source entity

Cardinality of target entity

Expected result

One (e.g., no discovery key defined or only one entity value discovered)

The established link is rendered as a one-to-one relationship

Many (e.g., a discovery key has been defined and there are multiple discovered entities)

Single one-to-one links are rendered, one per discovered target entity

Single one-to-one links are rendered, one per discovered source entity

Full all-to-all relationships mesh

In some situations though, it is necessary to link sources and targets based upon some criteria. In the event of this, it is possible to set a linking criteria to ensure only those links will be created.

The procedure to observe is as follows:

Create a link between two different entities using the procedure described in the previous section.

Click on the link (arrow). A form in the right hand side of the screen will be displayed with two options:

Use the dropdown selectors to set the linking criteria between the two entities. Service Operations will list all grouping keys defined in both source and target entities' value calculation queries. The way this should be interpreted is as follows: “link the entities whose value in the ‘from’ column matches exactly the value of the ‘to’ column".

Cliquez sur appliquer. The link criteria is established and displayed in textual form on top of the arrow between the two linked entities.

NOTE: By definition, only those entities with grouping keys in their value calculation definition can be linked using this mechanism. If Service Operations cannot retrieve the grouping keys for both queries, a message in the same form will be displayed informing of this situation.

Setting the general configuration for the model

These settings describe the general characteristics and structure of a model. Among other things, these settings are used to configure the overall behavior of Service Operations mainly by enabling or disabling its main functional modules. Ancillary configurations are also performed in this block, such as the predefined analysis time range, etc:


Conclusion

Valerio Arnaboldi , . Robin I.M. Dunbar , in Online Social Networks , 2015

6.2 Ego Network Structure and Information Diffusion

Social networks are a prominent tool for the diffusion of information in society. Therefore, modelling and predicting information diffusion through social networks is a hot research topic that has attracted a lot of interest in recent years, in particular after the advent of OSNs. Being able to predict (and possibly induce) large-scale information spread would clearly be important for a number of applications, including advertising and other marketing campaigns, as well as political campaigns. From the literature, it is known that tie strength has a direct impact on information diffusion. In fact, the amount of information exchanged between users is correlated with the strength of their social relationship [ 101 ]. Moreover, although there are many possible factors external to social relationships influencing the diffusion of information [ 102 ], a large portion of diffusion (estimated at over 50% [ 103 ]) maps onto social relationships between people, producing the so-called ‘word-of-mouth’ effect. This typically generates ‘cascades’ of information flowing through the network. Some existing models aim to reproduce these cascades by predicting how information will be diffused between pairs of nodes, according to the strength of their social relationship.


Voir la vidéo: COMMENT VERIFIER LES RESULTATS DE LA DV LOTTERY CHEZ SOI en 2021?